examples/notebooks/beam-ml/tfma_beam.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "# @title ###### Licensed to the Apache Software Foundation (ASF), Version 2.0 (the \"License\")\n",
        "\n",
        "# Licensed to the Apache Software Foundation (ASF) under one\n",
        "# or more contributor license agreements. See the NOTICE file\n",
        "# distributed with this work for additional information\n",
        "# regarding copyright ownership. The ASF licenses this file\n",
        "# to you under the Apache License, Version 2.0 (the\n",
        "# \"License\"); you may not use this file except in compliance\n",
        "# with the License. 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,\n",
        "# software distributed under the License is distributed on an\n",
        "# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n",
        "# KIND, either express or implied. See the License for the\n",
        "# specific language governing permissions and limitations\n",
        "# under the License"
      ],
      "metadata": {
        "id": "P5tEC4_l6bwd"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# TensorFlow Model Analysis in Beam\n",
        "\n",
        "<table align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/apache/beam/blob/master/examples/notebooks/beam-ml/tfma_beam.ipynb\"><img src=\"https://raw.githubusercontent.com/google/or-tools/main/tools/colab_32px.png\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/apache/beam/blob/master/examples/notebooks/beam-ml/tfma_beam.ipynb\"><img src=\"https://raw.githubusercontent.com/google/or-tools/main/tools/github_32px.png\" />View source on GitHub</a>\n",
        "  </td>\n",
        "</table>\n"
      ],
      "metadata": {
        "id": "1m9dEIsQAP_-"
      }
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "GNbarEZsalS2"
      },
      "source": [
        "[TensorFlow Model Analysis (TFMA)](https://www.tensorflow.org/tfx/guide/tfma) is a library for performing model evaluation across different slices of data. TFMA performs its computations in a distributed manner over large quantities of data by using Apache Beam.\n",
        "\n",
        "This example notebook shows how you can use TFMA to investigate and visualize the performance of a model as part of your Apache Beam pipeline by creating and comparing two models. This example uses [ExtractEvaluateAndWriteResults](https://www.tensorflow.org/tfx/model_analysis/api_docs/python/tfma/ExtractEvaluateAndWriteResults), which is a `PTransform` that performs extraction and evaluation and writes results all in one step.\n",
        "\n",
        "TFMA enables scalable and flexible execution of your evaluation pipeline. For additional information about TFMA, see the [TFMA basic notebook](https://www.tensorflow.org/tfx/tutorials/model_analysis/tfma_basic), which provides an in-depth look at TFMA capabilities."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Install Jupyter extensions\n",
        "If you are running this example in a local Jupyter notebook, before running Jupyter, you must install these Jupyter extensions in the environment.\n",
        "\n",
        "```bash\n",
        "jupyter nbextension enable --py widgetsnbextension --sys-prefix \n",
        "jupyter nbextension install --py --symlink tensorflow_model_analysis --sys-prefix \n",
        "jupyter nbextension enable --py tensorflow_model_analysis --sys-prefix \n",
        "```"
      ],
      "metadata": {
        "id": "GKcUZKcTRhW_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##  Install TFMA\n",
        "\n",
        "Installing TFMA pulls in all of the dependencies. The installation takes about a minute."
      ],
      "metadata": {
        "id": "-01Hts8eR9OV"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8aLJh4pFasK0"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "# Upgrade pip to the latest version, and then install TFMA.\n",
        "!pip install -U pip\n",
        "!pip install tensorflow-model-analysis\n",
        "\n",
        "# To use the newly installed version of pip, restart the runtime.\n",
        "exit() "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SUTczmH2dWk2"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "# This configuration was tested in Colab with TensorFlow 2.11, TFMA 0.43, and Apache Beam 2.44.\n",
        "# The setup is also compatible with the current release.\n",
        "import sys\n",
        "\n",
        "# Confirm that you're using Python 3.\n",
        "assert sys.version_info.major==3, 'This notebook must be run using Python 3.'\n",
        "\n",
        "import tensorflow as tf\n",
        "print('TF version: {}'.format(tf.__version__))\n",
        "import apache_beam as beam\n",
        "print('Beam version: {}'.format(beam.__version__))\n",
        "import tensorflow_model_analysis as tfma\n",
        "print('TFMA version: {}'.format(tfma.__version__))\n",
        "import tensorflow_datasets as tfds\n",
        "print('TFDS version: {}'.format(tfds.__version__))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note:** Before proceeding, verify that the output does not have errors. If errors occur, re-run the installation, and restart your kernel."
      ],
      "metadata": {
        "id": "KP7V1pIU_9H2"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SHL89whuLqmq"
      },
      "source": [
        "## Preprocess data\n",
        "\n",
        "This section includes the steps for preprocessing your data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6yapf7rN_lB7"
      },
      "source": [
        "### Create a diamond price prediction model\n",
        "\n",
        "This example uses the [TFDS diamonds dataset](https://www.tensorflow.org/datasets/catalog/diamonds) to train a linear regression model that predicts the price of a diamond. This dataset contains various physical attributes of the diamonds, such as the weight (carat), cut quality, color, and clarity, as well as the price of 53,940 diamonds. The model's performance is evaluated using metrics such as mean squared error and mean absolute error.\n",
        "\n",
        "To simulate a scenario where a model's performance improves over time as new data is added to the dataset, first use half of the diamond dataset to train a model called v1. Then, use additional data to train a second model called v2. These steps demonstrate the use of TFMA when comparing the performance of two models for the same task."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hQCHORIG8Ixv"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "# Load the data from TFDS and then split the dataset into parts to create train, test, and validation datasets.\n",
        "(ds_train_v1, ds_test, ds_val), info = tfds.load('diamonds', split=['train[:40%]', 'train[80%:90%]', 'train[90%:]'], as_supervised=True, with_info=True)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Load the numerical training data to use for normalization.\n",
        "def extract_numerical_features(item):\n",
        "  carat = item['carat']\n",
        "  depth = item['depth']\n",
        "  table = item['table']\n",
        "  x = item['x']\n",
        "  y = item['y']\n",
        "  z = item['z']\n",
        "  \n",
        "  return [carat, depth, table, x, y, z]\n",
        "\n",
        "def get_train_data(ds_train):\n",
        "  train_data = []\n",
        "  for item, label in ds_train:\n",
        "    features = extract_numerical_features(item)\n",
        "    train_data.append(features)\n",
        "\n",
        "  train_data = np.array(train_data)\n",
        "\n",
        "  return train_data"
      ],
      "metadata": {
        "id": "_sNqOzwNGo6V"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "code",
      "source": [
        "train_data_v1 = get_train_data(ds_train_v1)"
      ],
      "metadata": {
        "id": "PVVUZ1LOwQAf"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the length of the features.\n",
        "NUMERICAL_FEATURES = 6\n",
        "NUM_FEATURES = (NUMERICAL_FEATURES +\n",
        "                info.features['features']['color'].num_classes +\n",
        "                info.features['features']['cut'].num_classes +\n",
        "                info.features['features']['clarity'].num_classes)"
      ],
      "metadata": {
        "id": "__6xLw92aI9a"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZJt8Wu2LmX9j"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "# To transform the input data into a feature vector and label, select the input and output for the model.\n",
        "def transform_data(item, label):\n",
        "  numerical_features = extract_numerical_features(item)\n",
        "\n",
        "  # Categorical features are encoded using one-hot encoding.\n",
        "  color = tf.one_hot(item['color'], info.features['features']['color'].num_classes)\n",
        "  cut = tf.one_hot(item['cut'], info.features['features']['cut'].num_classes)\n",
        "  clarity = tf.one_hot(item['clarity'], info.features['features']['clarity'].num_classes)\n",
        "  \n",
        "  # Create the output tensor.\n",
        "  output = tf.concat([tf.stack(numerical_features, axis=0), color, cut, clarity], 0)\n",
        "  return output, [label]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f3ZxhNZDsbkx"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "ds_train_v1 = ds_train_v1.map(transform_data)\n",
        "ds_test = ds_test.map(transform_data)\n",
        "ds_val = ds_val.map(transform_data)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# To prepare the data for training, structure it in batches.\n",
        "BATCH_SIZE = 32\n",
        "ds_train_v1 = ds_train_v1.batch(BATCH_SIZE)\n",
        "ds_test = ds_test.batch(BATCH_SIZE)"
      ],
      "metadata": {
        "id": "sw3udkicwVZE"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Create TFRecords\n",
        "\n",
        "TFMA and Apache Beam need to read the dataset used during evaluation from a file. Create a `TFRecords` file that contains the validation dataset."
      ],
      "metadata": {
        "id": "KFd6NwPAacSM"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ipHOHiRqMJOi"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "!mkdir data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TkeG4uw1K9Dt"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "# Write the validation record to a file, which is used by TFMA.\n",
        "tfrecord_file = 'data/val_data.tfrecord'\n",
        "\n",
        "with tf.io.TFRecordWriter(tfrecord_file) as file_writer:\n",
        "  for x, y in ds_val:\n",
        "    record_bytes = tf.train.Example(features=tf.train.Features(feature={\n",
        "        \"inputs\": tf.train.Feature(float_list=tf.train.FloatList(value=x)),\n",
        "        \"output\": tf.train.Feature(float_list=tf.train.FloatList(value=[y])),\n",
        "    })).SerializeToString()\n",
        "    file_writer.write(record_bytes)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zhunMzSOLmdG"
      },
      "source": [
        "## Define and train one model"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Train a linear regression model that predicts the price of a diamond. The model is a neural network with one hidden layer. The model also uses a normalization layer to scale all of the numerical features between 0 and 1."
      ],
      "metadata": {
        "id": "Svsic-PSbGu7"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "so7l2WDzd2kg"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "def construct_model(model_name, train_data):\n",
        "  inputs = tf.keras.Input(shape=(NUM_FEATURES,), name='inputs')\n",
        "\n",
        "  # Normalize the numerical features.\n",
        "  normalization_layer = tf.keras.layers.Normalization()\n",
        "  # Fit the normalization layer to the training data.\n",
        "  normalization_layer.adapt(train_data)\n",
        "  # Split the input between numerical and categorical input.\n",
        "  input_numerical = tf.gather(inputs, indices=[*range(NUMERICAL_FEATURES)], axis=1)\n",
        "  input_normalized = normalization_layer(input_numerical)\n",
        "  input_one_hot = tf.gather(inputs, indices=[*range(NUMERICAL_FEATURES, NUM_FEATURES)], axis=1)\n",
        "  # Define one hidden layer with 8 neurons.\n",
        "  x = tf.keras.layers.Dense(8, activation='relu')(tf.concat([input_normalized, input_one_hot], 1))\n",
        "  outputs = tf.keras.layers.Dense(1, name='output')(x)\n",
        "  model = tf.keras.Model(inputs=inputs, outputs=outputs, name=model_name)\n",
        "\n",
        "  model.compile(\n",
        "    optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),\n",
        "    loss='mean_absolute_error')\n",
        "  \n",
        "  return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "buc0NIc4oRv4"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "model_v1 = construct_model('model_v1', train_data_v1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8bvna8ZJAKj5"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "# Train the model.\n",
        "history = model_v1.fit(\n",
        "    ds_train_v1,\n",
        "    validation_data=ds_test,\n",
        "    epochs=5,\n",
        "    verbose=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pyCfKRY9DUhO"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "# Save the model to disk.\n",
        "model_path_v1 = 'saved_model_v1'\n",
        "model_v1.save(model_path_v1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kwUycnjpLvTX"
      },
      "source": [
        "## Evaluate the model"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "With the trained model, you can use TFMA to analyze the performance. First, define the evaluation configuration. This example uses the most common metrics used for a linear regression model: mean squared error and mean absolute error. For more information about the supported evaluation parameters, see [TFMA metrics and plots](https://www.tensorflow.org/tfx/model_analysis/metrics). "
      ],
      "metadata": {
        "id": "7gmbEx6wG2Za"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b2NN9zVr-AE1"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "from google.protobuf import text_format\n",
        "\n",
        "# Define the TFMA evaluation configuration.\n",
        "eval_config = text_format.Parse(\"\"\"\n",
        "  ## Model information\n",
        "  model_specs {\n",
        "    # For keras and serving models, you need to add a `label_key`.\n",
        "    label_key: \"output\"\n",
        "  }\n",
        "\n",
        "  ## This post-training metric information is merged with any built-in\n",
        "  ## metrics from training.\n",
        "  metrics_specs {\n",
        "    metrics { class_name: \"ExampleCount\" }\n",
        "    metrics { class_name: \"MeanAbsoluteError\" }\n",
        "    metrics { class_name: \"MeanSquaredError\" }\n",
        "    metrics { class_name: \"MeanPrediction\" }\n",
        "  }\n",
        "\n",
        "  slicing_specs {}\n",
        "\"\"\", tfma.EvalConfig())"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, use the [ExtractEvaluateAndWriteResults](https://www.tensorflow.org/tfx/model_analysis/api_docs/python/tfma/ExtractEvaluateAndWriteResults) `PTransform`, which performs extraction and evaluation and writes results. To use this `PTransform` directly in your Apache Beam pipeline, use [TFXIO](https://www.tensorflow.org/tfx/tfx_bsl/api_docs/python/tfx_bsl/public/tfxio) to combine it with reading in your `TFRecords`."
      ],
      "metadata": {
        "id": "8JVSVK4iH-d2"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4NDEQAMDhJWL"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "from tfx_bsl.public import tfxio\n",
        "\n",
        "output_path = 'evaluation_results'\n",
        "\n",
        "eval_shared_model = tfma.default_eval_shared_model(\n",
        "    eval_saved_model_path=model_path_v1, eval_config=eval_config)\n",
        "\n",
        "tfx_io = tfxio.TFExampleRecord(\n",
        "          file_pattern=tfrecord_file,\n",
        "          raw_record_column_name=tfma.ARROW_INPUT_COLUMN)\n",
        "\n",
        "# Run Evaluation.\n",
        "with beam.Pipeline() as pipeline:\n",
        "    _ = (\n",
        "        pipeline\n",
        "        | 'ReadData' >> tfx_io.BeamSource()\n",
        "        | 'EvalModel' >> tfma.ExtractEvaluateAndWriteResults(\n",
        "           eval_shared_model=eval_shared_model,\n",
        "           eval_config=eval_config,\n",
        "           output_path=output_path))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "He97LPB_NbtU"
      },
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}],
      "source": [
        "# Visualize the results.\n",
        "result = tfma.load_eval_result(output_path=output_path)\n",
        "tfma.view.render_slicing_metrics(result)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following image shows an example of a visualisation when evaluating one model:"
      ],
      "metadata": {
        "id": "DYMNK_8k-eV2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "UhGtaw9897wK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Compare multiple models"
      ],
      "metadata": {
        "id": "I7ZuqLcdwpCs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can compare the performance of multiple models to select the best candidate to use in production. With Apache Beam, you can evaluate and compare multiple models in one step."
      ],
      "metadata": {
        "id": "ebkJsE3zJ2W2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Train a second model"
      ],
      "metadata": {
        "id": "ah1xX9jl44O8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "For this use case, train a second model on the full dataset."
      ],
      "metadata": {
        "id": "6GcGg08YKRhg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Preprocess the data.\n",
        "ds_train_v2 = tfds.load('diamonds', split=['train[:80%]'], as_supervised=True)[0]\n",
        "train_data_v2 = get_train_data(ds_train_v2)\n",
        "ds_train_v2 = ds_train_v2.map(transform_data)\n",
        "ds_train_v2 = ds_train_v2.batch(BATCH_SIZE)"
      ],
      "metadata": {
        "id": "cQYA0cdzwoXr"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define and train the model.\n",
        "model_v2 = construct_model('model_v2', train_data_v2)\n",
        "history = model_v2.fit(\n",
        "    ds_train_v2,\n",
        "    validation_data=ds_test,\n",
        "    epochs=5,\n",
        "    verbose=1)"
      ],
      "metadata": {
        "id": "WII_PC5rxzTc"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the model to a file.\n",
        "model_path_v2 = 'saved_model_v2'\n",
        "model_v2.save(model_path_v2)"
      ],
      "metadata": {
        "id": "ppVFHy7myhXu"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Evaluate the model\n",
        "The following code demonstrates how to compare the two models and then visualize the results."
      ],
      "metadata": {
        "id": "QKO-vh1X48tv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the TFMA evaluation configuration, including two model specs for the two models being compared.\n",
        "eval_config_compare = text_format.Parse(\"\"\"\n",
        "  ## Model information\n",
        "  model_specs {\n",
        "    name: \"model_v1\"\n",
        "    # For keras (and serving models), add a `label_key`.\n",
        "    label_key: \"output\"\n",
        "    is_baseline: true\n",
        "  }\n",
        "  model_specs {\n",
        "    name: \"model_v2\"\n",
        "    # For keras (and serving models), add a `label_key`.\n",
        "    label_key: \"output\"\n",
        "  }\n",
        "\n",
        "  ## This post-training metric information is merged with any built-in\n",
        "  ## metrics from training.\n",
        "  metrics_specs {\n",
        "    metrics { class_name: \"ExampleCount\" }\n",
        "    metrics { class_name: \"MeanAbsoluteError\" }\n",
        "    metrics { class_name: \"MeanSquaredError\" }\n",
        "    metrics { class_name: \"MeanPrediction\" }\n",
        "  }\n",
        "\n",
        "  slicing_specs {}\n",
        "\"\"\", tfma.EvalConfig())"
      ],
      "metadata": {
        "id": "pB4aXUo45RAg"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "code",
      "source": [
        "from tfx_bsl.public import tfxio\n",
        "\n",
        "output_path_compare = 'evaluation_results_compare'\n",
        "\n",
        "eval_shared_models = [\n",
        "  tfma.default_eval_shared_model(\n",
        "      model_name='model_v1',\n",
        "      eval_saved_model_path=model_path_v1,\n",
        "      eval_config=eval_config_compare),\n",
        "  tfma.default_eval_shared_model(\n",
        "      model_name='model_v2',\n",
        "      eval_saved_model_path=model_path_v2,\n",
        "      eval_config=eval_config_compare),\n",
        "]\n",
        "\n",
        "tfx_io = tfxio.TFExampleRecord(\n",
        "          file_pattern=tfrecord_file,\n",
        "          raw_record_column_name=tfma.ARROW_INPUT_COLUMN)\n",
        "\n",
        "# Run the evaluation.\n",
        "with beam.Pipeline() as pipeline:\n",
        "    _ = (\n",
        "        pipeline\n",
        "        | 'ReadData' >> tfx_io.BeamSource()\n",
        "        | 'EvalModel' >> tfma.ExtractEvaluateAndWriteResults(\n",
        "           eval_shared_model=eval_shared_models,\n",
        "           eval_config=eval_config_compare,\n",
        "           output_path=output_path_compare))"
      ],
      "metadata": {
        "id": "4eVdpW0aWTah"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use the following code to create a visualization of the results. By default, the visualisation displays one time series, which is the evolution of the size of the validation set.\n",
        "To add more interesting visualisations, you can select **add metric series**, and choose to visualise the loss and mean absolute error."
      ],
      "metadata": {
        "id": "oEinNfzv8ZgM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualize the results.\n",
        "results = tfma.load_eval_results(output_paths=output_path_compare)\n",
        "tfma.view.render_time_series(results)"
      ],
      "metadata": {
        "id": "G7B-GGYB6Dmu"
      },
      "execution_count": null,
			"outputs": [{
				"output_type": "stream",
				"name": "stdout",
				"text": [
					"\n"
				]
			}]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following image displays an example of a visualisation that evaluates multiple models:"
      ],
      "metadata": {
        "id": "GgM5vLt8-7cj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "BxsQmjkq-70M"
      }
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}