{ "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-14T21:42:41.251303Z", "iopub.status.busy": "2022-12-14T21:42:41.250745Z", "iopub.status.idle": "2022-12-14T21:42:41.254803Z", "shell.execute_reply": "2022-12-14T21:42:41.254296Z" }, "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 中运行 在 GitHub 上查看源代码 下载笔记本查看 TF Hub 模型
" ] }, { "cell_type": "markdown", "metadata": { "id": "9VusdTAH0isl" }, "source": [ "TF-Hub 上的 CORD-19 Swivel 文本嵌入向量模块 (https://tfhub.dev/tensorflow/cord-19/swivel-128d/1) 旨在支持研究人员分析与 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": "2022-12-14T21:42:41.258151Z", "iopub.status.busy": "2022-12-14T21:42:41.257739Z", "iopub.status.idle": "2022-12-14T21:42:44.289586Z", "shell.execute_reply": "2022-12-14T21:42:44.288806Z" }, "id": "Ym2nXOPuPV__" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:42:43.193433: 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 21:42:43.193555: 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 21:42:43.193586: 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": [ "# 分析嵌入向量\n", "\n", "首先，我们通过计算和绘制不同术语之间的相关矩阵来分析嵌入向量。如果嵌入向量学会了成功捕获不同单词的含义，则语义相似的单词的嵌入向量应相互靠近。我们来看一些与 COVID-19 相关的术语。" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:42:44.294285Z", "iopub.status.busy": "2022-12-14T21:42:44.293363Z", "iopub.status.idle": "2022-12-14T21:42:48.645701Z", "shell.execute_reply": "2022-12-14T21:42:48.644863Z" }, "id": "HNN_9bBKSLHU" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:42:44.865767: 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": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAHmCAYAAACWKUEfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfpUlEQVR4nO3de1zO5/8H8Ndd6u6kg6RCSY4VCjnkGLLCmMPMCOV8mGNzyimHTdgYG5uNSL7OxzHGaGLInCrMYRPJrJNDKNyl+/P7Q+6fe9Wt2+587sPr+X18Hg/35/i699307rquz3VJBEEQQEREREQwEjsAERERkbZgYURERERUiIURERERUSEWRkRERESFWBgRERERFWJhRERERFSIhRERERFRIRZGRERERIVYGBEREREVYmFEREREVIiFEREREWmd48ePo2vXrqhcuTIkEgn27Nnzxmvi4uLQqFEjSKVS1KxZE9HR0Wo/l4URERERaZ3c3Fx4e3tj5cqVpTr/1q1b6NKlC9q1a4fExERMmDABQ4cOxaFDh9R6roSLyBIREZE2k0gk2L17N7p3717iOVOnTsX+/ftx+fJlxb6PP/4Y2dnZOHjwYKmfxRYjIiIieidkMhkeP36stMlkMo3cOz4+HgEBAUr7AgMDER8fr9Z9ymkkDWnUsx2fiR1BLXvHXhU7glp07beBz4RbYkfQa+ZGpmJH0HvVTWzFjqCWlBePxI6glvi7R8v8Gfn3bmrkPpErYjB37lylfREREZgzZ85/vnd6ejocHR2V9jk6OuLx48d49uwZzM3NS3UfFkZERET0ToSHhyMsLExpn1QqFSlN8VgYERERkWryAo3cRiqVllkh5OTkhIyMDKV9GRkZsLa2LnVrEcDCiIiIiN5EkIud4I38/Pxw4MABpX2HDx+Gn5+fWvfRteEWREREZABycnKQmJiIxMREAC9fx09MTERqaiqAl91yAwcOVJw/cuRI3Lx5E1OmTMG1a9fw7bffYtu2bZg4caJaz2WLEREREakmf/ctRufOnUO7du0Un1+NTQoJCUF0dDTS0tIURRIAVK9eHfv378fEiROxfPlyVK1aFWvWrEFgYKBaz2VhRERERCoJInSl+fv7Q9VUi8XNau3v74+EhIT/9Fx2pREREREVYosRERERqSZCV5pYWBgRERGRajrwVpqmsCuNiIiIqBBbjIiIiEg1DU3wqAtYGBEREZFqBtSVxsKIiIiIVDOgwdccY/QaiUSCPXv2iB2DiIiIRMIWo9ekpaXBzs5O7BhERERaRYwJHsUiamGUl5cHU1NTMSMocXJyUnk8Pz8fJiYm7ygNERGRlmBXWsnkcjkWL16MmjVrQiqVwtXVFZ9//jkA4NKlS2jfvj3Mzc1hb2+P4cOHIycnR3FtaGgounfvjs8//xyVK1dGnTp11Lruyy+/hLOzM+zt7fHJJ58gPz9fcc6GDRvg6+uL8uXLw8nJCf369UNmZqYic9WqVfHdd98pfZeEhAQYGRnh9u3bAJS70lJSUiCRSLB161a0bdsWZmZm2LhxI+bMmQMfHx+l+yxbtgxubm6Kz3FxcWjatCksLS1ha2uLli1bKp5BRERE2kvtwig8PBwLFy7ErFmzcOXKFWzatAmOjo7Izc1FYGAg7OzscPbsWWzfvh1HjhzBmDFjlK6PjY3F9evXcfjwYfz000+lvu7o0aNITk7G0aNHsX79ekRHRyutk5Kfn4/58+cjKSkJe/bsQUpKCkJDQ19+SSMj9O3bF5s2bVK658aNG9GyZUtUq1atxO87bdo0jB8/HlevXi3VQnQvXrxA9+7d0bZtW1y8eBHx8fEYPnw4JBLJG68lIiLSSoJcM5sOUKsr7cmTJ1i+fDlWrFiBkJAQAECNGjXQqlUrrF69Gs+fP0dMTAwsLS0BACtWrEDXrl2xaNEiODo6AgAsLS2xZs0aRRdaaa+zs7PDihUrYGxsjLp166JLly6IjY3FsGHDAACDBw9W5HR3d8fXX3+NJk2aICcnB1ZWVggODsaSJUuQmpoKV1dXyOVybNmyBTNnzlT5nSdMmICePXuW+p/R48eP8ejRI7z//vuoUaMGAMDDw6PU1xMREWkdA5rHSK0Wo6tXr0Imk6FDhw7FHvP29lYUNwDQsmVLyOVyXL9+XbGvfv36SuOKSnudl5cXjI2NFZ+dnZ0VXWUAcP78eXTt2hWurq4oX7482rZtCwBITU0FAPj4+MDDw0PRanTs2DFkZmaid+/eKr+zr6+v6n8o/1KhQgWEhoYiMDAQXbt2xfLly5GWllbi+TKZDI8fP1baZPkv1HomERERaYZahZG5ufl/fuDrBZA6/j3oWSKRQF44GOxVd5y1tTU2btyIs2fPYvfu3QBeDvB+JTg4WFEYbdq0CUFBQbC3t1crr5GREQRBUNr3+lgnAFi3bh3i4+PRokULbN26FbVr18bp06eLvX9kZCRsbGyUti92H1eZiYiI6J0yoK40tQqjWrVqwdzcHLGxsUWOeXh4ICkpCbm5uYp9J0+ehJGRkWKQdXHe9rrXXbt2Dffv38fChQvRunVr1K1bV6k16ZV+/frh8uXLOH/+PHbs2IHg4OBS3f91Dg4OSE9PVyqOEhMTi5zXsGFDhIeH49SpU6hXr16R8U2vhIeH49GjR0rb5B5t1M5FRERUZuRyzWw6QK3CyMzMDFOnTsWUKVMQExOD5ORknD59GlFRUQgODoaZmRlCQkJw+fJlHD16FGPHjsWAAQMU44SK87bXvc7V1RWmpqb45ptvcPPmTezduxfz588vcp6bmxtatGiBIUOGoKCgAN26dVPn6wMA/P39kZWVhcWLFyM5ORkrV67Ezz//rDh+69YthIeHIz4+Hrdv38Yvv/yCv/76q8RxRlKpFNbW1kqb1ITTSxEREYlB7bfSZs2ahU8//RSzZ8+Gh4cH+vTpg8zMTFhYWODQoUN48OABmjRpgg8//BAdOnTAihUrVN7vba97nYODA6Kjo7F9+3Z4enpi4cKF+PLLL4s9Nzg4GElJSejRo8dbdQ16eHjg22+/xcqVK+Ht7Y0zZ85g0qRJSt/n2rVr6NWrF2rXro3hw4fjk08+wYgRI9R+FhERkVYwoK40ifDvATMkumc7PhM7glr2jr0qdgS16No6OJ8Jt8SOoNfMjbRnkll9Vd3EVuwIakl58UjsCGqJv3u0zJ8hu3hII/eRNnjztDdiY58NERERqSQIfF2fiIiIyOCwxYiIiIhU05HxQZrAwoiIiIhU05FX7TWBXWlEREREhdhiRERERKqxK42IiIioEBeRJSIiIjI8bDEiIiIi1diVRkRERFSIb6URERERGR62GBEREZFq7EojIiIiKmRAXWksjIiIiEg1AyqMOMaIiIiIqBBbjLTQ3rFXxY6gFhc8FzuCWm5LzMSOoJb0pw/EjqCW+8+eiB1BLS7lK4odQW2W5czFjqCWbGOZ2BHUkp2fK3YErSMIhjPBIwsjIiIiUo1daURERESGhy1GREREpBpf1yciIiIqxK40IiIiIsPDFiMiIiJSjV1pRERERIXYlUZERERkeNhiRERERKqxK42IiIiokAF1pbEwIiIiItUMqDDiGCMiIiKiQmwxIiIiItU4xoiIiIioELvS9EdWVhZGjRoFV1dXSKVSODk5ITAwECdPnlQ6Lz4+HsbGxujSpUuRe6SkpEAikSi2ChUqoG3btvjtt9+Uznv69CnCw8NRo0YNmJmZwcHBAW3btsWPP/5Ypt+RiIiINEPvW4x69eqFvLw8rF+/Hu7u7sjIyEBsbCzu37+vdF5UVBTGjh2LqKgo/PPPP6hcuXKRex05cgReXl64d+8ePv/8c7z//vv4888/4ejoCAAYOXIkfv/9d3zzzTfw9PTE/fv3cerUqSLPIiIi0insStMP2dnZ+O233xAXF4e2bdsCAKpVq4amTZsqnZeTk4OtW7fi3LlzSE9PR3R0NKZPn17kfvb29nBycoKTkxOmT5+OLVu24Pfff0e3bt0AAHv37sXy5cvRuXNnAICbmxsaN25cxt+SiIiojLErTT9YWVnBysoKe/bsgUwmK/G8bdu2oW7duqhTpw769++PtWvXQhCEEs9/9uwZYmJiAACmpqaK/U5OTjhw4ACePHmiuS9BRERE74xeF0blypVDdHQ01q9fD1tbW7Rs2RLTp0/HxYsXlc6LiopC//79AQBBQUF49OgRjh07VuR+LVq0gJWVFSwtLfHll1+icePG6NChg+L4Dz/8gFOnTsHe3h5NmjTBxIkTi4xlIiIi0jmCXDObDtDrwgh4Ocbon3/+wd69exEUFIS4uDg0atQI0dHRAIDr16/jzJkz6Nu3L4CXxVSfPn0QFRVV5F5bt25FQkICdu7ciZo1ayI6OhomJiaK423atMHNmzcRGxuLDz/8EH/88Qdat26N+fPnl5hPJpPh8ePHSlu+UKDZfwhERET/hVyumU0HSARVfUZ6aujQoTh8+DBu376NKVOm4IsvvoCxsbHiuCAIkEqlSEtLg42NDVJSUlC9enUkJCTAx8cHALB9+3ZMnz4dly9fhlQqLfFZn332GebNm4ecnBylbrdX5syZg7lz5yrt62VZD73LN9DMl30HXPBc7AhquS0xEzuCWibknhc7glruP9OtrmSX8hXFjqA2y3LmYkdQi4upndgR1JIi060XZq5mninzZzzb8ZlG7mP+4UyN3Kcs6X2LUXE8PT2Rm5uLFy9eICYmBkuWLEFiYqJiS0pKQuXKlbF58+YS7/Hhhx+iXLly+Pbbb9/4rBcvXuD58+KLh/DwcDx69Ehp627l9Z++HxERkUYZUIuRXr+Vdv/+ffTu3RuDBw9GgwYNUL58eZw7dw6LFy/GBx98gJ9++gkPHz7EkCFDYGNjo3Rtr169EBUVhZEjRxZ7b4lEgnHjxmHOnDkYMWIELCws4O/vj759+8LX1xf29va4cuUKpk+fjnbt2sHa2rrY+0il0iItTiYS42LPJSIiEoUBdS7pdYuRlZUVmjVrhq+++gpt2rRBvXr1MGvWLAwbNgwrVqxAVFQUAgICihRFwMvC6Ny5c0UGar8uJCQE+fn5WLFiBQAgMDAQ69evx3vvvQcPDw+MHTsWgYGB2LZtW5l9RyIiojJnQC1GBjnGSNttdQ4WO4JaOMaobHGMUdniGKOyxzFGZeudjDHaHKGR+5j3nfvmk0Sm111pREREpAE60tqjCXrdlUZEREQaIOI8RitXroSbmxvMzMzQrFkznDmjuoVs2bJlqFOnDszNzeHi4oKJEyeW+AJUcVgYERERkVbaunUrwsLCEBERgQsXLsDb2xuBgYHIzMws9vxNmzZh2rRpiIiIwNWrVxEVFYWtW7cWu8xXSVgYERERkWoiDb5eunQphg0bhkGDBsHT0xOrVq2ChYUF1q5dW+z5p06dQsuWLdGvXz+4ubnhvffeQ9++fd/YyvQ6FkZERESkmiBoZlNDXl4ezp8/j4CAAMU+IyMjBAQEID4+vthrWrRogfPnzysKoZs3b+LAgQOKxd1Lg4OviYiI6J2QyWRFFnUvbj4/ALh37x4KCgrg6OiotN/R0RHXrl0r9v79+vXDvXv30KpVKwiCgBcvXmDkyJHsSiMiIiIN0lBXWmRkJGxsbJS2yMhIjcWMi4vDggUL8O233+LChQvYtWsX9u/fr3LN0n9jixERERGppqHX9cPDwxEWFqa0r6T1RitWrAhjY2NkZGQo7c/IyICTk1Ox18yaNQsDBgzA0KFDAQD169dHbm4uhg8fjhkzZsDI6M3tQWwxIiIiondCKpXC2tpaaSupMDI1NUXjxo0RGxur2CeXyxEbGws/P79ir3n69GmR4ufVIvGlnc+aLUZERESk2lvOQfRfhYWFISQkBL6+vmjatCmWLVuG3NxcDBo0CAAwcOBAVKlSRdEd17VrVyxduhQNGzZEs2bNcOPGDcyaNQtdu3ZVFEhvwsKIiIiIVBLk4qwe1qdPH2RlZWH27NlIT0+Hj48PDh48qBiQnZqaqtRCNHPmTEgkEsycORN3796Fg4MDunbtis8//7zUz+RaaVqIa6WVLa6VVra4VlrZ41ppZYtrpRX1dNV4jdzHYuRyjdynLHGMEREREVEhdqURERGRaiKNMRIDCyMiIiJSTaQxRmJgVxoRERFRIbYYaSFdq1Z1bTBz9w1txY6glrBeCWJHUItE7ABqcjHTvcHXPia6ldlB0K0fNXckD8WOoH00NMGjLtCtf1uJiIjo3TOgwkjXGieIiIiIygxbjIiIiEg1A5rykIURERERqWZAXWksjIiIiEg1vq5PREREZHjYYkRERESqceZrIiIiokLsSiMiIiIyPGwxIiIiIpUEvpVGREREVIhdaURERESGhy1GREREpJoBvZWmty1GoaGhkEgkGDlyZJFjn3zyCSQSCUJDQ5XO/fcWFBSkuMbNzU2x38LCAvXr18eaNWuK3Hv16tXw9vaGlZUVbG1t0bBhQ0RGRpbZ9yQiIipzckEzmw7Q28IIAFxcXLBlyxY8e/ZMse/58+fYtGkTXF1dlc4NCgpCWlqa0rZ582alc+bNm4e0tDRcvnwZ/fv3x7Bhw/Dzzz8rjq9duxYTJkzAuHHjkJiYiJMnT2LKlCnIyckp2y9KREREGqHXXWmNGjVCcnIydu3aheDgYADArl274OrqiurVqyudK5VK4eTkpPJ+5cuXV5wzdepULF68GIcPH0anTp0AAHv37sVHH32EIUOGKK7x8vLS5FciIiJ69wzorTS9bjECgMGDB2PdunWKz2vXrsWgQYP+0z3lcjl27tyJhw8fwtTUVLHfyckJp0+fxu3bt//T/YmIiLQKu9L0R//+/XHixAncvn0bt2/fxsmTJ9G/f/8i5/3000+wsrJS2hYsWKB0ztSpU2FlZQWpVIoPP/wQdnZ2GDp0qOJ4REQEbG1t4ebmhjp16iA0NBTbtm2D3IAqbSIi0kOCXDObDtDrrjQAcHBwQJcuXRAdHQ1BENClSxdUrFixyHnt2rXDd999p7SvQoUKSp8nT56M0NBQpKWlYfLkyRg9ejRq1qypOO7s7Iz4+HhcvnwZx48fx6lTpxASEoI1a9bg4MGDMDIqWofKZDLIZDKlfflCAUwkxv/laxMREdFb0PvCCHjZnTZmzBgAwMqVK4s9x9LSUqnIKU7FihVRs2ZN1KxZE9u3b0f9+vXh6+sLT09PpfPq1auHevXqYfTo0Rg5ciRat26NY8eOoV27dkXuGRkZiblz5yrt+9CyHj4q30Cdr0hERFR2dKQbTBP0visNePnGWV5eHvLz8xEYGKiRe7q4uKBPnz4IDw9Xed6roik3N7fY4+Hh4Xj06JHS1sOKA7aJiEh7CHK5RjZdYBAtRsbGxrh69ariz8WRyWRIT09X2leuXLliu91eGT9+POrVq4dz587B19cXo0aNQuXKldG+fXtUrVoVaWlp+Oyzz+Dg4AA/P79i7yGVSiGVSpX2sRuNiIhIHAbRYgQA1tbWsLa2LvH4wYMH4ezsrLS1atVK5T09PT3x3nvvYfbs2QCAgIAAnD59Gr1790bt2rXRq1cvmJmZITY2Fvb29hr9PkRERO+MAb2VJhEEQTeSGpDtzsFiR1DLC4nYCdTTfUNbsSOoxb3XMrEjqOXe00diR1CLn0NdsSOozcek5JZsbeQg6FbnxNbnyWJHUMvljNNl/oycyT00ch+rL3Zr5D5lyWBajIiIiIjeRLfKeCIiInr3dGQOIk1gYURERESq6cj4IE1gVxoRERFRIbYYERERkUqCAbUYsTAiIiIi1VgYERERERXSkVmrNYFjjIiIiIgKscWIiIiIVGNXGhEREVEhAyqM2JVGREREVIgtRkRERKSSIS2rysKIiIiIVGNXGhEREZHhYYsRERERqWZALUYsjIiIiEglLglCovpMuCV2BLWkP30gdgS1hPVKEDuCWlKv7xY7glouN5kidgS1JOdbiR1BbUvy/xE7glquP/5b7AhqcbF0EDsCiYiFEREREanGFiMiIiKiQoazVBoLIyIiIlLNkMYY8XV9IiIiokJsMSIiIiLVDKjFiIURERERqWZAY4zYlUZERERUiC1GREREpJIhDb5mYURERESqsSuNiIiIyPCwxYiIiIhUYlcaERER0SvsSqPSCA0NRffu3cWOQURERBpisIXR60WNv78/JkyYIGoeIiIibSXINbPpAnalERERkWo6UtRogsG2GL0SGhqKY8eOYfny5ZBIJJBIJEhJSUFBQQGGDBmC6tWrw9zcHHXq1MHy5ctLvE9MTAzs7e0hk8mU9nfv3h0DBgwo669BRERUZsRsMVq5ciXc3NxgZmaGZs2a4cyZMyrPz87OxieffAJnZ2dIpVLUrl0bBw4cKPXzDL4wWr58Ofz8/DBs2DCkpaUhLS0NLi4ukMvlqFq1KrZv344rV65g9uzZmD59OrZt21bsfXr37o2CggLs3btXsS8zMxP79+/H4MGD39XXISIi0htbt25FWFgYIiIicOHCBXh7eyMwMBCZmZnFnp+Xl4eOHTsiJSUFO3bswPXr17F69WpUqVKl1M80+K40GxsbmJqawsLCAk5OTor9xsbGmDt3ruJz9erVER8fj23btuGjjz4qch9zc3P069cP69atQ+/evQEA//vf/+Dq6gp/f/8y/x5ERERlRqSutKVLl2LYsGEYNGgQAGDVqlXYv38/1q5di2nTphU5f+3atXjw4AFOnToFExMTAICbm5tazzT4FiNVVq5cicaNG8PBwQFWVlb44YcfkJqaWuL5w4YNwy+//IK7d+8CAKKjoxEaGgqJRFLiNTKZDI8fP1ba5LoyQo2IiAyCGF1peXl5OH/+PAICAhT7jIyMEBAQgPj4+GKv2bt3L/z8/PDJJ5/A0dER9erVw4IFC1BQUFDq57IwKsGWLVswadIkDBkyBL/88gsSExMxaNAg5OXllXhNw4YN4e3tjZiYGJw/fx5//PEHQkNDVT4nMjISNjY2Sltm7l0NfxsiIiLxFdcY8O+xua/cu3cPBQUFcHR0VNrv6OiI9PT0Yq+5efMmduzYgYKCAhw4cACzZs3CkiVL8Nlnn5U6IwsjAKampkWqyZMnT6JFixYYPXo0GjZsiJo1ayI5OfmN9xo6dCiio6Oxbt06BAQEwMXFReX54eHhePTokdJWybL0faFERERlTVMtRsU1BkRGRmosp1wuR6VKlfDDDz+gcePG6NOnD2bMmIFVq1aV+h4GP8YIeNn/+PvvvyMlJQVWVlaoUKECatWqhZiYGBw6dAjVq1fHhg0bcPbsWVSvXl3lvfr164dJkyZh9erViImJeeOzpVIppFKp0j4jCetVIiLSHpoa4REeHo6wsDClff/+GfhKxYoVYWxsjIyMDKX9GRkZSmOCX+fs7AwTExMYGxsr9nl4eCA9PR15eXkwNTV9Y0b+BAYwadIkGBsbw9PTEw4ODkhNTcWIESPQs2dP9OnTB82aNcP9+/cxevToN97LxsYGvXr1gpWVFWfFJiIieo1UKoW1tbXSVlJhZGpqisaNGyM2NlaxTy6XIzY2Fn5+fsVe07JlS9y4cQNy+f9Xcn/++SecnZ1LVRQBgEQQBMNZGe4d6dChA7y8vPD111+/1fXeTi00nKhspT97IHYEtehai1zq9d1iR1DL5SZTxI6gluR8K7EjqG2J0T9iR1DL9cd/ix1BLS6WDmJHUEtS+qkyf0aGht6udoyLU+v8rVu3IiQkBN9//z2aNm2KZcuWYdu2bbh27RocHR0xcOBAVKlSRdEdd+fOHXh5eSEkJARjx47FX3/9hcGDB2PcuHGYMWNGqZ7JrjQNevjwIeLi4hAXF4dvv/1W7DhEREQaIdbL0n369EFWVhZmz56N9PR0+Pj44ODBg4oB2ampqTAy+v9fdl1cXHDo0CFMnDgRDRo0QJUqVTB+/HhMnTq11M9kYaRBDRs2xMOHD7Fo0SLUqVNH7DhEREQ6b8yYMRgzZkyxx+KKaYHy8/PD6dOn3/p5LIw0KCUlRewIREREGifIS56PT9+wMCIiIiKVDGneYRZGREREpJIgGE6LkW69nkNERERUhthiRERERCqxK42IiIiokCENvmZXGhEREVEhthgRERGRSoa0RgYLIyIiIlKJXWlEREREBogtRkRERKSSIbUYsTAiIiIilQxpjBG70oiIiIgKscWIiIiIVGJXGpEa7j97InYEtejaf96Xm0wRO4Ja6n7bVuwIavl91AWxI6jtbu49sSOoxcXSQewIaknJyRA7gtYxpLXSWBgRERGRSoa0JAjHGBEREREVYosRERERqSRnVxoRERHRS4Y0xohdaURERESF2GJEREREKvF1fSIiIqJCnPmaiIiIyACxxYiIiIhUYlcaERERUSFDel2fXWlEREREhdhiRERERCpxHiMqlTlz5sDHx0fsGERERGVKEDSz6QK9LYyysrIwatQouLq6QiqVwsnJCYGBgTh58qTGnjFp0iTExsZq7H5ERETaSC5INLLpAr3tSuvVqxfy8vKwfv16uLu7IyMjA7Gxsbh//77GnmFlZQUrKyuN3Y+IiIjEpZctRtnZ2fjtt9+waNEitGvXDtWqVUPTpk0RHh6Obt26AQAkEgm+++47dOrUCebm5nB3d8eOHTuU7jN16lTUrl0bFhYWcHd3x6xZs5Cfn684/u+utNDQUHTv3h1ffvklnJ2dYW9vj08++UTpGiIiIl0jCBKNbLpALwujVy05e/bsgUwmK/G8WbNmoVevXkhKSkJwcDA+/vhjXL16VXG8fPnyiI6OxpUrV7B8+XKsXr0aX331lcpnHz16FMnJyTh69CjWr1+P6OhoREdHa+qrERERvXMcY6TjypUrh+joaKxfvx62trZo2bIlpk+fjosXLyqd17t3bwwdOhS1a9fG/Pnz4evri2+++UZxfObMmWjRogXc3NzQtWtXTJo0Cdu2bVP5bDs7O6xYsQJ169bF+++/jy5dunAcEhERkY7Qy8IIeDnG6J9//sHevXsRFBSEuLg4NGrUSKn1xs/PT+kaPz8/pRajrVu3omXLlnBycoKVlRVmzpyJ1NRUlc/18vKCsbGx4rOzszMyMzNLPF8mk+Hx48dKm1yQq/ltiYiIyo4hDb7W28IIAMzMzNCxY0fMmjULp06dQmhoKCIiIkp1bXx8PIKDg9G5c2f89NNPSEhIwIwZM5CXl6fyOhMTE6XPEokEcnnJhU5kZCRsbGyUtszcu6XKSERE9C5wjJGe8vT0RG5uruLz6dOnlY6fPn0aHh4eAIBTp06hWrVqmDFjBnx9fVGrVi3cvn1b45nCw8Px6NEjpa2SZRWNP4eIiIjeTC9f179//z569+6NwYMHo0GDBihfvjzOnTuHxYsX44MPPlCct337dvj6+qJVq1bYuHEjzpw5g6ioKABArVq1kJqaii1btqBJkybYv38/du/erfGsUqkUUqlUaZ+RxKDqVSIi0nK60g2mCXpZGFlZWaFZs2b46quvkJycjPz8fLi4uGDYsGGYPn264ry5c+diy5YtGD16NJydnbF582Z4enoCALp164aJEydizJgxkMlk6NKlC2bNmoU5c+aI9K2IiIjEoSMvlGmERBB05QU6zZJIJNi9eze6d+8udpQivJ1aiB1BLX880HwXY1nStd97zjj5ih1BLXW/bSt2BLWsH3VB7AhqW5CbJHYEtdiZlhc7glpScjLEjqCWRznJZf6M05V7auQ+zf/ZpZH7lCW9bDEiIiIizWFXGhEREVEhXXmjTBMMtjAy0B5EIiIitRnS7Hp8/YmIiIiokMG2GBEREVHpCDr32srbY2FEREREKskNaPQJu9KIiIiICrHFiIiIiFSSsyuNiIiI6CVDGmPErjQiIiKiQmwxIiIiIpUMaR4jFkZERESkErvSiIiIiAwQW4yIiIhIJXalERERERViYURERERUyJDGGLEw0kLmRqZiR1CLS/mKYkdQi4uZbuVNzrcSO4Jafh91QewIavm4xV2xI6htx6nKYkdQi5GO/VBNQYbYEUhELIyIiIhIJblu1bb/CQsjIiIiUsmQlgTh6/pEREREhdhiRERERCoJYgd4h1gYERERkUqG9Lo+u9KIiIiICrEwIiIiIpXkEolGtrexcuVKuLm5wczMDM2aNcOZM2dKdd2WLVsgkUjQvXt3tZ7HwoiIiIhUEjS0qWvr1q0ICwtDREQELly4AG9vbwQGBiIzM1PldSkpKZg0aRJat26t9jNZGBEREZFWWrp0KYYNG4ZBgwbB09MTq1atgoWFBdauXVviNQUFBQgODsbcuXPh7u6u9jNZGBEREZFKcg1tMpkMjx8/VtpkMlmxz8zLy8P58+cREBCg2GdkZISAgADEx8eXmHXevHmoVKkShgwZ8lbflYURERERqSSXaGaLjIyEjY2N0hYZGVnsM+/du4eCggI4Ojoq7Xd0dER6enqx15w4cQJRUVFYvXr1W39Xvq5PREREKmlq5uvw8HCEhYUp7ZNKpRq595MnTzBgwACsXr0aFSu+/ZqYLIyIiIjonZBKpaUuhCpWrAhjY2NkZCgv6puRkQEnJ6ci5ycnJyMlJQVdu3ZV7JPLX87AVK5cOVy/fh01atR443N1ristNDQUEomkyBYUFCR2NCIiIr0kxltppqamaNy4MWJjYxX75HI5YmNj4efnV+T8unXr4tKlS0hMTFRs3bp1Q7t27ZCYmAgXF5dSPVcnW4yCgoKwbt06pX1v2xQnCAIKCgpQrpxO/qMgIiIqc3KR1pANCwtDSEgIfH190bRpUyxbtgy5ubkYNGgQAGDgwIGoUqUKIiMjYWZmhnr16ildb2trCwBF9quicy1GwMsiyMnJSWmzs7NDSkoKJBIJEhMTFedmZ2dDIpEgLi4OABAXFweJRIKff/4ZjRs3hlQqxYkTJyCTyTBu3DhUqlQJZmZmaNWqFc6ePau4z6vr9u/fjwYNGsDMzAzNmzfH5cuXlbKdOHECrVu3hrm5OVxcXDBu3Djk5ua+i38sREREeqVPnz748ssvMXv2bPj4+CAxMREHDx5UDMhOTU1FWlqaRp+pk4WRJkybNg0LFy7E1atX0aBBA0yZMgU7d+7E+vXrceHCBdSsWROBgYF48OCB0nWTJ0/GkiVLcPbsWTg4OKBr167Iz88H8LJ/MygoCL169cLFixexdetWnDhxAmPGjBHjKxIREWmEpl7XfxtjxozB7du3IZPJ8Pvvv6NZs2aKY3FxcYiOji7x2ujoaOzZs0et5+lkYfTTTz/ByspKaVuwYIFa95g3bx46duyIGjVqQCqV4rvvvsMXX3yBTp06wdPTE6tXr4a5uTmioqKUrouIiEDHjh1Rv359rF+/HhkZGdi9ezeAl68hBgcHY8KECahVqxZatGiBr7/+GjExMXj+/LnGvj8REdG7JNbM12LQyYE17dq1w3fffae0r0KFCnj8+HGp7+Hr66v4c3JyMvLz89GyZUvFPhMTEzRt2hRXr15Vuu71AV8VKlRAnTp1FOckJSXh4sWL2Lhxo+IcQRAgl8tx69YteHh4FMkhk8mKTG4lF+QwkuhkzUpERKTTdLIwsrS0RM2aNYvsz8nJAfCyGHnlVTdXcffQtJycHIwYMQLjxo0rcszV1bXYayIjIzF37lylfVWsqqFqeTeN5yMiInobYg2+FoNeNUs4ODgAgNJArNcHYpekRo0aMDU1xcmTJxX78vPzcfbsWXh6eiqde/r0acWfHz58iD///FPREtSoUSNcuXIFNWvWLLKZmpoW++zw8HA8evRIaatsVXwRRUREJAYxxxi9azrZYiSTyYpMB16uXDlUrFgRzZs3x8KFC1G9enVkZmZi5syZb7yfpaUlRo0ahcmTJ6NChQpwdXXF4sWL8fTp0yJrrcybNw/29vZwdHTEjBkzULFiRXTv3h0AMHXqVDRv3hxjxozB0KFDYWlpiStXruDw4cNYsWJFsc8ubrIrdqMRERGJQycLo4MHD8LZ2VlpX506dXDt2jWsXbsWQ4YMQePGjVGnTh0sXrwY77333hvvuXDhQsjlcgwYMABPnjyBr68vDh06BDs7uyLnjR8/Hn/99Rd8fHywb98+RWtQgwYNcOzYMcyYMQOtW7eGIAioUaMG+vTpo7kvT0RE9I7pSmuPJkiE1wfkUIni4uLQrl07PHz4UDFhVFlpXtm/TO+vaRmyh2JHUIuL2duvoSOGcfKiU99rs3vldGswwsct7oodQW0fniq+a15bGWlona135feHf4kdQS2PcpLL/BmrXPpr5D4j7/xPI/cpSzrZYkRERETvjiG1GHEwCxEREVEhthiVkr+/P9jrSEREhsiQWoxYGBEREZFKhtQswK40IiIiokJsMSIiIiKVDGnmaxZGREREpJIhjTFiVxoRERFRIbYYERERkUqG1GLEwoiIiIhU4ltpRERERAaILUZERESkEt9KIyIiIirEMUZEREREhTjGiIiIiMgAscWIiIiIVJIbUJsRCyP6zyzLmYsdQS0+JhXFjqCWJfn/iB1BLXdz74kdQS07TlUWO4Lafk74TuwIaskZMVjsCGp5luYqdgStY0hjjNiVRkRERFSILUZERESkkuF0pLEwIiIiojdgVxoRERGRAWKLEREREanEma+JiIiIChnS6/rsSiMiIiIqxBYjIiIiUslw2otYGBEREdEbGNJbaSyMiIiISCWOMSIiIiIyQGwxIiIiIpUMp72ILUYaJ5FIsGfPHrFjEBERaYxcQ5suYGFEREREVIhdaURERKQSB1/rKLlcjsWLF6NmzZqQSqVwdXXF559/DgC4dOkS2rdvD3Nzc9jb22P48OHIyclRXOvv748JEyYo3a979+4IDQ1VfE5LS0OXLl1gbm6O6tWrY9OmTXBzc8OyZcuUrrt37x569OgBCwsL1KpVC3v37i2rr0xERFTmBA1tukCvCqPw8HAsXLgQs2bNwpUrV7Bp0yY4OjoiNzcXgYGBsLOzw9mzZ7F9+3YcOXIEY8aMUev+AwcOxD///IO4uDjs3LkTP/zwAzIzM4ucN3fuXHz00Ue4ePEiOnfujODgYDx48EBTX5OIiIjKiN50pT158gTLly/HihUrEBISAgCoUaMGWrVqhdWrV+P58+eIiYmBpaUlAGDFihXo2rUrFi1aBEdHxzfe/9q1azhy5AjOnj0LX19fAMCaNWtQq1atIueGhoaib9++AIAFCxbg66+/xpkzZxAUFKSpr0tERPTO6MrAaU3Qm8Lo6tWrkMlk6NChQ7HHvL29FUURALRs2RJyuRzXr18vVWF0/fp1lCtXDo0aNVLsq1mzJuzs7Iqc26BBA8WfLS0tYW1tXWzLEgDIZDLIZDKlfXJBDiOJXjXmERGRDhN0piPsv9Obn77m5ub/6XojIyMIgvL/8fn5+W91LxMTE6XPEokEcnnx9XZkZCRsbGyUtn9yUt/quURERPTf6E1hVKtWLZibmyM2NrbIMQ8PDyQlJSE3N1ex7+TJkzAyMkKdOnUAAA4ODkhLS1McLygowOXLlxWf69SpgxcvXiAhIUGx78aNG3j48OF/yh0eHo5Hjx4pbZWtXP/TPYmIiDSJ8xjpIDMzM0ydOhVTpkxBTEwMkpOTcfr0aURFRSE4OBhmZmYICQnB5cuXcfToUYwdOxYDBgxQdKO1b98e+/fvx/79+3Ht2jWMGjUK2dnZivvXrVsXAQEBGD58OM6cOYOEhAQMHz4c5ubmkEgkb51bKpXC2tpaaWM3GhERaRM5BI1sukBvxhgBwKxZs1CuXDnMnj0b//zzD5ydnTFy5EhYWFjg0KFDGD9+PJo0aQILCwv06tULS5cuVVw7ePBgJCUlYeDAgShXrhwmTpyIdu3aKd0/JiYGQ4YMQZs2beDk5ITIyEj88ccfMDMze9dflYiI6J3RjZJGMyTCvwfWUKn9/fffcHFxwZEjR4od9P22mlf219i93oWcgudiR1BLe/NqYkdQy9n84gfua6u7z+6JHUEttS0rix1BbT8nfCd2BLXkjBgsdgS1PEt7+14AMVQ+dbTMnzHK7SON3Oe7lG0auU9Z0qsWo7L266+/IicnB/Xr10daWhqmTJkCNzc3tGnTRuxoREREZUZXusE0gYWRGvLz8zF9+nTcvHkT5cuXR4sWLbBx48Yib6ERERHpE10ZOK0JLIzUEBgYiMDAQLFjEBERURlhYUREREQqGdIEjyyMiIiISCVD6krjhDlEREREhdhiRERERCqxK42IiIioELvSiIiIiAwQW4yIiIhIJbkBLZLBwoiIiIhUMpyyiIURERERvYEhLQnCMUZEREREhVgYERERkUqChv73NlauXAk3NzeYmZmhWbNmOHPmTInnrl69Gq1bt4adnR3s7OwQEBCg8vzisDAiIiIileQa2tS1detWhIWFISIiAhcuXIC3tzcCAwORmZlZ7PlxcXHo27cvjh49ivj4eLi4uOC9997D3bt3S/1MFkZERESklZYuXYphw4Zh0KBB8PT0xKpVq2BhYYG1a9cWe/7GjRsxevRo+Pj4oG7dulizZg3kcjliY2NL/UwOvtZC1U1sxY6glmxjmdgR1OIg6Na/9tcf/y12BLW4WDqIHUEtRpCIHUFtOSMGix1BLRYR4WJHUMupjtFiR1BL5XfwDE0NvpbJZJDJlH9mSKVSSKXSIufm5eXh/PnzCA///39/jIyMEBAQgPj4+FI97+nTp8jPz0eFChVKnZEtRkRERKSSpsYYRUZGwsbGRmmLjIws9pn37t1DQUEBHB0dlfY7OjoiPT29VLmnTp2KypUrIyAgoNTfVbd+dSYiIiKdFR4ejrCwMKV9xbUWacLChQuxZcsWxMXFwczMrNTXsTAiIiIilTS1VlpJ3WbFqVixIoyNjZGRkaG0PyMjA05OTiqv/fLLL7Fw4UIcOXIEDRo0UCsju9KIiIhIJUEQNLKpw9TUFI0bN1YaOP1qILWfn1+J1y1evBjz58/HwYMH4evrq/Z3ZYsRERERaaWwsDCEhITA19cXTZs2xbJly5Cbm4tBgwYBAAYOHIgqVaooxiktWrQIs2fPxqZNm+Dm5qYYi2RlZQUrK6tSPZOFEREREakk1pIgffr0QVZWFmbPno309HT4+Pjg4MGDigHZqampMDL6/86v7777Dnl5efjwww+V7hMREYE5c+aU6pksjIiIiEglTY0xehtjxozBmDFjij0WFxen9DklJeU/P4+FEREREan0tst56CIOviYiIiIqxBYjIiIiUkmsMUZiYGFEREREKqn7qr0uY1caERERUSG2GBEREZFKYr6V9q4ZRIuRIAgYPnw4KlSoAIlEgsTERLEjERER6QxNLSKrCwyixejgwYOIjo5GXFwc3N3dUbFiRbEjERERkRYyiMIoOTkZzs7OaNGihWgZ8vLyYGpqKtrziYiI3pYhvZWm911poaGhGDt2LFJTUyGRSODm5ga5XI7IyEhUr14d5ubm8Pb2xo4dOwC8XKCuatWq+O6775Tuk5CQACMjI9y+fRsAkJ2djaFDh8LBwQHW1tZo3749kpKSFOfPmTMHPj4+WLNmDapXrw4zM7N396WJiIg0SIxFZMWi94XR8uXLMW/ePFStWhVpaWk4e/YsIiMjERMTg1WrVuGPP/7AxIkT0b9/fxw7dgxGRkbo27cvNm3apHSfjRs3omXLlqhWrRoAoHfv3sjMzMTPP/+M8+fPo1GjRujQoQMePHiguObGjRvYuXMndu3axXFNREREOkDvu9JsbGxQvnx5GBsbw8nJCTKZDAsWLMCRI0fg5+cHAHB3d8eJEyfw/fffo23btggODsaSJUuQmpoKV1dXyOVybNmyBTNnzgQAnDhxAmfOnEFmZiakUikA4Msvv8SePXuwY8cODB8+HMDL7rOYmBg4ODiUmE8mk0EmkyntKxAKYCwxLot/HERERGpjV5oeu3HjBp4+fYqOHTvCyspKscXExCA5ORkA4OPjAw8PD0Wr0bFjx5CZmYnevXsDAJKSkpCTkwN7e3ule9y6dUtxDwCoVq2ayqIIACIjI2FjY6O0XXn0Vxl9eyIiIvXxrTQ9lpOTAwDYv38/qlSponTsVesPAAQHB2PTpk2YNm0aNm3ahKCgINjb2yvu4ezsXGRVXwCwtbVV/NnS0vKNecLDwxEWFqa0b2i94NJ+HSIiojIn15HxQZpgcIWRp6cnpFIpUlNT0bZt2xLP69evH2bOnInz589jx44dWLVqleJYo0aNkJ6ejnLlysHNze0/5ZFKpUoFGQB2oxEREYnE4Aqj8uXLY9KkSZg4cSLkcjlatWqFR48e4eTJk7C2tkZISAgAwM3NDS1atMCQIUNQUFCAbt26Ke4REBAAPz8/dO/eHYsXL0bt2rXxzz//YP/+/ejRowd8fX3F+npEREQaZzjtRQZYGAHA/Pnz4eDggMjISNy8eRO2trZo1KgRpk+frnRecHAwRo8ejYEDB8Lc3FyxXyKR4MCBA5gxYwYGDRqErKwsODk5oU2bNnB0dHzXX4eIiKhMGdLga4mgKxMLGJC+1bqLHUEt2XLZm0/SIi2MKogdQS1fPTgjdgS1uFiqfuFA2ziaWIsdQW1bmz4XO4JaLCLCxY6gliMdo8WOoJYuGZvL/Bktq7TXyH1O3v1VI/cpSwbZYkRERESlZ0gtRiyMiIiISCVD6lwyuHmMiIiIiErCFiMiIiJSiV1pRERERIV0ZdZqTWBhRERERCpxjBERERGRAWKLEREREanEMUZEREREhdiVRkRERGSA2GJEREREKrErjYiIiKiQIb2uz640IiIiokJsMSIiIiKV5AY0+JqFEREREalkSF1pLIy0UMqLR2JHUEt2fq7YEdRyR/JQ7AhqcbF0EDuCWlJyMsSOoJYU6FZeAHiW5ip2BLWc6hgtdgS1dDw3TewIJCIWRkRERKQSu9KIiIiICrErjYiIiKiQIbUY8XV9IiIiokJsMSIiIiKV2JVGREREVIhdaUREREQGiC1GREREpBK70oiIiIgKCYJc7AjvDLvSiIiIiAqxxYiIiIhUkrMrjYiIiOglgW+lERERERkevS2M4uLiIJFIkJ2dLXYUIiIinSaHoJFNF+hNYeTv748JEyaIHUPBzc0Ny5YtEzsGERHRfyYIgkY2XcAxRq/Jy8uDqamp2DGIiIi0Cme+1jGhoaE4duwYli9fDolEAolEgpSUFADA+fPn4evrCwsLC7Ro0QLXr19XXDdnzhz4+PhgzZo1qF69OszMzAAAqamp+OCDD2BlZQVra2t89NFHyMjIUFyXnJyMDz74AI6OjrCyskKTJk1w5MgRxXF/f3/cvn0bEydOVOQhIiIi7acXhdHy5cvh5+eHYcOGIS0tDWlpaXBxcQEAzJgxA0uWLMG5c+dQrlw5DB48WOnaGzduYOfOndi1axcSExMhl8vxwQcf4MGDBzh27BgOHz6Mmzdvok+fPoprcnJy0LlzZ8TGxiIhIQFBQUHo2rUrUlNTAQC7du1C1apVMW/ePEUeIiIiXSVo6H+6QC+60mxsbGBqagoLCws4OTkBAK5duwYA+Pzzz9G2bVsAwLRp09ClSxc8f/5c0TqUl5eHmJgYODg4AAAOHz6MS5cu4datW4riKiYmBl5eXjh79iyaNGkCb29veHt7K54/f/587N69G3v37sWYMWNQoUIFGBsbo3z58oo8JZHJZJDJZEr75IIcRhK9qFmJiEgP6Mr4IE3Q+5++DRo0UPzZ2dkZAJCZmanYV61aNUVRBABXr16Fi4uLoigCAE9PT9ja2uLq1asAXrYYTZo0CR4eHrC1tYWVlRWuXr2qaDFSR2RkJGxsbJS2u09uq30fIiIi+u/0vjAyMTFR/PnVWB+5/P/XfLG0tFT7npMmTcLu3buxYMEC/Pbbb0hMTET9+vWRl5en9r3Cw8Px6NEjpa1K+Wpq34eIiKisGNLr+nrRlQYApqamKCgo+M/38fDwwJ07d3Dnzh1Fq9GVK1eQnZ0NT09PAMDJkycRGhqKHj16AHjZgvRqsLe6eaRSKaRSqdI+dqMREZE2YVeaDnJzc8Pvv/+OlJQU3Lt3T6lVSB0BAQGoX78+goODceHCBZw5cwYDBw5E27Zt4evrCwCoVauWYrB2UlIS+vXrV+R5bm5uOH78OO7evYt79+795+9HREREZU9vCqNJkybB2NgYnp6ecHBweKvxPsDL7rYff/wRdnZ2aNOmDQICAuDu7o6tW7cqzlm6dCns7OzQokULdO3aFYGBgWjUqJHSfebNm4eUlBTUqFFDaQwTERGRrpELgkY2XSARDKl9TEf4VWkndgS1ZOfnih1BLcY61lWpa3lTcjLefBL9J1cbuIodQS0JyarfztU2Hc9NEzuCWkxdvN980n9kZ1VTI/d5mHNDI/cpS7r1Ny4RERFRGdKbwddERERUNnTljTJNYIsRERERqSTmIrIrV66Em5sbzMzM0KxZM5w5c0bl+du3b0fdunVhZmaG+vXr48CBA2o9j4URERERqSTW4OutW7ciLCwMERERuHDhAry9vREYGKg0UfPrTp06hb59+2LIkCFISEhA9+7d0b17d1y+fLnUz+Tgay3EwddlS9cGM+taXg6+LnscfF22OPi6KCuL6hq5T87TW2qd36xZMzRp0gQrVqwA8HKCZhcXF4wdOxbTphX9/6lPnz7Izc3FTz/9pNjXvHlz+Pj4YNWqVaV6pm79jUtERETvnKYWkZXJZHj8+LHS9u/1Ql/Jy8vD+fPnERAQoNhnZGSEgIAAxMfHF3tNfHy80vkAEBgYWOL5xWFhRERERCppqiutuPVBIyMji33mvXv3UFBQAEdHR6X9jo6OSE9PL/aa9PR0tc4vDt9KIyIionciPDwcYWFhSvv+vSyW2FgYERERkUqaGo5c3PqgJalYsSKMjY2RkaE8bjEjIwNOTsWPW3NyclLr/OKwK42IiIhU0tQYI3WYmpqicePGiI2NVeyTy+WIjY2Fn59fsdf4+fkpnQ8Ahw8fLvH84rDFiIiIiLRSWFgYQkJC4Ovri6ZNm2LZsmXIzc3FoEGDAAADBw5ElSpVFOOUxo8fj7Zt22LJkiXo0qULtmzZgnPnzuGHH34o9TNZGBEREZFKYs3s06dPH2RlZWH27NlIT0+Hj48PDh48qBhgnZqaCiOj/+/8atGiBTZt2oSZM2di+vTpqFWrFvbs2YN69eqV+pmcx0gLcR6jsqVr8wLpWl7OY1T2OI9R2eI8RkWZmFbRyH3y8+5q5D5lSbf+xiUiIiIqQ+xKIyIiIpUMqmtJIIPw/PlzISIiQnj+/LnYUUqFecsW85YtXcsrCLqXmXmprHCMkYF4/PgxbGxs8OjRI1hbW4sd542Yt2wxb9nStbyA7mVmXiorHGNEREREVIiFEREREVEhFkZEREREhVgYGQipVIqIiAitW6yvJMxbtpi3bOlaXkD3MjMvlRUOviYiIiIqxBYjIiIiokIsjIiIiIgKsTAiIiIiKsTCiIiIiKgQCyMiIiKiQlxEVo/duXMHEokEVatWBQCcOXMGmzZtgqenJ4YPHy5yujd78eIFnj9/DisrK7GjEOml7OxsnDlzBpmZmZDL5UrHBg4cKFKqovLz82Fubo7ExETUq1dP7DilYmxsjLS0NFSqVElp//3791GpUiUUFBSIlIzehIWRHuvXrx+GDx+OAQMGID09HR07doSXlxc2btyI9PR0zJ49W+yIAIB9+/bh/v37CA0NVez7/PPPMX/+fLx48QLt27fH1q1bYWdnJ17IUjp27Bhyc3Ph5+enlXlDQkIwZMgQtGnTRuwob1RQUIDo6GjExsYW+4P7119/FSnZm+Xl5eHWrVuoUaMGypXTzr9m9+3bh+DgYOTk5MDa2hoSiURxTCKRaFVhZGJiAldXV50qJkqaCUcmk8HU1PQdpyF1aOd/saQRly9fRtOmTQEA27ZtQ7169XDy5En88ssvGDlypNYURkuXLsWHH36o+Hzq1CnMnj0b8+bNg4eHB2bMmIH58+dj6dKlIqZUtmjRIuTk5GD+/PkAXv4l2KlTJ/zyyy8AgEqVKiE2NhZeXl5ixizi0aNHCAgIQLVq1TBo0CCEhISgSpUqYscq1vjx4xEdHY0uXbqgXr16Sj+4tdXTp08xduxYrF+/HgDw559/wt3dHWPHjkWVKlUwbdo0kRP+v08//RSDBw/GggULYGFhIXacN5oxYwamT5+ODRs2oEKFCmLHKdHXX38N4GVxuWbNGqUW74KCAhw/fhx169YVKx6VhkB6y9LSUrh165YgCILQtWtXYeHChYIgCMLt27cFMzMzEZMpc3BwEC5cuKD4PHHiRCEwMFDxef/+/ULNmjXFiFaihg0bClu2bFF83rZtm2Bubi6cOHFCuH//vtClSxehd+/eIiYsWWZmprBkyRKhQYMGQrly5YSgoCBh+/btQl5entjRlNjb2wv79+8XO4Zaxo0bJzRu3Fj47bffBEtLSyE5OVkQBEHYs2eP4OPjI3I6ZRYWFop8usDHx0ewsrISpFKpULt2baFhw4ZKm7Zwc3MT3NzcBIlEIri4uCg+u7m5CbVr1xbee+894fTp02LHJBXYYqTHvLy8sGrVKnTp0gWHDx9WtG78888/sLe3Fznd/3vy5IlSnhMnTqB3796Kz15eXvjnn3/EiFaiW7duoUGDBorPBw4cwIcffoiWLVsCAGbOnKn0HbSJg4MDwsLCEBYWhgsXLmDdunUYMGAArKys0L9/f4wePRq1atUSOyZMTU1Rs2ZNsWOoZc+ePdi6dSuaN2+u1MLl5eWF5ORkEZMVFRgYiHPnzsHd3V3sKKXSvXt3sSOUyq1btwAA7dq1w65du7SyS51UY2GkxxYtWoQePXrgiy++QEhICLy9vQEAe/fuVXSxaYMqVarg6tWrcHV1RU5ODpKSkvDVV18pjt+/f1/rmvpfvHihtOZRfHw8JkyYoPhcuXJl3Lt3T4RkpZeWlobDhw/j8OHDMDY2RufOnXHp0iV4enpi8eLFmDhxoqj5Pv30UyxfvhwrVqzQiW40AMjKyioy2BYAcnNzteI77N27V/HnLl26YPLkybhy5Qrq168PExMTpXO7dev2ruOpFBERIXYEtRw9elTsCPSWWBjpMX9/f9y7dw+PHz9W+q1l+PDhWlVo9O7dGxMmTMD06dNx4MABODk5oXnz5orj586dQ506dURMWFSNGjVw/PhxuLu7IzU1FX/++afSgOa///5bq1rlXsnPz8fevXuxbt06/PLLL2jQoAEmTJiAfv36wdraGgCwe/duDB48WPTC6MSJEzh69Ch+/vlneHl5FfnBvWvXLpGSlczX1xf79+/H2LFjAUBRDK1ZswZ+fn5iRgNQfKvLvHnziuyTSCRaOdA5OzsbO3bsQHJyMiZPnowKFSrgwoULcHR01Mqxcn///Tf27t2L1NRU5OXlKR3TpjGTpIyFkZ4zNjYu0pTr5uYmTpgSzJ49G3fv3sW4cePg5OSE//3vfzA2NlYc37x5M7p27SpiwqI++eQTjBkzBr/99htOnz4NPz8/eHp6Ko7/+uuvaNiwoYgJi+fs7Ay5XI6+ffvizJkz8PHxKXJOu3btYGtr+86z/ZutrS169Oghdgy1LFiwAJ06dcKVK1fw4sULLF++HFeuXMGpU6dw7NgxseMVebNPl1y8eBEBAQGwsbFBSkoKhg0bhgoVKmDXrl1ITU1FTEyM2BGVxMbGolu3bnB3d8e1a9dQr149pKSkQBAENGrUSOx4pIJEEEp4p5B0XvXq1VU239+8efMdptE/a9euxb59++Dk5ISIiAg4OTkpjo0ePRoBAQHo2bOniAmL2rBhA3r37g0zMzOxo+it5ORkLFy4EElJScjJyUGjRo0wdepU1K9fX+xoOi0gIACNGjXC4sWLUb58eSQlJcHd3R2nTp1Cv379kJKSInZEJU2bNkWnTp0wd+5cRd5KlSohODgYQUFBGDVqlNgRqQQsjPTY8uXLlT7n5+cjISEBBw8exOTJk7Xq1WFVnj9/jhUrVmDSpEliRyHSG69eK/83iUQCMzMz1KxZE23atFFqvRWTjY0NLly4gBo1aigVRrdv30adOnXw/PlzsSMqKV++PBITE1GjRg3Y2dnhxIkT8PLyQlJSEj744AOtK+To/7ErTY+NHz++2P0rV67EuXPn3nEa1bKysvD777/D1NQUHTp0gLGxMfLz8/Htt98iMjISL1680KnC6MKFC5g9ezZ++uknsaOo1Wol9ridRo0aITY2FnZ2dmjYsKHKFs8LFy68w2SlV1BQgN27d+Pq1asAAE9PT3zwwQdaN9HjV199haysLDx9+lTR3f7w4UNYWFjAysoKmZmZcHd3x9GjR+Hi4iJyWkAqleLx48dF9v/5559wcHAQIZFqlpaWinFFzs7OSE5OVsxrpu0vZhg67fovld6JTp06ITw8HOvWrRM7CoCXg2zff/99PH78GBKJBL6+vli3bh26d++OcuXKYc6cOQgJCRE7ZhGHDh3C4cOHYWpqiqFDhyrGEkybNg379u1DYGCg2BEBvPxNW1d88MEHirf9dOX17Nf98ccf6NatG9LT0xUvDCxatAgODg7Yt2+fVi1nsWDBAvzwww9Ys2YNatSoAQC4ceMGRowYgeHDh6Nly5b4+OOPMXHiROzYsUPktC/fkps3bx62bdsG4GXLVmpqKqZOnYpevXqJnK6o5s2b48SJE/Dw8EDnzp3x6aef4tKlS9i1a5fSyyWkhUSdRYlEsWjRIqFatWpix1Bo27at0LdvX+HSpUvCpEmTBIlEItSuXVvYvn272NFKtGbNGkEikQj29vaCkZGR4ODgIGzYsEGwtbUVRowYIVy5ckXsiCSC5s2bC127dhUePHig2PfgwQOhW7dugp+fn4jJinJ3dxcSEhKK7L9w4YJQvXp1QRAE4eTJk4KTk9M7Tla87OxsISAgQLC1tRWMjY0FFxcXwcTERGjTpo2Qk5MjdrwikpOThaSkJEEQBCEnJ0cYMWKEUL9+faFnz55CSkqKyOlIFY4x0mP/7ooQBAHp6enIysrCt99+qzULydrb2+O3336Dp6cnnj17BisrK+zatQsffPCB2NFK1KBBAwwYMACTJ0/Gzp070bt3bzRv3hzbtm1TLNpLhsfc3Bznzp0rshTM5cuX0aRJEzx79kykZEVZWFjg+PHj8PX1Vdp/9uxZtG3bFk+fPkVKSgrq1auHnJwckVIWdeLECVy8eFExsD0gIEDsSKRn2JWmx/7dFWFkZAQHBwf4+/tr1Vo9Dx8+RMWKFQG8/MFiYWGhVV0OxUlOTlbMbN2zZ0+UK1cOX3zxhU4URTt27MC2bduKnVtFm8btFBQU4Kuvviox64MHD0RKVrLatWsjIyOjSGGUmZmpdbN4t2vXDiNGjMCaNWsUU0skJCRg1KhRaN++PQDg0qVLqF69upgxFe7cuQMXFxe0atUKrVq1EjtOqZ0/f14x3szLy0srp/GgfxG5xYrKSH5+vrB+/XohPT1d7ChvJJFIhKNHjwpJSUlCUlKSYGlpKezfv1/x+dWmTSQSiZCRkaH4bGVlpRPrTi1fvlywsrISxowZI5iamgojRowQAgICBBsbG2H69Olix1Mya9YswdnZWfjyyy8FMzMzYf78+cKQIUMEe3t7Yfny5WLHK9b+/fsFLy8vYfv27cKdO3eEO3fuCNu3bxfq168v7N+/X3j06JFiE1taWpoQEBAgSCQSwdTUVDA1NRWMjIyEjh07Kv7e+PXXX4VDhw6JnPQlIyMjoU2bNsIPP/yg1FWprTIyMoR27doJEolEsLOzE+zs7ASJRCK0b99eyMzMFDseqcCuND1mYWGBq1evolq1amJHUcnIyAgSiQTF/av4ar+2zcRrZGSEzz77TLFy9tSpUzF58mRFy9cr48aNEyNeierWrYuIiAj07dtX6ZXn2bNn48GDB1ixYoXYERVq1KiBr7/+Gl26dFF69fnrr7/G6dOnsWnTJrEjFmFkZKT486tu7Ff/Xr/+WZv+fb527Rr+/PNPAECdOnW0bpb5VxISErBp0yZs2bIFWVlZCAoKQv/+/dG1a1el5Xm0RZ8+fXDz5k3ExMTAw8MDAHDlyhWEhISgZs2a2Lx5s8gJqSQsjPSYv78/JkyYoPVv99y+fbtU52lTgefm5vbGta8kEonWTaL5erFcqVIlHD58GN7e3vjrr7/QvHlz3L9/X+yICpaWloo19JydnbF//340atQIN2/eRMOGDfHo0SOxIxahzuzWbdu2LcMk+ksQBMTFxWHTpk3YuXMn5HI5evbsibVr14odTYmNjQ2OHDmCJk2aKO0/c+YM3nvvPWRnZ4sTjN6IY4z02OjRo/Hpp5/i77//RuPGjWFpaal0/PXV4cVUmoLn8uXL7yBJ6enq5GxOTk548OABqlWrBldXV5w+fRre3t64detWsS12YqpatSrS0tLg6uqKGjVq4JdffkGjRo1w9uxZrWwhAHSr2Bk8eLDK49pWaLwikUjQrl07tGvXDqNGjcKQIUOwfv16rcsrl8uLrO8HACYmJjq9NIshYGGkxz7++GMAyt052to1VZwnT55g8+bNWLNmDc6fP6/1eXVB+/btsXfvXjRs2BCDBg1SzFFz7tw5rVu+pEePHoiNjUWzZs0wduxY9O/fH1FRUUhNTRV9gVtVsrOzERUVpTTgdvDgwVo3n9TDhw+VPufn5+Py5cvIzs5WDL7WRn///Tc2bdqETZs24fLly/Dz88PKlSvFjlVE+/btMX78eGzevBmVK1cGANy9excTJ05Ehw4dRE5HqrArTY+9qYtKm7qmXnf8+HFERUVh586dqFy5Mnr27IlevXoVaZIWU+fOnbF582bFD7uFCxdi5MiRisVX79+/j9atW+PKlSsipixKLpdDLpcrZmHesmULTp06hVq1amHEiBEwNTUVOWHJ4uPjER8fj1q1amndosKvnDt3DoGBgTA3N0fTpk0BvHz9/dmzZ4oWL20ml8sxatQo1KhRA1OmTBE7jpLvv/8emzZtwsmTJ1G3bl0EBwejX79+Wvv32J07d9CtWzf88ccfipnD79y5g3r16mHv3r068QaroWJhRFohPT0d0dHRiIqKwuPHj/HRRx9h1apVSEpKUlq1XlsYGxsjLS0NlSpVAgBYW1sjMTER7u7uAICMjAxUrlxZ61q5UlNT4eLiUmR8lCAIuHPnDlxdXUVKph9at26NmjVrYvXq1Yri88WLFxg6dChu3ryJ48ePi5zwza5fvw5/f3+kpaWJHUWJi4sL+vbti+DgYHh7e4sdp1QEQcCRI0dw7do1AICHhwfnXdIB7ErTM3v37kWnTp1gYmKCvXv3qjy3W7du7yiVal27dsXx48fRpUsXLFu2DEFBQTA2NsaqVavEjlaif/8+oSu/X1SvXl2poHvlwYMHqF69utYVctevX8c333yj6Jby8PDA2LFjtfbNqXPnzikVRQBQrlw5TJkypchEitoqOTkZL168EDtGEampqW984UFb5Ofnw9zcHImJiejYsSM6duwodiRSAwsjPdO9e3ekp6ejUqVKKt9G06YxRj///DPGjRuHUaNGoVatWmLH0Wuvxpf9W05ODszMzERIVLKdO3fi448/hq+vL/z8/AAAp0+fRr169bBlyxatXB/L2toaqampRSZQvXPnDsqXLy9SquKFhYUpfRYEAWlpadi/f79Wrk0okUjw22+/4fvvv0dycjJ27NiBKlWqYMOGDahevbpWTfpoYmICV1dXrfk7ltTDwkjPvP62g668+XDixAlERUWhcePG8PDwwIABAxQDx7WVRCIpUmBo82+zr34ISiQSzJo1CxYWFopjBQUF+P333+Hj4yNSuuJNmTIF4eHhmDdvntL+iIgITJkyRSsLoz59+mDIkCH48ssv0aJFCwDAyZMnMXnyZPTt21fkdMoSEhKUPr+aGX/JkiVvfGNNDDt37sSAAQMQHByMhIQEyGQyAMCjR4+wYMECHDhwQOSEymbMmIHp06djw4YNqFChgthxSA0cY6THXk2hrytyc3OxdetWrF27FmfOnEFBQQGWLl2KwYMHa91v20ZGRujUqZPitfF9+/ahffv2iikRZDIZDh48qDW/MbZr1w7Ay3l2/Pz8lAZZm5qaws3NDZMmTdKqFjsLCwtcvHixyFIaf/31F7y9vfH06VORkpUsLy8PkydPxqpVqxTdUSYmJhg1ahQWLlyotdMM6IKGDRti4sSJGDhwoNLkpAkJCejUqRPS09PFjqikYcOGuHHjBvLz81GtWrUi06Vo0/I7pIyFkR4zNjZGq1at0L9/f3z44Yews7MTO1KpXb9+HVFRUdiwYQOys7PRsWPHN46ZepdCQ0NL1UK0bt26d5Cm9AYNGoSvv/5a6wrN4nTu3Bm9e/fGoEGDlPavW7cOW7ZswaFDh0RKVryCggKcPHkS9evXh1QqRXJyMoCXM3i/3kKnbbKysnD9+nUAL2e+dnBwEDlR8SwsLHDlyhW4ubkpFUY3b96Ep6cnnj9/LnZEJXPnzlV5PCIi4h0lIXWxMNJjujaFfnEKCgrw008/ISoqSqsKI11T2jmKdu3aVcZJSm/VqlWYPXs2PvroIzRv3hzAyzFG27dvx9y5cxVzwwDa8yKBmZkZrl69qjULr6qSm5uLsWPHIiYmRtHtbmxsjIEDB+Kbb77RumLO3d0dP/zwAwICApQKo5iYGCxcuFDrpsYg3cXCyABo+xT68fHxuH//Pt5//33FvpiYGERERCA3Nxfdu3fHN998o1XFXGnGYEgkEkRFRb2DNG/271aXkmhTC9fr646pok0vEvj6+mLRokU6MYHfiBEjcOTIEaxYsQItW7YE8HK837hx49CxY0d89913IidUFhkZif/9739Yu3YtOnbsiAMHDuD27duYOHEiZs2ahbFjx4odsVh5eXnIzMwsMuaTU2NoLxZGBubChQsYMmQILl68qDU/TDp16gR/f39MnToVAHDp0iU0atQIoaGh8PDwwBdffIERI0Zgzpw54gZ9jZGREapVq4aGDRuqfFV/9+7d7zAVie3gwYMIDw/H/Pnzi12Gx9raWqRkRVWsWBE7duyAv7+/0v6jR4/io48+QlZWljjBXnPx4kXUq1dPUSR//vnniIyMVIwvk0qlmDRpEubPny9mzGL9+eefGDJkCE6dOqW0X1dWHjBkLIwMQHFT6AcHB2PkyJFiRwMAODs7Y9++fYp5XmbMmIFjx47hxIkTAIDt27cjIiJCq5rKP/nkE2zevBnVqlXDoEGD0L9/f755oiG62IL4yuutXK+PQdPGH4YWFhY4f/68YuX3V/744w80bdoUubm5IiX7f69PpOru7o6zZ8+ifPnyuHHjBnJycuDp6QkrKyuxYxarZcuWKFeuHKZNmwZnZ+ciYxJ1ZZJKQ8TCSI/pyhT6ZmZm+OuvvxRv0LVq1QqdOnXCjBkzALxcsLV+/fp48uSJmDGLkMlk2LVrF9auXYtTp06hS5cuGDJkCN577z2tfnVf2+liC+Irx44dU3lcmxaZ7dChA+zt7RETE6OYw+rZs2cICQnBgwcPcOTIEZETAvb29jhw4ACaNWsGIyMjZGRkaO3g8H+ztLTE+fPni8xpRdqPhZEe05Up9KtVq4YNGzagTZs2yMvLg62tLfbt26cYp3Hp0iW0bdsWDx48EDlpyW7fvo3o6GjExMTgxYsX+OOPP7T2N1ltp4stiLro0qVLCAoKgkwmU/z9kJSUBKlUil9++QVeXl4iJwSGDx+OmJgYODs7IzU1FVWrVoWxsXGx5968efMdp1OtSZMm+Oqrr7Rq4kkqHU7wqMd0ZQr9zp07Y9q0aVi0aBH27NkDCwsLtG7dWnH84sWLqFGjhogJ38zIyAgSiQSCIGhVd4kuevjwIRwdHRWfjx07hk6dOik+N2nSBHfu3BEj2hu9aS20Nm3avKMkb1a/fn389ddf2Lhxo2Itr1e/SJmbm4uc7qUffvgBPXv2xI0bNzBu3DgMGzZMq6eaePz4seLPixYtwpQpU7BgwQLUr18fJiYmSudq03gzUsbCSI+9KoqePn2K1NRU5OXlKR1v0KCBGLGKmD9/Pnr27Im2bdvCysoK69evV5qAcO3atXjvvfdETFi817vSTpw4gffffx8rVqxAUFBQqd+ooqIcHR1x69YtuLi4IC8vDxcuXFCaE+bJkydFfshoi38PZAaUxxppU9EcGRkJR0dHDBs2TGn/2rVrkZWVpejKFFtQUBAA4Pz58xg/frxWF0a2trZFxpb9+w1FbRxvRspYGOmxrKwshIaG4uDBg8Ue15b/MCtWrIjjx4/j0aNHsLKyKtJUvn37dq3rlho9ejS2bNkCFxcXDB48GJs3b0bFihXFjqUXdLkF8eHDh0qf8/PzkZCQgFmzZuHzzz8XKVXxXo1B/DcvLy98/PHHWlMYvaJNU0mU5OjRo4o/p6SkwMXFpcjfZ3K5HKmpqe86GqmBY4z0WHBwMG7fvo1ly5bB398fu3fvRkZGBj777DMsWbIEXbp0ETuizjIyMoKrqysaNmyosrtSmyZM1BX37t1Dz549ceLECUULYo8ePRTHO3TogObNm2tdoaHKsWPHEBYWhvPnz4sdRaGkySi1dSZpXfP6G3Wvu3//PipVqqQ1v5hSUWwx0mO//vorfvzxR/j6+irm3enYsSOsra0RGRnJwug/GDhwoE6M39JFutiC+CaOjo6KZTe0hYuLC06ePFmkMDp58qTSrOL0dl51mf1bTk6O4i1A0k4sjPRYbm6u4rcVOzs7ZGVloXbt2qhfvz4XMPyPoqOjxY6g92xsbIrdr83zRV28eFHpsyAISEtLw8KFC+Hj4yNOqBIMGzYMEyZMQH5+Ptq3bw8AiI2NxZQpU/Dpp5+KnE53hYWFAXg5tmzWrFlKS6sUFBTg999/17p/F0gZCyM9VqdOHVy/fh1ubm7w9vbG999/Dzc3N6xatQrOzs5ixyPSOz4+Poq3E1/XvHlzrVmC55XJkyfj/v37GD16tOLFDDMzM0ydOhXh4eEip9NdCQkJAF4WxZcuXVJ6kcTU1BTe3t6YNGmSWPGoFDjGSI/973//w4sXLxAaGorz588jKCgIDx48gKmpKaKjo9GnTx+xIxLpldu3byt9NjIygoODg1Z3neTk5ODq1aswNzdHrVq1tHJGcV00aNAgLF++nK/l6yAWRgbk6dOnuHbtGlxdXfkGFZEGde7cGZs3b1Z0/y1cuBAjR46Era0tgJcDblu3bs1JKYl0AAsjIqL/6N9vIFlbWyMxMRHu7u4AgIyMDFSuXJlvIhHpAI4x0mMFBQWIjo5GbGwsMjMzIZfLlY7/+uuvIiUj0i///v2Sv28S6S4WRnps/PjxiI6ORpcuXVCvXj2+Xk5ERPQGLIz02JYtW7Bt2zZ07txZ7ChEek0ikRT5xYO/iBDpJhZGeszU1BQ1a9YUOwaR3hMEAaGhoYo3up4/f46RI0fC0tISwMt19YhIN3DwtR5bsmQJbt68iRUrVvC3V6IyNGjQoFKdpwvrfREZOhZGeqxHjx44evQoKlSoAC8vryIrknMdLyIiImXsStNjtra2SotvEhERkWpsMSIiIiIqxBYjA5CVlaVY2btOnTpwcHAQOREREZF2MhI7AJWd3NxcDB48GM7OzmjTpg3atGmDypUrY8iQIXj69KnY8YiIiLQOCyM9FhYWhmPHjmHfvn3Izs5GdnY2fvzxRxw7dgyffvqp2PGIiIi0DscY6bGKFStix44d8Pf3V9p/9OhRfPTRR8jKyhInGBERkZZii5Eee/r0KRwdHYvsr1SpErvSiIiIisEWIz3WoUMH2NvbIyYmBmZmZgCAZ8+eISQkBA8ePMCRI0dETkhERKRdWBjpsUuXLiEoKAgymQze3t4AgKSkJJiZmeHQoUPw8vISOSEREZF2YWGk554+fYqNGzfi2rVrAAAPDw8EBwfD3Nxc5GRERETah4WRnsrPz0fdunXx008/wcPDQ+w4REREOoGDr/WUiYkJnj9/LnYMIiIincLCSI998sknWLRoEV68eCF2FCIiIp3ArjQ91qNHD8TGxsLKygr169eHpaWl0vFdu3aJlIyIiEg7ca00PWZra4tevXqJHYOIiEhnsMWIiIiIqBBbjAxAVlYWrl+/DgCoU6cOHBwcRE5ERESknTj4Wo/l5uZi8ODBcHZ2Rps2bdCmTRtUrlwZQ4YM4ZIgRERExWBhpMfCwsJw7Ngx7Nu3D9nZ2cjOzsaPP/6IY8eO4dNPPxU7HhERkdbhGCM9VrFiRezYsQP+/v5K+48ePYqPPvoIWVlZ4gQjIiLSUmwx0mNPnz6Fo6Njkf2VKlViVxoREVEx2GKkxzp06AB7e3vExMTAzMwMAPDs2TOEhITgwYMHOHLkiMgJiYiItAsLIz126dIlBAUFQSaTwdvbGwCQlJQEqVSKX375BV5eXiInJCIi0i4sjPTc06dPsXHjRly7dg0A4OHhgeDgYJibm4ucjIiISPuwMNJjkZGRcHR0xODBg5X2r127FllZWZg6dapIyYiIiLQTB1/rse+//x5169Ytst/LywurVq0SIREREZF2Y2Gkx9LT0+Hs7Fxkv4ODA9LS0kRIREREpN1YGOkxFxcXnDx5ssj+kydPonLlyiIkIiIi0m5cK02PDRs2DBMmTEB+fj7at28PAIiNjcWUKVM48zUREVExOPhajwmCgGnTpuHrr79GXl4eAMDMzAxTp07F7NmzRU5HRESkfVgYGYCcnBxcvXoV5ubmqFWrFqRSqdiRiIiItBILIyIiIqJCHHxNREREVIiFEREREVEhFkZEREREhVgYERERERViYURERERUiIURERERUSEWRkRERESFWBgRERERFfo/oVniEVkR/1IAAAAASUVORK5CYII=\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": [ "可以看到，嵌入向量成功捕获了不同术语的含义。每个单词都与其所在簇的其他单词相似（即“coronavirus”与“SARS”和“MERS”高度相关），但与其他簇的术语不同（即“SARS”与“Spain”之间的相似度接近于 0）。\n", "\n", "现在，我们来看看如何使用这些嵌入向量解决特定任务。" ] }, { "cell_type": "markdown", "metadata": { "id": "idJ1jFmH7xMa" }, "source": [ "## SciCite：引用意图分类\n", "\n", "本部分介绍了将嵌入向量用于下游任务（如文本分类）的方法。我们将使用 TensorFlow 数据集中的 [SciCite 数据集](https://tensorflow.google.cn/datasets/catalog/scicite)对学术论文中的引文意图进行分类。给定一个带有学术论文引文的句子，对引用的主要意图进行分类：是背景信息、使用方法，还是比较结果。" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2022-12-14T21:42:48.649514Z", "iopub.status.busy": "2022-12-14T21:42:48.648996Z", "iopub.status.idle": "2022-12-14T21:42:49.322587Z", "shell.execute_reply": "2022-12-14T21:42:49.321660Z" }, "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-14T21:42:49.326568Z", "iopub.status.busy": "2022-12-14T21:42:49.326284Z", "iopub.status.idle": "2022-12-14T21:42:49.761010Z", "shell.execute_reply": "2022-12-14T21:42:49.760093Z" }, "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", "我们将使用 Estimator 在 [SciCite 数据集](https://tensorflow.google.cn/datasets/catalog/scicite)上对分类器进行训练。让我们设置 input_fns，将数据集读取到模型中。" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "cellView": "both", "execution": { "iopub.execute_input": "2022-12-14T21:42:49.764702Z", "iopub.status.busy": "2022-12-14T21:42:49.764153Z", "iopub.status.idle": "2022-12-14T21:42:49.769390Z", "shell.execute_reply": "2022-12-14T21:42:49.768828Z" }, "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": "2022-12-14T21:42:49.772632Z", "iopub.status.busy": "2022-12-14T21:42:49.772111Z", "iopub.status.idle": "2022-12-14T21:42:49.779420Z", "shell.execute_reply": "2022-12-14T21:42:49.778767Z" }, "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-14T21:42:49.782759Z", "iopub.status.busy": "2022-12-14T21:42:49.782170Z", "iopub.status.idle": "2022-12-14T21:42:49.786195Z", "shell.execute_reply": "2022-12-14T21:42:49.785604Z" }, "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": "2022-12-14T21:42:49.789394Z", "iopub.status.busy": "2022-12-14T21:42:49.788938Z", "iopub.status.idle": "2022-12-14T21:44:24.027511Z", "shell.execute_reply": "2022-12-14T21:44:24.026508Z" }, "id": "cO1FWkZW2WS9" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:42:49.944792: 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_55626/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 21:42:51.606735: 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.797, accuracy 0.659\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:42:52.907787: 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 21:42:54.348922: 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.724, accuracy 0.703\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:42:55.250551: 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 21:42:56.592261: 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.673, accuracy 0.732\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:42:57.531646: 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 21:42:58.849640: 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.739\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:42:59.774741: 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 21:43:01.085012: 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.626, accuracy 0.757\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:02.507653: 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 21:43:03.903652: 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.614, accuracy 0.761\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:04.818431: 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 21:43:06.357206: 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.609, accuracy 0.769\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:07.310568: 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 21:43:08.633451: 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.586, accuracy 0.782\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:09.557532: 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 21:43:10.827364: 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.581, accuracy 0.783\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:11.789486: 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 21:43:13.185712: 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.583, accuracy 0.776\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:14.101954: 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 21:43:15.381008: 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.571, accuracy 0.789\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:16.333631: 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 21:43:17.628058: 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.573, accuracy 0.774\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:18.569037: 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 21:43:19.991966: 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.559, accuracy 0.793\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:20.936393: 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 21:43:22.288659: 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.568, accuracy 0.782\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:23.221558: 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 21:43:24.532759: 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.562, accuracy 0.784\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:25.520853: 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 21:43:26.875396: 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.566, accuracy 0.780\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:27.829207: 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 21:43:29.180763: 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.556, accuracy 0.785\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:30.125850: 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 21:43:31.514597: 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.556, accuracy 0.787\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:32.457847: 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 21:43:34.149400: 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.558, accuracy 0.778\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:35.143225: 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 21:43:36.462402: 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.556, accuracy 0.783\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:37.454875: 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 21:43:38.807818: 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.554, accuracy 0.782\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:39.770718: 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 21:43:41.074971: 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.549, accuracy 0.784\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:42.004150: 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 21:43:43.315299: 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.551, accuracy 0.784\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:44.238165: 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 21:43:45.674709: 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.544, accuracy 0.786\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:46.644853: 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 21:43:47.970517: 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.539, accuracy 0.793\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:48.923991: 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 21:43:50.355042: 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.545, accuracy 0.787\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:51.311623: 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 21:43:52.737111: 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.789\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:53.681737: 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 21:43:55.050884: 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.543, accuracy 0.790\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:55.994610: 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 21:43:57.381780: 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.539, accuracy 0.791\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:43:58.291692: 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 21:43:59.827555: 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.539, accuracy 0.791\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:00.875266: 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 21:44:02.150170: 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.533, accuracy 0.801\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:03.069729: 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 21:44:04.490394: 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.540, accuracy 0.791\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:05.437356: 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 21:44:06.754939: 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.537, accuracy 0.791\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:07.864979: 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 21:44:09.281294: 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.542, accuracy 0.788\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:10.251222: 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 21:44:11.561167: 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.787\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:12.524633: 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 21:44:13.882438: 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.529, accuracy 0.793\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:14.833350: 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 21:44:16.280598: 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.540, accuracy 0.792\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:17.252976: 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 21:44:18.604710: 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.539, accuracy 0.788\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:19.542903: 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 21:44:20.944670: 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.539, accuracy 0.789\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:21.886642: 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 21:44:23.215022: 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.539, 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-14T21:44:24.031360Z", "iopub.status.busy": "2022-12-14T21:44:24.030664Z", "iopub.status.idle": "2022-12-14T21:44:24.398254Z", "shell.execute_reply": "2022-12-14T21:44:24.397504Z" }, "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": [ "可以看到，损失迅速减小，而准确率迅速提高。我们绘制一些样本来检查预测与真实标签的关系：" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:24.403056Z", "iopub.status.busy": "2022-12-14T21:44:24.402488Z", "iopub.status.idle": "2022-12-14T21:44:24.406389Z", "shell.execute_reply": "2022-12-14T21:44:24.405686Z" }, "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-14T21:44:24.409560Z", "iopub.status.busy": "2022-12-14T21:44:24.409176Z", "iopub.status.idle": "2022-12-14T21:44:25.231163Z", "shell.execute_reply": "2022-12-14T21:44:25.230392Z" }, "id": "nlxFER_Oriam" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:24.825812: 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_55626/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 嵌入向量有了更多了解，我们鼓励您参加 CORD-19 Kaggle 竞赛，为从 COVID-19 相关学术文本中获得更深入的科学洞见做出贡献。\n", "\n", "- 参加 [CORD-19 Kaggle Challenge](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge)\n", "- 详细了解 [COVID-19 开放研究数据集 (CORD-19)](https://api.semanticscholar.org/CorpusID:216056360)\n", "- 访问 https://tfhub.dev/tensorflow/cord-19/swivel-128d/1，参阅文档并详细了解 TF-Hub 嵌入向量\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.16" } }, "nbformat": 4, "nbformat_minor": 0 }