{
"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": "2022-12-14T13:17:09.697816Z",
"iopub.status.busy": "2022-12-14T13:17:09.697383Z",
"iopub.status.idle": "2022-12-14T13:17:09.701499Z",
"shell.execute_reply": "2022-12-14T13:17:09.700943Z"
},
"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": [
"# Exploring the TF-Hub CORD-19 Swivel Embeddings\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MfBg1C5NB3X0"
},
"source": [
"
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9VusdTAH0isl"
},
"source": [
"The CORD-19 Swivel text embedding module from TF-Hub (https://tfhub.dev/tensorflow/cord-19/swivel-128d/1)\n",
" was built to support researchers analyzing natural languages text related to COVID-19.\n",
"These embeddings were trained on the titles, authors, abstracts, body texts, and\n",
"reference titles of articles in the [CORD-19 dataset](https://api.semanticscholar.org/CorpusID:216056360).\n",
"\n",
"In this colab we will:\n",
"- Analyze semantically similar words in the embedding space\n",
"- Train a classifier on the SciCite dataset using the CORD-19 embeddings\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "L69VQv2Z0isl"
},
"source": [
"## Setup\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T13:17:09.705214Z",
"iopub.status.busy": "2022-12-14T13:17:09.704748Z",
"iopub.status.idle": "2022-12-14T13:17:12.705854Z",
"shell.execute_reply": "2022-12-14T13:17:12.705147Z"
},
"id": "Ym2nXOPuPV__"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:11.613975: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
"2022-12-14 13:17:11.614081: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
"2022-12-14 13:17:11.614090: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\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": [
"# Analyze the embeddings\n",
"\n",
"Let's start off by analyzing the embedding by calculating and plotting a correlation matrix between different terms. If the embedding learned to successfully capture the meaning of different words, the embedding vectors of semantically similar words should be close together. Let's take a look at some COVID-19 related terms."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T13:17:12.710796Z",
"iopub.status.busy": "2022-12-14T13:17:12.709942Z",
"iopub.status.idle": "2022-12-14T13:17:17.172824Z",
"shell.execute_reply": "2022-12-14T13:17:17.172200Z"
},
"id": "HNN_9bBKSLHU"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:13.443325: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"data": {
"image/png": "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\n",
"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": [
"We can see that the embedding successfully captured the meaning of the different terms. Each word is similar to the other words of its cluster (i.e. \"coronavirus\" highly correlates with \"SARS\" and \"MERS\"), while they are different from terms of other clusters (i.e. the similarity between \"SARS\" and \"Spain\" is close to 0).\n",
"\n",
"Now let's see how we can use these embeddings to solve a specific task."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "idJ1jFmH7xMa"
},
"source": [
"## SciCite: Citation Intent Classification\n",
"\n",
"This section shows how one can use the embedding for downstream tasks such as text classification. We'll use the [SciCite dataset](https://www.tensorflow.org/datasets/catalog/scicite) from TensorFlow Datasets to classify citation intents in academic papers. Given a sentence with a citation from an academic paper, classify whether the main intent of the citation is as background information, use of methods, or comparing results."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"cellView": "form",
"execution": {
"iopub.execute_input": "2022-12-14T13:17:17.176817Z",
"iopub.status.busy": "2022-12-14T13:17:17.176569Z",
"iopub.status.idle": "2022-12-14T13:17:17.945950Z",
"shell.execute_reply": "2022-12-14T13:17:17.945240Z"
},
"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": "2022-12-14T13:17:17.950131Z",
"iopub.status.busy": "2022-12-14T13:17:17.949506Z",
"iopub.status.idle": "2022-12-14T13:17:18.406737Z",
"shell.execute_reply": "2022-12-14T13:17:18.405982Z"
},
"id": "CVjyBD0ZPh4Z"
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
string
\n",
"
label
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
The finding that BMI is closely related to TBF...
\n",
"
result
\n",
"
\n",
"
\n",
"
1
\n",
"
The average magnitude of the NBR increases wit...
\n",
"
background
\n",
"
\n",
"
\n",
"
2
\n",
"
It has been reported that NF-κB activation can...
\n",
"
result
\n",
"
\n",
"
\n",
"
3
\n",
"
, 2008; Quraan and Cheyne, 2008; Quraan and Ch...
\n",
"
background
\n",
"
\n",
"
\n",
"
4
\n",
"
5B), but, interestingly, they shared conserved...
\n",
"
background
\n",
"
\n",
"
\n",
"
5
\n",
"
Some investigators have noted an association o...
\n",
"
background
\n",
"
\n",
"
\n",
"
6
\n",
"
In our previous study, it is documented that b...
\n",
"
background
\n",
"
\n",
"
\n",
"
7
\n",
"
These subjects have intact cognitive function ...
\n",
"
background
\n",
"
\n",
"
\n",
"
8
\n",
"
Another study reported improved knee function ...
\n",
"
background
\n",
"
\n",
"
\n",
"
9
\n",
"
C. Data Analysis Transcription Speech samples ...
\n",
"
method
\n",
"
\n",
"
\n",
"
10
\n",
"
o) was administered 14 days after the inductio...
\n",
"
method
\n",
"
\n",
"
\n",
"
11
\n",
"
showed that individuals who had previously exp...
\n",
"
result
\n",
"
\n",
"
\n",
"
12
\n",
"
However, a more stringent microarray experimen...
\n",
"
background
\n",
"
\n",
"
\n",
"
13
\n",
"
These results, of a fast short term depression...
\n",
"
result
\n",
"
\n",
"
\n",
"
14
\n",
"
The proportion of laboratory confirmed cases (...
\n",
"
background
\n",
"
\n",
"
\n",
"
15
\n",
"
Scientometric studies employing bibliometric a...
\n",
"
method
\n",
"
\n",
"
\n",
"
16
\n",
"
Our choice of studying CFI in higher detail is...
\n",
"
background
\n",
"
\n",
"
\n",
"
17
\n",
"
5 mg), GST-53BP2(715-1005) (1 mg), GST-GL(1-25...
\n",
"
background
\n",
"
\n",
"
\n",
"
18
\n",
"
DCS is preferable to External Storage (ES) at ...
\n",
"
background
\n",
"
\n",
"
\n",
"
19
\n",
"
RDo, where RD, RF and RDo represent relative d...
\n",
"
method
\n",
"
\n",
" \n",
"
\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": [
"## Training a citaton intent classifier\n",
"\n",
"We'll train a classifier on the [SciCite dataset](https://www.tensorflow.org/datasets/catalog/scicite) using an Estimator. Let's set up the input_fns to read the dataset into the model"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"cellView": "both",
"execution": {
"iopub.execute_input": "2022-12-14T13:17:18.410573Z",
"iopub.status.busy": "2022-12-14T13:17:18.409875Z",
"iopub.status.idle": "2022-12-14T13:17:18.415396Z",
"shell.execute_reply": "2022-12-14T13:17:18.414820Z"
},
"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": [
"Let's build a model which use the CORD-19 embeddings with a classification layer on top."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T13:17:18.418943Z",
"iopub.status.busy": "2022-12-14T13:17:18.418276Z",
"iopub.status.idle": "2022-12-14T13:17:18.425707Z",
"shell.execute_reply": "2022-12-14T13:17:18.425100Z"
},
"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": "2022-12-14T13:17:18.428792Z",
"iopub.status.busy": "2022-12-14T13:17:18.428341Z",
"iopub.status.idle": "2022-12-14T13:17:18.431960Z",
"shell.execute_reply": "2022-12-14T13:17:18.431415Z"
},
"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": [
"## Train and evaluate the model\n",
"\n",
"Let's train and evaluate the model to see the performance on the SciCite task"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T13:17:18.435301Z",
"iopub.status.busy": "2022-12-14T13:17:18.434769Z",
"iopub.status.idle": "2022-12-14T13:18:49.957216Z",
"shell.execute_reply": "2022-12-14T13:18:49.956181Z"
},
"id": "cO1FWkZW2WS9"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:18.608727: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n",
"/tmpfs/tmp/ipykernel_82254/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": [
"2022-12-14 13:17:20.267388: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.805, accuracy 0.673\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:21.578882: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:23.130041: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.709, accuracy 0.737\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:24.039425: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:25.420241: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.665, accuracy 0.751\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:26.350485: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:27.689877: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.650, accuracy 0.747\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:28.631305: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:29.956245: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.624, accuracy 0.770\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:30.865582: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:32.199344: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.608, accuracy 0.771\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:33.109644: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:34.629701: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.602, accuracy 0.771\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:35.579652: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:36.885602: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.595, accuracy 0.772\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:37.808432: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:39.100259: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.590, accuracy 0.770\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:40.033136: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:41.326140: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.586, accuracy 0.775\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:42.234369: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:43.573459: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.578, accuracy 0.780\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:44.523910: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:45.878334: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.578, accuracy 0.772\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:46.794796: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:48.083793: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.567, accuracy 0.788\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:48.989880: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:50.334086: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.570, accuracy 0.776\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:51.258123: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:52.623831: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.569, accuracy 0.777\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:53.561873: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:54.974251: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.556, accuracy 0.792\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:55.901999: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:57.212540: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.557, accuracy 0.787\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:58.141921: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:17:59.779189: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.558, accuracy 0.780\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:00.883698: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:02.185680: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.551, accuracy 0.791\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:03.124206: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:04.422033: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.552, accuracy 0.789\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:05.320345: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:06.614288: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.561, accuracy 0.777\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:07.515576: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:08.759732: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.551, accuracy 0.785\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:09.678704: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:10.946382: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.558, accuracy 0.777\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:11.872005: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:13.209142: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.558, accuracy 0.772\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:14.122017: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:15.466316: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.547, accuracy 0.787\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:16.373200: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:17.641901: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.789\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:18.559729: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:19.888893: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.542, accuracy 0.790\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:20.794698: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:22.126832: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.550, accuracy 0.788\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:23.012987: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:24.336729: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.546, accuracy 0.784\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:25.570025: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:26.913488: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.784\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:27.815429: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:29.076040: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.789\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:29.997144: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:31.386816: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.553, accuracy 0.775\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:32.291647: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:33.555454: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.546, accuracy 0.787\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:34.496894: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:35.804268: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.541, accuracy 0.790\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:36.731427: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:38.103627: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.538, accuracy 0.789\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:39.004639: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:40.282839: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.784\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:41.203176: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:42.534588: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.789\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:43.479215: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:44.775580: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.542, accuracy 0.785\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:45.694676: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:47.028380: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.543, accuracy 0.786\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:47.928337: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:49.191316: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. 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.537, accuracy 0.790\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": "2022-12-14T13:18:49.960875Z",
"iopub.status.busy": "2022-12-14T13:18:49.960605Z",
"iopub.status.idle": "2022-12-14T13:18:50.557519Z",
"shell.execute_reply": "2022-12-14T13:18:50.556640Z"
},
"id": "RUNGAeyf1ygC"
},
"outputs": [
{
"data": {
"image/png": "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\n",
"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": [
"We can see that the loss quickly decreases while especially the accuracy rapidly increases. Let's plot some examples to check how the prediction relates to the true labels:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"execution": {
"iopub.execute_input": "2022-12-14T13:18:50.563044Z",
"iopub.status.busy": "2022-12-14T13:18:50.562359Z",
"iopub.status.idle": "2022-12-14T13:18:50.566200Z",
"shell.execute_reply": "2022-12-14T13:18:50.565323Z"
},
"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": "2022-12-14T13:18:50.569632Z",
"iopub.status.busy": "2022-12-14T13:18:50.569089Z",
"iopub.status.idle": "2022-12-14T13:18:51.131975Z",
"shell.execute_reply": "2022-12-14T13:18:51.131045Z"
},
"id": "nlxFER_Oriam"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2022-12-14 13:18:50.725415: W tensorflow/core/common_runtime/graph_constructor.cc:1526] Importing a graph with a lower producer version 27 into an existing graph with producer version 1286. Shape inference will have run different parts of the graph with different producer versions.\n",
"/tmpfs/tmp/ipykernel_82254/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",
"
string
\n",
"
label
\n",
"
prediction
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
The diffraction grating, LED, and split detect...
\n",
"
background
\n",
"
method
\n",
"
\n",
"
\n",
"
1
\n",
"
Our ideas are based on a previous paper [4] de...
\n",
"
background
\n",
"
method
\n",
"
\n",
"
\n",
"
2
\n",
"
Our finding is consistent with the literature ...
\n",
"
result
\n",
"
result
\n",
"
\n",
"
\n",
"
3
\n",
"
Test scores from each of the cognitive domains...
\n",
"
method
\n",
"
method
\n",
"
\n",
"
\n",
"
4
\n",
"
The optimization algorithm was set to maximize...
\n",
"
method
\n",
"
method
\n",
"
\n",
"
\n",
"
5
\n",
"
To quantify the extent of substitution saturat...
\n",
"
method
\n",
"
method
\n",
"
\n",
"
\n",
"
6
\n",
"
Examples of gesture control are based on the e...
\n",
"
method
\n",
"
method
\n",
"
\n",
"
\n",
"
7
\n",
"
The identification of these features has been ...
\n",
"
method
\n",
"
result
\n",
"
\n",
"
\n",
"
8
\n",
"
Postulated mechanisms for observed effects of ...
\n",
"
background
\n",
"
background
\n",
"
\n",
"
\n",
"
9
\n",
"
The right inferior phrenic artery is the most ...
\n",
"
background
\n",
"
background
\n",
"
\n",
" \n",
"
\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": [
"We can see that for this random sample, the model predicts the correct label most of the times, indicating that it can embed scientific sentences pretty well."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oLE0kCfO5CIA"
},
"source": [
"# What's next?\n",
"\n",
"Now that you've gotten to know a bit more about the CORD-19 Swivel embeddings from TF-Hub, we encourage you to participate in the CORD-19 Kaggle competition to contribute to gaining scientific insights from COVID-19 related academic texts.\n",
"\n",
"* Participate in the [CORD-19 Kaggle Challenge](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge)\n",
"* Learn more about the [COVID-19 Open Research Dataset (CORD-19)](https://api.semanticscholar.org/CorpusID:216056360)\n",
"* See documentation and more about the TF-Hub embeddings at https://tfhub.dev/tensorflow/cord-19/swivel-128d/1\n",
"* Explore the CORD-19 embedding space with the [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)"
]
}
],
"metadata": {
"colab": {
"collapsed_sections": [
"5wFF5JFyD2Ki"
],
"name": "Exploring the TF-Hub CORD-19 Swivel Embeddings",
"private_outputs": true,
"provenance": [],
"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.16"
}
},
"nbformat": 4,
"nbformat_minor": 0
}