{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mammography classification\n",
    "1. [Introduction](#Introduction)\n",
    "2. [Prerequisites and Preprocessing](#Prequisites-and-Preprocessing)\n",
    "  1. [Permissions and environment variables](#Permissions-and-environment-variables)\n",
    "  2. [Prepare the data](#Prepare-the-data)\n",
    "3. [Training the model](#Training-the-model)\n",
    "  1. [Training parameters](#Training-parameters)\n",
    "  2. [Start the training](#Start-the-training)\n",
    "4. [Inference](#Inference)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Welcome to our Mammography Classification based on AWS Sage Maker Image Classification built-in algorithm. In this demo, we will use the Amazon SageMaker image classification algorithm to train on real patients' mammography.\n",
    "\n",
    "They will be classified in 5 categories:\n",
    "- Mediolateral-Oblique Left (MLO Left)\n",
    "- Mediolateral-Oblique Right (MLO Right)\n",
    "- Cranial-Caudal Left (CC Left)\n",
    "- Cranial-Caudal Right (CC Right)\n",
    "- Not a mammography\n",
    "\n",
    "To get started, we need to set up the environment with a few prerequisite steps, for permissions, configurations, and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prequisites and Preprocessing\n",
    "\n",
    "### Permissions and environment variables\n",
    "\n",
    "Here we set up the linkage and authentication to AWS services. There are three parts to this:\n",
    "\n",
    "* The roles used to give learning and hosting access to your data. This will automatically be obtained from the role used to start the notebook\n",
    "* The S3 bucket that you want to use for training and model data\n",
    "* The Amazon sagemaker image classification docker image which need not be changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "import sagemaker\n",
    "import boto3\n",
    "from datetime import datetime\n",
    "from sagemaker import get_execution_role\n",
    "from botocore.client import ClientError\n",
    "\n",
    "role = get_execution_role()\n",
    "print(role)\n",
    "\n",
    "sess = sagemaker.Session()\n",
    "\n",
    "# Replace the name of the bucket created in the first steps of the workshop\n",
    "# bucket=<<mammography-workshop-files-YY-YYYY-YY-XXXXXXXXXXXX>>\n",
    "\n",
    "bucket='mammography-workshop-files-...'\n",
    "\n",
    "#Validate if variable 'bucket' was configured correctly\n",
    "s3 = boto3.resource('s3')\n",
    "try:\n",
    "    s3.meta.client.head_bucket(Bucket=bucket)\n",
    "except ClientError:\n",
    "    print (\"\\x1b[31m ERROR: Please, configure the variable 'bucket' with a valid S3 bucket name \\x1b[0m\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sagemaker import image_uris\n",
    "training_image = image_uris.retrieve(\n",
    "    region=boto3.Session().region_name, framework=\"image-classification\"\n",
    ")\n",
    "print (training_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the model\n",
    "\n",
    "Now that we are done with all the setup that is needed, we are ready to train our object detector. To begin, let us create a ``sageMaker.estimator.Estimator`` object. This estimator will launch the training job.\n",
    "### Training parameters\n",
    "There are two kinds of parameters that need to be set for training. The first one are the parameters for the training job. These include:\n",
    "\n",
    "* **Training instance count**: This is the number of instances on which to run the training. When the number of instances is greater than one, then the image classification algorithm will run in distributed settings. \n",
    "* **Training instance type**: This indicates the type of machine on which to run the training. For SageMaker Image Classification built-in algorithm, it is mandatory to use GPU instances for the training. For more information on Recommended instances for Image Classification algorithm: https://docs.aws.amazon.com/sagemaker/latest/dg/image-classification.html#IC-instances\n",
    "* **Output bucket**: This the s3 bucket in which the training output will be stored. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "prefix_output='output'\n",
    "\n",
    "s3_output_location = 's3://{}/{}'.format(bucket, prefix_output)\n",
    "\n",
    "ic = sagemaker.estimator.Estimator(training_image,\n",
    "                                         role, \n",
    "                                         instance_count=1, \n",
    "                                         instance_type='ml.p2.xlarge',\n",
    "                                         volume_size = 50,\n",
    "                                         max_run = 360000,\n",
    "                                         input_mode= 'File',\n",
    "                                         output_path=s3_output_location,\n",
    "                                         sagemaker_session=sess)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apart from the above set of parameters, there are hyperparameters that are specific to the algorithm. These are:\n",
    "\n",
    "* **num_layers**: The number of layers (depth) for the network. We use 18 in this samples but other values such as 50, 152 can be used.\n",
    "* **image_shape**: The input image dimensions,'num_channels, height, width', for the network. It should be no larger than the actual image size. The number of channels should be same as the actual image.\n",
    "* **num_classes**: This is the number of output classes for the new dataset. As mentioned in the beggining, we have 5 different output classes: MLO Right, MLO Left, CC Right, CC Left, Not a mammography.\n",
    "* **num_training_samples**: This is the total number of training samples. It is set to 875, since it is the amount of available images we have for training. The higher the training samples you have, better are the chances of you getting a good classification model.\n",
    "* **mini_batch_size**: The number of training samples used for each mini batch. In distributed training, the number of training samples used per batch will be N * mini_batch_size where N is the number of hosts on which training is run. This is the amount of images that will be loaded into memory for training. If this number is too high, your instance might run out of memory. If this number is too low, your accuracy might suffer.\n",
    "* **epochs**: Number of training epochs, i.e, the amount of training cycles in a full dataset. The correct number of epochs need to be tested, because you don't want to underfit or overfit your model. Just remember that more epochs means taking longer and costing more. \n",
    "* **learning_rate**: Learning rate for training.\n",
    "* **top_k**: Report the top-k accuracy during training.\n",
    "* **precision_dtype**: Training datatype precision (default: float32). If set to 'float16', the training will be done in mixed_precision mode and will be faster than float32 mode\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ic.set_hyperparameters(num_layers=18,\n",
    "                       image_shape=\"3,300,150\",\n",
    "                       num_classes=5,\n",
    "                       num_training_samples=1752,\n",
    "                       mini_batch_size=120,\n",
    "                       epochs=20,\n",
    "                       learning_rate=0.01,\n",
    "                       optimizer='sgd',\n",
    "                       top_k=2,\n",
    "                       precision_dtype='float32'\n",
    "                      )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input data specification\n",
    "Set the data type and channels used for training the model.\n",
    "\n",
    "The next block of code defines where the images are and how they are classified.\n",
    "\n",
    "There are two separate datasets: one for **training** and one for **validation**.\n",
    "\n",
    "This is important because the model needs to test itself on data that it already knows and with data that it has never seen, in order for us to find out if it is a good model to make generalizations on new data.\n",
    "\n",
    "In order for us to provide to the model the data already classified, we are using an \".lst\" file, that consists of all the location of the images and their classification.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sagemaker.session import TrainingInput\n",
    "\n",
    "# raw-jpg stores all the original images\n",
    "prefix = 'raw-jpg'\n",
    "\n",
    "\n",
    "# Four channels: train, validation, train_lst, and validation_lst\n",
    "s3train = 's3://{}/{}/train/'.format(bucket, prefix)\n",
    "s3validation = 's3://{}/{}/test/'.format(bucket, prefix)\n",
    "s3train_lst = 's3://{}/{}/train-data.lst'.format(bucket, prefix)\n",
    "s3validation_lst = 's3://{}/{}/test-data.lst'.format(bucket, prefix)\n",
    "\n",
    "train_data = TrainingInput(s3train, distribution='FullyReplicated', \n",
    "                        content_type='application/x-image', s3_data_type='S3Prefix')\n",
    "validation_data = TrainingInput(s3validation, distribution='FullyReplicated', \n",
    "                             content_type='application/x-image', s3_data_type='S3Prefix')\n",
    "train_lst = TrainingInput(s3train_lst, distribution='FullyReplicated', \n",
    "                        content_type='application/x-image', s3_data_type='S3Prefix')\n",
    "validation_lst = TrainingInput(s3validation_lst, distribution='FullyReplicated', \n",
    "                             content_type='application/x-image', s3_data_type='S3Prefix')\n",
    "\n",
    "data_channels = {'train': train_data, 'validation': validation_data, 'train_lst': train_lst, 'validation_lst': validation_lst }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note:Ground Truth\n",
    "\n",
    "If we were to use the Ground Truth file generated in the previous module, this is where we would declare the output file generated by Groung Truth.\n",
    "\n",
    "It would look something like this:\n",
    "```\n",
    "train_data = sagemaker.session.s3_input(s3_train_data, \n",
    "                                        distribution='FullyReplicated', \n",
    "                                        content_type='image/jpeg', \n",
    "                                        s3_data_type='AugmentedManifestFile', \n",
    "                                        attribute_names=['source-ref', 'sthakur-groundtruth-demo'])\n",
    "```\n",
    "\n",
    "There is a great blog post that explains how to use Ground Truth output file in Sage Maker with more details. You can check it out later.\n",
    "https://aws.amazon.com/pt/blogs/machine-learning/easily-train-models-using-datasets-labeled-by-amazon-sagemaker-ground-truth/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start the training\n",
    "Start training by calling the fit method in the estimator.\n",
    "\n",
    "It will take about **10 minutes** to finish the execution. Wait until it ends before executing the next block of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "job_name = 'mammography-classification-' + datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")\n",
    "\n",
    "ic.fit(inputs=data_channels, logs=True, job_name=job_name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preparation\n",
    "\n",
    "You may have noticed that **the best Validation Accuracy found was around 75%, which is not ideal yet**.\n",
    "\n",
    "**Training accuracy** so different from your **validation accuracy** is also a bad indicator.\n",
    "\n",
    "When navigating through the mammography images, you may notice that every image has a different size, and this is the main reason why our Valication Accuracy is so low.\n",
    "\n",
    "To prove that, we will train the model again, but now we will use **images that were all resized to the same dimension**. In our case: 150 width, 300 height. \n",
    "\n",
    "We used OpenCV lib (https://opencv.org/) to perform the resize using Python. For information only, the main code executed can be found below:\n",
    "\n",
    "    #filepath is the full path for the mammography stored locally\n",
    "  \n",
    "    img = cv2.imread(filepath) \n",
    "\n",
    "    res = cv2.resize(img,(150,300),interpolation=cv2.INTER_AREA)\n",
    "\n",
    "\n",
    "\n",
    "**For the sake of time, we already provided you with all the resized images needed for this lab.**\n",
    "\n",
    "So, let's run it all over again, but now using the resized mammography images for the training stored in the same bucket, but inside **resize** folder\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "#'resize' folder stores all the resized images\n",
    "prefix = 'resize'\n",
    "\n",
    "# Four channels: train, validation, train_lst, and validation_lst\n",
    "s3train = 's3://{}/{}/train/'.format(bucket, prefix)\n",
    "s3validation = 's3://{}/{}/test/'.format(bucket, prefix)\n",
    "s3train_lst = 's3://{}/{}/train-data.lst'.format(bucket, prefix)\n",
    "s3validation_lst = 's3://{}/{}/test-data.lst'.format(bucket, prefix)\n",
    "\n",
    "train_data = TrainingInput(s3train, distribution='FullyReplicated', \n",
    "                        content_type='application/x-image', s3_data_type='S3Prefix')\n",
    "validation_data = TrainingInput(s3validation, distribution='FullyReplicated', \n",
    "                             content_type='application/x-image', s3_data_type='S3Prefix')\n",
    "train_lst = TrainingInput(s3train_lst, distribution='FullyReplicated', \n",
    "                        content_type='application/x-image', s3_data_type='S3Prefix')\n",
    "validation_lst = TrainingInput(s3validation_lst, distribution='FullyReplicated', \n",
    "                             content_type='application/x-image', s3_data_type='S3Prefix')\n",
    "\n",
    "data_channels = {'train': train_data, 'validation': validation_data, 'train_lst': train_lst, 'validation_lst': validation_lst }\n",
    "\n",
    "# Note that:\n",
    "# image_shape=\"num_channels, height, width\"\n",
    "\n",
    "ic.set_hyperparameters(num_layers=18,\n",
    "                       image_shape=\"3,300,150\",\n",
    "                       num_classes=5,\n",
    "                       num_training_samples=1752,\n",
    "                       mini_batch_size=250,\n",
    "                       epochs=20,\n",
    "                       optimizer='sgd',\n",
    "                       learning_rate=0.01,\n",
    "                       top_k=2,\n",
    "                       precision_dtype='float32'\n",
    "                      )\n",
    "\n",
    "job_name = 'mammography-classification-' + datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")\n",
    "\n",
    "ic.fit(inputs=data_channels, logs=True, job_name=job_name)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training job analytics\n",
    "\n",
    "We will now plot a pivot table with the analytics collected during training execution.\n",
    "These are metrics collected from Cloud Watch. So, this graph might not show all checkpoints collected, but the average of those collected in the 1-minute range. Those factors might change the amount of lines ploted in the graph depending on the duration of the execution.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "job_name=ic.latest_training_job.name\n",
    "metric_name = 'validation:accuracy'\n",
    "parent = sagemaker.analytics.TrainingJobAnalytics(training_job_name=job_name,metric_names=[metric_name],period=1)\n",
    "parent.dataframe().sort_values(['value'], ascending=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference\n",
    "\n",
    "***\n",
    "\n",
    "In order for us to use the model we just trained and tested, we need to deploy it.\n",
    "To do that, you need to invoke the method *deploy* of the Estimator.\n",
    "When doing that, AWS will provision a SageMaker EC2 instance (you **won't** be able to see nor manage it through the EC2 console) whose only purpose is to respond to invokations.\n",
    "\n",
    "We are using an m5.large, but in production, plan accordingly.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "ic_classifier = ic.deploy(initial_instance_count = 1,\n",
    "                          instance_type = 'ml.m5.large')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confusion Matrix explained"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Confusion Matrix is one of multiple ways to determine the performance of a classification algorithm.\n",
    "It basically plots the expected values and the predicted values returned by the model in a matrix layout, so we can easily see how much the model is acing and how much it is failing.\n",
    "\n",
    "**If my model is ~98% accurate, why would I need a Confusion Matrix?**\n",
    "\n",
    "Because it still is 2% wrong. And it is important to understand where it is wrong: is it 2% wrong spread all over your classes or do you have a class that is bringing your accuracy down?\n",
    "\n",
    "Or even the 2% might be misleading. If you have more data on a class that is \"easy\" to predict and, therefore, it is bringing your accuracy up, but in reality, some other class might have less data but it could be failing to predict correctly. Of course, this is a problem for algorithms classifing 3 or more classes of data, which is our case.\n",
    "\n",
    "Before we jump into our own model, let's take a look at the example below.\n",
    "Interpreting the matrix, we discover that there should be 5 cats and 5 dogs in an imaginary image classification training. But when invoking the model, it predicted 4 cats e 6 dogs. **The correct values are in the diagonal part of the matrix, in bold**.\n",
    "\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confusion Matrix for Mammography Classification\n",
    "\n",
    "Now that we've understood what is a confusion matrix, let's execute the code below to generate a confusion matrix for our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "import boto3\n",
    "\n",
    "import logging\n",
    "\n",
    "import json\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "import seaborn as sn\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from botocore.exceptions import ClientError\n",
    "\n",
    "debug = False\n",
    "# debug = True\n",
    "\n",
    "prefix = \"resize/validate\"\n",
    "\n",
    "endpoint_name = ic_classifier.endpoint_name\n",
    "\n",
    "expected = []\n",
    "\n",
    "predicted = []\n",
    "\n",
    "def list_bucket_objects(bucket_name, prefix):\n",
    "    \"\"\"List the objects in an Amazon S3 bucket\n",
    "\n",
    "    :param bucket_name: string\n",
    "    :param prefix: string\n",
    "    :return: List of bucket objects. If error, return None.\n",
    "    \"\"\"\n",
    "\n",
    "    # Retrieve the list of bucket objects\n",
    "    s_3 = boto3.client('s3')\n",
    "\n",
    "    try:\n",
    "        response = s_3.list_objects_v2(Bucket=bucket_name, Prefix=prefix)\n",
    "    except ClientError as e:\n",
    "        logging.error(e)\n",
    "        return None\n",
    "\n",
    "    # Only return the contents if we found some keys\n",
    "    if response['KeyCount'] > 0:\n",
    "        return response['Contents']\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "def get_object(bucket_name, object_name):\n",
    "    \"\"\"Retrieve an object from an Amazon S3 bucket\n",
    "\n",
    "    :param bucket_name: string\n",
    "    :param object_name: string\n",
    "    :return: botocore.response.StreamingBody object. If error, return None.\n",
    "    \"\"\"\n",
    "\n",
    "    # Retrieve the object\n",
    "    s3 = boto3.client('s3')\n",
    "    try:\n",
    "        response = s3.get_object(Bucket=bucket_name, Key=object_name)\n",
    "    except ClientError as e:\n",
    "        logging.error(e)\n",
    "        return None\n",
    "    # Return an open StreamingBody object\n",
    "    return response['Body']\n",
    "\n",
    "def get_expected_value(object_key):\n",
    "    if \"CCD\" in object_key:\n",
    "        return \"CC-Right\"\n",
    "    elif \"CCE\" in object_key:\n",
    "        return \"CC-Left\"\n",
    "    elif \"MLOD\" in object_key:\n",
    "        return \"MLO-Right\"\n",
    "    elif \"MLOE\" in object_key:\n",
    "        return \"MLO-Left\"\n",
    "    elif \"NAO\" in object_key:\n",
    "        return \"Not-a-mammography\"\n",
    "    else:\n",
    "        logging.warning(object_key)\n",
    "        sys.exit(\"Unsupported mammography type on expected array\")\n",
    "\n",
    "\n",
    "\n",
    "def get_best_prediction_position(prediction):\n",
    "\n",
    "    logging.info(prediction)\n",
    "    \n",
    "    index = np.argmax(prediction)\n",
    "    object_categories = ['Not-a-mammography', 'CC-Right', 'CC-Left', 'MLO-Right', 'MLO-Left']\n",
    "    return object_categories[index]\n",
    "\n",
    "\n",
    "# Set up logging\n",
    "import logging\n",
    "logger = logging.getLogger()\n",
    "\n",
    "if debug:\n",
    "    logger.setLevel(logging.INFO)\n",
    "else:\n",
    "    logger.setLevel(logging.WARN)\n",
    "\n",
    "\n",
    "sagemaker = boto3.client('runtime.sagemaker')\n",
    "\n",
    "# Retrieve the bucket's objects\n",
    "objects = list_bucket_objects(bucket, prefix)\n",
    "\n",
    "if objects is not None:\n",
    "    # List the object names\n",
    "    logging.info('Objects in ' + bucket)\n",
    "    for obj in objects:\n",
    "        object_key = obj[\"Key\"]\n",
    "        if object_key.endswith(\".jpg\") or object_key.endswith(\".png\") or object_key.endswith(\".jpeg\"):\n",
    "\n",
    "            logging.info(object_key)\n",
    "\n",
    "            expected.append(get_expected_value(object_key))\n",
    "\n",
    "            s3_object = get_object(bucket, object_key)\n",
    "\n",
    "            s3_object_byte_array = s3_object.read()\n",
    "\n",
    "            #invoke sagemaker and append on predicted array\n",
    "            sagemaker_invoke = sagemaker.invoke_endpoint(EndpointName=endpoint_name,\n",
    "                                                         ContentType='application/x-image',\n",
    "                                                         Body=s3_object_byte_array)\n",
    "\n",
    "            prediction = json.loads(sagemaker_invoke['Body'].read().decode())\n",
    "\n",
    "            best_prediction_position = get_best_prediction_position (prediction)\n",
    "\n",
    "            predicted.append(best_prediction_position)\n",
    "\n",
    "\n",
    "else:\n",
    "    # Didn't get any keys\n",
    "    logging.warning('No objects in ' + bucket)\n",
    "\n",
    "\n",
    "#Confusion matrix using scikit learn\n",
    "results = confusion_matrix(expected, predicted)\n",
    "print(results)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Confusion matrix using pandas and seaborn\n",
    "data = {'y_Actual':    expected,\n",
    "        'y_Predicted': predicted\n",
    "        }\n",
    "\n",
    "df = pd.DataFrame(data, columns=['y_Actual','y_Predicted'])\n",
    "confusion_matrix = pd.crosstab(df['y_Actual'], df['y_Predicted'], rownames=['Expected'], colnames=['Predicted'])\n",
    "\n",
    "sn.heatmap(confusion_matrix, annot=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download test image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!wget -O /tmp/test.jpg https://mammography-workshop.s3.amazonaws.com/sample/resize_RIGHT_CC.jpg\n",
    "file_name = '/tmp/test.jpg'\n",
    "# test image\n",
    "from IPython.display import Image\n",
    "Image(file_name)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluation\n",
    "\n",
    "Evaluate the image through the network for inteference. The network outputs class probabilities and typically, one selects the class with the maximum probability as the final class output.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import numpy as np\n",
    "\n",
    "with open(file_name, 'rb') as f:\n",
    "    payload = f.read()\n",
    "    payload = bytearray(payload)\n",
    "    \n",
    "result = json.loads(ic_classifier.predict(payload, initial_args={'ContentType': 'application/x-image'}))\n",
    "# the result will output the probabilities for all classes\n",
    "# find the class with maximum probability and print the class index\n",
    "index = np.argmax(result)\n",
    "object_categories = ['Not a Mammography', 'CC-Right', 'CC-Left', 'MLO-Right', 'MLO-Left']\n",
    "print(\"Result: \" + object_categories[index] + \", probability - \" + str(result[index]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clean up\n",
    "\n",
    "When we're done with the endpoint, we can just delete it and the backing instances will be released. \n",
    "\n",
    "After the workshop, you may uncomment the code below and run it to delete the endpoint.\n",
    "\n",
    "**DON'T DO IT NOW!** \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#ic_classifier.delete_endpoint()"
   ]
  }
 ],
 "metadata": {
  "instance_type": "ml.t3.medium",
  "kernelspec": {
   "display_name": "Python 3 (Data Science)",
   "language": "python",
   "name": "python3__SAGEMAKER_INTERNAL__arn:aws:sagemaker:us-west-2:236514542706:image/datascience-1.0"
  },
  "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.10"
  },
  "notice": "Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.  Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance with the License. A copy of the License is located at http://aws.amazon.com/apache2.0/ or in the \"license\" file accompanying this file. This file is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."
 },
 "nbformat": 4,
 "nbformat_minor": 4
}