{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "5wFF5JFyD2Ki" }, "source": [ "#### Copyright 2019 The TensorFlow Hub Authors.\n", "\n", "Licensed under the Apache License, Version 2.0 (the \"License\");" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2024-01-11T19:14:37.871009Z", "iopub.status.busy": "2024-01-11T19:14:37.870792Z", "iopub.status.idle": "2024-01-11T19:14:37.874529Z", "shell.execute_reply": "2024-01-11T19:14:37.873988Z" }, "id": "Uf6NouXxDqGk" }, "outputs": [], "source": [ "# Copyright 2019 The TensorFlow Hub Authors. All Rights Reserved.\n", "#\n", "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", "# you may not use this file except in compliance with the License.\n", "# You may obtain a copy of the License at\n", "#\n", "# http://www.apache.org/licenses/LICENSE-2.0\n", "#\n", "# Unless required by applicable law or agreed to in writing, software\n", "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", "# See the License for the specific language governing permissions and\n", "# limitations under the License.\n", "# ==============================================================================" ] }, { "cell_type": "markdown", "metadata": { "id": "ORy-KvWXGXBo" }, "source": [ "# TF-Hub CORD-19 Swivel 埋め込みを探索する\n" ] }, { "cell_type": "markdown", "metadata": { "id": "MfBg1C5NB3X0" }, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
TensorFlow.org で表示\n", " Google Colabで実行\n", "GitHub でソースを表示ノートブックをダウンロード TF Hub モデルを参照
" ] }, { "cell_type": "markdown", "metadata": { "id": "9VusdTAH0isl" }, "source": [ "TF-Hub (https://tfhub.dev/tensorflow/cord-19/swivel-128d/1) の CORD-19 Swivel テキスト埋め込みモジュールは、COVID-19 に関連する自然言語テキストを分析する研究者をサポートするために構築されました。これらの埋め込みは、[CORD-19 データセット](https://api.semanticscholar.org/CorpusID:216056360)の論文のタイトル、著者、抄録、本文、および参照タイトルをトレーニングしています。\n", "\n", "この Colab では、以下を取り上げます。\n", "\n", "- 埋め込み空間内の意味的に類似した単語の分析\n", "- CORD-19 埋め込みを使用した SciCite データセットによる分類器のトレーニング\n" ] }, { "cell_type": "markdown", "metadata": { "id": "L69VQv2Z0isl" }, "source": [ "## セットアップ\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2024-01-11T19:14:37.877965Z", "iopub.status.busy": "2024-01-11T19:14:37.877741Z", "iopub.status.idle": "2024-01-11T19:14:41.387210Z", "shell.execute_reply": "2024-01-11T19:14:41.386303Z" }, "id": "Ym2nXOPuPV__" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:39.268168: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", "2024-01-11 19:14:39.268216: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", "2024-01-11 19:14:39.269802: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n" ] } ], "source": [ "import functools\n", "import itertools\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import seaborn as sns\n", "import pandas as pd\n", "\n", "import tensorflow.compat.v1 as tf\n", "tf.disable_eager_execution()\n", "tf.logging.set_verbosity('ERROR')\n", "\n", "import tensorflow_datasets as tfds\n", "import tensorflow_hub as hub\n", "\n", "try:\n", " from google.colab import data_table\n", " def display_df(df):\n", " return data_table.DataTable(df, include_index=False)\n", "except ModuleNotFoundError:\n", " # If google-colab is not available, just display the raw DataFrame\n", " def display_df(df):\n", " return df" ] }, { "cell_type": "markdown", "metadata": { "id": "_VgRRf2I7tER" }, "source": [ "# 埋め込みを分析する\n", "\n", "まず、異なる単語間の相関行列を計算してプロットし、埋め込みを分析してみましょう。異なる単語の意味をうまく捉えられるように埋め込みが学習できていれば、意味的に似た単語の埋め込みベクトルは近くにあるはずです。COVID-19 関連の用語をいくつか見てみましょう。" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2024-01-11T19:14:41.391810Z", "iopub.status.busy": "2024-01-11T19:14:41.391333Z", "iopub.status.idle": "2024-01-11T19:14:45.150576Z", "shell.execute_reply": "2024-01-11T19:14:45.149903Z" }, "id": "HNN_9bBKSLHU" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:42.226805: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Use the inner product between two embedding vectors as the similarity measure\n", "def plot_correlation(labels, features):\n", " corr = np.inner(features, features)\n", " corr /= np.max(corr)\n", " sns.heatmap(corr, xticklabels=labels, yticklabels=labels)\n", "\n", "\n", "with tf.Graph().as_default():\n", " # Load the module\n", " query_input = tf.placeholder(tf.string)\n", " module = hub.Module('https://tfhub.dev/tensorflow/cord-19/swivel-128d/1')\n", " embeddings = module(query_input)\n", "\n", " with tf.train.MonitoredTrainingSession() as sess:\n", "\n", " # Generate embeddings for some terms\n", " queries = [\n", " # Related viruses\n", " \"coronavirus\", \"SARS\", \"MERS\",\n", " # Regions\n", " \"Italy\", \"Spain\", \"Europe\",\n", " # Symptoms\n", " \"cough\", \"fever\", \"throat\"\n", " ]\n", "\n", " features = sess.run(embeddings, feed_dict={query_input: queries})\n", " plot_correlation(queries, features)" ] }, { "cell_type": "markdown", "metadata": { "id": "Bg-PGqtm8B7K" }, "source": [ "埋め込みが異なる用語の意味をうまく捉えていることが分かります。それぞれの単語は所属するクラスタの他の単語に類似していますが（「コロナウイルス」は「SARS」や「MERS」と高い関連性がある）、ほかのクラスタの単語とは異なります（「SARS」と「スペイン」の類似度はゼロに近い）。\n", "\n", "では、これらの埋め込みを使用して特定のタスクを解決する方法を見てみましょう。" ] }, { "cell_type": "markdown", "metadata": { "id": "idJ1jFmH7xMa" }, "source": [ "## SciCite: 引用の意図の分類\n", "\n", "このセクションでは、テキスト分類など下流のタスクに埋め込みを使う方法を示します。学術論文の引用の意図の分類には、TensorFlow Dataset の SciCite データセットを使用します。学術論文からの引用がある文章がある場合に、その引用の主な意図が背景情報、方法の使用、または結果の比較のうち、どれであるかを分類します。" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2024-01-11T19:14:45.154612Z", "iopub.status.busy": "2024-01-11T19:14:45.154338Z", "iopub.status.idle": "2024-01-11T19:14:45.909294Z", "shell.execute_reply": "2024-01-11T19:14:45.908535Z" }, "id": "-FB19HLfVp2V" }, "outputs": [], "source": [ "#@title Set up the dataset from TFDS\n", "\n", "class Dataset:\n", " \"\"\"Build a dataset from a TFDS dataset.\"\"\"\n", " def __init__(self, tfds_name, feature_name, label_name):\n", " self.dataset_builder = tfds.builder(tfds_name)\n", " self.dataset_builder.download_and_prepare()\n", " self.feature_name = feature_name\n", " self.label_name = label_name\n", " \n", " def get_data(self, for_eval):\n", " splits = THE_DATASET.dataset_builder.info.splits\n", " if tfds.Split.TEST in splits:\n", " split = tfds.Split.TEST if for_eval else tfds.Split.TRAIN\n", " else:\n", " SPLIT_PERCENT = 80\n", " split = \"train[{}%:]\".format(SPLIT_PERCENT) if for_eval else \"train[:{}%]\".format(SPLIT_PERCENT)\n", " return self.dataset_builder.as_dataset(split=split)\n", "\n", " def num_classes(self):\n", " return self.dataset_builder.info.features[self.label_name].num_classes\n", "\n", " def class_names(self):\n", " return self.dataset_builder.info.features[self.label_name].names\n", "\n", " def preprocess_fn(self, data):\n", " return data[self.feature_name], data[self.label_name]\n", "\n", " def example_fn(self, data):\n", " feature, label = self.preprocess_fn(data)\n", " return {'feature': feature, 'label': label}, label\n", "\n", "\n", "def get_example_data(dataset, num_examples, **data_kw):\n", " \"\"\"Show example data\"\"\"\n", " with tf.Session() as sess:\n", " batched_ds = dataset.get_data(**data_kw).take(num_examples).map(dataset.preprocess_fn).batch(num_examples)\n", " it = tf.data.make_one_shot_iterator(batched_ds).get_next()\n", " data = sess.run(it)\n", " return data\n", "\n", "\n", "TFDS_NAME = 'scicite' #@param {type: \"string\"}\n", "TEXT_FEATURE_NAME = 'string' #@param {type: \"string\"}\n", "LABEL_NAME = 'label' #@param {type: \"string\"}\n", "THE_DATASET = Dataset(TFDS_NAME, TEXT_FEATURE_NAME, LABEL_NAME)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2024-01-11T19:14:45.913508Z", "iopub.status.busy": "2024-01-11T19:14:45.913223Z", "iopub.status.idle": "2024-01-11T19:14:46.419276Z", "shell.execute_reply": "2024-01-11T19:14:46.418618Z" }, "id": "CVjyBD0ZPh4Z" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stringlabel
0The finding that BMI is closely related to TBF...result
1The average magnitude of the NBR increases wit...background
2It has been reported that NF-κB activation can...result
3, 2008; Quraan and Cheyne, 2008; Quraan and Ch...background
45B), but, interestingly, they shared conserved...background
5Some investigators have noted an association o...background
6In our previous study, it is documented that b...background
7These subjects have intact cognitive function ...background
8Another study reported improved knee function ...background
9C. Data Analysis Transcription Speech samples ...method
10o) was administered 14 days after the inductio...method
11showed that individuals who had previously exp...result
12However, a more stringent microarray experimen...background
13These results, of a fast short term depression...result
14The proportion of laboratory confirmed cases (...background
15Scientometric studies employing bibliometric a...method
16Our choice of studying CFI in higher detail is...background
175 mg), GST-53BP2(715-1005) (1 mg), GST-GL(1-25...background
18DCS is preferable to External Storage (ES) at ...background
19RDo, where RD, RF and RDo represent relative d...method
\n", "
" ], "text/plain": [ " string label\n", "0 The finding that BMI is closely related to TBF... result\n", "1 The average magnitude of the NBR increases wit... background\n", "2 It has been reported that NF-κB activation can... result\n", "3 , 2008; Quraan and Cheyne, 2008; Quraan and Ch... background\n", "4 5B), but, interestingly, they shared conserved... background\n", "5 Some investigators have noted an association o... background\n", "6 In our previous study, it is documented that b... background\n", "7 These subjects have intact cognitive function ... background\n", "8 Another study reported improved knee function ... background\n", "9 C. Data Analysis Transcription Speech samples ... method\n", "10 o) was administered 14 days after the inductio... method\n", "11 showed that individuals who had previously exp... result\n", "12 However, a more stringent microarray experimen... background\n", "13 These results, of a fast short term depression... result\n", "14 The proportion of laboratory confirmed cases (... background\n", "15 Scientometric studies employing bibliometric a... method\n", "16 Our choice of studying CFI in higher detail is... background\n", "17 5 mg), GST-53BP2(715-1005) (1 mg), GST-GL(1-25... background\n", "18 DCS is preferable to External Storage (ES) at ... background\n", "19 RDo, where RD, RF and RDo represent relative d... method" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#@title Let's take a look at a few labeled examples from the training set\n", "NUM_EXAMPLES = 20 #@param {type:\"integer\"}\n", "data = get_example_data(THE_DATASET, NUM_EXAMPLES, for_eval=False)\n", "display_df(\n", " pd.DataFrame({\n", " TEXT_FEATURE_NAME: [ex.decode('utf8') for ex in data[0]],\n", " LABEL_NAME: [THE_DATASET.class_names()[x] for x in data[1]]\n", " }))" ] }, { "cell_type": "markdown", "metadata": { "id": "65s9UpYJ_1ct" }, "source": [ "## 引用の意図分類器をトレーニングする\n", "\n", "分類器のトレーニングには、SciCite データセットに対して Estimator を使用します。input_fns を設定してデータセットをモデルに読み込みましょう。" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "cellView": "both", "execution": { "iopub.execute_input": "2024-01-11T19:14:46.422958Z", "iopub.status.busy": "2024-01-11T19:14:46.422704Z", "iopub.status.idle": "2024-01-11T19:14:46.429480Z", "shell.execute_reply": "2024-01-11T19:14:46.428815Z" }, "id": "OldapWmKSGsW" }, "outputs": [], "source": [ "def preprocessed_input_fn(for_eval):\n", " data = THE_DATASET.get_data(for_eval=for_eval)\n", " data = data.map(THE_DATASET.example_fn, num_parallel_calls=1)\n", " return data\n", "\n", "\n", "def input_fn_train(params):\n", " data = preprocessed_input_fn(for_eval=False)\n", " data = data.repeat(None)\n", " data = data.shuffle(1024)\n", " data = data.batch(batch_size=params['batch_size'])\n", " return data\n", "\n", "\n", "def input_fn_eval(params):\n", " data = preprocessed_input_fn(for_eval=True)\n", " data = data.repeat(1)\n", " data = data.batch(batch_size=params['batch_size'])\n", " return data\n", "\n", "\n", "def input_fn_predict(params):\n", " data = preprocessed_input_fn(for_eval=True)\n", " data = data.batch(batch_size=params['batch_size'])\n", " return data" ] }, { "cell_type": "markdown", "metadata": { "id": "KcrmWUkVKg2u" }, "source": [ "上に分類レイヤーを持ち、CORD-19 埋め込みを使用するモデルを構築してみましょう。" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2024-01-11T19:14:46.433011Z", "iopub.status.busy": "2024-01-11T19:14:46.432398Z", "iopub.status.idle": "2024-01-11T19:14:46.440234Z", "shell.execute_reply": "2024-01-11T19:14:46.439565Z" }, "id": "ff0uKqJCA9zh" }, "outputs": [], "source": [ "def model_fn(features, labels, mode, params):\n", " # Embed the text\n", " embed = hub.Module(params['module_name'], trainable=params['trainable_module'])\n", " embeddings = embed(features['feature'])\n", "\n", " # Add a linear layer on top\n", " logits = tf.layers.dense(\n", " embeddings, units=THE_DATASET.num_classes(), activation=None)\n", " predictions = tf.argmax(input=logits, axis=1)\n", "\n", " if mode == tf.estimator.ModeKeys.PREDICT:\n", " return tf.estimator.EstimatorSpec(\n", " mode=mode,\n", " predictions={\n", " 'logits': logits,\n", " 'predictions': predictions,\n", " 'features': features['feature'],\n", " 'labels': features['label']\n", " })\n", " \n", " # Set up a multi-class classification head\n", " loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n", " labels=labels, logits=logits)\n", " loss = tf.reduce_mean(loss)\n", "\n", " if mode == tf.estimator.ModeKeys.TRAIN:\n", " optimizer = tf.train.GradientDescentOptimizer(learning_rate=params['learning_rate'])\n", " train_op = optimizer.minimize(loss, global_step=tf.train.get_or_create_global_step())\n", " return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)\n", "\n", " elif mode == tf.estimator.ModeKeys.EVAL:\n", " accuracy = tf.metrics.accuracy(labels=labels, predictions=predictions)\n", " precision = tf.metrics.precision(labels=labels, predictions=predictions)\n", " recall = tf.metrics.recall(labels=labels, predictions=predictions)\n", "\n", " return tf.estimator.EstimatorSpec(\n", " mode=mode,\n", " loss=loss,\n", " eval_metric_ops={\n", " 'accuracy': accuracy,\n", " 'precision': precision,\n", " 'recall': recall,\n", " })\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2024-01-11T19:14:46.443436Z", "iopub.status.busy": "2024-01-11T19:14:46.442868Z", "iopub.status.idle": "2024-01-11T19:14:46.446906Z", "shell.execute_reply": "2024-01-11T19:14:46.446326Z" }, "id": "yZUclu8xBYlj" }, "outputs": [], "source": [ "#@title Hyperparmeters { run: \"auto\" }\n", "\n", "EMBEDDING = 'https://tfhub.dev/tensorflow/cord-19/swivel-128d/1' #@param {type: \"string\"}\n", "TRAINABLE_MODULE = False #@param {type: \"boolean\"}\n", "STEPS = 8000#@param {type: \"integer\"}\n", "EVAL_EVERY = 200 #@param {type: \"integer\"}\n", "BATCH_SIZE = 10 #@param {type: \"integer\"}\n", "LEARNING_RATE = 0.01 #@param {type: \"number\"}\n", "\n", "params = {\n", " 'batch_size': BATCH_SIZE,\n", " 'learning_rate': LEARNING_RATE,\n", " 'module_name': EMBEDDING,\n", " 'trainable_module': TRAINABLE_MODULE\n", "}" ] }, { "cell_type": "markdown", "metadata": { "id": "weZKWK-pLBll" }, "source": [ "## モデルをトレーニングして評価する\n", "\n", "モデルをトレーニングして評価を行い、SciCite タスクでのパフォーマンスを見てみましょう。" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2024-01-11T19:14:46.450303Z", "iopub.status.busy": "2024-01-11T19:14:46.450060Z", "iopub.status.idle": "2024-01-11T19:16:51.019059Z", "shell.execute_reply": "2024-01-11T19:16:51.018324Z" }, "id": "cO1FWkZW2WS9" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:46.602646: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n", "/tmpfs/tmp/ipykernel_104176/393120678.py:7: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.\n", " logits = tf.layers.dense(\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:48.222056: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 0: loss 0.842, accuracy 0.636\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:49.978652: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:51.615497: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 200: loss 0.740, accuracy 0.703\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:53.260719: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:54.679780: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 400: loss 0.684, accuracy 0.737\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:56.356281: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:57.807068: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 600: loss 0.649, accuracy 0.751\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:14:59.467871: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:00.894589: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 800: loss 0.637, accuracy 0.749\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:02.610492: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:04.081191: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 1000: loss 0.629, accuracy 0.754\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:05.722098: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:07.136146: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 1200: loss 0.604, accuracy 0.770\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:08.777994: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:10.244259: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 1400: loss 0.598, accuracy 0.766\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:11.911174: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:13.285140: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 1600: loss 0.587, accuracy 0.775\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:14.942509: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:16.353150: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 1800: loss 0.578, accuracy 0.776\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:18.047069: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:19.417233: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 2000: loss 0.582, accuracy 0.771\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:21.073059: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:22.539460: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 2200: loss 0.577, accuracy 0.776\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:24.225553: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:25.624548: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 2400: loss 0.572, accuracy 0.777\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:27.265684: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:28.690927: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 2600: loss 0.568, accuracy 0.779\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:30.326410: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:31.769095: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 2800: loss 0.568, accuracy 0.778\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:33.414151: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:34.849879: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 3000: loss 0.559, accuracy 0.783\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:36.508477: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:37.994444: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 3200: loss 0.561, accuracy 0.786\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:39.638953: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:41.057612: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 3400: loss 0.566, accuracy 0.774\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:43.015137: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:44.365486: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 3600: loss 0.553, accuracy 0.783\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:46.039061: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:47.514670: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 3800: loss 0.563, accuracy 0.772\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:49.159915: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:50.506473: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 4000: loss 0.560, accuracy 0.779\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:52.129647: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:53.559881: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 4200: loss 0.554, accuracy 0.782\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:55.225119: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:56.639571: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 4400: loss 0.552, accuracy 0.778\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:58.273462: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:15:59.725267: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 4600: loss 0.553, accuracy 0.781\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:01.378686: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:02.802899: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 4800: loss 0.551, accuracy 0.782\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:04.437966: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:05.884323: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 5000: loss 0.549, accuracy 0.783\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:07.527458: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:08.986769: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 5200: loss 0.550, accuracy 0.777\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:10.649124: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:12.121480: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 5400: loss 0.554, accuracy 0.773\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:13.823252: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:15.215645: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 5600: loss 0.543, accuracy 0.788\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:16.862731: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:18.317355: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 5800: loss 0.545, accuracy 0.778\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:19.961560: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:21.406026: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 6000: loss 0.541, accuracy 0.786\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:23.045624: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:24.537088: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 6200: loss 0.541, accuracy 0.788\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:26.181818: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:27.724668: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 6400: loss 0.538, accuracy 0.787\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:29.364966: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:30.723931: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 6600: loss 0.542, accuracy 0.787\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:32.384707: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:34.110425: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 6800: loss 0.542, accuracy 0.794\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:35.753712: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:37.173630: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 7000: loss 0.542, accuracy 0.789\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:38.802880: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:40.201037: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 7200: loss 0.537, accuracy 0.792\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:41.840580: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:43.260351: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 7400: loss 0.535, accuracy 0.790\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:44.948129: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:46.328297: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 7600: loss 0.550, accuracy 0.781\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:48.010033: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:49.480537: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Global step 7800: loss 0.541, accuracy 0.787\n" ] } ], "source": [ "estimator = tf.estimator.Estimator(functools.partial(model_fn, params=params))\n", "metrics = []\n", "\n", "for step in range(0, STEPS, EVAL_EVERY):\n", " estimator.train(input_fn=functools.partial(input_fn_train, params=params), steps=EVAL_EVERY)\n", " step_metrics = estimator.evaluate(input_fn=functools.partial(input_fn_eval, params=params))\n", " print('Global step {}: loss {:.3f}, accuracy {:.3f}'.format(step, step_metrics['loss'], step_metrics['accuracy']))\n", " metrics.append(step_metrics)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2024-01-11T19:16:51.022756Z", "iopub.status.busy": "2024-01-11T19:16:51.022505Z", "iopub.status.idle": "2024-01-11T19:16:51.403391Z", "shell.execute_reply": "2024-01-11T19:16:51.402665Z" }, "id": "RUNGAeyf1ygC" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "global_steps = [x['global_step'] for x in metrics]\n", "fig, axes = plt.subplots(ncols=2, figsize=(20,8))\n", "\n", "for axes_index, metric_names in enumerate([['accuracy', 'precision', 'recall'],\n", " ['loss']]):\n", " for metric_name in metric_names:\n", " axes[axes_index].plot(global_steps, [x[metric_name] for x in metrics], label=metric_name)\n", " axes[axes_index].legend()\n", " axes[axes_index].set_xlabel(\"Global Step\")" ] }, { "cell_type": "markdown", "metadata": { "id": "1biWylvB6ayg" }, "source": [ "損失はすぐに減少しますが、特に精度は急速に上がることが分かります。予測と真のラベルがどのように関係しているかを確認するために、いくつかの例をプロットしてみましょう。" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2024-01-11T19:16:51.407803Z", "iopub.status.busy": "2024-01-11T19:16:51.407501Z", "iopub.status.idle": "2024-01-11T19:16:51.411203Z", "shell.execute_reply": "2024-01-11T19:16:51.410530Z" }, "id": "zK_NJXtoyG2o" }, "outputs": [], "source": [ "predictions = estimator.predict(functools.partial(input_fn_predict, params))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2024-01-11T19:16:51.414538Z", "iopub.status.busy": "2024-01-11T19:16:51.414123Z", "iopub.status.idle": "2024-01-11T19:16:52.026540Z", "shell.execute_reply": "2024-01-11T19:16:52.025850Z" }, "id": "nlxFER_Oriam" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2024-01-11 19:16:51.528015: W tensorflow/core/common_runtime/graph_constructor.cc:1583] Importing a graph with a lower producer version 27 into an existing graph with producer version 1645. Shape inference will have run different parts of the graph with different producer versions.\n", "/tmpfs/tmp/ipykernel_104176/393120678.py:7: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.\n", " logits = tf.layers.dense(\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stringlabelprediction
0The diffraction grating, LED, and split detect...backgroundmethod
1Our ideas are based on a previous paper [4] de...backgroundmethod
2Our finding is consistent with the literature ...resultresult
3Test scores from each of the cognitive domains...methodmethod
4The optimization algorithm was set to maximize...methodmethod
5To quantify the extent of substitution saturat...methodmethod
6Examples of gesture control are based on the e...methodmethod
7The identification of these features has been ...methodresult
8Postulated mechanisms for observed effects of ...backgroundbackground
9The right inferior phrenic artery is the most ...backgroundbackground
\n", "
" ], "text/plain": [ " string label prediction\n", "0 The diffraction grating, LED, and split detect... background method\n", "1 Our ideas are based on a previous paper [4] de... background method\n", "2 Our finding is consistent with the literature ... result result\n", "3 Test scores from each of the cognitive domains... method method\n", "4 The optimization algorithm was set to maximize... method method\n", "5 To quantify the extent of substitution saturat... method method\n", "6 Examples of gesture control are based on the e... method method\n", "7 The identification of these features has been ... method result\n", "8 Postulated mechanisms for observed effects of ... background background\n", "9 The right inferior phrenic artery is the most ... background background" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "first_10_predictions = list(itertools.islice(predictions, 10))\n", "\n", "display_df(\n", " pd.DataFrame({\n", " TEXT_FEATURE_NAME: [pred['features'].decode('utf8') for pred in first_10_predictions],\n", " LABEL_NAME: [THE_DATASET.class_names()[pred['labels']] for pred in first_10_predictions],\n", " 'prediction': [THE_DATASET.class_names()[pred['predictions']] for pred in first_10_predictions]\n", " }))" ] }, { "cell_type": "markdown", "metadata": { "id": "OSGcrkE069_Q" }, "source": [ "このランダムサンプルでは、ほとんどの場合、モデルが正しいラベルを予測しており、科学的な文をうまく埋め込むことができていることが分かります。" ] }, { "cell_type": "markdown", "metadata": { "id": "oLE0kCfO5CIA" }, "source": [ "# 次のステップ\n", "\n", "TF-Hub の CORD-19 Swivel 埋め込みについて少し説明しました。COVID-19 関連の学術的なテキストから科学的洞察の取得に貢献できる、CORD-19 Kaggle コンペへの参加をお勧めします。\n", "\n", "- [CORD-19 Kaggle Challenge](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) に参加しましょう。\n", "- 詳細については [COVID-19 Open Research Dataset (CORD-19)](https://api.semanticscholar.org/CorpusID:216056360) をご覧ください。\n", "- TF-Hub 埋め込みに関する詳細のドキュメントは https://tfhub.dev/tensorflow/cord-19/swivel-128d/1 をご覧ください。\n", "- [TensorFlow Embedding Projector](http://projector.tensorflow.org/?config=https://storage.googleapis.com/tfhub-examples/tensorflow/cord-19/swivel-128d/1/tensorboard/full_projector_config.json) を利用して CORD-19 埋め込み空間を見てみましょう。" ] } ], "metadata": { "colab": { "collapsed_sections": [ "5wFF5JFyD2Ki" ], "name": "cord_19_embeddings.ipynb", "toc_visible": true }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.18" } }, "nbformat": 4, "nbformat_minor": 0 }