practice(4_17).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J5pnOEZ_WGbh"
      },
      "source": [
        "### The Sequential model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bhIPZ9e_WGbi"
      },
      "source": [
        "**The `Sequential` class**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5M7rCnuZWGbi"
      },
      "outputs": [],
      "source": [
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "model = keras.Sequential([\n",
        "    layers.Dense(64, activation=\"relu\"),\n",
        "    layers.Dense(10, activation=\"softmax\")\n",
        "])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eTbKSKtKWGbj"
      },
      "source": [
        "**Incrementally building a Sequential model**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6_23trMNWGbk"
      },
      "outputs": [],
      "source": [
        "model = keras.Sequential()\n",
        "model.add(layers.Dense(64, activation=\"relu\"))\n",
        "model.add(layers.Dense(10, activation=\"softmax\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N0UuSWIBWGbk"
      },
      "source": [
        "**Calling a model for the first time to build it**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6iJd7JBcWGbk"
      },
      "outputs": [],
      "source": [
        "model.build(input_shape=(None, 3))\n",
        "model.weights"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S3tCbQ5OWGbk"
      },
      "source": [
        "**The summary method**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MA0Zui35WGbk",
        "outputId": "4b43cf20-09f5-4b71-af6a-3ad13ab1f01e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_2 (Dense)             (None, 64)                256       \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 10)                650       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 906 (3.54 KB)\n",
            "Trainable params: 906 (3.54 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fhbnd0NvWGbl"
      },
      "source": [
        "**Naming models and layers with the `name` argument**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ley9b8t8WGbl",
        "outputId": "37e6dbf5-4c77-4205-dce8-8350a9f10a7a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"my_example_model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " my_first_layer (Dense)      (None, 64)                256       \n",
            "                                                                 \n",
            " my_last_layer (Dense)       (None, 10)                650       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 906 (3.54 KB)\n",
            "Trainable params: 906 (3.54 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model = keras.Sequential(name=\"my_example_model\")\n",
        "model.add(layers.Dense(64, activation=\"relu\", name=\"my_first_layer\"))\n",
        "model.add(layers.Dense(10, activation=\"softmax\", name=\"my_last_layer\"))\n",
        "model.build((None, 3))\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7xTPTXs6WGbl"
      },
      "source": [
        "**Specifying the input shape of your model in advance**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CZBpVP8tWGbl"
      },
      "outputs": [],
      "source": [
        "model = keras.Sequential()\n",
        "model.add(keras.Input(shape=(3,)))\n",
        "model.add(layers.Dense(64, activation=\"relu\"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "khY1kbrDWGbl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bbef3bd6-9992-4225-96b6-1df5e1e2fc86"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=================================================================\n",
            " dense_4 (Dense)             (None, 64)                256       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 256 (1.00 KB)\n",
            "Trainable params: 256 (1.00 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "viDCKqmwWGbl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c71bb23-5098-4a17-a867-cf3f10e59691"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_4 (Dense)             (None, 64)                256       \n",
            "                                                                 \n",
            " dense_5 (Dense)             (None, 10)                650       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 906 (3.54 KB)\n",
            "Trainable params: 906 (3.54 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.add(layers.Dense(10, activation=\"softmax\"))\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T9_InCO0WGbl"
      },
      "source": [
        "### The Functional API"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zovm_hTpWGbl"
      },
      "source": [
        "#### A simple example"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2mLTO6-xWGbl"
      },
      "source": [
        "**A simple Functional model with two `Dense` layers**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4PQ4LY44WGbm"
      },
      "outputs": [],
      "source": [
        "inputs = keras.Input(shape=(3,), name=\"my_input\")\n",
        "features = layers.Dense(64, activation=\"relu\")(inputs)\n",
        "outputs = layers.Dense(10, activation=\"softmax\")(features)\n",
        "model = keras.Model(inputs=inputs, outputs=outputs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CGA3PsUSWGbm"
      },
      "outputs": [],
      "source": [
        "inputs = keras.Input(shape=(3,), name=\"my_input\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c7-cemvWWGbm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e8d11708-1cff-40f4-a644-ccd197b444ab"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([None, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ],
      "source": [
        "inputs.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WlEaMYKNWGbm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "341969ea-d2be-4af5-d768-64751ccf4f66"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tf.float32"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ],
      "source": [
        "inputs.dtype"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "G9yHqZtrWGbm"
      },
      "outputs": [],
      "source": [
        "features = layers.Dense(64, activation=\"relu\")(inputs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yxB4LUizWGbm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d1e1371-eeec-4674-c1e8-8f4726ec9984"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([None, 64])"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ],
      "source": [
        "features.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M0S_3O26WGbm"
      },
      "outputs": [],
      "source": [
        "outputs = layers.Dense(10, activation=\"softmax\")(features)\n",
        "model = keras.Model(inputs=inputs, outputs=outputs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hxRLDY39WGbm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cec6ff47-4bf2-4da7-c9be-a9b30a7e776f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " my_input (InputLayer)       [(None, 3)]               0         \n",
            "                                                                 \n",
            " dense_9 (Dense)             (None, 64)                256       \n",
            "                                                                 \n",
            " dense_10 (Dense)            (None, 10)                650       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 906 (3.54 KB)\n",
            "Trainable params: 906 (3.54 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t-44CeA_WGbm"
      },
      "source": [
        "#### Multi-input, multi-output models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L5HEEpctWGbm"
      },
      "source": [
        "**A multi-input, multi-output Functional model**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9SmENZHvWGbn"
      },
      "outputs": [],
      "source": [
        "vocabulary_size = 10000\n",
        "num_tags = 100\n",
        "num_departments = 4\n",
        "\n",
        "title = keras.Input(shape=(vocabulary_size,), name=\"title\")\n",
        "text_body = keras.Input(shape=(vocabulary_size,), name=\"text_body\")\n",
        "tags = keras.Input(shape=(num_tags,), name=\"tags\")\n",
        "\n",
        "features = layers.Concatenate()([title, text_body, tags])\n",
        "features = layers.Dense(64, activation=\"relu\")(features)\n",
        "\n",
        "priority = layers.Dense(1, activation=\"sigmoid\", name=\"priority\")(features)\n",
        "department = layers.Dense(\n",
        "    num_departments, activation=\"softmax\", name=\"department\")(features)\n",
        "\n",
        "model = keras.Model(inputs=[title, text_body, tags], outputs=[priority, department])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EM729igqWGbn"
      },
      "source": [
        "#### Training a multi-input, multi-output model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VVDj8TqKWGbn"
      },
      "source": [
        "**Training a model by providing lists of input & target arrays**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E_ot0fmtWGbn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "caf6329b-08e1-40ca-c185-b55f7d9ec900"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "40/40 [==============================] - 3s 9ms/step - loss: 21.7501 - priority_loss: 0.3348 - department_loss: 21.4153 - priority_mean_absolute_error: 0.5002 - department_accuracy: 0.1852\n",
            "40/40 [==============================] - 0s 5ms/step - loss: 15.4239 - priority_loss: 0.3407 - department_loss: 15.0832 - priority_mean_absolute_error: 0.5073 - department_accuracy: 0.1359\n",
            "40/40 [==============================] - 0s 4ms/step\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "num_samples = 1280\n",
        "\n",
        "title_data = np.random.randint(0, 2, size=(num_samples, vocabulary_size))\n",
        "text_body_data = np.random.randint(0, 2, size=(num_samples, vocabulary_size))\n",
        "tags_data = np.random.randint(0, 2, size=(num_samples, num_tags))\n",
        "\n",
        "priority_data = np.random.random(size=(num_samples, 1))\n",
        "department_data = np.random.randint(0, 2, size=(num_samples, num_departments))\n",
        "\n",
        "model.compile(optimizer=\"rmsprop\",\n",
        "              loss=[\"mean_squared_error\", \"categorical_crossentropy\"],\n",
        "              metrics=[[\"mean_absolute_error\"], [\"accuracy\"]])\n",
        "model.fit([title_data, text_body_data, tags_data],\n",
        "          [priority_data, department_data],\n",
        "          epochs=1)\n",
        "model.evaluate([title_data, text_body_data, tags_data],\n",
        "               [priority_data, department_data])\n",
        "priority_preds, department_preds = model.predict([title_data, text_body_data, tags_data])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6BQbrIZWGbn"
      },
      "source": [
        "**Training a model by providing dicts of input & target arrays**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "z8ozIhAwWGbn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ba3402c9-c65f-4035-e786-f76212db001b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "40/40 [==============================] - 1s 6ms/step - loss: 21.4784 - priority_loss: 0.3407 - department_loss: 21.1377 - priority_mean_absolute_error: 0.5073 - department_accuracy: 0.2352\n",
            "40/40 [==============================] - 0s 5ms/step - loss: 11.4373 - priority_loss: 0.3407 - department_loss: 11.0965 - priority_mean_absolute_error: 0.5073 - department_accuracy: 0.1562\n",
            "40/40 [==============================] - 0s 4ms/step\n"
          ]
        }
      ],
      "source": [
        "model.compile(optimizer=\"rmsprop\",\n",
        "              loss={\"priority\": \"mean_squared_error\", \"department\": \"categorical_crossentropy\"},\n",
        "              metrics={\"priority\": [\"mean_absolute_error\"], \"department\": [\"accuracy\"]})\n",
        "model.fit({\"title\": title_data, \"text_body\": text_body_data, \"tags\": tags_data},\n",
        "          {\"priority\": priority_data, \"department\": department_data},\n",
        "          epochs=1)\n",
        "model.evaluate({\"title\": title_data, \"text_body\": text_body_data, \"tags\": tags_data},\n",
        "               {\"priority\": priority_data, \"department\": department_data})\n",
        "priority_preds, department_preds = model.predict(\n",
        "    {\"title\": title_data, \"text_body\": text_body_data, \"tags\": tags_data})"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8rZQHE7-WGbn"
      },
      "source": [
        "#### The power of the Functional API: Access to layer connectivity"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0GvR0Sv4WGbu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 369
        },
        "outputId": "3a41aa0d-0907-4ee4-8fbd-459595415ba2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "keras.utils.plot_model(model, \"ticket_classifier.png\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WvznoGB_WGbu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 422
        },
        "outputId": "e7a85008-4dea-455e-9805-0d7da60438e1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ],
      "source": [
        "keras.utils.plot_model(model, \"ticket_classifier_with_shape_info.png\", show_shapes=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aEvXRalmWGbu"
      },
      "source": [
        "**Retrieving the inputs or outputs of a layer in a Functional model**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-5EkTi3EWGbu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c60ef20-0989-4f5c-f267-db2c2c622ca6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<keras.src.engine.input_layer.InputLayer at 0x7cb0d426eef0>,\n",
              " <keras.src.engine.input_layer.InputLayer at 0x7cb0d426e800>,\n",
              " <keras.src.engine.input_layer.InputLayer at 0x7cb03bf47ee0>,\n",
              " <keras.src.layers.merging.concatenate.Concatenate at 0x7cb032eea7a0>,\n",
              " <keras.src.layers.core.dense.Dense at 0x7cb032eeada0>,\n",
              " <keras.src.layers.core.dense.Dense at 0x7cb032ee9e10>,\n",
              " <keras.src.layers.core.dense.Dense at 0x7cb032ee8790>]"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ],
      "source": [
        "model.layers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-hWFo4I7WGbu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c86b980-389f-4ae4-9adb-1e62519f2223"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<KerasTensor: shape=(None, 10000) dtype=float32 (created by layer 'title')>,\n",
              " <KerasTensor: shape=(None, 10000) dtype=float32 (created by layer 'text_body')>,\n",
              " <KerasTensor: shape=(None, 100) dtype=float32 (created by layer 'tags')>]"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ],
      "source": [
        "model.layers[3].input"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hd46NiGcWGbu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d15b937-cf33-4aed-d85e-6f7f228cac55"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<KerasTensor: shape=(None, 20100) dtype=float32 (created by layer 'concatenate')>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ],
      "source": [
        "model.layers[3].output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D9xCiMCaWGbu"
      },
      "outputs": [],
      "source": [
        "features = model.layers[4].output\n",
        "difficulty = layers.Dense(3, activation=\"softmax\", name=\"difficulty\")(features)\n",
        "\n",
        "new_model = keras.Model(\n",
        "    inputs=[title, text_body, tags],\n",
        "    outputs=[priority, department, difficulty])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EomFJg7kWGbw"
      },
      "source": [
        "### Remember: Use the right tool for the job"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CcTEnmaIWGbw"
      },
      "source": [
        "## Using built-in training and evaluation loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PVZ9aoG7WGbw"
      },
      "source": [
        "**The standard workflow: `compile()`, `fit()`, `evaluate()`, `predict()`**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ooftllLWWGbw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d6eabc5c-85c8-4ca5-c707-620301543b3a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "11490434/11490434 [==============================] - 0s 0us/step\n",
            "Epoch 1/3\n",
            "1563/1563 [==============================] - 8s 4ms/step - loss: 0.2931 - accuracy: 0.9136 - val_loss: 0.1408 - val_accuracy: 0.9590\n",
            "Epoch 2/3\n",
            "1563/1563 [==============================] - 5s 3ms/step - loss: 0.1600 - accuracy: 0.9540 - val_loss: 0.1127 - val_accuracy: 0.9674\n",
            "Epoch 3/3\n",
            "1563/1563 [==============================] - 6s 4ms/step - loss: 0.1291 - accuracy: 0.9628 - val_loss: 0.1035 - val_accuracy: 0.9732\n",
            "313/313 [==============================] - 1s 2ms/step - loss: 0.0959 - accuracy: 0.9755\n",
            "313/313 [==============================] - 1s 2ms/step\n"
          ]
        }
      ],
      "source": [
        "from tensorflow.keras.datasets import mnist\n",
        "\n",
        "def get_mnist_model():\n",
        "    inputs = keras.Input(shape=(28 * 28,))\n",
        "    features = layers.Dense(512, activation=\"relu\")(inputs)\n",
        "    features = layers.Dropout(0.5)(features)\n",
        "    outputs = layers.Dense(10, activation=\"softmax\")(features)\n",
        "    model = keras.Model(inputs, outputs)\n",
        "    return model\n",
        "\n",
        "(images, labels), (test_images, test_labels) = mnist.load_data()\n",
        "images = images.reshape((60000, 28 * 28)).astype(\"float32\") / 255\n",
        "test_images = test_images.reshape((10000, 28 * 28)).astype(\"float32\") / 255\n",
        "train_images, val_images = images[10000:], images[:10000]\n",
        "train_labels, val_labels = labels[10000:], labels[:10000]\n",
        "\n",
        "model = get_mnist_model()\n",
        "model.compile(optimizer=\"rmsprop\",\n",
        "              loss=\"sparse_categorical_crossentropy\",\n",
        "              metrics=[\"accuracy\"])\n",
        "model.fit(train_images, train_labels,\n",
        "          epochs=3,\n",
        "          validation_data=(val_images, val_labels))\n",
        "test_metrics = model.evaluate(test_images, test_labels)\n",
        "predictions = model.predict(test_images)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D3TThQqMWGbw"
      },
      "source": [
        "### Writing your own metrics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sTqCoAD0WGbw"
      },
      "source": [
        "**Implementing a custom metric by subclassing the `Metric` class**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IZA8UuVpWGbw"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "class RootMeanSquaredError(keras.metrics.Metric):\n",
        "\n",
        "    def __init__(self, name=\"rmse\", **kwargs):\n",
        "        super().__init__(name=name, **kwargs)\n",
        "        self.mse_sum = self.add_weight(name=\"mse_sum\", initializer=\"zeros\")\n",
        "        self.total_samples = self.add_weight(\n",
        "            name=\"total_samples\", initializer=\"zeros\", dtype=\"int32\")\n",
        "\n",
        "    def update_state(self, y_true, y_pred, sample_weight=None):\n",
        "        y_true = tf.one_hot(y_true, depth=tf.shape(y_pred)[1])\n",
        "        mse = tf.reduce_sum(tf.square(y_true - y_pred))\n",
        "        self.mse_sum.assign_add(mse)\n",
        "        num_samples = tf.shape(y_pred)[0]\n",
        "        self.total_samples.assign_add(num_samples)\n",
        "\n",
        "    def result(self):\n",
        "        return tf.sqrt(self.mse_sum / tf.cast(self.total_samples, tf.float32))\n",
        "\n",
        "    def reset_state(self):\n",
        "        self.mse_sum.assign(0.)\n",
        "        self.total_samples.assign(0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MRJbsef-WGbw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5f27ad22-e146-405a-e5ca-3a6ab481cfca"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/3\n",
            "1563/1563 [==============================] - 7s 4ms/step - loss: 0.2955 - accuracy: 0.9125 - rmse: 7.1754 - val_loss: 0.1541 - val_accuracy: 0.9551 - val_rmse: 7.3594\n",
            "Epoch 2/3\n",
            "1563/1563 [==============================] - 6s 4ms/step - loss: 0.1583 - accuracy: 0.9546 - rmse: 7.3522 - val_loss: 0.1069 - val_accuracy: 0.9689 - val_rmse: 7.4012\n",
            "Epoch 3/3\n",
            "1563/1563 [==============================] - 6s 4ms/step - loss: 0.1301 - accuracy: 0.9624 - rmse: 7.3822 - val_loss: 0.0970 - val_accuracy: 0.9742 - val_rmse: 7.4187\n",
            "313/313 [==============================] - 1s 3ms/step - loss: 0.0864 - accuracy: 0.9760 - rmse: 7.4326\n"
          ]
        }
      ],
      "source": [
        "model = get_mnist_model()\n",
        "model.compile(optimizer=\"rmsprop\",\n",
        "              loss=\"sparse_categorical_crossentropy\",\n",
        "              metrics=[\"accuracy\", RootMeanSquaredError()])\n",
        "model.fit(train_images, train_labels,\n",
        "          epochs=3,\n",
        "          validation_data=(val_images, val_labels))\n",
        "test_metrics = model.evaluate(test_images, test_labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gmGjd6bLWGbw"
      },
      "source": [
        "### Using callbacks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vi9gb9i7WGbw"
      },
      "source": [
        "#### The EarlyStopping and ModelCheckpoint callbacks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iLC2AUaBWGbx"
      },
      "outputs": [],
      "source": [
        "callbacks_list = [\n",
        "    keras.callbacks.EarlyStopping(\n",
        "        monitor=\"val_accuracy\",\n",
        "        patience=2,\n",
        "    ),\n",
        "    keras.callbacks.ModelCheckpoint(\n",
        "        filepath=\"checkpoint_path.keras\",\n",
        "        monitor=\"val_loss\",\n",
        "        save_best_only=True,\n",
        "    )\n",
        "]\n",
        "model = get_mnist_model()\n",
        "model.compile(optimizer=\"rmsprop\",\n",
        "              loss=\"sparse_categorical_crossentropy\",\n",
        "              metrics=[\"accuracy\"])\n",
        "model.fit(train_images, train_labels,\n",
        "          epochs=10,\n",
        "          callbacks=callbacks_list,\n",
        "          validation_data=(val_images, val_labels))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2Ya8ZdPoWGbx"
      },
      "outputs": [],
      "source": [
        "model = keras.models.load_model(\"checkpoint_path.keras\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7kq9GJ3TWGbx"
      },
      "source": [
        "### Writing your own callbacks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "duGXiHDeWGbx"
      },
      "outputs": [],
      "source": [
        "from matplotlib import pyplot as plt\n",
        "\n",
        "class LossHistory(keras.callbacks.Callback):\n",
        "    def on_train_begin(self, logs):\n",
        "        self.per_batch_losses = []\n",
        "\n",
        "    def on_batch_end(self, batch, logs):\n",
        "        self.per_batch_losses.append(logs.get(\"loss\"))\n",
        "\n",
        "    def on_epoch_end(self, epoch, logs):\n",
        "        plt.clf()\n",
        "        plt.plot(range(len(self.per_batch_losses)), self.per_batch_losses,\n",
        "                 label=\"Training loss for each batch\")\n",
        "        plt.xlabel(f\"Batch (epoch {epoch})\")\n",
        "        plt.ylabel(\"Loss\")\n",
        "        plt.legend()\n",
        "        plt.savefig(f\"plot_at_epoch_{epoch}\")\n",
        "        self.per_batch_losses = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Yzbv6LP0WGbx"
      },
      "outputs": [],
      "source": [
        "model = get_mnist_model()\n",
        "model.compile(optimizer=\"rmsprop\",\n",
        "              loss=\"sparse_categorical_crossentropy\",\n",
        "              metrics=[\"accuracy\"])\n",
        "model.fit(train_images, train_labels,\n",
        "          epochs=10,\n",
        "          callbacks=[LossHistory()],\n",
        "          validation_data=(val_images, val_labels))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GQDQRyebWGbx"
      },
      "source": [
        "### Monitoring and visualization with TensorBoard"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UFh52dDbWGbx"
      },
      "outputs": [],
      "source": [
        "model = get_mnist_model()\n",
        "model.compile(optimizer=\"rmsprop\",\n",
        "              loss=\"sparse_categorical_crossentropy\",\n",
        "              metrics=[\"accuracy\"])\n",
        "\n",
        "tensorboard = keras.callbacks.TensorBoard(\n",
        "    log_dir=\"/full_path_to_your_log_dir\",\n",
        ")\n",
        "model.fit(train_images, train_labels,\n",
        "          epochs=10,\n",
        "          validation_data=(val_images, val_labels),\n",
        "          callbacks=[tensorboard])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1DA_nFvwWGbx"
      },
      "outputs": [],
      "source": [
        "%load_ext tensorboard\n",
        "%tensorboard --logdir /full_path_to_your_log_dir"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WPt2q9_VWGby"
      },
      "source": [
        "## Writing your own training and evaluation loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6bFTDpGHWGby"
      },
      "source": [
        "### Low-level usage of metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wEXUTVuqWGby"
      },
      "outputs": [],
      "source": [
        "metric = keras.metrics.SparseCategoricalAccuracy()\n",
        "targets = [0, 1, 2]\n",
        "predictions = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n",
        "metric.update_state(targets, predictions)\n",
        "current_result = metric.result()\n",
        "print(f\"result: {current_result:.2f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ao738Gh3WGby"
      },
      "outputs": [],
      "source": [
        "values = [0, 1, 2, 3, 4]\n",
        "mean_tracker = keras.metrics.Mean()\n",
        "for value in values:\n",
        "    mean_tracker.update_state(value)\n",
        "print(f\"Mean of values: {mean_tracker.result():.2f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ET9CIhpiWGby"
      },
      "source": [
        "### A complete training and evaluation loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BRPVkRY4WGby"
      },
      "outputs": [],
      "source": [
        "model = get_mnist_model()\n",
        "\n",
        "loss_fn = keras.losses.SparseCategoricalCrossentropy()\n",
        "optimizer = keras.optimizers.RMSprop()\n",
        "metrics = [keras.metrics.SparseCategoricalAccuracy()]\n",
        "loss_tracking_metric = keras.metrics.Mean()\n",
        "\n",
        "def train_step(inputs, targets):\n",
        "    with tf.GradientTape() as tape:\n",
        "        predictions = model(inputs, training=True)\n",
        "        loss = loss_fn(targets, predictions)\n",
        "    gradients = tape.gradient(loss, model.trainable_weights)\n",
        "    optimizer.apply_gradients(zip(gradients, model.trainable_weights))\n",
        "\n",
        "    logs = {}\n",
        "    for metric in metrics:\n",
        "        metric.update_state(targets, predictions)\n",
        "        logs[metric.name] = metric.result()\n",
        "\n",
        "    loss_tracking_metric.update_state(loss)\n",
        "    logs[\"loss\"] = loss_tracking_metric.result()\n",
        "    return logs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sAVAEsrXWGby"
      },
      "outputs": [],
      "source": [
        "def reset_metrics():\n",
        "    for metric in metrics:\n",
        "        metric.reset_state()\n",
        "    loss_tracking_metric.reset_state()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Nj3h71TrWGby"
      },
      "outputs": [],
      "source": [
        "training_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_labels))\n",
        "training_dataset = training_dataset.batch(32)\n",
        "epochs = 3\n",
        "for epoch in range(epochs):\n",
        "    reset_metrics()\n",
        "    for inputs_batch, targets_batch in training_dataset:\n",
        "        logs = train_step(inputs_batch, targets_batch)\n",
        "    print(f\"Results at the end of epoch {epoch}\")\n",
        "    for key, value in logs.items():\n",
        "        print(f\"...{key}: {value:.4f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MT35P70GWGbz"
      },
      "outputs": [],
      "source": [
        "def test_step(inputs, targets):\n",
        "    predictions = model(inputs, training=False)\n",
        "    loss = loss_fn(targets, predictions)\n",
        "\n",
        "    logs = {}\n",
        "    for metric in metrics:\n",
        "        metric.update_state(targets, predictions)\n",
        "        logs[\"val_\" + metric.name] = metric.result()\n",
        "\n",
        "    loss_tracking_metric.update_state(loss)\n",
        "    logs[\"val_loss\"] = loss_tracking_metric.result()\n",
        "    return logs\n",
        "\n",
        "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_labels))\n",
        "val_dataset = val_dataset.batch(32)\n",
        "reset_metrics()\n",
        "for inputs_batch, targets_batch in val_dataset:\n",
        "    logs = test_step(inputs_batch, targets_batch)\n",
        "print(\"Evaluation results:\")\n",
        "for key, value in logs.items():\n",
        "    print(f\"...{key}: {value:.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r_Fpco6kWGbz"
      },
      "source": [
        "### Make it fast with tf.function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H6vSA-h3WGbz"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def test_step(inputs, targets):\n",
        "    predictions = model(inputs, training=False)\n",
        "    loss = loss_fn(targets, predictions)\n",
        "\n",
        "    logs = {}\n",
        "    for metric in metrics:\n",
        "        metric.update_state(targets, predictions)\n",
        "        logs[\"val_\" + metric.name] = metric.result()\n",
        "\n",
        "    loss_tracking_metric.update_state(loss)\n",
        "    logs[\"val_loss\"] = loss_tracking_metric.result()\n",
        "    return logs\n",
        "\n",
        "val_dataset = tf.data.Dataset.from_tensor_slices((val_images, val_labels))\n",
        "val_dataset = val_dataset.batch(32)\n",
        "reset_metrics()\n",
        "for inputs_batch, targets_batch in val_dataset:\n",
        "    logs = test_step(inputs_batch, targets_batch)\n",
        "print(\"Evaluation results:\")\n",
        "for key, value in logs.items():\n",
        "    print(f\"...{key}: {value:.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hXmZFhupWGbz"
      },
      "source": [
        "### Leveraging fit() with a custom training loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g6QDah78WGbz"
      },
      "outputs": [],
      "source": [
        "loss_fn = keras.losses.SparseCategoricalCrossentropy()\n",
        "loss_tracker = keras.metrics.Mean(name=\"loss\")\n",
        "\n",
        "class CustomModel(keras.Model):\n",
        "    def train_step(self, data):\n",
        "        inputs, targets = data\n",
        "        with tf.GradientTape() as tape:\n",
        "            predictions = self(inputs, training=True)\n",
        "            loss = loss_fn(targets, predictions)\n",
        "        gradients = tape.gradient(loss, self.trainable_weights)\n",
        "        self.optimizer.apply_gradients(zip(gradients, self.trainable_weights))\n",
        "\n",
        "        loss_tracker.update_state(loss)\n",
        "        return {\"loss\": loss_tracker.result()}\n",
        "\n",
        "    @property\n",
        "    def metrics(self):\n",
        "        return [loss_tracker]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Mqyqj0nFWGbz"
      },
      "outputs": [],
      "source": [
        "inputs = keras.Input(shape=(28 * 28,))\n",
        "features = layers.Dense(512, activation=\"relu\")(inputs)\n",
        "features = layers.Dropout(0.5)(features)\n",
        "outputs = layers.Dense(10, activation=\"softmax\")(features)\n",
        "model = CustomModel(inputs, outputs)\n",
        "\n",
        "model.compile(optimizer=keras.optimizers.RMSprop())\n",
        "model.fit(train_images, train_labels, epochs=3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Cv06-_ZlWGbz"
      },
      "outputs": [],
      "source": [
        "class CustomModel(keras.Model):\n",
        "    def train_step(self, data):\n",
        "        inputs, targets = data\n",
        "        with tf.GradientTape() as tape:\n",
        "            predictions = self(inputs, training=True)\n",
        "            loss = self.compiled_loss(targets, predictions)\n",
        "        gradients = tape.gradient(loss, self.trainable_weights)\n",
        "        self.optimizer.apply_gradients(zip(gradients, self.trainable_weights))\n",
        "        self.compiled_metrics.update_state(targets, predictions)\n",
        "        return {m.name: m.result() for m in self.metrics}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1x8kcgFtWGbz"
      },
      "outputs": [],
      "source": [
        "inputs = keras.Input(shape=(28 * 28,))\n",
        "features = layers.Dense(512, activation=\"relu\")(inputs)\n",
        "features = layers.Dropout(0.5)(features)\n",
        "outputs = layers.Dense(10, activation=\"softmax\")(features)\n",
        "model = CustomModel(inputs, outputs)\n",
        "\n",
        "model.compile(optimizer=keras.optimizers.RMSprop(),\n",
        "              loss=keras.losses.SparseCategoricalCrossentropy(),\n",
        "              metrics=[keras.metrics.SparseCategoricalAccuracy()])\n",
        "model.fit(train_images, train_labels, epochs=3)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.0"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}