{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "IJhWonqQN7u0" }, "source": [ "##### Copyright 2018 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-14T12:30:14.242923Z", "iopub.status.busy": "2022-12-14T12:30:14.242409Z", "iopub.status.idle": "2022-12-14T12:30:14.246343Z", "shell.execute_reply": "2022-12-14T12:30:14.245736Z" }, "id": "MegtYH2UN8tT" }, "outputs": [], "source": [ "# Copyright 2018 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": "MlHqSdgSEwPE" }, "source": [ "# Universal Sentence Encoder-Lite demo\n" ] }, { "cell_type": "markdown", "metadata": { "id": "MfBg1C5NB3X0" }, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", "
\n", " View on TensorFlow.org\n", " \n", " Run in Google Colab\n", " \n", " View on GitHub\n", " \n", " Download notebook\n", " \n", " See TF Hub model\n", "
" ] }, { "cell_type": "markdown", "metadata": { "id": "j0HuiScHQ3OK" }, "source": [ "This Colab illustrates how to use the Universal Sentence Encoder-Lite for sentence similarity task. This module is very similar to [Universal Sentence Encoder](https://www.tensorflow.org/hub/modules/google/universal-sentence-encoder/2) with the only difference that you need to run [SentencePiece](https://github.com/google/sentencepiece) processing on your input sentences.\n", "\n", "The Universal Sentence Encoder makes getting sentence level embeddings as easy as it has historically been to lookup the embeddings for individual words. The sentence embeddings can then be trivially used to compute sentence level meaning similarity as well as to enable better performance on downstream classification tasks using less supervised training data." ] }, { "cell_type": "markdown", "metadata": { "id": "wqCB2pyK-WSU" }, "source": [ "# Getting started" ] }, { "cell_type": "markdown", "metadata": { "id": "rWeEjoO5M0Cx" }, "source": [ "## Setup" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:14.249805Z", "iopub.status.busy": "2022-12-14T12:30:14.249575Z", "iopub.status.idle": "2022-12-14T12:30:17.496025Z", "shell.execute_reply": "2022-12-14T12:30:17.495080Z" }, "id": "f5_potQBMzcU" }, "outputs": [], "source": [ "# Install seaborn for pretty visualizations\n", "!pip3 install --quiet seaborn\n", "# Install SentencePiece package\n", "# SentencePiece package is needed for Universal Sentence Encoder Lite. We'll\n", "# use it for all the text processing and sentence feature ID lookup.\n", "!pip3 install --quiet sentencepiece" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:17.500096Z", "iopub.status.busy": "2022-12-14T12:30:17.499825Z", "iopub.status.idle": "2022-12-14T12:30:20.065601Z", "shell.execute_reply": "2022-12-14T12:30:20.064899Z" }, "id": "dMTa6V4a-cmf" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 12:30:18.447410: 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 12:30:18.447510: 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 12:30:18.447519: 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" ] }, { "name": "stdout", "output_type": "stream", "text": [ "WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.9/site-packages/tensorflow/python/compat/v2_compat.py:107: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "non-resource variables are not supported in the long term\n" ] } ], "source": [ "from absl import logging\n", "\n", "import tensorflow.compat.v1 as tf\n", "tf.disable_v2_behavior()\n", "\n", "import tensorflow_hub as hub\n", "import sentencepiece as spm\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" ] }, { "cell_type": "markdown", "metadata": { "id": "WPXYQDBiFJHd" }, "source": [ "## Load the module from TF-Hub" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:20.069975Z", "iopub.status.busy": "2022-12-14T12:30:20.069255Z", "iopub.status.idle": "2022-12-14T12:30:25.119524Z", "shell.execute_reply": "2022-12-14T12:30:25.118812Z" }, "id": "HEWUT-lmAkxM" }, "outputs": [], "source": [ "module = hub.Module(\"https://tfhub.dev/google/universal-sentence-encoder-lite/2\")" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:25.123161Z", "iopub.status.busy": "2022-12-14T12:30:25.122923Z", "iopub.status.idle": "2022-12-14T12:30:25.549711Z", "shell.execute_reply": "2022-12-14T12:30:25.549025Z" }, "id": "5277Z-9qARYF" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" ] } ], "source": [ "input_placeholder = tf.sparse_placeholder(tf.int64, shape=[None, None])\n", "encodings = module(\n", " inputs=dict(\n", " values=input_placeholder.values,\n", " indices=input_placeholder.indices,\n", " dense_shape=input_placeholder.dense_shape))" ] }, { "cell_type": "markdown", "metadata": { "id": "Yydbhuba_nek" }, "source": [ "## Load SentencePiece model from the TF-Hub Module\n", "The SentencePiece model is conveniently stored inside the module's assets. It has to be loaded in order to initialize the processor." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:25.553675Z", "iopub.status.busy": "2022-12-14T12:30:25.553149Z", "iopub.status.idle": "2022-12-14T12:30:26.359662Z", "shell.execute_reply": "2022-12-14T12:30:26.358938Z" }, "id": "2CyUjKzE_tcJ" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "SentencePiece model loaded at b'/tmpfs/tmp/tfhub_modules/539544f0a997d91c327c23285ea00c37588d92cc/assets/universal_encoder_8k_spm.model'.\n" ] } ], "source": [ "with tf.Session() as sess:\n", " spm_path = sess.run(module(signature=\"spm_path\"))\n", "\n", "sp = spm.SentencePieceProcessor()\n", "with tf.io.gfile.GFile(spm_path, mode=\"rb\") as f:\n", " sp.LoadFromSerializedProto(f.read())\n", "print(\"SentencePiece model loaded at {}.\".format(spm_path))" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:26.363305Z", "iopub.status.busy": "2022-12-14T12:30:26.362684Z", "iopub.status.idle": "2022-12-14T12:30:26.367449Z", "shell.execute_reply": "2022-12-14T12:30:26.366847Z" }, "id": "6y5kkN-l-5QV" }, "outputs": [], "source": [ "def process_to_IDs_in_sparse_format(sp, sentences):\n", " # An utility method that processes sentences with the sentence piece processor\n", " # 'sp' and returns the results in tf.SparseTensor-similar format:\n", " # (values, indices, dense_shape)\n", " ids = [sp.EncodeAsIds(x) for x in sentences]\n", " max_len = max(len(x) for x in ids)\n", " dense_shape=(len(ids), max_len)\n", " values=[item for sublist in ids for item in sublist]\n", " indices=[[row,col] for row in range(len(ids)) for col in range(len(ids[row]))]\n", " return (values, indices, dense_shape)" ] }, { "cell_type": "markdown", "metadata": { "id": "PVpHEWrPAdxR" }, "source": [ "### Test the module with a few examples" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:26.370478Z", "iopub.status.busy": "2022-12-14T12:30:26.369969Z", "iopub.status.idle": "2022-12-14T12:30:29.099170Z", "shell.execute_reply": "2022-12-14T12:30:29.098441Z" }, "id": "pSkjuGYoCBfU" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Message: Elephant\n", "Embedding size: 512\n", "Embedding: [0.053387485444545746, 0.05319438502192497, -0.052356019616127014, ...]\n", "\n", "Message: I am a sentence for which I would like to get its embedding.\n", "Embedding size: 512\n", "Embedding: [0.03533294424414635, -0.047149717807769775, 0.012305551208555698, ...]\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.004081601742655039, -0.08954868465662003, 0.037371981889009476, ...]\n", "\n" ] } ], "source": [ "# 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", "values, indices, dense_shape = process_to_IDs_in_sparse_format(sp, messages)\n", "\n", "# Reduce logging output.\n", "logging.set_verbosity(logging.ERROR)\n", "\n", "with tf.Session() as session:\n", " session.run([tf.global_variables_initializer(), tf.tables_initializer()])\n", " message_embeddings = session.run(\n", " encodings,\n", " feed_dict={input_placeholder.values: values,\n", " input_placeholder.indices: indices,\n", " input_placeholder.dense_shape: dense_shape})\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": "markdown", "metadata": { "id": "46jrIgHyFDz9" }, "source": [ "# Semantic Textual Similarity (STS) 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": 9, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:29.102878Z", "iopub.status.busy": "2022-12-14T12:30:29.102349Z", "iopub.status.idle": "2022-12-14T12:30:29.107525Z", "shell.execute_reply": "2022-12-14T12:30:29.106926Z" }, "id": "OIQudHgWBGSk" }, "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_placeholder, messages):\n", " values, indices, dense_shape = process_to_IDs_in_sparse_format(sp,messages)\n", "\n", " message_embeddings = session.run(\n", " encodings,\n", " feed_dict={input_placeholder.values: values,\n", " input_placeholder.indices: indices,\n", " input_placeholder.dense_shape: dense_shape})\n", " \n", " plot_similarity(messages, message_embeddings, 90)" ] }, { "cell_type": "markdown", "metadata": { "id": "wlDqttNcE0Bx" }, "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": 10, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:29.110268Z", "iopub.status.busy": "2022-12-14T12:30:29.110051Z", "iopub.status.idle": "2022-12-14T12:30:30.911319Z", "shell.execute_reply": "2022-12-14T12:30:30.910560Z" }, "id": "_GSCW5QIBKVe" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "messages = [\n", " # Smartphones\n", " \"I like my phone\",\n", " \"My phone is not good.\",\n", " \"Your cellphone looks great.\",\n", "\n", " # Weather\n", " \"Will it snow tomorrow?\",\n", " \"Recently a lot of hurricanes have hit the US\",\n", " \"Global warming is real\",\n", "\n", " # Food and health\n", " \"An apple a day, keeps the doctors away\",\n", " \"Eating strawberries is healthy\",\n", " \"Is paleo better than keto?\",\n", "\n", " # Asking about age\n", " \"How old are you?\",\n", " \"what is your age?\",\n", "]\n", "\n", "\n", "with tf.Session() as session:\n", " session.run(tf.global_variables_initializer())\n", " session.run(tf.tables_initializer())\n", " run_and_plot(session, input_placeholder, messages)" ] }, { "cell_type": "markdown", "metadata": { "id": "QkZ4sRBYBnL8" }, "source": [ "## Evaluation: STS (Semantic Textual Similarity) Benchmark\n", "\n", "The [**STS Benchmark**](https://ixa2.si.ehu.es/stswiki/index.php/STSbenchmark) provides an intristic evaluation of the degree to which similarity scores computed using sentence embeddings align with human judgements. The benchmark requires systems to return similarity scores for a diverse selection of sentence pairs. [Pearson correlation](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient) is then used to evaluate the quality of the machine similarity scores against human judgements." ] }, { "cell_type": "markdown", "metadata": { "id": "kNMVfSelBsHW" }, "source": [ "### Download data" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:30.916085Z", "iopub.status.busy": "2022-12-14T12:30:30.915823Z", "iopub.status.idle": "2022-12-14T12:30:32.831132Z", "shell.execute_reply": "2022-12-14T12:30:32.830446Z" }, "id": "8zAWVzBMBptq" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading data from http://ixa2.si.ehu.es/stswiki/images/4/48/Stsbenchmark.tar.gz\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\r", " 8192/409630 [..............................] - ETA: 0s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", " 16384/409630 [>.............................] - ETA: 3s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", " 32768/409630 [=>............................] - ETA: 2s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", " 57344/409630 [===>..........................] - ETA: 2s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", "106496/409630 [======>.......................] - ETA: 1s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", "163840/409630 [==========>...................] - ETA: 0s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", "245760/409630 [================>.............] - ETA: 0s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", "253952/409630 [=================>............] - ETA: 0s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", "327680/409630 [======================>.......] - ETA: 0s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", "385024/409630 [===========================>..] - ETA: 0s" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r", "409630/409630 [==============================] - 1s 2us/step\n" ] } ], "source": [ "import pandas\n", "import scipy\n", "import math\n", "\n", "\n", "def load_sts_dataset(filename):\n", " # Loads a subset of the STS dataset into a DataFrame. In particular both\n", " # sentences and their human rated similarity score.\n", " sent_pairs = []\n", " with tf.gfile.GFile(filename, \"r\") as f:\n", " for line in f:\n", " ts = line.strip().split(\"\\t\")\n", " # (sent_1, sent_2, similarity_score)\n", " sent_pairs.append((ts[5], ts[6], float(ts[4])))\n", " return pandas.DataFrame(sent_pairs, columns=[\"sent_1\", \"sent_2\", \"sim\"])\n", "\n", "\n", "def download_and_load_sts_data():\n", " sts_dataset = tf.keras.utils.get_file(\n", " fname=\"Stsbenchmark.tar.gz\",\n", " origin=\"http://ixa2.si.ehu.es/stswiki/images/4/48/Stsbenchmark.tar.gz\",\n", " extract=True)\n", "\n", " sts_dev = load_sts_dataset(\n", " os.path.join(os.path.dirname(sts_dataset), \"stsbenchmark\", \"sts-dev.csv\"))\n", " sts_test = load_sts_dataset(\n", " os.path.join(\n", " os.path.dirname(sts_dataset), \"stsbenchmark\", \"sts-test.csv\"))\n", "\n", " return sts_dev, sts_test\n", "\n", "\n", "sts_dev, sts_test = download_and_load_sts_data()" ] }, { "cell_type": "markdown", "metadata": { "id": "l8lEawD6B4Fr" }, "source": [ "### Build evaluation graph" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:32.834831Z", "iopub.status.busy": "2022-12-14T12:30:32.834179Z", "iopub.status.idle": "2022-12-14T12:30:33.956004Z", "shell.execute_reply": "2022-12-14T12:30:33.955343Z" }, "id": "etiZUkP-B6bR" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n" ] } ], "source": [ "sts_input1 = tf.sparse_placeholder(tf.int64, shape=(None, None))\n", "sts_input2 = tf.sparse_placeholder(tf.int64, shape=(None, None))\n", "\n", "# For evaluation we use exactly normalized rather than\n", "# approximately normalized.\n", "sts_encode1 = tf.nn.l2_normalize(\n", " module(\n", " inputs=dict(values=sts_input1.values,\n", " indices=sts_input1.indices,\n", " dense_shape=sts_input1.dense_shape)),\n", " axis=1)\n", "sts_encode2 = tf.nn.l2_normalize(\n", " module(\n", " inputs=dict(values=sts_input2.values,\n", " indices=sts_input2.indices,\n", " dense_shape=sts_input2.dense_shape)),\n", " axis=1)\n", "\n", "sim_scores = -tf.acos(tf.reduce_sum(tf.multiply(sts_encode1, sts_encode2), axis=1))\n" ] }, { "cell_type": "markdown", "metadata": { "id": "e4Q34ssLB-rw" }, "source": [ "### Evaluate sentence embeddings" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2022-12-14T12:30:33.959731Z", "iopub.status.busy": "2022-12-14T12:30:33.959209Z", "iopub.status.idle": "2022-12-14T12:30:34.022302Z", "shell.execute_reply": "2022-12-14T12:30:34.021640Z" }, "id": "-vRFEFPJPyeF" }, "outputs": [], "source": [ "#@title Choose dataset for benchmark\n", "dataset = sts_dev #@param [\"sts_dev\", \"sts_test\"] {type:\"raw\"}\n", "\n", "values1, indices1, dense_shape1 = process_to_IDs_in_sparse_format(sp, dataset['sent_1'].tolist())\n", "values2, indices2, dense_shape2 = process_to_IDs_in_sparse_format(sp, dataset['sent_2'].tolist())\n", "similarity_scores = dataset['sim'].tolist()" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T12:30:34.025216Z", "iopub.status.busy": "2022-12-14T12:30:34.024981Z", "iopub.status.idle": "2022-12-14T12:30:36.654597Z", "shell.execute_reply": "2022-12-14T12:30:36.653890Z" }, "id": "_QJ2DI85CBDh" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pearson correlation coefficient = 0.7856484834952554\n", "p-value = 1.0658075485e-314\n" ] } ], "source": [ "def run_sts_benchmark(session):\n", " \"\"\"Returns the similarity scores\"\"\"\n", " scores = session.run(\n", " sim_scores,\n", " feed_dict={\n", " sts_input1.values: values1,\n", " sts_input1.indices: indices1,\n", " sts_input1.dense_shape: dense_shape1,\n", " sts_input2.values: values2,\n", " sts_input2.indices: indices2,\n", " sts_input2.dense_shape: dense_shape2,\n", " })\n", " return scores\n", "\n", "\n", "with tf.Session() as session:\n", " session.run(tf.global_variables_initializer())\n", " session.run(tf.tables_initializer())\n", " scores = run_sts_benchmark(session)\n", "\n", "pearson_correlation = scipy.stats.pearsonr(scores, similarity_scores)\n", "print('Pearson correlation coefficient = {0}\\np-value = {1}'.format(\n", " pearson_correlation[0], pearson_correlation[1]))" ] } ], "metadata": { "colab": { "collapsed_sections": [ "IJhWonqQN7u0" ], "name": "Semantic Similarity with TF-Hub Universal Encoder Lite", "private_outputs": true, "provenance": [], "toc_visible": true }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.16" } }, "nbformat": 4, "nbformat_minor": 0 }