Fashion_MNIST_Deployment.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Fashion_MNIST_Deployment.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOWZsNCqwghxoLU7cFm6v7O",
      "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/aadi-mishra/Deep-Learning-Projects-Keras/blob/main/Fashion_MNIST_Deployment.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4_IYVk6pEU4"
      },
      "source": [
        "## Local Deployment Steps \n",
        "* We save our trained model\n",
        "* We install TensorFlow ModelServer. ModelServer provides the server that a client program can use to access our trained model.\n",
        "* We the launch our TF ModelServer providing a specific end-point for out trained model.\n",
        "* Lastly, we create code that will call these server end-point and pass an image. The image will be classified by our model and the predicted class returned to the client."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u7o1nYY8otZo"
      },
      "source": [
        "# Install Tensorflow ModelServer \n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9C5lXjF3oH3X"
      },
      "source": [
        "# Import Libraries\n",
        "from keras.datasets import fashion_mnist\n",
        "from keras import models\n",
        "from keras import layers\n",
        "from keras.utils import to_categorical\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "\n",
        "\n",
        "import tempfile\n",
        "import os\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v0hMY7lXuV02"
      },
      "source": [
        "# Define class names to display\n",
        "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ECQM2XBts2eP"
      },
      "source": [
        "## Our ML workflow\n",
        "* Get data --Load Fashion MNIST data\n",
        "* Prepare Data -- Pre-process data\n",
        "* Create Model -- Define network structure \n",
        "* Define loss measurement -- use sparse categorical cross-entropy\n",
        "* Train model to minimize loss -- Use optimizer with backprop to update model's weights to minimize loss \n",
        "* Evaluate training performance -- Measure loss on training data \n",
        "* Evaluate testing performance -- Measure loss on testing data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M_1htpDdo-oY"
      },
      "source": [
        "# Load the data\n",
        "(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AKbdzSRDvIKp",
        "outputId": "6f48fec2-c872-464f-d782-6d344a715538"
      },
      "source": [
        "# Inspecting our data \n",
        "print(\"Training dataset : \", train_images.shape, train_labels.shape)\n",
        "print(\"Testing dataset : \", test_images.shape, test_labels.shape)\n",
        "print(train_labels[100])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Training dataset :  (60000, 28, 28) (60000,)\n",
            "Testing dataset :  (10000, 28, 28) (10000,)\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bltU9SDcvpn2"
      },
      "source": [
        "# Visualizing an image and its associated label\n",
        "def show_training_image(index):\n",
        "  img_label = str(train_labels[index]) + ' (' + class_names[train_labels[index]] + ')'\n",
        "  plt.figure()\n",
        "  plt.title('Image Label ' + img_label)\n",
        "  plt.imshow(train_images[index], cmap='gray')\n",
        "  plt.colorbar()\n",
        "  plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "LiXPboNOwr0c",
        "outputId": "badbffa3-7456-4f13-cb9a-dc11c4eb621a"
      },
      "source": [
        "img_index = 10\n",
        "show_training_image(img_index)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zQ8gecTcyBdm"
      },
      "source": [
        "### Prepare Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKR2lBH2wwX0"
      },
      "source": [
        "# Normalizing our data\n",
        "train_images = train_images.reshape((60000, 28, 28, 1))\n",
        "train_images = train_images / 255.0\n",
        "\n",
        "test_images = test_images.reshape((10000, 28, 28, 1))\n",
        "test_images = test_images / 255.0\n",
        "\n",
        "\n",
        "train_labels = to_categorical(train_labels)\n",
        "test_labels = to_categorical(test_labels)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-tRFsDPGyv5J"
      },
      "source": [
        "### Creating Model\n",
        "\n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7XltYOL2yiHc"
      },
      "source": [
        "model = models.Sequential()\n",
        "model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
        "model.add(layers.Flatten())\n",
        "model.add(layers.Dense(64, activation='relu'))\n",
        "model.add(layers.Dense(10, activation='softmax'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LZoS32hYy-xS",
        "outputId": "25e038f6-ccb0-4278-f37d-654dba04d4a5"
      },
      "source": [
        "# Visualising our network \n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "conv2d_9 (Conv2D)            (None, 26, 26, 32)        320       \n",
            "_________________________________________________________________\n",
            "max_pooling2d_6 (MaxPooling2 (None, 13, 13, 32)        0         \n",
            "_________________________________________________________________\n",
            "conv2d_10 (Conv2D)           (None, 11, 11, 64)        18496     \n",
            "_________________________________________________________________\n",
            "max_pooling2d_7 (MaxPooling2 (None, 5, 5, 64)          0         \n",
            "_________________________________________________________________\n",
            "conv2d_11 (Conv2D)           (None, 3, 3, 64)          36928     \n",
            "_________________________________________________________________\n",
            "flatten_2 (Flatten)          (None, 576)               0         \n",
            "_________________________________________________________________\n",
            "dense_4 (Dense)              (None, 64)                36928     \n",
            "_________________________________________________________________\n",
            "dense_5 (Dense)              (None, 10)                650       \n",
            "=================================================================\n",
            "Total params: 93,322\n",
            "Trainable params: 93,322\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bMbKyQmszKis"
      },
      "source": [
        "# Compiling the model \n",
        "train_hist = model.compile(optimizer='rmsprop', loss= 'categorical_crossentropy', metrics=['accuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7SJi9xJt0Fh-",
        "outputId": "16b7cfa7-7772-4090-da2e-db54abf80341"
      },
      "source": [
        "# Traiining the model\n",
        "train_hist = model.fit(train_images, train_labels, epochs=9, batch_size = 128)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/9\n",
            "469/469 [==============================] - 47s 99ms/step - loss: 0.1084 - accuracy: 0.9597\n",
            "Epoch 2/9\n",
            "469/469 [==============================] - 46s 99ms/step - loss: 0.0995 - accuracy: 0.9633\n",
            "Epoch 3/9\n",
            "469/469 [==============================] - 46s 99ms/step - loss: 0.0925 - accuracy: 0.9657\n",
            "Epoch 4/9\n",
            "469/469 [==============================] - 46s 99ms/step - loss: 0.0857 - accuracy: 0.9683\n",
            "Epoch 5/9\n",
            "469/469 [==============================] - 47s 100ms/step - loss: 0.0791 - accuracy: 0.9711\n",
            "Epoch 6/9\n",
            "469/469 [==============================] - 46s 98ms/step - loss: 0.0744 - accuracy: 0.9727\n",
            "Epoch 7/9\n",
            "469/469 [==============================] - 47s 99ms/step - loss: 0.0683 - accuracy: 0.9743\n",
            "Epoch 8/9\n",
            "469/469 [==============================] - 47s 99ms/step - loss: 0.0636 - accuracy: 0.9770\n",
            "Epoch 9/9\n",
            "469/469 [==============================] - 47s 100ms/step - loss: 0.0605 - accuracy: 0.9773\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z9PWWbfA0P5y"
      },
      "source": [
        "def plot_acc(hist):\n",
        "  # plot the accuracy\n",
        "  plt.title('Accuracy History')\n",
        "  plt.plot(hist.history['accuracy'])\n",
        "  plt.ylabel('Accuracy')\n",
        "  plt.xlabel('epoch')\n",
        "  plt.show()\n",
        "  \n",
        "def plot_loss(hist):\n",
        "  # plot the loss\n",
        "  plt.title('Loss History')\n",
        "  plt.plot(hist.history['loss'])\n",
        "  plt.ylabel('loss')\n",
        "  plt.xlabel('epoch')\n",
        "  plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "6lQ2Fz-m2HBm",
        "outputId": "ded6d0bc-b58e-4a82-e4fc-c5f8137c5604"
      },
      "source": [
        "plot_loss(train_hist)\n",
        "plot_acc(train_hist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZAekJ15F2Hrd",
        "outputId": "2ec61170-7859-4a49-eafc-d098886f74c9"
      },
      "source": [
        "# get the tempfile location for this Colab session\n",
        "MODEL_DIR = tempfile.gettempdir()\n",
        "version = 1   # NOTE: Adjust if you don't want to replace a version of your model\n",
        "export_path = os.path.join(MODEL_DIR, str(version))  # the final path includes the version\n",
        "print('Saving model to : {}\\n'.format(export_path))\n",
        "\n",
        "# if path already exists delete everything at the location\n",
        "if os.path.isdir(export_path):\n",
        "  print('\\nPreviously saved model found, deleting it\\n')\n",
        "  !rm -r {export_path}\n",
        "\n",
        "# Save the model  \n",
        "tf.saved_model.save(model, export_path)\n",
        "\n",
        "# Print save complete message\n",
        "print('Model saved')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving model to : /tmp/1\n",
            "\n",
            "INFO:tensorflow:Assets written to: /tmp/1/assets\n",
            "Model saved\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZHNnHewj8AG0",
        "outputId": "7c030101-9899-43ad-f52a-d2052f4fce9c"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/gdrive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "akoSFlEL-hiS",
        "outputId": "b7a461a1-f459-4046-afd5-28d03394eb5d"
      },
      "source": [
        "%cd TFmodels/"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/gdrive/My Drive/TFmodels\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VTsCyRAY-jyD",
        "outputId": "25ff7ec6-7335-4790-daf9-dfd02407897c"
      },
      "source": [
        "!ls"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "my_model.h5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rh1iCxziA2x8"
      },
      "source": [
        "# Deploying our Trained Model\n",
        "\n",
        "Once we are satisified with the model's performance we can deploy it so other programs can use it.  This is a complex subject since the deployment strategies depend on how our model will be used.\n",
        "\n",
        "In this script we will show a very basic way of deploying the model.  We will do just enough so we can make predictions with our trained model from Python.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PRZuK-JoA4aW"
      },
      "source": [
        "## TensorFlow ModelServer\n",
        "\n",
        "We are going to use the Tensorflow ModelServer to serve our model.  This install may only work in Colab.  \n",
        "\n",
        "*The recommendation for general installation and usage of the server is to use a docker container.  This is documented in the repo, https://github.com/tensorflow/serving/blob/master/tensorflow_serving/g3doc/setup.md*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tBw-HNkLBHZW"
      },
      "source": [
        "## Add TensorFlow Serving as installable\n",
        "\n",
        "Before we can install the TensorFlow ModelServer we need to make it known to the APT installer so the installer know where to fetch the bits.\n",
        "\n",
        "We do this by adding a key in to the APT database refering to the tensorflow-serving files location."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f2dwpb8Y-ode",
        "outputId": "de89dc44-9ac8-4937-d840-1a661f8717c9"
      },
      "source": [
        "# add the key\n",
        "!echo 'deb http://storage.googleapis.com/tensorflow-serving-apt stable tensorflow-model-server tensorflow-model-server-universal' | tee /etc/apt/sources.list.d/tensorflow-serving.list && \\\n",
        "curl https://storage.googleapis.com/tensorflow-serving-apt/tensorflow-serving.release.pub.gpg | apt-key add -\n",
        "# update the database with the new key\n",
        "!apt update"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "deb http://storage.googleapis.com/tensorflow-serving-apt stable tensorflow-model-server tensorflow-model-server-universal\n",
            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
            "100  2943  100  2943    0     0  14939      0 --:--:-- --:--:-- --:--:-- 14939\n",
            "OK\n",
            "Get:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease [3,626 B]\n",
            "Get:2 http://storage.googleapis.com/tensorflow-serving-apt stable InRelease [3,012 B]\n",
            "Ign:3 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease\n",
            "Get:4 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ Packages [52.7 kB]\n",
            "Ign:5 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n",
            "Hit:6 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release\n",
            "Hit:7 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n",
            "Get:8 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease [15.9 kB]\n",
            "Get:9 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]\n",
            "Hit:10 http://archive.ubuntu.com/ubuntu bionic InRelease\n",
            "Get:11 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]\n",
            "Get:12 http://storage.googleapis.com/tensorflow-serving-apt stable/tensorflow-model-server-universal amd64 Packages [348 B]\n",
            "Get:14 http://storage.googleapis.com/tensorflow-serving-apt stable/tensorflow-model-server amd64 Packages [340 B]\n",
            "Hit:16 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n",
            "Get:17 http://archive.ubuntu.com/ubuntu bionic-backports InRelease [74.6 kB]\n",
            "Get:18 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease [15.9 kB]\n",
            "Get:19 http://security.ubuntu.com/ubuntu bionic-security/universe amd64 Packages [1,402 kB]\n",
            "Hit:20 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n",
            "Get:21 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 Packages [2,475 kB]\n",
            "Get:22 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic/main Sources [1,749 kB]\n",
            "Get:23 http://security.ubuntu.com/ubuntu bionic-security/main amd64 Packages [2,045 kB]\n",
            "Get:24 http://archive.ubuntu.com/ubuntu bionic-updates/universe amd64 Packages [2,170 kB]\n",
            "Get:25 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic/main amd64 Packages [895 kB]\n",
            "Get:26 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic/main amd64 Packages [39.5 kB]\n",
            "Fetched 11.1 MB in 7s (1,577 kB/s)\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "50 packages can be upgraded. Run 'apt list --upgradable' to see them.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rHar6_N4BXf2"
      },
      "source": [
        "## Install TensorFlow ModelServer\n",
        "We use apt-get to fetch and install TensorFlow ModelServer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3MhJRUck_BQg",
        "outputId": "59193d51-4c11-48f7-8764-cdc05577dff1"
      },
      "source": [
        "!apt-get install tensorflow-model-server"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "The following NEW packages will be installed:\n",
            "  tensorflow-model-server\n",
            "0 upgraded, 1 newly installed, 0 to remove and 50 not upgraded.\n",
            "Need to get 223 MB of archives.\n",
            "After this operation, 0 B of additional disk space will be used.\n",
            "Get:1 http://storage.googleapis.com/tensorflow-serving-apt stable/tensorflow-model-server amd64 tensorflow-model-server all 2.4.1 [223 MB]\n",
            "Fetched 223 MB in 4s (56.5 MB/s)\n",
            "Selecting previously unselected package tensorflow-model-server.\n",
            "(Reading database ... 160980 files and directories currently installed.)\n",
            "Preparing to unpack .../tensorflow-model-server_2.4.1_all.deb ...\n",
            "Unpacking tensorflow-model-server (2.4.1) ...\n",
            "Setting up tensorflow-model-server (2.4.1) ...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zFnsV0oGBi_c"
      },
      "source": [
        "### Start TensorFlow ModelServer\n",
        "\n",
        "This is where we start TensorFlow ModelServer and load our model.  After it loads we can start making inference requests using REST.  There are some important parameters:\n",
        "\n",
        "* `rest_api_port`: The port that you'll use for REST requests.\n",
        "* `model_name`: You'll use this in the URL of the REST requests.  It can be anything.\n",
        "* `model_base_path`: This is the path to the directory where you've saved your model.\n",
        "\n",
        "We need to define these as Python variables and as shell environment variables.  This will make this information available in Python code and in \n",
        "the shell where we will start the TensorFlow ModelServer process."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "APvcpT2q_Cw_"
      },
      "source": [
        "# Define the environment variable where our saved model resides\n",
        "os.environ['MODEL_DIR'] = MODEL_DIR\n",
        "# Define the Python constant and environment variable to point to the port number used to access our model\n",
        "REST_PORT = '8501'\n",
        "os.environ['REST_PORT'] = REST_PORT\n",
        "# Define the Python constant and environment variable to point to the our model name.\n",
        "#  This is an abitrary name.\n",
        "MODEL_NAME = 'fashion_mnist'\n",
        "os.environ['MODEL_NAME'] = MODEL_NAME"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LharZ-WmBnJW",
        "outputId": "d1f2c85a-d9f8-40a4-9274-2f79ac5d5a63"
      },
      "source": [
        "# Run the shell command to launch tensorflow_model_server.  Output status and error\n",
        "#  messages to the file server.log\n",
        "%%bash --bg \n",
        "nohup tensorflow_model_server \\\n",
        "  --rest_api_port=\"${REST_PORT}\" \\\n",
        "  --model_name=\"${MODEL_NAME}\" \\\n",
        "  --model_base_path=\"${MODEL_DIR}\" >server.log 2>&1\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Starting job # 0 in a separate thread.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D2mWHgpmBqL0",
        "outputId": "148abb9c-eeb2-430f-ed98-9468d05cb722"
      },
      "source": [
        "# Display the tail (last few lines) of the server log which will show any errors\n",
        "!tail server.log"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2021-04-03 18:37:32.821300: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:206] Restoring SavedModel bundle.\n",
            "2021-04-03 18:37:32.822904: I external/org_tensorflow/tensorflow/core/platform/profile_utils/cpu_utils.cc:112] CPU Frequency: 2199995000 Hz\n",
            "2021-04-03 18:37:32.864689: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running initialization op on SavedModel bundle at path: /tmp/1\n",
            "2021-04-03 18:37:32.872398: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:277] SavedModel load for tags { serve }; Status: success: OK. Took 87546 microseconds.\n",
            "2021-04-03 18:37:32.873635: I tensorflow_serving/servables/tensorflow/saved_model_warmup_util.cc:59] No warmup data file found at /tmp/1/assets.extra/tf_serving_warmup_requests\n",
            "2021-04-03 18:37:32.873875: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: fashion_mnist version: 1}\n",
            "2021-04-03 18:37:32.875189: I tensorflow_serving/model_servers/server.cc:371] Running gRPC ModelServer at 0.0.0.0:8500 ...\n",
            "[warn] getaddrinfo: address family for nodename not supported\n",
            "2021-04-03 18:37:32.876203: I tensorflow_serving/model_servers/server.cc:391] Exporting HTTP/REST API at:localhost:8501 ...\n",
            "[evhttp_server.cc : 238] NET_LOG: Entering the event loop ...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dzUIpn-1BtOo"
      },
      "source": [
        "def show_image(index, title, show_colorbar=False):\n",
        "  plt.figure()\n",
        "  plt.title('\\n\\n{}'.format(title), fontdict={'size': 16})\n",
        "  plt.imshow(test_images[index].reshape(28,28), cmap='gray')  # data is grayscale, but displays in color without cmap='gray'\n",
        "  if (show_colorbar):\n",
        "    plt.colorbar()\n",
        "  plt.axis('off')\n",
        "  plt.show()\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hr6p42rXBwlr"
      },
      "source": [
        "!pip install -q requests    # Install the requests library which makes HTTP requests to the TensorFlow server \n",
        "                            # using our trained our model \n",
        "import requests     # import requests "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VZzw7BlfBz_7"
      },
      "source": [
        "# Select a random image to classify\n",
        "import random\n",
        "image_index = random.randint(0,len(test_images)-1)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6-PIuIdGB33I"
      },
      "source": [
        " # Import json library and create the json data structure to be passed in the request.\n",
        "import json\n",
        "\n",
        "# The data is assumed to be a list of images, a 4D tensor of the shape [*,28,28,1].  \n",
        "# Convert the single 3d to 4d\n",
        "check_images = np.reshape(test_images[image_index],(-1,28,28,1))\n",
        "\n",
        "# Construct json data passed to server.  \"instances\" will hold the image(s) we \n",
        "#   want the model to classify\n",
        "data = json.dumps({'signature_name': 'serving_default', 'instances': check_images.tolist()}) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "id": "QoLsVhUjB74X",
        "outputId": "e2a28686-7b03-461a-9049-248bf90fbf92"
      },
      "source": [
        " #Create the request\n",
        "\n",
        "# HTTP request header\n",
        "headers = {'content-type': 'application/json'}\n",
        "\n",
        "# Build the url to the service using the constants we defined earlier, should be of the form:\n",
        "#      http://localhost:8501/v1/models/fashion_mnist:predict\n",
        "predict_service_url = 'http://localhost:' + REST_PORT + '/v1/models/' + MODEL_NAME + ':predict'\n",
        "\n",
        "# Make request to the service.  Pass the headers and data.  Wait for the server's reponse.\n",
        "json_response = requests.post(predict_service_url, data=data, headers=headers)\n",
        "\n",
        "# Parse the response.  For each images we pass we get a list of probabilities \n",
        "predictions = json.loads(json_response.text)['predictions']\n",
        "# predictions[0] is the 10 probabilites for our first and only image.\n",
        "# predictions[0] has values in the form [0.1, 0.05, ...., 0.6]\n",
        "\n",
        "# The numpy argmax function returns the index of the highest value.  This is \n",
        "# the highest probabilty class predicted by our model. \n",
        "predicted_class = np.argmax(predictions[0])\n",
        "\n",
        "# Display image, the actual class and the predicted class\n",
        "show_image(img_index, 'Model predicted class: {} (class {}). \\n Actually class: {} (class {})'.format(\n",
        "  class_names[predicted_class], predicted_class, class_names[test_labels[image_index]], test_labels[image_index]))"
      ],
      "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-100-c5c677e92df4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     22\u001b[0m \u001b[0;31m# Display image, the actual class and the predicted class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     23\u001b[0m show_image(img_index, 'Model predicted class: {} (class {}). \\n Actually class: {} (class {})'.format(\n\u001b[0;32m---> 24\u001b[0;31m  class_names[predicted_class], predicted_class, class_names[test_labels[image_index]], test_labels[image_index]))\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: only integer scalar arrays can be converted to a scalar index"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PVet8UTjCB0H"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}