python-examples/use-keras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "co7MV6sX7Xto"
   },
   "source": [
    "# Evaluate MedDRA Coding similarity to verbatim using Universal Sentence Encoder with Transformer\n",
    "\n",
    "The Universal Sentence Encoder encodes text into high dimensional vectors that can be used for text classification, semantic similarity, clustering and other natural language tasks.\n",
    "\n",
    "In this notebook, I will use the model which is trained and optimized for greater-than-word length text, such as sentences, phrases or short paragraphs. It is trained on a variety of data sources and a variety of tasks with the aim of dynamically accommodating a wide variety of natural language understanding tasks. The input is variable length English text and the output is a 512 dimensional vector. The universal-sentence-encoder-large model is trained with a Transformer encoder.\n",
    "\n",
    "The size of the model is about 800MB.\n",
    "\n",
    "This notebook ran on Sagemaker."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pOTzp8O36CyQ"
   },
   "source": [
    "# Getting Started\n",
    "\n",
    "This section sets up the environment for access to the Universal Sentence Encoder on TF Hub and provides examples of applying the encoder to words, sentences, and paragraphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "MSeY-MUQo2Ha",
    "outputId": "62db0062-49cf-4b42-efb4-71a314157c69"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_hub as hub\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import pandas as pd\n",
    "import re\n",
    "import seaborn as sns\n",
    "import keras.layers as layers\n",
    "from keras.models import Model\n",
    "from keras import backend as K\n",
    "np.random.seed(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zwty8Z6mAkdV"
   },
   "outputs": [],
   "source": [
    "module_url = \"https://tfhub.dev/google/universal-sentence-encoder-large/3\" #@param [\"https://tfhub.dev/google/universal-sentence-encoder/2\", \"https://tfhub.dev/google/universal-sentence-encoder-large/3\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 289
    },
    "colab_type": "code",
    "id": "Q8F4LNGFqOiq",
    "outputId": "990861e4-846a-4498-9298-5447afa61602"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Using /tmp/tfhub_modules to cache modules.\n",
      "INFO:tensorflow:Downloading TF-Hub Module 'https://tfhub.dev/google/universal-sentence-encoder-large/3'.\n",
      "INFO:tensorflow:Downloading https://tfhub.dev/google/universal-sentence-encoder-large/3: 180.00MB\n",
      "INFO:tensorflow:Downloading https://tfhub.dev/google/universal-sentence-encoder-large/3: 380.00MB\n",
      "INFO:tensorflow:Downloading https://tfhub.dev/google/universal-sentence-encoder-large/3: 580.00MB\n",
      "INFO:tensorflow:Downloading https://tfhub.dev/google/universal-sentence-encoder-large/3: 780.00MB\n",
      "INFO:tensorflow:Downloaded https://tfhub.dev/google/universal-sentence-encoder-large/3, Total size: 810.60MB\n",
      "INFO:tensorflow:Downloaded TF-Hub Module 'https://tfhub.dev/google/universal-sentence-encoder-large/3'.\n",
      "Message: Elephant\n",
      "Embedding size: 512\n",
      "Embedding: [0.04498473182320595, -0.057433925569057465, 0.0022114794701337814, ...]\n",
      "\n",
      "Message: I am a sentence for which I would like to get its embedding.\n",
      "Embedding size: 512\n",
      "Embedding: [0.05568018555641174, -0.009607925079762936, 0.006246298085898161, ...]\n",
      "\n",
      "Message: Universal Sentence Encoder embeddings also support short paragraphs. There is no hard limit on how long the paragraph is. Roughly, the longer the more 'diluted' the embedding will be.\n",
      "Embedding size: 512\n",
      "Embedding: [0.038749415427446365, 0.07652014493942261, -0.0007946003461256623, ...]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Import the Universal Sentence Encoder's TF Hub module\n",
    "embed = hub.Module(module_url)\n",
    "\n",
    "# Compute a representation for each message, showing various lengths supported.\n",
    "word = \"Elephant\"\n",
    "sentence = \"I am a sentence for which I would like to get its embedding.\"\n",
    "paragraph = (\n",
    "    \"Universal Sentence Encoder embeddings also support short paragraphs. \"\n",
    "    \"There is no hard limit on how long the paragraph is. Roughly, the longer \"\n",
    "    \"the more 'diluted' the embedding will be.\")\n",
    "messages = [word, sentence, paragraph]\n",
    "\n",
    "# Reduce logging output.\n",
    "tf.logging.set_verbosity(tf.logging.ERROR)\n",
    "\n",
    "with tf.Session() as session:\n",
    "  session.run([tf.global_variables_initializer(), tf.tables_initializer()])\n",
    "  message_embeddings = session.run(embed(messages))\n",
    "\n",
    "  for i, message_embedding in enumerate(np.array(message_embeddings).tolist()):\n",
    "    print(\"Message: {}\".format(messages[i]))\n",
    "    print(\"Embedding size: {}\".format(len(message_embedding)))\n",
    "    message_embedding_snippet = \", \".join(\n",
    "        (str(x) for x in message_embedding[:3]))\n",
    "    print(\"Embedding: [{}, ...]\\n\".format(message_embedding_snippet))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 90
    },
    "colab_type": "code",
    "id": "lNRSk5lukD_u",
    "outputId": "f4b07c61-fbba-4244-ef9e-ab0a7f04708d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.00341095, -0.0381117 , -0.01249462, ..., -0.03188571,\n",
       "         0.03693527, -0.04350929],\n",
       "       [ 0.00599075, -0.03070364,  0.02946818, ..., -0.01874219,\n",
       "         0.05244366,  0.01933832]], dtype=float32)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute a representation for each message, showing various lengths supported.\n",
    "messages = [\"That band rocks!\", \"That song is really cool.\"]\n",
    "\n",
    "with tf.Session() as session:\n",
    "  session.run([tf.global_variables_initializer(), tf.tables_initializer()])\n",
    "  message_embeddings = session.run(embed(messages))\n",
    "message_embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "O2cYc2WEkSGP",
    "outputId": "627031de-f995-4bf8-fe55-b8837ff33356"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embed_size = embed.get_output_info_dict()['default'].get_shape()[1].value\n",
    "embed_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 417
    },
    "colab_type": "code",
    "id": "UgdEV2sQt3DS",
    "outputId": "6ede117c-547e-46a9-dc05-0ede8ee0719b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2019-02-10 02:13:44--  https://raw.githubusercontent.com/Tony607/Keras-Text-Transfer-Learning/master/train_5500.txt\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.248.133\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.248.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 335860 (328K) [text/plain]\n",
      "Saving to: ‘train_5500.txt’\n",
      "\n",
      "train_5500.txt      100%[===================>] 327.99K  --.-KB/s    in 0.01s   \n",
      "\n",
      "2019-02-10 02:13:45 (26.2 MB/s) - ‘train_5500.txt’ saved [335860/335860]\n",
      "\n",
      "--2019-02-10 02:13:45--  https://raw.githubusercontent.com/Tony607/Keras-Text-Transfer-Learning/master/test_data.txt\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.248.133\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.248.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 23354 (23K) [text/plain]\n",
      "Saving to: ‘test_data.txt’\n",
      "\n",
      "test_data.txt       100%[===================>]  22.81K  --.-KB/s    in 0.001s  \n",
      "\n",
      "2019-02-10 02:13:45 (22.7 MB/s) - ‘test_data.txt’ saved [23354/23354]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!wget https://raw.githubusercontent.com/Tony607/Keras-Text-Transfer-Learning/master/train_5500.txt\n",
    "!wget https://raw.githubusercontent.com/Tony607/Keras-Text-Transfer-Learning/master/test_data.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 198
    },
    "colab_type": "code",
    "id": "MElqkcDiDKsp",
    "outputId": "2dcf04b0-c631-484c-9137-363fae821197"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>label</th>\n",
       "      <th>text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>DESC</td>\n",
       "      <td>How did serfdom develop in and then leave Russ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ENTY</td>\n",
       "      <td>What films featured the character Popeye Doyle ?</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>DESC</td>\n",
       "      <td>How can I find a list of celebrities ' real na...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ENTY</td>\n",
       "      <td>What fowl grabs the spotlight after the Chines...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ABBR</td>\n",
       "      <td>What is the full form of .com ?</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  label                                               text\n",
       "0  DESC  How did serfdom develop in and then leave Russ...\n",
       "1  ENTY   What films featured the character Popeye Doyle ?\n",
       "2  DESC  How can I find a list of celebrities ' real na...\n",
       "3  ENTY  What fowl grabs the spotlight after the Chines...\n",
       "4  ABBR                    What is the full form of .com ?"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_dataframe(filename):\n",
    "    lines = open(filename, 'r').read().splitlines()\n",
    "    data = []\n",
    "    for i in range(0, len(lines)):\n",
    "        label = lines[i].split(' ')[0]\n",
    "        label = label.split(\":\")[0]\n",
    "        text = ' '.join(lines[i].split(' ')[1:])\n",
    "        text = re.sub('[^A-Za-z0-9 ,\\?\\'\\\"-._\\+\\!/\\`@=;:]+', '', text)\n",
    "        data.append([label, text])\n",
    "\n",
    "    df = pd.DataFrame(data, columns=['label', 'text'])\n",
    "    df.label = df.label.astype('category')\n",
    "    return df\n",
    "\n",
    "df_train = get_dataframe('train_5500.txt')\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4TkOWZyCFmZN"
   },
   "outputs": [],
   "source": [
    "df_train = get_dataframe('test_data.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "3HAtd4X5DayF",
    "outputId": "73ada7e8-e7c9-48d7-de4e-97874207a60d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "category_counts = len(df_train.label.cat.categories)\n",
    "category_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Sf9A4Xl6J7c6"
   },
   "source": [
    "## Wrap embed module in a Lambda layer\n",
    "Explicitly cast the input as a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PRD3fWgJjOrP"
   },
   "outputs": [],
   "source": [
    "def UniversalEmbedding(x):\n",
    "    return embed(tf.squeeze(tf.cast(x, tf.string)), signature=\"default\", as_dict=True)[\"default\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 290
    },
    "colab_type": "code",
    "id": "t3fllZkVjXKV",
    "outputId": "8827cbe8-2a1e-4240-fff4-cdc661e8e327"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 1)                 0         \n",
      "_________________________________________________________________\n",
      "lambda_1 (Lambda)            (None, 512)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 256)               131328    \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 6)                 1542      \n",
      "=================================================================\n",
      "Total params: 132,870\n",
      "Trainable params: 132,870\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "input_text = layers.Input(shape=(1,), dtype=tf.string)\n",
    "embedding = layers.Lambda(UniversalEmbedding, output_shape=(embed_size,))(input_text)\n",
    "dense = layers.Dense(256, activation='relu')(embedding)\n",
    "pred = layers.Dense(category_counts, activation='softmax')(dense)\n",
    "model = Model(inputs=[input_text], outputs=pred)\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5Ube1DvYEJ3q"
   },
   "outputs": [],
   "source": [
    "train_text = df_train['text'].tolist()\n",
    "train_text = np.array(train_text, dtype=object)[:, np.newaxis]\n",
    "\n",
    "train_label = np.asarray(pd.get_dummies(df_train.label), dtype = np.int8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "WX3s8yIVFWHI",
    "outputId": "5468a7ae-f1c3-4019-8f76-91dab02ec482"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500, 1)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_text.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "9PfsPdG8FZBI",
    "outputId": "b7d95197-8bad-4280-fc43-5a2e2373f1f2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500, 6)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_label.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "colab_type": "code",
    "id": "gPYVmBr2Fbob",
    "outputId": "a6df6922-eae1-4018-9660-f7c6cfdf8d74"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0, 1],\n",
       "       [0, 0, 0, 0, 1, 0],\n",
       "       [0, 0, 0, 1, 0, 0]], dtype=int8)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_label[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "X9MJnOnKI6F0"
   },
   "outputs": [],
   "source": [
    "df_test = get_dataframe('test_data.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QWAjtjdeI9P4"
   },
   "outputs": [],
   "source": [
    "test_text = df_test['text'].tolist()\n",
    "test_text = np.array(test_text, dtype=object)[:, np.newaxis]\n",
    "test_label = np.asarray(pd.get_dummies(df_test.label), dtype = np.int8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bqcRy_JWXe0u"
   },
   "source": [
    "## Train Keras model and save weights\n",
    "This only train and save our Keras layers not the embed module' weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 419
    },
    "colab_type": "code",
    "id": "_stfC_7VFhS8",
    "outputId": "09262f88-ed9d-4f2a-bda1-7112d0a219b8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 500 samples, validate on 500 samples\n",
      "Epoch 1/10\n",
      "500/500 [==============================] - 10s 19ms/step - loss: 1.5725 - acc: 0.5820 - val_loss: 1.2812 - val_acc: 0.7820\n",
      "Epoch 2/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 1.0754 - acc: 0.8140 - val_loss: 0.8339 - val_acc: 0.8600\n",
      "Epoch 3/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 0.7070 - acc: 0.8820 - val_loss: 0.5620 - val_acc: 0.9000\n",
      "Epoch 4/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 0.4949 - acc: 0.8960 - val_loss: 0.4182 - val_acc: 0.9060\n",
      "Epoch 5/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 0.3875 - acc: 0.9120 - val_loss: 0.3355 - val_acc: 0.9240\n",
      "Epoch 6/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 0.3143 - acc: 0.9200 - val_loss: 0.2819 - val_acc: 0.9300\n",
      "Epoch 7/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 0.2697 - acc: 0.9280 - val_loss: 0.2396 - val_acc: 0.9380\n",
      "Epoch 8/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 0.2317 - acc: 0.9440 - val_loss: 0.2087 - val_acc: 0.9440\n",
      "Epoch 9/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 0.2011 - acc: 0.9460 - val_loss: 0.1819 - val_acc: 0.9560\n",
      "Epoch 10/10\n",
      "500/500 [==============================] - 4s 8ms/step - loss: 0.1771 - acc: 0.9600 - val_loss: 0.1604 - val_acc: 0.9640\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as session:\n",
    "  K.set_session(session)\n",
    "  session.run(tf.global_variables_initializer())\n",
    "  session.run(tf.tables_initializer())\n",
    "  history = model.fit(train_text, \n",
    "            train_label,\n",
    "            validation_data=(test_text, test_label),\n",
    "            epochs=10,\n",
    "            batch_size=32)\n",
    "  model.save_weights('./model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "UW1CiBhnXnxa",
    "outputId": "1c9f90b9-3757-461e-d06e-076e524bd792"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-rw-r--  1 ec2-user ec2-user 534K Feb 10 02:14 model.h5\n"
     ]
    }
   ],
   "source": [
    "!ls -alh | grep model.h5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nQux6qLdXabG"
   },
   "source": [
    "## Make predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fSDxetlfUEiD"
   },
   "outputs": [],
   "source": [
    "new_text = [\"In what year did the titanic sink ?\", \"What is the highest peak in California ?\", \"Who invented the light bulb ?\"]\n",
    "new_text = np.array(new_text, dtype=object)[:, np.newaxis]\n",
    "with tf.Session() as session:\n",
    "  K.set_session(session)\n",
    "  session.run(tf.global_variables_initializer())\n",
    "  session.run(tf.tables_initializer())\n",
    "  model.load_weights('./model.h5')  \n",
    "  predicts = model.predict(new_text, batch_size=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 126
    },
    "colab_type": "code",
    "id": "xaR0d5VPU23Z",
    "outputId": "edeceb9e-d431-42d7-dd5d-dfe4381650a4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8.6309177e-05, 6.0993282e-04, 8.9653727e-04, 7.8736040e-05,\n",
       "        4.1685201e-04, 9.9791163e-01],\n",
       "       [1.6639127e-03, 2.2343441e-03, 2.3854697e-02, 2.3831504e-03,\n",
       "        6.6457403e-01, 3.0528989e-01],\n",
       "       [5.8392278e-04, 9.6685765e-04, 4.6175569e-02, 9.4956499e-01,\n",
       "        2.1396172e-03, 5.6900643e-04]], dtype=float32)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "yyDGVtigW57f",
    "outputId": "6261f056-7f3a-4413-c051-3c1d92c4fbc6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['NUM', 'LOC', 'HUM']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "categories = df_train.label.cat.categories.tolist()\n",
    "predict_logits = predicts.argmax(axis=1)\n",
    "predict_labels = [categories[logit] for logit in predict_logits]\n",
    "predict_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BnvjATdy64eR"
   },
   "source": [
    "# Semantic Textual Similarity Task Example\n",
    "\n",
    "The embeddings produced by the Universal Sentence Encoder are approximately normalized. The semantic similarity of two sentences can be trivially computed as the inner product of the encodings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "h1FFCTKm7ba4"
   },
   "outputs": [],
   "source": [
    "def plot_similarity(labels, features, rotation):\n",
    "  corr = np.inner(features, features)\n",
    "  sns.set(font_scale=1.2)\n",
    "  g = sns.heatmap(\n",
    "      corr,\n",
    "      xticklabels=labels,\n",
    "      yticklabels=labels,\n",
    "      vmin=0,\n",
    "      vmax=1,\n",
    "      cmap=\"YlOrRd\")\n",
    "  g.set_xticklabels(labels, rotation=rotation)\n",
    "  g.set_title(\"Semantic Textual Similarity\")\n",
    "\n",
    "\n",
    "def run_and_plot(session_, input_tensor_, messages_, encoding_tensor):\n",
    "  message_embeddings_ = session_.run(\n",
    "      encoding_tensor, feed_dict={input_tensor_: messages_})\n",
    "  plot_similarity(messages_, message_embeddings_, 90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "339tuJ5Pwqqv"
   },
   "source": [
    "## Similarity Visualized\n",
    "Here we show the similarity in a heat map. The final graph is a 9x9 matrix where each entry `[i, j]` is colored based on the inner product of the encodings for sentence `i` and `j`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hYhmukbSKpnp"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "messages = [\n",
    "    # AETERM\n",
    "      'LEFT KNEE PAIN',\n",
    "      'HEADACHE',\n",
    "      'OTITIS MEDIA',\n",
    "      'worsening of renal disorder',\n",
    "      'HEADACHE',\n",
    "      'SEIZURE',\n",
    " #AEDECOD\n",
    "      'Arthralgia',\n",
    "      'Bradycardia',\n",
    "      'Headache'\n",
    "      'Otitis media',\n",
    "      'Renal disorder',\n",
    "      'Headache',\n",
    "      'Seizure',\n",
    "]\n",
    "\n",
    "similarity_input_placeholder = tf.placeholder(tf.string, shape=(None))\n",
    "similarity_message_encodings = embed(similarity_input_placeholder)\n",
    "with tf.Session() as session:\n",
    "  session.run(tf.global_variables_initializer())\n",
    "  session.run(tf.tables_initializer())\n",
    "  run_and_plot(session, similarity_input_placeholder, messages,\n",
    "               similarity_message_encodings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Transfer Learning - Semantic Similarity with TF-Hub Universal Encoder",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "conda_tensorflow_p36",
   "language": "python",
   "name": "conda_tensorflow_p36"
  },
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}