train_deploy_image_classifier.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "![Impressions](https://PixelServer20190423114238.azurewebsites.net/api/impressions/NotebookVM/tutorials/quickstart-ci/AzureMLin10mins.png)"
      ],
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Train and deploy a model in Azure Machine Learning"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Import Data\n",
        "\n",
        "* Download the MNIST dataset\n",
        "* Display some sample images"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "from azureml.opendatasets import MNIST\n",
        "\n",
        "data_folder = os.path.join(os.getcwd(), \"/tmp/qs_data\")\n",
        "os.makedirs(data_folder, exist_ok=True)\n",
        "\n",
        "mnist_file_dataset = MNIST.get_file_dataset()\n",
        "mnist_file_dataset.download(data_folder, overwrite=True)"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 1,
          "data": {
            "text/plain": "['/tmp/qs_data/https%3A/%2Fazureopendatastorage.azurefd.net/mnist/t10k-images-idx3-ubyte.gz',\n '/tmp/qs_data/https%3A/%2Fazureopendatastorage.azurefd.net/mnist/t10k-labels-idx1-ubyte.gz',\n '/tmp/qs_data/https%3A/%2Fazureopendatastorage.azurefd.net/mnist/train-images-idx3-ubyte.gz',\n '/tmp/qs_data/https%3A/%2Fazureopendatastorage.azurefd.net/mnist/train-labels-idx1-ubyte.gz']"
          },
          "metadata": {}
        }
      ],
      "execution_count": 1,
      "metadata": {
        "gather": {
          "logged": 1659805570333
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Take a look at the data\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from utils import load_data\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import glob\n",
        "\n",
        "\n",
        "# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the model converge faster.\n",
        "X_train = (\n",
        "    load_data(\n",
        "        glob.glob(\n",
        "            os.path.join(data_folder, \"**/train-images-idx3-ubyte.gz\"), recursive=True\n",
        "        )[0],\n",
        "        False,\n",
        "    )\n",
        "    / 255.0\n",
        ")\n",
        "X_test = (\n",
        "    load_data(\n",
        "        glob.glob(\n",
        "            os.path.join(data_folder, \"**/t10k-images-idx3-ubyte.gz\"), recursive=True\n",
        "        )[0],\n",
        "        False,\n",
        "    )\n",
        "    / 255.0\n",
        ")\n",
        "y_train = load_data(\n",
        "    glob.glob(\n",
        "        os.path.join(data_folder, \"**/train-labels-idx1-ubyte.gz\"), recursive=True\n",
        "    )[0],\n",
        "    True,\n",
        ").reshape(-1)\n",
        "y_test = load_data(\n",
        "    glob.glob(\n",
        "        os.path.join(data_folder, \"**/t10k-labels-idx1-ubyte.gz\"), recursive=True\n",
        "    )[0],\n",
        "    True,\n",
        ").reshape(-1)\n",
        "\n",
        "\n",
        "# now let's show some randomly chosen images from the traininng set.\n",
        "count = 0\n",
        "sample_size = 30\n",
        "plt.figure(figsize=(16, 6))\n",
        "for i in np.random.permutation(X_train.shape[0])[:sample_size]:\n",
        "    count = count + 1\n",
        "    plt.subplot(1, sample_size, count)\n",
        "    plt.axhline(\"\")\n",
        "    plt.axvline(\"\")\n",
        "    plt.text(x=10, y=-10, s=y_train[i], fontsize=18)\n",
        "    plt.imshow(X_train[i].reshape(28, 28), cmap=plt.cm.Greys)\n",
        "plt.show()"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 1152x432 with 30 Axes>",
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "execution_count": 2,
      "metadata": {
        "gather": {
          "logged": 1659805572869
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Train model and log metrics with MLflow\n",
        "\n",
        "Train the [LogisticRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) classifier from the [SciKit Learn framework](https://scikit-learn.org/) to classify the data.\n",
        "\n"
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create the model\n",
        "import mlflow\n",
        "import numpy as np\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from azureml.core import Workspace\n",
        "\n",
        "# connect to your workspace\n",
        "ws = Workspace.from_config()\n",
        "\n",
        "# create experiment and start logging to a new run in the experiment\n",
        "experiment_name = \"azure-ml-in10-mins-tutorial\"\n",
        "\n",
        "# set up MLflow to track the metrics\n",
        "mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())\n",
        "mlflow.set_experiment(experiment_name)\n",
        "mlflow.autolog()\n",
        "\n",
        "# set up the Logistic regression model\n",
        "reg = 0.5\n",
        "clf = LogisticRegression(\n",
        "    C=1.0 / reg, solver=\"liblinear\", multi_class=\"auto\", random_state=42\n",
        ")\n",
        "\n",
        "# train the model\n",
        "with mlflow.start_run() as run:\n",
        "    clf.fit(X_train, y_train)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": "2022/08/06 17:06:18 INFO mlflow.tracking.fluent: Autologging successfully enabled for sklearn.\n2022/08/06 17:06:18 INFO mlflow.tracking.fluent: Autologging successfully enabled for pyspark.\n2022/08/06 17:06:18 INFO mlflow.pyspark.ml: No SparkSession detected. Autologging will log pyspark.ml models contained in the default allowlist. To specify a custom allowlist, initialize a SparkSession prior to calling mlflow.pyspark.ml.autolog() and specify the path to your allowlist file via the spark.mlflow.pysparkml.autolog.logModelAllowlistFile conf.\n2022/08/06 17:06:18 INFO mlflow.tracking.fluent: Autologging successfully enabled for pyspark.ml.\n"
        }
      ],
      "execution_count": 3,
      "metadata": {
        "gather": {
          "logged": 1659805739537
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## View Experiment\n",
        "In the left-hand menu in Azure Machine Learning Studio, select __Experiments__ and then select your experiment.\n",
        "\n",
        "## Version control your models with the model registry\n",
        "\n",
        "Once you have executed the code cell below you will be able to see the model in the registry by selecting __Models__ in the left-hand menu in Azure Machine Learning Studio.Registered models are identified by name and version. Each time you register a model with the same name as an existing one, the registry increments the version. "
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "# register the model\n",
        "model_uri = \"runs:/{}/model\".format(run.info.run_id)\n",
        "model = mlflow.register_model(model_uri, \"sklearn_mnist_model\")"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": "Registered model 'sklearn_mnist_model' already exists. Creating a new version of this model...\n2022/08/06 17:09:00 INFO mlflow.tracking._model_registry.client: Waiting up to 300 seconds for model version to finish creation.                     Model name: sklearn_mnist_model, version 4\nCreated version '4' of model 'sklearn_mnist_model'.\n"
        }
      ],
      "execution_count": 4,
      "metadata": {
        "gather": {
          "logged": 1659805740489
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Deploy the model for real-time inference\n",
        "Deploy a model so that an application can consume (inference) the model over REST.\n",
        "\n",
        "### Create deployment configuration"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "# create environment for the deploy\n",
        "from azureml.core.environment import Environment\n",
        "from azureml.core.conda_dependencies import CondaDependencies\n",
        "from azureml.core.webservice import AciWebservice\n",
        "\n",
        "# get a curated environment\n",
        "env = Environment.get(\n",
        "    workspace=ws, \n",
        "    name=\"AzureML-sklearn-1.0-ubuntu20.04-py38-cpu\",\n",
        "    version=1\n",
        ")\n",
        "env.inferencing_stack_version='latest'\n",
        "\n",
        "# create deployment config i.e. compute resources\n",
        "aciconfig = AciWebservice.deploy_configuration(\n",
        "    cpu_cores=1,\n",
        "    memory_gb=1,\n",
        "    tags={\"data\": \"MNIST\", \"method\": \"sklearn\"},\n",
        "    description=\"Predict MNIST with sklearn\",\n",
        ")"
      ],
      "outputs": [],
      "execution_count": 5,
      "metadata": {
        "gather": {
          "logged": 1659805741833
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Deploy model\n",
        "\n",
        "Deploy the model to Azure Container Instance (ACI)."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "import uuid\n",
        "from azureml.core.model import InferenceConfig\n",
        "from azureml.core.environment import Environment\n",
        "from azureml.core.model import Model\n",
        "\n",
        "# get the registered model\n",
        "model = Model(ws, \"sklearn_mnist_model\")\n",
        "\n",
        "# create an inference config i.e. the scoring script and environment\n",
        "inference_config = InferenceConfig(entry_script=\"score.py\", environment=env)\n",
        "\n",
        "# deploy the service\n",
        "service_name = \"sklearn-mnist-svc-\" + str(uuid.uuid4())[:4]\n",
        "service = Model.deploy(\n",
        "    workspace=ws,\n",
        "    name=service_name,\n",
        "    models=[model],\n",
        "    inference_config=inference_config,\n",
        "    deployment_config=aciconfig,\n",
        ")\n",
        "\n",
        "service.wait_for_deployment(show_output=True)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Tips: You can try get_logs(): https://aka.ms/debugimage#dockerlog or local deployment: https://aka.ms/debugimage#debug-locally to debug if deployment takes longer than 10 minutes.\nRunning\n2022-08-06 17:09:04+00:00 Creating Container Registry if not exists.\n2022-08-06 17:09:05+00:00 Registering the environment.\n2022-08-06 17:09:05+00:00 Use the existing image.\n2022-08-06 17:09:05+00:00 Generating deployment configuration.\n2022-08-06 17:09:06+00:00 Submitting deployment to compute.\n2022-08-06 17:09:13+00:00 Checking the status of deployment sklearn-mnist-svc-53b4..\n2022-08-06 17:12:18+00:00 Checking the status of inference endpoint sklearn-mnist-svc-53b4.\nSucceeded\nACI service creation operation finished, operation \"Succeeded\"\nCPU times: user 1.13 s, sys: 134 ms, total: 1.26 s\nWall time: 4min 38s\n"
        }
      ],
      "execution_count": 6,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Test the model service\n",
        "\n",
        "Test the model by sending a raw HTTP request to test the web service. "
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# send raw HTTP request to test the web service.\n",
        "import requests\n",
        "\n",
        "# send a random row from the test set to score\n",
        "random_index = np.random.randint(0, len(X_test) - 1)\n",
        "input_data = '{\"data\": [' + str(list(X_test[random_index])) + \"]}\"\n",
        "\n",
        "headers = {\"Content-Type\": \"application/json\"}\n",
        "\n",
        "resp = requests.post(service.scoring_uri, input_data, headers=headers)\n",
        "\n",
        "print(\"POST to url\", service.scoring_uri)\n",
        "print(\"label:\", y_test[random_index])\n",
        "print(\"prediction:\", resp.text)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "POST to url http://7aa2b8fb-61ec-4f78-b9b7-71986888ff2b.westeurope.azurecontainer.io/score\nlabel: 4\nprediction: [4]\n"
        }
      ],
      "execution_count": 7,
      "metadata": {
        "gather": {
          "logged": 1659806020466
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Clean up resources\n",
        "\n",
        "If you want to keep workspace and only delete endpoint, delete the Model service using:"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "service.delete()"
      ],
      "outputs": [],
      "execution_count": 8,
      "metadata": {
        "gather": {
          "logged": 1659806025647
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    }
  ],
  "metadata": {
    "authors": [
      {
        "name": "cewidste"
      }
    ],
    "kernelspec": {
      "name": "python38-azureml",
      "language": "python",
      "display_name": "Python 3.8 - AzureML"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.5",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "notice": "Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT License.",
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    },
    "categories": [
      "tutorials",
      "compute-instance-quickstarts"
    ],
    "kernel_info": {
      "name": "python38-azureml"
    },
    "microsoft": {
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}