11_tensorflow_exam_skills_checklist.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/fyemane/TensorFlow-ZTM-/blob/main/11_tensorflow_exam_skills_checklist.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Building and training neural network models using TensorFlow 2.x"
      ],
      "metadata": {
        "id": "MnKKt1K2YVcO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "print(tf.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JOvq-rtjY2qj",
        "outputId": "fe71fb59-b4ab-441f-e024-2a0c07536c74"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.12.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!wget https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n",
        "\n",
        "# Import series of helper functions for the notebook\n",
        "from helper_functions import unzip_data, create_tensorboard_callback, plot_loss_curves, compare_historys"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NkyOR8NJbH0Z",
        "outputId": "954453d8-09ec-4440-d144-abdf77281747"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2023-07-29 20:52:24--  https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 10246 (10K) [text/plain]\n",
            "Saving to: ‘helper_functions.py’\n",
            "\n",
            "\rhelper_functions.py   0%[                    ]       0  --.-KB/s               \rhelper_functions.py 100%[===================>]  10.01K  --.-KB/s    in 0s      \n",
            "\n",
            "2023-07-29 20:52:24 (69.6 MB/s) - ‘helper_functions.py’ saved [10246/10246]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "from tensorflow.keras import datasets"
      ],
      "metadata": {
        "id": "Xp6O1dsyY7FM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "(train_images, train_labels), (test_images, test_labels) = datasets.fashion_mnist.load_data()"
      ],
      "metadata": {
        "id": "N9ZA8UUbY9NA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Preprocesss\n",
        "# ...normalize (get between 0 & 1)"
      ],
      "metadata": {
        "id": "i1TKIpOEZEDf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Build model\n",
        "\n",
        "# Compile model\n",
        "\n",
        "# Train model.."
      ],
      "metadata": {
        "id": "7Nj48SECZTtr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_datasets as tfds\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import layers\n",
        "import tensorflow_hub as hub"
      ],
      "metadata": {
        "id": "f5LfTWYiUs8K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "(test_data, train_data, validation_data), ds_info = tfds.load(\"sci_tail\",\n",
        "                                             split=['test', 'train', 'validation'],\n",
        "                                             shuffle_files=True,\n",
        "                                             with_info=True)"
      ],
      "metadata": {
        "id": "XVJiFUUOaUjJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ds_info.features"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i8EE48MLUuJv",
        "outputId": "0c0b3893-03cd-4f1d-cbe8-9deeb5683a1d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "FeaturesDict({\n",
              "    'hypothesis': Text(shape=(), dtype=string),\n",
              "    'label': ClassLabel(shape=(), dtype=int64, num_classes=2),\n",
              "    'premise': Text(shape=(), dtype=string),\n",
              "})"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_data"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZYytURJiVT2l",
        "outputId": "fa652888-24cb-4252-dbd6-3d85809d1526"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_PrefetchDataset element_spec={'hypothesis': TensorSpec(shape=(), dtype=tf.string, name=None), 'label': TensorSpec(shape=(), dtype=tf.int64, name=None), 'premise': TensorSpec(shape=(), dtype=tf.string, name=None)}>"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class_names = ds_info.features[\"label\"].names\n",
        "class_names[:10]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l8kh2rnyYGyJ",
        "outputId": "6e8a9a76-36d3-4980-97f9-f48e98da1a30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['entails', 'neutral']"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_df = tfds.as_dataframe(train_data)\n",
        "validation_df = tfds.as_dataframe(validation_data)\n",
        "test_df = tfds.as_dataframe(test_data)\n",
        "train_df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "ajh-X_pEc1uc",
        "outputId": "961fc434-c9cc-497c-cff0-b2fd1aaad7c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                          hypothesis  label  \\\n",
              "0  b'Thermoregulation is the process when animals...      0   \n",
              "1  b'Precipitation and runoff in the water cycle ...      1   \n",
              "2  b'Tides is the term for when the water of the ...      0   \n",
              "3     b'A cell wall is not present in animal cells.'      1   \n",
              "4  b'Plasma completes the list: solid, liquid, gas.'      0   \n",
              "\n",
              "                                             premise  \n",
              "0  b'Thermoregulation is a survival trick that he...  \n",
              "1  b'Hydrologic Cycle: Precipitation = Evapotrans...  \n",
              "2  b'Tides are periodic rises and falls of large ...  \n",
              "3  b'Lignins are built into the structure of the ...  \n",
              "4  b'Matter can exist as a solid , a liquid , a g...  "
            ],
            "text/html": [
              "\n",
              "\n",
              "  <div id=\"df-9747e94c-4054-400e-80d3-39ab0830ce2a\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <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>hypothesis</th>\n",
              "      <th>label</th>\n",
              "      <th>premise</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>b'Thermoregulation is the process when animals...</td>\n",
              "      <td>0</td>\n",
              "      <td>b'Thermoregulation is a survival trick that he...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>b'Precipitation and runoff in the water cycle ...</td>\n",
              "      <td>1</td>\n",
              "      <td>b'Hydrologic Cycle: Precipitation = Evapotrans...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>b'Tides is the term for when the water of the ...</td>\n",
              "      <td>0</td>\n",
              "      <td>b'Tides are periodic rises and falls of large ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>b'A cell wall is not present in animal cells.'</td>\n",
              "      <td>1</td>\n",
              "      <td>b'Lignins are built into the structure of the ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>b'Plasma completes the list: solid, liquid, gas.'</td>\n",
              "      <td>0</td>\n",
              "      <td>b'Matter can exist as a solid , a liquid , a g...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-9747e94c-4054-400e-80d3-39ab0830ce2a')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "\n",
              "\n",
              "\n",
              "    <div id=\"df-c96948de-d749-480f-aa74-8e75378a75a2\">\n",
              "      <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-c96948de-d749-480f-aa74-8e75378a75a2')\"\n",
              "              title=\"Suggest charts.\"\n",
              "              style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "      </button>\n",
              "    </div>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "    background-color: #E8F0FE;\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: #1967D2;\n",
              "    height: 32px;\n",
              "    padding: 0 0 0 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: #E2EBFA;\n",
              "    box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: #174EA6;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "    background-color: #3B4455;\n",
              "    fill: #D2E3FC;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart:hover {\n",
              "    background-color: #434B5C;\n",
              "    box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "    filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "    fill: #FFFFFF;\n",
              "  }\n",
              "</style>\n",
              "\n",
              "    <script>\n",
              "      async function quickchart(key) {\n",
              "        const containerElement = document.querySelector('#' + key);\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      }\n",
              "    </script>\n",
              "\n",
              "      <script>\n",
              "\n",
              "function displayQuickchartButton(domScope) {\n",
              "  let quickchartButtonEl =\n",
              "    domScope.querySelector('#df-c96948de-d749-480f-aa74-8e75378a75a2 button.colab-df-quickchart');\n",
              "  quickchartButtonEl.style.display =\n",
              "    google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "}\n",
              "\n",
              "        displayQuickchartButton(document);\n",
              "      </script>\n",
              "      <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-9747e94c-4054-400e-80d3-39ab0830ce2a button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-9747e94c-4054-400e-80d3-39ab0830ce2a');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_hypotheses = train_df[\"hypothesis\"]\n",
        "train_labels = train_df[\"label\"]\n",
        "train_premises = train_df[\"premise\"]\n",
        "\n",
        "val_hypotheses = validation_df[\"hypothesis\"]\n",
        "val_labels = validation_df[\"label\"]\n",
        "val_premises = validation_df[\"premise\"]\n",
        "\n",
        "test_hypotheses = test_df[\"hypothesis\"]\n",
        "test_labels = test_df[\"label\"]\n",
        "test_premises = test_df[\"premise\"]"
      ],
      "metadata": {
        "id": "m5zk4asWfJo3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_hub as hub\n",
        "tf_hub_embedding_layer = hub.KerasLayer(\"https://tfhub.dev/google/universal-sentence-encoder/4\",\n",
        "                                        input_shape=[],\n",
        "                                        dtype=tf.string,\n",
        "                                        trainable=False,\n",
        "                                        name=\"universal_sentence_encoder\")"
      ],
      "metadata": {
        "id": "d4YI2rroZOQQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a model using the Sequential API\n",
        "hypothesis_inputs = layers.Input(shape=[], dtype=\"string\", name=\"hypothesis_inputs\")\n",
        "hypothesis_embeddings = tf_hub_embedding_layer(hypothesis_inputs)\n",
        "hypothesis_outputs = layers.Dense(64, activation=\"relu\")(hypothesis_embeddings)\n",
        "hypothesis_model = tf.keras.Model(inputs=hypothesis_inputs,\n",
        "                                  outputs=hypothesis_outputs)\n",
        "\n",
        "premise_inputs = layers.Input(shape=[], dtype=\"string\", name=\"premise_inputs\")\n",
        "premise_embeddings = tf_hub_embedding_layer(premise_inputs)\n",
        "premise_outputs = layers.Dense(64, activation=\"relu\")(premise_embeddings)\n",
        "premise_model = tf.keras.Model(inputs=premise_inputs,\n",
        "                                  outputs=premise_outputs)\n",
        "\n",
        "combined_embeddings = layers.Concatenate(name=\"text_inputs\")([hypothesis_model.output,\n",
        "                                                              premise_model.output])\n",
        "z = layers.Dense(128, activation=\"relu\")(combined_embeddings)\n",
        "z = layers.Dropout(0.5)(z)\n",
        "output_layer = layers.Dense(1, activation=\"sigmoid\", name=\"output_layer\")(z)\n",
        "model_1 = tf.keras.Model(inputs=[hypothesis_model.input,\n",
        "                                 premise_model.input],\n",
        "                         outputs=output_layer,\n",
        "                         name=\"model_1\")\n",
        "\n",
        "# Compile\n",
        "model_1.compile(loss=\"binary_crossentropy\",\n",
        "                optimizer=tf.keras.optimizers.Adam(),\n",
        "                metrics=[\"accuracy\"])\n",
        "\n",
        "# Get a summary\n",
        "model_1.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DskQfWziaAEc",
        "outputId": "ce9c316b-b410-4f9f-cb1a-8af38904ffb6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_1\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " hypothesis_inputs (InputLayer)  [(None,)]           0           []                               \n",
            "                                                                                                  \n",
            " premise_inputs (InputLayer)    [(None,)]            0           []                               \n",
            "                                                                                                  \n",
            " universal_sentence_encoder (Ke  (None, 512)         256797824   ['hypothesis_inputs[0][0]',      \n",
            " rasLayer)                                                        'premise_inputs[0][0]']         \n",
            "                                                                                                  \n",
            " dense_17 (Dense)               (None, 64)           32832       ['universal_sentence_encoder[8][0\n",
            "                                                                 ]']                              \n",
            "                                                                                                  \n",
            " dense_18 (Dense)               (None, 64)           32832       ['universal_sentence_encoder[9][0\n",
            "                                                                 ]']                              \n",
            "                                                                                                  \n",
            " text_inputs (Concatenate)      (None, 128)          0           ['dense_17[0][0]',               \n",
            "                                                                  'dense_18[0][0]']               \n",
            "                                                                                                  \n",
            " dense_19 (Dense)               (None, 128)          16512       ['text_inputs[0][0]']            \n",
            "                                                                                                  \n",
            " dropout_2 (Dropout)            (None, 128)          0           ['dense_19[0][0]']               \n",
            "                                                                                                  \n",
            " output_layer (Dense)           (None, 1)            129         ['dropout_2[0][0]']              \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 256,880,129\n",
            "Trainable params: 82,305\n",
            "Non-trainable params: 256,797,824\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.utils import plot_model\n",
        "plot_model(model_1, show_shapes=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 754
        },
        "id": "beZ35I1kqJP4",
        "outputId": "21491140-60b0-4239-f912-dcdf12b049e2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_pipedata = tf.data.Dataset.from_tensor_slices((train_hypotheses,\n",
        "                                                    train_premises))\n",
        "train_pipelabels = tf.data.Dataset.from_tensor_slices((train_labels))\n",
        "train_dataset = tf.data.Dataset.zip((train_pipedata, train_pipelabels))\n",
        "train_dataset = train_dataset.batch(32).prefetch(tf.data.AUTOTUNE)\n",
        "\n",
        "val_pipedata = tf.data.Dataset.from_tensor_slices((val_hypotheses,\n",
        "                                                    val_premises))\n",
        "val_pipelabels = tf.data.Dataset.from_tensor_slices((val_labels))\n",
        "val_dataset = tf.data.Dataset.zip((val_pipedata, val_pipelabels))\n",
        "val_dataset = val_dataset.batch(32).prefetch(tf.data.AUTOTUNE)"
      ],
      "metadata": {
        "id": "gkKLR8xZamdR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_dataset, val_dataset"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eC7WAaxhbRi1",
        "outputId": "fdb95e51-692c-4941-91b1-1a10e03349fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<_PrefetchDataset element_spec=((TensorSpec(shape=(None,), dtype=tf.string, name=None), TensorSpec(shape=(None,), dtype=tf.string, name=None)), TensorSpec(shape=(None,), dtype=tf.int64, name=None))>,\n",
              " <_PrefetchDataset element_spec=((TensorSpec(shape=(None,), dtype=tf.string, name=None), TensorSpec(shape=(None,), dtype=tf.string, name=None)), TensorSpec(shape=(None,), dtype=tf.int64, name=None))>)"
            ]
          },
          "metadata": {},
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_1.fit(train_dataset,\n",
        "            validation_data=val_dataset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "id": "H2-XWkhVpdN6",
        "outputId": "03b0608d-fd18-458c-eefd-83d2119e279d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-95-4098879696d4>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m model_1.fit(train_dataset,\n\u001b[0m\u001b[1;32m      2\u001b[0m             \u001b[0msteps_per_epoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.1\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_dataset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m             validation_data=val_dataset)\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     68\u001b[0m             \u001b[0;31m# To get the full stack trace, call:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;31m# `tf.debugging.disable_traceback_filtering()`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m             \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    924\u001b[0m       \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    925\u001b[0m       \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 926\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_no_variable_creation_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    927\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_variable_creation_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    928\u001b[0m       \u001b[0;31m# Release the lock early so that multiple threads can perform the call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'NoneType' object is not callable"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "qNFinXB7phY2"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}