dog-breed-classifier.ipynb

{
  "cells": [
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "##make sure the latest version is installed. 0.1.74 and restart the kernel\n!pip install --upgrade azureml-sdk",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Check core SDK version number\nimport azureml.core\n\nprint(\"SDK version:\", azureml.core.VERSION)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "# Dog breed classification using Pytorch Estimators on Azure Machine Learning service\n\nHave you ever seen a dog and not been able to tell the breed? Some dogs look so similar, that it can be nearly impossible to tell. For instance these are a few breeds that are difficult to tell apart:\n\n#### Alaskan Malamutes vs Siberian Huskies\n![Image of Alaskan Malamute vs Siberian Husky](http://cdn.akc.org/content/article-body-image/malamutehusky.jpg)\n\n#### Whippet vs Italian Greyhound \n![Image of Whippet vs Italian Greyhound](http://cdn.akc.org/content/article-body-image/whippetitalian.jpg)\n\nThere are sites like http://what-dog.net, which use Microsoft Cognitive Services to be able to make this easier. \n\nIn this tutorial, you will learn how to train your own image classification model using transfer learning. The Azure Machine Learning python SDK's [PyTorch estimator](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-train-pytorch) enables you to easily submit PyTorch training jobs for both single-node and distributed runs on Azure compute. The model is trained to classify dog breeds using a pretrained ResNet18 model that has been trained on the [Stanford Dog dataset](http://vision.stanford.edu/aditya86/ImageNetDogs/). This dataset has been built using images and annotation from ImageNet for the task of fine-grained image categorization. For time, we will use a subset of this dataset which includes 10 dog breeds."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## What is Azure Machine Learning service?\nAzure Machine Learning service (Preview) is a cloud service that you can use to develop and deploy machine learning models. Using Azure Machine Learning service, you can track your models as you build, train, deploy, and manage them, all at the broad scale that the cloud provides.\n![](https://docs.microsoft.com/en-us/azure/machine-learning/service/media/overview-what-is-azure-ml/aml.png)\n\n\n## How can we use it for training image classification models?\nTraining machine learning models, particularly deep neural networks, is often a time- and compute-intensive task. Once you've finished writing your training script and running on a small subset of data on your local machine, you will likely want to scale up your workload.\n\nTo facilitate training, the Azure Machine Learning Python SDK provides a high-level abstraction, the estimator class, which allows users to easily train their models in the Azure ecosystem. You can create and use an Estimator object to submit any training code you want to run on remote compute, whether it's a single-node run or distributed training across a GPU cluster. For PyTorch and TensorFlow jobs, Azure Machine Learning also provides respective custom PyTorch and TensorFlow estimators to simplify using these frameworks.\n\n### Steps to train with a Pytorch Estimator:\nIn this tutorial, we will:\n- Connect to an Azure Machine Learning service Workspace \n- Create a remote compute target\n- Upload your training data (Optional)\n- Create your training script\n- Create an Estimator object\n- Submit your training job"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Prerequisites\n* Sign up for an [Azure account](https://azure.microsoft.com/en-ca/free/search)\n* Understand the [architecture and terms](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture) introduced by Azure Machine Learning\n![](https://docs.microsoft.com/en-us/azure/machine-learning/service/media/concept-azure-machine-learning-architecture/workflow.png)"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Initialize workspace\nWe will provide a [Workspace](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#workspace) object to use in this tutorial. If you want to use a different subscription, you can enter the information below and create a Workspace. This step checks to see if the workspace is created and writes a `config.json` that can be used to reference the workspace in other notebooks. `Workspace.from_config()` creates a workspace object from the details stored in `config.json`.\n\n**You will be asked to login during this step. Please use the AAD credentials provided to you.**"
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "from azureml.core.workspace import Workspace\n\nsubscription_id = \"f4a274f8-242a-48cc-b543-3b6a61f32a5f\"\nresource_group = \"pycon-canada\"\nworkspace_name = \"pycon-canada\" ## or use \"pycon-canada-2\"\nworkspace_region = \"westeurope\"\n\nws = Workspace.create(name = workspace_name,\n                      subscription_id = subscription_id,\n                      resource_group = resource_group, \n                      location = workspace_region,\n                      create_resource_group = True,\n                      exist_ok = True)\nws.write_config()\n\nws = Workspace.from_config()\nprint('Workspace name: ' + ws.name, \n      'Azure region: ' + ws.location, \n      'Subscription id: ' + ws.subscription_id, \n      'Resource group: ' + ws.resource_group, sep = '\\n')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Create a remote compute target\nFor this tutorial, we already have a  [Azure Batch AI](https://docs.microsoft.com/azure/batch-ai/overview) cluster with a NC6s_v2, P100 GPU machine, created to use as the [compute target](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#compute-target) to execute your training script on. \n\nThis code creates a cluster for you if it does not already exist in your workspace.\n\n**Creation of the cluster takes approximately 5 minutes.** If the cluster is already in your workspace this code will skip the cluster creation process."
    },
    {
      "metadata": {
        "scrolled": false,
        "trusted": true
      },
      "cell_type": "code",
      "source": "from azureml.core.compute import ComputeTarget, BatchAiCompute\nfrom azureml.core.compute_target import ComputeTargetException\n\n# choose a name for your cluster\ncluster_name = \"pycon\"\n\ntry:\n    compute_target = ComputeTarget(workspace=ws, name=cluster_name)\n    print('Found existing compute target.')\nexcept ComputeTargetException:\n    print('Creating a new compute target...')\n    compute_config = BatchAiCompute.provisioning_configuration(vm_size='Standard_NC6s_v2', \n                                                                autoscale_enabled=True,\n                                                                cluster_min_nodes=1, \n                                                                cluster_max_nodes=1)\n\n    # create the cluster\n    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n\n    compute_target.wait_for_completion(show_output=True)\n\n    # Use the 'status' property to get a detailed status for the current cluster. \n    print(compute_target.status.serialize())",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Upload training data\nThe dataset we will use consists of ~150 images per class. Some breeds have more, while others have less. Each class has about 100 training images each for dog breeds, with ~50 validation images for each class. We will look at 10 classes in this tutorial.\n\nTo make the data accessible for remote training, you will need to upload the data from your local machine to the cloud. AML provides a convenient way to do so via a [Datastore](https://docs.microsoft.com/azure/machine-learning/service/how-to-access-data). The datastore provides a mechanism for you to upload/download data, and interact with it from your remote compute targets. It is an abstraction over Azure Storage. The datastore can reference either an Azure Blob container or Azure file share as the underlying storage. \n\nYou can view the subset of the data used [here](https://github.com/heatherbshapiro/pycon-canada/tree/master/breeds-10). \n\nFirst, download the dataset (located [here](https://github.com/heatherbshapiro/pycon-canada/raw/master/breeds-10.zip) as a zip file) locally to your current directory and extract the files. This will create a folder called breeds-10 with two subfolders train and val that contain the training and validation images, respectively.\n\n**If you already have a datstore uploaded you can skip the following code and access it through the following code:**\n\n`from azureml.core.datastore import Datastore\nds= Datastore.get(ws,\"breeds\")`"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import os\nimport urllib\nfrom zipfile import ZipFile\n\n# download data\ndownload_url = 'https://github.com/heatherbshapiro/pycon-canada/raw/master/breeds-10.zip'\ndata_file = './breeds-10.zip'\nurllib.request.urlretrieve(download_url, filename=data_file)\n\n# extract files\nwith ZipFile(data_file, 'r') as zip:\n    print('extracting files...')\n    zip.extractall()\n    print('done')\n    \n# delete zip file\nos.remove(data_file)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "To make the data accessible for remote training, you will need to upload the data from your local machine to the cloud. AML provides a convenient way to do so via a Datastore. The datastore provides a mechanism for you to upload/download data, and interact with it from your remote compute targets.\n\n**Note: If your data is already stored in Azure, or you download the data as part of your training script, you will not need to do this step.**\n\nEach workspace is associated with a default datastore. In this tutorial, we will upload the training data to this default datastore."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "ds = ws.get_default_datastore()\nprint(ds.datastore_type, ds.account_name, ds.container_name)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The following code will upload the training data to the path ./breeds-10 on the default datastore."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "ds.upload(src_dir='./breeds-10', target_path='breeds-10')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Now let's get a reference to the path on the datastore with the training data. We can do so using the `path` method. In the next section, we can then pass this reference to our training script's `--data_dir` argument. "
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "path_on_datastore = 'breeds-10'\nds_data = ds.path(path_on_datastore)\nprint(ds_data)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Download the Data\n\nIf you are interested in downloading the data locally, you can run `ds.download(\"./\", 'breeds-10')`. This might take several minutes."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Train model on the remote compute\nNow that you have your data and training script prepared, you are ready to train on your remote compute cluster. You can take advantage of Azure compute to leverage GPUs to cut down your training time.     "
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Create a project directory\nCreate a directory that will contain all the necessary code from your local machine, in this case, Azure Notebooks, that you will need access to on the remote resource. This includes the training script and any additional files your training script depends on."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "import os\n\nproject_folder = './pytorch-dog-breeds-10'\nos.makedirs(project_folder, exist_ok=True)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Prepare training script\nNow you will need to create your training script. In this tutorial, the training script is already provided for you at `pytorch_train-10.py`. In practice, you should be able to take any custom training script as is and run it with AML without having to modify your code.\n\nHowever, if you would like to use AML's [tracking and metrics](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#metrics) capabilities, you will have to add a small amount of AML code inside your training script. \n\nIn `pytorch_train_10.py`, we will log some metrics to our AML run. To do so, we will access the AML run object within the script:\n```Python\nfrom azureml.core.run import Run\nrun = Run.get_context()\n```\nFurther within `pytorch_train_10.py`, we log the learning rate and momentum parameters, and the best validation accuracy the model achieves:\n```Python\nrun.log('lr', np.float(learning_rate))\nrun.log('momentum', np.float(momentum))\n\nrun.log('best_val_acc', np.float(best_acc))\n```"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Once your script is ready, copy the training script `pytorch_train_10.py` into your project directory."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "import shutil\nshutil.copy('pytorch_train_10.py', project_folder)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Create an experiment\nCreate an [Experiment](https://docs.microsoft.com/azure/machine-learning/service/concept-azure-machine-learning-architecture#experiment) to track all the runs in your workspace for this transfer learning PyTorch tutorial. \n\n**Please enter your own unique name so that you can track your specific runs.**"
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "from azureml.core import Experiment\n\nexperiment_name = <<ENTER UNIQUE NAME HERE>> ## An example would be \"pytorch-dogs-hs\"\nexperiment = Experiment(ws, name=experiment_name)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Create a PyTorch estimator\nThe AML SDK's PyTorch estimator enables you to easily submit PyTorch training jobs for both single-node and distributed runs. For more information on the PyTorch estimator, refer [here](https://docs.microsoft.com/azure/machine-learning/service/how-to-train-pytorch). The following code will define a single-node PyTorch job."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "##BATCH AI\nfrom azureml.train.dnn import PyTorch\n\nscript_params = {\n    '--data_dir': ds_data.as_mount(),\n    '--num_epochs': 10,\n    '--output_dir': './outputs'\n}\n\nestimator = PyTorch(source_directory=project_folder, \n                    script_params=script_params,\n                    compute_target=compute_target, \n                    entry_script='pytorch_train_10.py',\n                    use_gpu=True)\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The `script_params` parameter is a dictionary containing the command-line arguments to your training script `entry_script`. Please note the following:\n- We passed our training data reference `ds_data` to our script's `--data_dir` argument. This will 1) mount our datastore on the remote compute and 2) provide the path to the training data `breeds` on our datastore.\n- We specified the output directory as `./outputs`. The `outputs` directory is specially treated by AML in that all the content in this directory gets uploaded to your workspace as part of your run history. The files written to this directory are therefore accessible even once your remote run is over. In this tutorial, we will save our trained model to this output directory.\n\nTo leverage the Azure VM's GPU for training, we set `use_gpu=True`."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Submit job\nRun your experiment by submitting your estimator object. Note that this call is asynchronous."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "run = experiment.submit(estimator)\nprint(run.get_details())",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Monitor your run\nYou can monitor the progress of the run with a Jupyter widget. Like the run submission, the widget is asynchronous and provides live updates every 10-15 seconds until the job completes."
    },
    {
      "metadata": {
        "scrolled": false,
        "trusted": true
      },
      "cell_type": "code",
      "source": "from azureml.train.widgets import RunDetails\nRunDetails(run).show()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Test the web service on model with 120 classes\nThe run will take a few minutes to run on a Standard_NC6s_v2 VM with one node per job. You can also test images against a model that was trained the same way with 120 classes instead of 10. We will send the data as a JSON string to the web service hosted in ACI and use the SDK's `run` API to invoke the service. Here we will take an arbitrary image from our validation data to predict on.\n\n**If at any point throughout the process you want to test an existing webservice while you wait, please try out the `webservice-test.ipynb`**"
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "# importing the requests library \nimport requests \nimport os, json, base64\nfrom io import BytesIO\nimport matplotlib.pyplot as plt\nfrom skimage import io\nfrom PIL import Image\nimport urllib.request\nimport io\n\n##Get random dog\ndef get_random_dog():\n    r = requests.get(url =\"https://dog.ceo/api/breeds/image/random\")\n    URL= r.json()['message']\n    return URL\n\n##Get Random Dog Image\nURL = get_random_dog()\n\n##whippet Example \n# URL=\"https://s3.amazonaws.com/cdn-origin-etr.akc.org/wp-content/uploads/2017/11/12223018/Whippet-On-White-03.jpg\"\n\n##italian greyhound Example\n# URL=\"https://s3.amazonaws.com/cdn-origin-etr.akc.org/wp-content/uploads/2017/11/12231757/Italian-Greyhound-On-White-03.jpg\"\n\n##chihuahua Example\n# URL =\"https://s3.amazonaws.com/cdn-origin-etr.akc.org/wp-content/uploads/2017/11/12213613/Chihuahua-onWhite-13.jpg\"\n\nwith urllib.request.urlopen(URL) as url:\n    test_img = io.BytesIO(url.read())\n\n# ## If you downloaded the dataset, you can try this arbitrary image from the test dataset\n# # test_img = os.path.join('breeds-10', 'val', 'n02085620-Chihuahua', 'n02085620_1271.jpg') \n\nplt.imshow(Image.open(test_img))\n",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "\ndef imgToBase64(img):\n    \"\"\"Convert pillow image to base64-encoded image\"\"\"\n    imgio = BytesIO()\n    img.save(imgio, 'JPEG')\n    img_str = base64.b64encode(imgio.getvalue())\n    return img_str.decode('utf-8')\n\nbase64Img = imgToBase64(Image.open(test_img))\n# api-endpoint \nscoringURI = \"http://137.117.58.22:80/score\"\n\ndata = {'data':base64Img} \nheaders = {'content-type': 'application/json'}\n    \n# sending post request and saving response as response object \nr = requests.post(url = scoringURI, data=json.dumps(data), headers=headers)\nr.json()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Register the model\nOnce the run completes, we can register the model that was created.\n\n**Please use a unique name for the model**. You will need to edit the init() function in the pytorch_score.py file to match the unique name used. Change the line `model_path = Model.get_model_path('dogs')` to use the unique name."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "## if you need to reference the run object specifically uncomment this section\n\n# from azureml.core import Run\n# run = Run(experiment, run_id=\"\") ",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "model = run.register_model(model_name= <<INSERT UNIQUE MODEL NAME>>, model_path = 'outputs/model.pt')\nprint(model.name, model.id, model.version, sep = '\\t')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Deploy model as web service\nOnce you have your trained model, you can deploy the model on Azure. You can deploy your trained model as a web service on Azure Container Instances (ACI), Azure Kubernetes Service (AKS), IoT edge device, or field programmable gate arrays (FPGAs)\n\nACI is generally cheaper than AKS and can be set up in 4-6 lines of code. ACI is the perfect option for testing deployments. Later, when you're ready to use your models and web services for high-scale, production usage, you can deploy them to AKS.\n\n\nIn this tutorial, we will deploy the model as a web service in [Azure Container Instances](https://docs.microsoft.com/en-us/azure/container-instances/) (ACI). \n\n\nFor more information on deploying models using Azure ML, refer [here](https://docs.microsoft.com/azure/machine-learning/service/how-to-deploy-and-where)."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Create scoring script\n\nFirst, we will create a scoring script that will be invoked by the web service call. Note that the scoring script must have two required functions:\n* `init()`: In this function, you typically load the model into a `global` object. This function is executed only once when the Docker container is started. \n* `run(input_data)`: In this function, the model is used to predict a value based on the input data. The input and output typically use JSON as serialization and deserialization format, but you are not limited to that.\n\nRefer to the scoring script `pytorch_score.py` for this tutorial. Our web service will use this file to predict whether an image is an ant or a bee. When writing your own scoring script, don't forget to test it locally first before you go and deploy the web service."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Create environment file\nThen, we will need to create an environment file (`myenv.yml`) that specifies all of the scoring script's package dependencies. This file is used to ensure that all of those dependencies are installed in the Docker image by AML. In this case, we need to specify `torch`, `torchvision`, `pillow`, and `azureml-sdk`."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "%%writefile myenv.yml\nname: myenv\nchannels:\n  - defaults\ndependencies:\n  - pip:\n    - torch\n    - torchvision\n    - pillow\n    - azureml-core",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Configure the container image\nNow configure the Docker image that you will use to build your ACI container."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "from azureml.core.image import ContainerImage\n\nimage_config = ContainerImage.image_configuration(execution_script='pytorch_score.py', \n                                                  runtime='python', \n                                                  conda_file='myenv.yml',\n                                                  description='Image with dog breed model')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Configure the ACI container\nWe are almost ready to deploy. Create a deployment configuration file to specify the number of CPUs and gigabytes of RAM needed for your ACI container. While it depends on your model, the default of `1` core and `1` gigabyte of RAM is usually sufficient for many models."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "from azureml.core.webservice import AciWebservice\n\naciconfig = AciWebservice.deploy_configuration(cpu_cores=1, \n                                               memory_gb=1, \n                                               tags={'data': 'dog_breeds',  'method':'transfer learning', 'framework':'pytorch'},\n                                               description='Classify dog breeds using transfer learning with PyTorch')",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Deploy the registered model\nFinally, let's deploy a web service from our registered model. First, retrieve the model from your workspace."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "from azureml.core.model import Model\n\nmodel = Model(ws, name=<<Use the name above>>)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Then, deploy the web service using the ACI config and image config files created in the previous steps. We pass the `model` object in a list to the `models` parameter. If you would like to deploy more than one registered model, append the additional models to this list.\n\n** Please use a unique service name**"
    },
    {
      "metadata": {
        "scrolled": false,
        "trusted": true
      },
      "cell_type": "code",
      "source": "%%time\nfrom azureml.core.webservice import Webservice\n\nservice_name = <<INSERT UNIQUE SERVICE NAME>>\nservice = Webservice.deploy_from_model(workspace=ws,\n                                       name=service_name,\n                                       models=[model],\n                                       image_config=image_config,\n                                       deployment_config=aciconfig,)\n\nservice.wait_for_deployment(show_output=True)\nprint(service.state)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If your deployment fails for any reason and you need to redeploy, make sure to delete the service before you do so: `service.delete()`"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "**Tip: If something goes wrong with the deployment, the first thing to look at is the logs from the service by running the following command:**"
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "service.get_logs()",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Get the web service's HTTP endpoint, which accepts REST client calls. This endpoint can be shared with anyone who wants to test the web service or integrate it into an application."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(service.scoring_uri)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Test the web service\nFinally, let's test our deployed web service. We will send the data as a JSON string to the web service hosted in ACI and use the SDK's `run` API to invoke the service. Here we will take an arbitrary image from online to predict on. This is the same as above, but now we are testing on our own trained model. You can use any dog image, but please remember we only trained on 10 classes."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "from skimage import io\nfrom PIL import Image\nimport urllib.request\nimport io\n\n##Get random dog\ndef get_random_dog():\n    r = requests.get(url =\"https://dog.ceo/api/breeds/image/random\")\n    URL= r.json()['message']\n    return URL\n\n##Get Random Dog Image\nURL = get_random_dog()\n\n##whippet Example \n# URL=\"https://s3.amazonaws.com/cdn-origin-etr.akc.org/wp-content/uploads/2017/11/12223018/Whippet-On-White-03.jpg\"\n\n##italian greyhound Example\n# URL=\"https://s3.amazonaws.com/cdn-origin-etr.akc.org/wp-content/uploads/2017/11/12231757/Italian-Greyhound-On-White-03.jpg\"\n\n##chihuahua Example\n# URL =\"https://s3.amazonaws.com/cdn-origin-etr.akc.org/wp-content/uploads/2017/11/12213613/Chihuahua-onWhite-13.jpg\"\n\nwith urllib.request.urlopen(URL) as url:\n    test_img = io.BytesIO(url.read())\n\n# ## If you downloaded the dataset, you can try this arbitrary image from the test dataset\n# # test_img = os.path.join('breeds-10', 'val', 'n02085620-Chihuahua', 'n02085620_1271.jpg') \n\nplt.imshow(Image.open(test_img))\n\n##whippet\n# URL=\"https://s3.amazonaws.com/cdn-origin-etr.akc.org/wp-content/uploads/2017/11/12223018/Whippet-On-White-03.jpg\"\n\n##italian greyhound\n# URL=\"https://s3.amazonaws.com/cdn-origin-etr.akc.org/wp-content/uploads/2017/11/12231757/Italian-Greyhound-On-White-03.jpg\"\n\n\nwith urllib.request.urlopen(URL) as url:\n    test_img = io.BytesIO(url.read())\n\nplt.imshow(Image.open(test_img))",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "def imgToBase64(img):\n    \"\"\"Convert pillow image to base64-encoded image\"\"\"\n    imgio = BytesIO()\n    img.save(imgio, 'JPEG')\n    img_str = base64.b64encode(imgio.getvalue())\n    return img_str.decode('utf-8')\n\nbase64Img = imgToBase64(Image.open(test_img))\n\nresult = service.run(input_data=json.dumps({'data': base64Img}))\nprint(json.loads(result))",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Delete web service\nOnce you no longer need the web service, you should delete it."
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "service.delete()",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python36",
      "display_name": "Python 3.6",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.6",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}