HTTP/2 200 content-type: application/octet-stream x-guploader-uploadid: ABgVH8_4ASanNjpJWkU0jXEqGeI3-w4b4kWq2WvfvVzFaVzLlLORR918hdmSISHRghTSr71Htp9DMIo expires: Wed, 16 Jul 2025 15:37:50 GMT date: Wed, 16 Jul 2025 14:37:50 GMT cache-control: public, max-age=3600 last-modified: Sat, 03 Jun 2023 11:15:19 GMT etag: "bca36f6ee96ae82201bcf8abd4a383ee" x-goog-generation: 1685790919493060 x-goog-metageneration: 1 x-goog-stored-content-encoding: identity x-goog-stored-content-length: 158418 x-goog-hash: crc32c=Hl7Efw== x-goog-hash: md5=vKNvbulq6CIBvPir1KOD7g== x-goog-storage-class: MULTI_REGIONAL accept-ranges: bytes content-length: 158418 server: UploadServer alt-svc: h3=":443"; ma=2592000,h3-29=":443"; ma=2592000 { "cells": [ { "cell_type": "markdown", "metadata": { "id": "wlFbFLUghfjo" }, "source": [ "##### Copyright 2021 The TensorFlow Authors." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "id": "4FyfuZX-gTKS" }, "outputs": [], "source": [ "#@title 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", "# https://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." ] }, { "cell_type": "markdown", "metadata": { "id": "I_16rv9EPhB_" }, "source": [ "# TensorFlow Ranking Keras pipeline for distributed training\n", "\n", "\u003ctable class=\"tfo-notebook-buttons\" align=\"left\"\u003e\n", " \u003ctd\u003e\n", " \u003ca target=\"_blank\" href=\"https://www.tensorflow.org/ranking/tutorials/ranking_dnn_distributed\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" /\u003eView on TensorFlow.org\u003c/a\u003e\n", " \u003c/td\u003e\n", " \u003ctd\u003e\n", " \u003ca target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/ranking/blob/master/docs/tutorials/ranking_dnn_distributed.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /\u003eRun in Google Colab\u003c/a\u003e\n", " \u003c/td\u003e\n", " \u003ctd\u003e\n", " \u003ca target=\"_blank\" href=\"https://github.com/tensorflow/ranking/blob/master/docs/tutorials/ranking_dnn_distributed.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /\u003eView source on GitHub\u003c/a\u003e\n", " \u003c/td\u003e\n", " \u003ctd\u003e\n", " \u003ca href=\"https://storage.googleapis.com/tensorflow_docs/ranking/docs/tutorials/ranking_dnn_distributed.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/download_logo_32px.png\" /\u003eDownload notebook\u003c/a\u003e\n", " \u003c/td\u003e\n", "\u003c/table\u003e" ] }, { "cell_type": "markdown", "metadata": { "id": "V8tMYn22vtDV" }, "source": [ "TensorFlow Ranking can handle heterogeneous dense and sparse features, and scales up to millions of data points. However, building and deploying a learning to rank model to operate at scale creates additional challenges beyond simply designing a model. The Ranking library provides workflow utility classes for building [distributed training](https://www.tensorflow.org/guide/distributed_training) for large-scale ranking applications. For more information about these features, see the TensorFlow Ranking [Overview](../overview).\n", "\n", "This tutorial shows you how to build a ranking model that enables a distributed processing strategy by using the Ranking library's support for a pipeline processing architecture.\n", "\n", "Note: An advanced version of this code is also available as a [Python script](https://github.com/tensorflow/ranking/blob/master/tensorflow_ranking/examples/keras/antique_ragged.py). The script version supports flags for hyperparameters, and advanced use-cases like [Document Interaction Network](https://research.google/pubs/pub49364)." ] }, { "cell_type": "markdown", "metadata": { "id": "UxG7i8xbDIDF" }, "source": [ "## ANTIQUE dataset\n", "\n", "In this tutorial, you will build a ranking model for ANTIQUE, a question-answering dataset. Given a query, and a list of answers, the objective is to rank the answers with optimal rank related metrics, such as NDCG. For more details about ranking metrics, review evaluation measures [offline metrics](https://en.wikipedia.org/wiki/Evaluation_measures_(information_retrieval)#Offline_metrics).\n", "\n", "[ANTIQUE](https://ciir.cs.umass.edu/downloads/Antique/) is a publicly available dataset for open-domain non-factoid question answering, collected from Yahoo! answers.\n", "Each question has a list of answers, whose relevance are graded on a scale of 0-4, 0 for irrelevant and 4 for fully relevant.\n", "The list size can vary depending on the query, so we use a fixed \"list size\" of 50, where the list is either truncated or padded with default values.\n", "The dataset is split into 2206 queries for training and 200 queries for testing. For more details, please read the technical paper on [arXiv](https://arxiv.org/abs/1905.08957)." ] }, { "cell_type": "markdown", "metadata": { "id": "ucWaXnFazZXD" }, "source": [ "## Setup\n", "\n", "Download and install the TensorFlow Ranking and TensorFlow Serving packages." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "aPmhLkMWgPLO" }, "outputs": [], "source": [ "!pip install -q tensorflow-ranking tensorflow-serving-api\n", "!pip install -U \"tensorflow-text==2.11.*\"" ] }, { "cell_type": "markdown", "metadata": { "id": "9OKDJUjq0rnm" }, "source": [ "Import TensorFlow Ranking library and useful libraries through the notebook." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "fmlaz2D5Ux3J" }, "outputs": [], "source": [ "import pathlib\n", "\n", "import tensorflow as tf\n", "import tensorflow_ranking as tfr\n", "import tensorflow_text as tf_text\n", "from tensorflow_serving.apis import input_pb2\n", "from google.protobuf import text_format" ] }, { "cell_type": "markdown", "metadata": { "id": "JNilCoqq1jJn" }, "source": [ "## Data preparation\n", "\n", "Download training, test data, and vocabulary file." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "Mwxtsi4wqoOJ" }, "outputs": [], "source": [ "!wget -O \"/tmp/train.tfrecords\" \"https://ciir.cs.umass.edu/downloads/Antique/tf-ranking/ELWC/train.tfrecords\"\n", "!wget -O \"/tmp/test.tfrecords\" \"https://ciir.cs.umass.edu/downloads/Antique/tf-ranking//ELWC/test.tfrecords\"\n", "!wget -O \"/tmp/vocab.txt\" \"https://ciir.cs.umass.edu/downloads/Antique/tf-ranking/vocab.txt\"" ] }, { "cell_type": "markdown", "metadata": { "id": "T7L-IOmOWm3s" }, "source": [ "Here, the dataset is saved in a ranking-specific ExampleListWithContext (ELWC) format. Detailed in the next section, shows how to generate and store data in the ELWC format." ] }, { "cell_type": "markdown", "metadata": { "id": "6tuna6Td3_UO" }, "source": [ "### ELWC Data Formats for Ranking\n", "\n", "The data for a single question consists of a list of `query_tokens` representing the question (the \"context\"), and a list of answers (the \"examples\"). Each answer is represented as a list of `document_tokens` and a `relevance` score. The following code shows a _simplified_ representation of a question's data:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "9uqSmfoaQc_-" }, "outputs": [], "source": [ "example_list_with_context = {\n", " \"context\": {\n", " \"query_tokens\": [\"this\", \"is\", \"a\", \"question\"]\n", " },\n", " \"examples\": [\n", " {\n", " \"document_tokens\": [\"this\", \"is\", \"a\", \"relevant\", \"answer\"],\n", " \"relevance\": [4]\n", " },\n", " {\n", " \"document_tokens\": [\"irrelevant\", \"data\"],\n", " \"relevance\": [0]\n", " }\n", " ]\n", "}" ] }, { "cell_type": "markdown", "metadata": { "id": "95QnMu1cyPYA" }, "source": [ "The data files, downloaded in the previous section, contain a serialized [protobuffer](https://developers.google.com/protocol-buffers/) representation of this sort of data.\n", "These protobuffers are quite long when viewed as text, but encode the same data." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "ooOmCPHbyd02" }, "outputs": [], "source": [ "CONTEXT = text_format.Parse(\n", " \"\"\"\n", " features {\n", " feature {\n", " key: \"query_tokens\"\n", " value { bytes_list { value: [\"this\", \"is\", \"a\", \"question\"] } }\n", " }\n", " }\"\"\", tf.train.Example())" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "eE7hpEBBykVS" }, "outputs": [], "source": [ "EXAMPLES = [\n", " text_format.Parse(\n", " \"\"\"\n", " features {\n", " feature {\n", " key: \"document_tokens\"\n", " value { bytes_list { value: [\"this\", \"is\", \"a\", \"relevant\", \"answer\"] } }\n", " }\n", " feature {\n", " key: \"relevance\"\n", " value { int64_list { value: 4 } }\n", " }\n", " }\"\"\", tf.train.Example()),\n", " text_format.Parse(\n", " \"\"\"\n", " features {\n", " feature {\n", " key: \"document_tokens\"\n", " value { bytes_list { value: [\"irrelevant\", \"data\"] } }\n", " }\n", " feature {\n", " key: \"relevance\"\n", " value { int64_list { value: 0 } }\n", " }\n", " }\"\"\", tf.train.Example()),\n", "]" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "iImhGlJyyo--", "outputId": "5c3c018d-c7e2-491c-8426-cdee999b9251" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "examples {\n", " features {\n", " feature {\n", " key: \"document_tokens\"\n", " value {\n", " bytes_list {\n", " value: \"this\"\n", " value: \"is\"\n", " value: \"a\"\n", " value: \"relevant\"\n", " value: \"answer\"\n", " }\n", " }\n", " }\n", " feature {\n", " key: \"relevance\"\n", " value {\n", " int64_list {\n", " value: 4\n", " }\n", " }\n", " }\n", " }\n", "}\n", "examples {\n", " features {\n", " feature {\n", " key: \"document_tokens\"\n", " value {\n", " bytes_list {\n", " value: \"irrelevant\"\n", " value: \"data\"\n", " }\n", " }\n", " }\n", " feature {\n", " key: \"relevance\"\n", " value {\n", " int64_list {\n", " value: 0\n", " }\n", " }\n", " }\n", " }\n", "}\n", "context {\n", " features {\n", " feature {\n", " key: \"query_tokens\"\n", " value {\n", " bytes_list {\n", " value: \"this\"\n", " value: \"is\"\n", " value: \"a\"\n", " value: \"question\"\n", " }\n", " }\n", " }\n", " }\n", "}\n", "\n" ] } ], "source": [ "ELWC = input_pb2.ExampleListWithContext()\n", "ELWC.context.CopyFrom(CONTEXT)\n", "for example in EXAMPLES:\n", " example_features = ELWC.examples.add()\n", " example_features.CopyFrom(example)\n", "\n", "print(ELWC)" ] }, { "cell_type": "markdown", "metadata": { "id": "fCjUs4tk0oej" }, "source": [ "While the text format is verbose, protos can be efficiently serialized to a byte string (and parsed back into a proto)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "Bt3c6fUOKkAG", "outputId": "949bd7be-8785-48d0-ef1d-c1bbefdc44f9" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "b\"\\nL\\nJ\\n4\\n\\x0fdocument_tokens\\x12!\\n\\x1f\\n\\x04this\\n\\x02is\\n\\x01a\\n\\x08relevant\\n\\x06answer\\n\\x12\\n\\trelevance\\x12\\x05\\x1a\\x03\\n\\x01\\x04\\n?\\n=\\n\\x12\\n\\trelevance\\x12\\x05\\x1a\\x03\\n\\x01\\x00\\n'\\n\\x0fdocument_tokens\\x12\\x14\\n\\x12\\n\\nirrelevant\\n\\x04data\\x12-\\n+\\n)\\n\\x0cquery_tokens\\x12\\x19\\n\\x17\\n\\x04this\\n\\x02is\\n\\x01a\\n\\x08question\"\n" ] } ], "source": [ "serialized_elwc = ELWC.SerializeToString()\n", "print(serialized_elwc)" ] }, { "cell_type": "markdown", "metadata": { "id": "DI8maZPqKxQ0" }, "source": [ "The following parser configuration parses the binary representation into a dictionary of tensors:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "EdhG7t3MGr1G", "outputId": "c634ede5-00e4-4358-f035-00d18513a480" }, "outputs": [ { "data": { "text/plain": [ "{'_list_size_': \u003ctf.Tensor: shape=(1,), dtype=int32, numpy=array([2], dtype=int32)\u003e,\n", " '_mask_': \u003ctf.Tensor: shape=(1, 2), dtype=bool, numpy=array([[ True, True]])\u003e,\n", " 'document_tokens': \u003ctf.RaggedTensor [[[b'this', b'is', b'a', b'relevant', b'answer'], [b'irrelevant', b'data']]]\u003e,\n", " 'query_tokens': \u003ctf.RaggedTensor [[b'this', b'is', b'a', b'question']]\u003e,\n", " 'relevance': \u003ctf.Tensor: shape=(1, 2), dtype=int64, numpy=array([[4, 0]])\u003e}" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def parse_elwc(elwc):\n", " return tfr.data.parse_from_example_list(\n", " [elwc],\n", " list_size=2,\n", " context_feature_spec={\"query_tokens\": tf.io.RaggedFeature(dtype=tf.string)},\n", " example_feature_spec={\n", " \"document_tokens\":\n", " tf.io.RaggedFeature(dtype=tf.string),\n", " \"relevance\":\n", " tf.io.FixedLenFeature(shape=[], dtype=tf.int64, default_value=0)\n", " },\n", " size_feature_name=\"_list_size_\",\n", " mask_feature_name=\"_mask_\")\n", "\n", "parse_elwc(serialized_elwc)" ] }, { "cell_type": "markdown", "metadata": { "id": "nCluYFt8LSP-" }, "source": [ "Note with ELWC, you could also generate `size` and/or `mask` features to indicate the valid size and/or to mask out the valid entries in the list as long as `size_feature_name` and/or `mask_feature_name` are defined." ] }, { "cell_type": "markdown", "metadata": { "id": "scY9IVwMThDi" }, "source": [ "The above parser is defined in `tfr.data` and wrapped in our predefined dataset builder `tfr.keras.pipeline.BaseDatasetBuilder`." ] }, { "cell_type": "markdown", "metadata": { "id": "tFbFBTUh9WXf" }, "source": [ "## Overview of the ranking pipeline\n", "\n", "Follow the steps depicted in the figure below to train a ranking model with ranking pipeline. In particular, this example uses the `tfr.keras.model.FeatureSpecInputCreator` and `tfr.keras.pipeline.BaseDatasetBuilder` defined specific for the datasets with `feature_spec`.\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "aQ-VTA56sOTA" }, "source": [ "## Create a model builder\n", "\n", "Instead of directly building a `tf.keras.Model` object, create a model_builder, which is called in the ranking pipeline to build the `tf.keras.Model`, as all training parameters must be defined under the `strategy.scope` (called in `train_and_validate` function in ranking pipeline) in order to train with distributed strategies.\n", "\n", "This framework uses the [keras functional api](https://www.tensorflow.org/guide/keras/functional) to build models, where inputs (`tf.keras.Input`), preprocessors (`tf.keras.layers.experimental.preprocessing`), and scorer (`tf.keras.Sequential`) are required to define the model." ] }, { "cell_type": "markdown", "metadata": { "id": "at0nVKnts8Pn" }, "source": [ "### Specify Features\n", "\n", "[Feature Specification](https://www.tensorflow.org/api_docs/python/tf/io) are TensorFlow abstractions that are used to capture rich information about each feature.\n", "\n", "Create feature specifications for context features, example features, and labels, consistent with the input formats for ranking, such as ELWC format.\n", "\n", "The `default_value` of `label_spec` feature is set to -1 to take care of the padding items to be masked out." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "nSXd4pEPqaQW" }, "outputs": [], "source": [ "context_feature_spec = {\n", " \"query_tokens\": tf.io.RaggedFeature(dtype=tf.string),\n", "}\n", "example_feature_spec = {\n", " \"document_tokens\":\n", " tf.io.RaggedFeature(dtype=tf.string),\n", "}\n", "label_spec = (\n", " \"relevance\",\n", " tf.io.FixedLenFeature(shape=(1,), dtype=tf.int64, default_value=-1)\n", ")" ] }, { "cell_type": "markdown", "metadata": { "id": "dw78n3UVZLnR" }, "source": [ "### Define `input_creator`\n", "\n", "`input_creator` create dictionaries of context and example `tf.keras.Input`s for input features defined in `context_feature_spec` and `example_feature_spec`." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "4AAidWeFY8_h" }, "outputs": [], "source": [ "input_creator = tfr.keras.model.FeatureSpecInputCreator(\n", " context_feature_spec, example_feature_spec)" ] }, { "cell_type": "markdown", "metadata": { "id": "pmjkqpY0_zoH" }, "source": [ "Callling the `input_creator` returns the dictionaries of Keras-Tensors, that are used as the inputs when building the model:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "F4w_7U1m_3Ev", "outputId": "ce2cfdca-9025-41d6-fb99-7180595ae0bf" }, "outputs": [ { "data": { "text/plain": [ "({'query_tokens': \u003cKerasTensor: type_spec=RaggedTensorSpec(TensorShape([None, None]), tf.string, 1, tf.int64) (created by layer 'query_tokens')\u003e},\n", " {'document_tokens': \u003cKerasTensor: type_spec=RaggedTensorSpec(TensorShape([None, None, None]), tf.string, 2, tf.int64) (created by layer 'document_tokens')\u003e})" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "input_creator()" ] }, { "cell_type": "markdown", "metadata": { "id": "dg0N0FscZVin" }, "source": [ "### Define `preprocessor`\n", "\n", "In the `preprocessor`, the input tokens are converted to a one-hot vector through the String Lookup preprocessing layer and then embeded as an embedding vector through the Embedding preprocessing layer. Finally, compute an embedding vector for the full sentence by the average of token embeddings." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "2eSAoISdtQ9r" }, "outputs": [], "source": [ "class LookUpTablePreprocessor(tfr.keras.model.Preprocessor):\n", "\n", " def __init__(self, vocab_file, vocab_size, embedding_dim):\n", " self._vocab_file = vocab_file\n", " self._vocab_size = vocab_size\n", " self._embedding_dim = embedding_dim\n", "\n", " def __call__(self, context_inputs, example_inputs, mask):\n", " list_size = tf.shape(mask)[1]\n", " lookup = tf.keras.layers.StringLookup(\n", " max_tokens=self._vocab_size,\n", " vocabulary=self._vocab_file,\n", " mask_token=None)\n", " embedding = tf.keras.layers.Embedding(\n", " input_dim=self._vocab_size,\n", " output_dim=self._embedding_dim,\n", " embeddings_initializer=None,\n", " embeddings_constraint=None)\n", " # StringLookup and Embedding are shared over context and example features.\n", " context_features = {\n", " key: tf.reduce_mean(embedding(lookup(value)), axis=-2)\n", " for key, value in context_inputs.items()\n", " }\n", " example_features = {\n", " key: tf.reduce_mean(embedding(lookup(value)), axis=-2)\n", " for key, value in example_inputs.items()\n", " }\n", " return context_features, example_features" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "VhIxo4hOZY0L" }, "outputs": [], "source": [ "_VOCAB_FILE = '/tmp/vocab.txt'\n", "_VOCAB_SIZE = len(pathlib.Path(_VOCAB_FILE).read_text().split())" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "Vd2kk-kGb4sv" }, "outputs": [], "source": [ "preprocessor = LookUpTablePreprocessor(_VOCAB_FILE, _VOCAB_SIZE, 20)" ] }, { "cell_type": "markdown", "metadata": { "id": "lMo8KPBwvmIw" }, "source": [ "Note that the vocabulary uses the same tokenizer that BERT does. You could also use [BertTokenizer](https://www.tensorflow.org/text/guide/subwords_tokenizer) to tokenize the raw sentences." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "VvqaOQjSv1l2", "outputId": "737015a0-7889-4645-9956-b34172ddd561" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u003ctf.RaggedTensor [[[7592], [23435, 12314], [999]]]\u003e\n", "\u003ctf.RaggedTensor [[[b'hello'], [b'tensorflow'], [b'!']]]\u003e\n" ] } ], "source": [ "tokenizer = tf_text.BertTokenizer(_VOCAB_FILE)\n", "example_tokens = tokenizer.tokenize(\"Hello TensorFlow!\".lower())\n", "\n", "print(example_tokens)\n", "print(tokenizer.detokenize(example_tokens))" ] }, { "cell_type": "markdown", "metadata": { "id": "ggv8lIpkekng" }, "source": [ "### Define `scorer`\n", "\n", "This example uses a Deep Neural Network (DNN) univariate scorer, predefined in TensorFlow Ranking." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "k31ZYnnAfIpe" }, "outputs": [], "source": [ "scorer = tfr.keras.model.DNNScorer(\n", " hidden_layer_dims=[64, 32, 16],\n", " output_units=1,\n", " activation=tf.nn.relu,\n", " use_batch_norm=True)" ] }, { "cell_type": "markdown", "metadata": { "id": "3PwsTZ5PiZBN" }, "source": [ "### Make `model_builder`\n", "\n", "In addition to `input_creator`, `preprocessor`, and `scorer`, specify the mask feature name to take the mask feature generated in datasets." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "5uMDkiSOifL2" }, "outputs": [], "source": [ "model_builder = tfr.keras.model.ModelBuilder(\n", " input_creator=input_creator,\n", " preprocessor=preprocessor,\n", " scorer=scorer,\n", " mask_feature_name=\"example_list_mask\",\n", " name=\"antique_model\",\n", ")" ] }, { "cell_type": "markdown", "metadata": { "id": "6NY35Ct_-TTr" }, "source": [ "Check the model architecture," ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "-hvxdkNF-P76", "outputId": "1ed4c533-92fa-41b1-eb45-456fd1e04138" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "\u003cIPython.core.display.Image object\u003e" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model = model_builder.build()\n", "tf.keras.utils.plot_model(model, expand_nested=True)" ] }, { "cell_type": "markdown", "metadata": { "id": "ZGJ6rRJyZmiB" }, "source": [ "## Create a dataset builder\n", "\n", "A `dataset_builder` is designed to create datasets for training and validation and to define [signatures](https://www.tensorflow.org/guide/saved_model#specifying_signatures_during_export) for exporting trained model as `tf.function`. " ] }, { "cell_type": "markdown", "metadata": { "id": "-AycDBrIoct_" }, "source": [ "### Specify data hyperparameters\n", "\n", "Define the hyperparameters to be used to build datasets in `dataset_builder` by creating a `dataset_hparams` object.\n", "\n", "Load training dataset at `/tmp/train.tfrecords` with `tf.data.TFRecordDataset` reader. In each batch, each feature tensor has a shape `(batch_size, list_size, feature_sizes)` with `batch_size` equal to 32 and `list_size` equal to 50. Validate with the test data at `/tmp/test.tfrecords` at the same `batch_size` and `list_size`." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "PvAPaDXPjJ3L" }, "outputs": [], "source": [ "dataset_hparams = tfr.keras.pipeline.DatasetHparams(\n", " train_input_pattern=\"/tmp/train.tfrecords\",\n", " valid_input_pattern=\"/tmp/test.tfrecords\",\n", " train_batch_size=32,\n", " valid_batch_size=32,\n", " list_size=50,\n", " dataset_reader=tf.data.TFRecordDataset)" ] }, { "cell_type": "markdown", "metadata": { "id": "oPg0FRazjo8P" }, "source": [ "### Make `dataset_builder`\n", "\n", "TensorFlow Ranking provides a pre-defined `SimpleDatasetBuilder` to generate datasets from ELWC using `feature_spec`s. As a mask feature is used to determine valid examples in each padded list, must specify the `mask_feature_name` consistent with the `mask_feature_name` used in `model_builder`." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "JtdPgebnjC18" }, "outputs": [], "source": [ "dataset_builder = tfr.keras.pipeline.SimpleDatasetBuilder(\n", " context_feature_spec,\n", " example_feature_spec,\n", " mask_feature_name=\"example_list_mask\",\n", " label_spec=label_spec,\n", " hparams=dataset_hparams)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "n3rK7Yb0_RL8", "outputId": "2ac33742-8bb2-42df-8827-b10589155a28" }, "outputs": [ { "data": { "text/plain": [ "({'document_tokens': RaggedTensorSpec(TensorShape([None, 50, None]), tf.string, 2, tf.int32),\n", " 'example_list_mask': TensorSpec(shape=(32, 50), dtype=tf.bool, name=None),\n", " 'query_tokens': RaggedTensorSpec(TensorShape([32, None]), tf.string, 1, tf.int32)},\n", " TensorSpec(shape=(32, 50), dtype=tf.float32, name=None))" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ds_train = dataset_builder.build_train_dataset()\n", "ds_train.element_spec" ] }, { "cell_type": "markdown", "metadata": { "id": "EIhdYyRok9Li" }, "source": [ "## Create a ranking pipeline\n", "\n", "A `ranking_pipeline` is an optimized ranking model training package that implement distributed training, export model as `tf.function`, and integrate useful callbacks including tensorboard and restoring upon failures." ] }, { "cell_type": "markdown", "metadata": { "id": "RqM6WW-Kp95E" }, "source": [ "### Specify pipeline hyperparameters\n", "\n", "Specify the hyperparameters to be used to run the pipeline in `ranking_pipeline` by creating a `pipeline_hparams` object. \n", "\n", "Train the model with `approx_ndcg_loss` at learning rate equal to 0.05 for 5 epoch with 1000 steps in each epoch using `MirroredStrategy`. Evaluate the model on the validation dataset for 100 steps after each epoch. Save the trained model under `/tmp/ranking_model_dir`." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "tx1r0ef7lLEG" }, "outputs": [], "source": [ "pipeline_hparams = tfr.keras.pipeline.PipelineHparams(\n", " model_dir=\"/tmp/ranking_model_dir\",\n", " num_epochs=5,\n", " steps_per_epoch=1000,\n", " validation_steps=100,\n", " learning_rate=0.05,\n", " loss=\"approx_ndcg_loss\",\n", " strategy=\"MirroredStrategy\")" ] }, { "cell_type": "markdown", "metadata": { "id": "UMOA9Cojln6K" }, "source": [ "### Define `ranking_pipeline`\n", "\n", "TensorFlow Ranking provides a pre-defined `SimplePipeline` to support model training with distributed strategies." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "gLC-8SwamAvh", "outputId": "ba429aa6-b657-4506-f4c6-4b1c7deaad0d" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING:tensorflow:There are non-GPU devices in `tf.distribute.Strategy`, not using nccl allreduce.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "WARNING:tensorflow:There are non-GPU devices in `tf.distribute.Strategy`, not using nccl allreduce.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0',)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0',)\n" ] } ], "source": [ "ranking_pipeline = tfr.keras.pipeline.SimplePipeline(\n", " model_builder,\n", " dataset_builder=dataset_builder,\n", " hparams=pipeline_hparams)" ] }, { "cell_type": "markdown", "metadata": { "id": "_EPvXEbomK29" }, "source": [ "## Train and evaluate the model\n", "\n", "The `train_and_validate` function evaluates the trained model on the validation dataset after every epoch." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "BZr8MX6VmQSj", "outputId": "2a923f85-7cbd-45f4-fb92-c249aeae0880" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/5\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/indexed_slices.py:450: UserWarning: Converting sparse IndexedSlices(IndexedSlices(indices=Tensor(\"gradient_tape/antique_model/flatten_list_2/RaggedGatherNd/RaggedGatherNd/RaggedGather/Reshape_1:0\", shape=(1600,), dtype=int32, device=/job:localhost/replica:0/task:0/device:CPU:0), values=Tensor(\"gradient_tape/antique_model/flatten_list_2/RaggedGatherNd/RaggedGatherNd/RaggedGather/Reshape:0\", shape=(1600, 20), dtype=float32, device=/job:localhost/replica:0/task:0/device:CPU:0), dense_shape=Tensor(\"gradient_tape/antique_model/flatten_list_2/RaggedGatherNd/RaggedGatherNd/RaggedGather/Cast:0\", shape=(2,), dtype=int32, device=/job:localhost/replica:0/task:0/device:CPU:0))) to a dense Tensor of unknown shape. This may consume a large amount of memory.\n", " \"shape. This may consume a large amount of memory.\" % value)\n", "/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/indexed_slices.py:450: UserWarning: Converting sparse IndexedSlices(IndexedSlices(indices=Tensor(\"gradient_tape/while/antique_model/flatten_list_2/RaggedGatherNd/RaggedGatherNd/RaggedGather/Reshape_1:0\", shape=(1600,), dtype=int32, device=/job:localhost/replica:0/task:0/device:CPU:0), values=Tensor(\"gradient_tape/while/antique_model/flatten_list_2/RaggedGatherNd/RaggedGatherNd/RaggedGather/Reshape:0\", shape=(1600, 20), dtype=float32, device=/job:localhost/replica:0/task:0/device:CPU:0), dense_shape=Tensor(\"gradient_tape/while/antique_model/flatten_list_2/RaggedGatherNd/RaggedGatherNd/RaggedGather/Cast:0\", shape=(2,), dtype=int32, device=/job:localhost/replica:0/task:0/device:CPU:0))) to a dense Tensor of unknown shape. This may consume a large amount of memory.\n", " \"shape. This may consume a large amount of memory.\" % value)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "1000/1000 [==============================] - 121s 121ms/step - loss: -0.8845 - metric/ndcg_1: 0.7122 - metric/ndcg_5: 0.7813 - metric/ndcg_10: 0.8413 - metric/ndcg: 0.8856 - val_loss: -0.8672 - val_metric/ndcg_1: 0.6557 - val_metric/ndcg_5: 0.7689 - val_metric/ndcg_10: 0.8243 - val_metric/ndcg: 0.8678\n", "Epoch 2/5\n", "1000/1000 [==============================] - 88s 88ms/step - loss: -0.8957 - metric/ndcg_1: 0.7428 - metric/ndcg_5: 0.8005 - metric/ndcg_10: 0.8551 - metric/ndcg: 0.8959 - val_loss: -0.8731 - val_metric/ndcg_1: 0.6614 - val_metric/ndcg_5: 0.7812 - val_metric/ndcg_10: 0.8348 - val_metric/ndcg: 0.8733\n", "Epoch 3/5\n", "1000/1000 [==============================] - 50s 50ms/step - loss: -0.8955 - metric/ndcg_1: 0.7422 - metric/ndcg_5: 0.7991 - metric/ndcg_10: 0.8545 - metric/ndcg: 0.8957 - val_loss: -0.8695 - val_metric/ndcg_1: 0.6414 - val_metric/ndcg_5: 0.7759 - val_metric/ndcg_10: 0.8315 - val_metric/ndcg: 0.8699\n", "Epoch 4/5\n", "1000/1000 [==============================] - 53s 53ms/step - loss: -0.9009 - metric/ndcg_1: 0.7563 - metric/ndcg_5: 0.8094 - metric/ndcg_10: 0.8620 - metric/ndcg: 0.9011 - val_loss: -0.8624 - val_metric/ndcg_1: 0.6179 - val_metric/ndcg_5: 0.7627 - val_metric/ndcg_10: 0.8253 - val_metric/ndcg: 0.8626\n", "Epoch 5/5\n", "1000/1000 [==============================] - 52s 52ms/step - loss: -0.9042 - metric/ndcg_1: 0.7646 - metric/ndcg_5: 0.8152 - metric/ndcg_10: 0.8662 - metric/ndcg: 0.9044 - val_loss: -0.8733 - val_metric/ndcg_1: 0.6579 - val_metric/ndcg_5: 0.7741 - val_metric/ndcg_10: 0.8362 - val_metric/ndcg: 0.8741\n", "INFO:tensorflow:Assets written to: /tmp/ranking_model_dir/export/latest_model/assets\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Assets written to: /tmp/ranking_model_dir/export/latest_model/assets\n" ] } ], "source": [ "ranking_pipeline.train_and_validate(verbose=1)" ] }, { "cell_type": "markdown", "metadata": { "id": "45WYaJNaGfLM" }, "source": [ "### Launch TensorBoard" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "sHfuUVQ5D1jq" }, "outputs": [], "source": [ "%load_ext tensorboard\n", "%tensorboard --logdir=\"/tmp/ranking_model_dir\" --port 12345" ] }, { "cell_type": "markdown", "metadata": { "id": "S1s1BKWSP8p_" }, "source": [ "\u003c!-- \u003cimg class=\"tfo-display-only-on-site\" src=\"https://user-images.githubusercontent.com/18746174/136845677-8cd41b8f-0a1a-4b38-b905-779966839e5f.png\" /\u003e --\u003e" ] }, { "cell_type": "markdown", "metadata": { "id": "juSvnOWiSbVw" }, "source": [ "### Generate predictions and evaluate\n", "\n", "Get the test data." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "a23f4q4wSbIQ" }, "outputs": [], "source": [ "ds_test = dataset_builder.build_valid_dataset()\n", "\n", "# Get input features from the first batch of the test data\n", "for x, y in ds_test.take(1):\n", " break" ] }, { "cell_type": "markdown", "metadata": { "id": "3werWYrkfYPV" }, "source": [ "Load the saved model and run a prediction." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "FgBWzIzXfanI" }, "outputs": [], "source": [ "loaded_model = tf.keras.models.load_model(\"/tmp/ranking_model_dir/export/latest_model\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "-E4XmBSbSyFY" }, "outputs": [], "source": [ "# Predict ranking scores\n", "scores = loaded_model.predict(x)\n", "min_score = tf.reduce_min(scores)\n", "scores = tf.where(tf.greater_equal(y, 0.), scores, min_score - 1e-5)\n", "\n", "# Sort the answers by scores\n", "sorted_answers = tfr.utils.sort_by_scores(\n", " scores,\n", " [tf.strings.reduce_join(x['document_tokens'], -1, separator=' ')])[0]" ] }, { "cell_type": "markdown", "metadata": { "id": "C2pUkpuTTVFh" }, "source": [ "Check the top 5 answers for question number 4." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "8lHaFjyiTfo-", "outputId": "1f1fbb08-572d-48c7-9acd-1c0a8df7e962" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Q: why do people ask questions they know ?\n", "A1: because it re ##as ##ures them that they were right in the first place .\n", "A2: people like to that be ##cao ##use they want to be recognise that they are the one knows the answer and the questions int ##he first place .\n", "A3: to rev ##ali ##date their knowledge and perhaps they choose answers that are mostly with their side simply because they are being subjective . . . .\n", "A4: so they can weasel out the judge mental and super ##ci ##lio ##us know all cr ##aa ##p like yourself . . . don ##t judge others , what gives you the right ? . . how do you know what others know . ? . . by asking this question you are putting yourself in the same league as the others you want ot condemn . . face it you already know what your shallow , self absorbed answer is . . . get a reality check pill ##ock , . . . and if you want to go gr ##iz ##z ##ling to the yahoo policeman bring it on . . it will only reinforce my answer and the pathetic ##iness of your q ##est ##ion . . . the only thing you could do that would be even more pathetic is give me the top answer award . . . then you would suck beyond all measure\n", "A5: human nature i guess . i have noticed that too . maybe it is just for re ##ass ##urance or approval .\n" ] } ], "source": [ "question = tf.strings.reduce_join(\n", " x['query_tokens'][4, :], -1, separator=' ').numpy()\n", "top_answers = sorted_answers[4, :5].numpy()\n", "\n", "print(\n", " f'Q: {question.decode()}\\n' +\n", " '\\n'.join([f'A{i+1}: {ans.decode()}' for i, ans in enumerate(top_answers)]))" ] } ], "metadata": { "colab": { "collapsed_sections": [], "name": "ranking_dnn_distributed.ipynb", "provenance": [], "toc_visible": true }, "kernelspec": { "display_name": "Python 3", "name": "python3" } }, "nbformat": 4, "nbformat_minor": 0 }