 archived/image-classification-with-shutterstock-datasets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Using Shutterstock's Image datasets to train a multi-label image classification model"
   ],
   "metadata": {}
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "This notebook's CI test result for us-west-2 is as follows. CI test results in other regions can be found at the end of the notebook. \n",
    "\n",
    "![This us-west-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/us-west-2/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Introduction\n",
    "\n",
    "This example of **multi-label image classification** trains the **Amazon SageMaker 1P image classification algorithm**. We will use the Amazon SageMaker image classification algorithm in transfer learning mode to fine-tune a pre-trained model (trained on ImageNet data) to learn to classify a new multi-label dataset. The pre-trained model will be fine-tuned using the [Free Sample: Images & Metadata of \u201cWhole Foods\u201d Shoppers dataset from Shutterstock\u2019s Image Datasets](https://aws.amazon.com/marketplace/pp/prodview-y6xuddt42fmbu?ref_=srh_res_product_title). \n",
    "\n",
    "You can learn more about this implementation from [**Using Shutterstock's image datasets to train your computer vision models**](https://aws.amazon.com/blogs/awsmarketplace/using-shutterstocks-image-datasets-to-train-your-computer-vision-models/).\n",
    "\n",
    "To get started, we need to set up the environment with a few prerequisite steps, for permissions, configurations, and so on.\n",
    "\n",
    "Note: This notebook is a modification of the existing [SageMaker example notebook for multi-label image classification](https://github.com/aws/amazon-sagemaker-examples/blob/master/introduction_to_amazon_algorithms/imageclassification_mscoco_multi_label/Image-classification-multilabel-lst.ipynb)."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Prerequisites\n",
    "\n",
    "### Step 1: Set permissions and environment variables\n",
    "\n",
    "Here we set up the pointers 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 SageMaker training and model data\n",
    "* The S3 bucket that is storing the images from the Shutterstock Image Dataset for Whole Foods Shoppers\n",
    "* The SageMaker image classification docker image (which we will not need to change)\n",
    "\n",
    "**FILL IN YOUR S3 BUCKET NAME:** For our `images_bucket` variable, replace `<enter-images-bucket-name>` with the name of the S3 bucket that contains your Shutterstock Image Dataset. If you stored your images under a prefix, please also update the `images_bucket_prefix` variable with this prefix."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import boto3\n",
    "import sagemaker\n",
    "from sagemaker import get_execution_role\n",
    "from sagemaker.amazon.amazon_estimator import get_image_uri\n",
    "\n",
    "# SageMaker notebook execution role\n",
    "role = get_execution_role()\n",
    "print(\"Sagemaker Execution Role: {}\".format(role))\n",
    "\n",
    "# SageMaker S3 Bucket for training and model data\n",
    "sagemaker_bucket = sagemaker.Session().default_bucket()\n",
    "sagemaker_bucket_prefix = \"wholefoods-ic-multilabel\"\n",
    "print(\"Using S3 Bucket for SageMaker training and model data: {}\".format(sagemaker_bucket))\n",
    "\n",
    "# SageMaker Training image for image classification\n",
    "training_image = sagemaker.image_uris.retrieve(\n",
    "    region=sagemaker.Session().boto_region_name, framework=\"image-classification\", version=\"latest\"\n",
    ")\n",
    "print(\"Using Training Image: {}\".format(training_image))\n",
    "\n",
    "\n",
    "images_adx_directory = \"adx_free_data_sample/wholefoods/\"\n",
    "\n",
    "# TO DO: enter the name of the S3 bucket that contains your Shutterstock Image Dataset\n",
    "images_bucket = \"<enter-images-bucket-name>\"\n",
    "\n",
    "# TO DO: enter the prefix (if applicable) where your images are stored, if you stored them under an additional prefix\n",
    "images_bucket_prefix = \"\"\n",
    "\n",
    "print(\"Using S3 Bucket with Training Images: {}\".format(images_bucket))\n",
    "\n",
    "# Pointer to image metadata file\n",
    "image_metadata_filename = \"AWS_Wholefood Shoppers_ Metadata.csv\""
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Data Preparation\n",
    "\n",
    "The Shutterstock Image Datasets are collections of curated images from Shutterstock\u2019s library of more than 370 million images. You can subscribe to one of the preexisting collections, such as Food & Beverage, Clothing, or Hospitality, or you can work with the Shutterstock Data Exchange team to request a custom collection of images for your use case. Each image includes a descriptive title with up to 200 characters and an optimal 7-50 keywords. \n",
    "\n",
    "For this example, we use the [Free Sample: Images & Metadata of \u201cWhole Foods\u201d Shoppers dataset from Shutterstock\u2019s Image Datasets](https://aws.amazon.com/marketplace/pp/prodview-y6xuddt42fmbu?ref_=srh_res_product_title) to demonstrate how to train a multi-label image classification model using Shutterstock\u2019s pre-labeled image assets. This dataset contains images of Whole Foods shoppers. Each image is tagged with 30-50 keywords describing what is seen in the image.\n",
    "\n",
    "An image can contain objects of multiple keywords. Because the purpose of this notebook is to show how the Shutterstock dataset can be used to train for multi-label image classification, we will limit the keywords that we are training on for demonstration purposes. We have a limited set of 200 images in our free sample.\n",
    "\n",
    "To start, we will train the model to learn to classify the first 5 keywords that appear in our dataset.\n",
    "\n",
    "1. Adult\n",
    "2. Beautiful\n",
    "3. Buying\n",
    "4. Car\n",
    "5. Casual\n",
    "\n",
    "\n",
    "The image classification algorithm can take two types of input formats. The first is a [recordIO file format](https://mxnet.apache.org/versions/1.7.0/api/faq/recordio) and the other is an LST file format. We will use the LST file format for training. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Step 2: Parse the metadata .csv file to create a .lst file for training\n",
    "A .lst file is a tab-separated file with three columns that contains a list of image files. The first column specifies the image index, the second column specifies the class label index for the image, and the third column specifies the relative path of the image file. The image index in the first column should be unique across all the images. \n",
    "\n",
    "The Whole Foods Shoppers dataset comes with a metadata file in CSV format. We will use this to generate our .lst file. This CSV metadata file has the following headers in the first row: 'ASSET_ID' | 'COLLECTION' |'KEYWORDS' | 'DESCRIPTION'. \n",
    "\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import numpy as np\n",
    "import csv\n",
    "\n",
    "origin_file = images_bucket_prefix + image_metadata_filename\n",
    "destination_file = \"./%s\" % image_metadata_filename\n",
    "\n",
    "s3 = boto3.resource(\"s3\")\n",
    "s3.Bucket(images_bucket).download_file(origin_file, destination_file)\n",
    "\n",
    "# Create a dictionary (key: keyword, value: list of associated images IDs)\n",
    "keyword_images = {}\n",
    "\n",
    "# convert the metadata CSV file into a nested list\n",
    "with open(destination_file, \"r\", encoding=\"UTF-8\", newline=\"\") as f:\n",
    "    reader = csv.reader(f)\n",
    "    data = list(reader)\n",
    "\n",
    "    # CSV header in Row 1 should be ['ASSET_ID, 'COLLECTION', 'KEYWORDS', 'DESCRIPTION']\n",
    "    print(\"Data Columns: {}\".format(data[0]))\n",
    "\n",
    "    # Remove header row\n",
    "    data.pop(0)\n",
    "\n",
    "    # Map the keywords to the associated image IDs\n",
    "    for row in data:\n",
    "        image_id = row[0]\n",
    "        image_keywords = row[2].split(\",\")\n",
    "\n",
    "        for word in image_keywords:\n",
    "            if word not in keyword_images:\n",
    "                keyword_images[word] = []\n",
    "            keyword_images[word].append(image_id)\n",
    "\n",
    "\n",
    "# Train for the first 5 keywords\n",
    "num_training_keywords = 5\n",
    "training_keywords = list(keyword_images.keys())[0:num_training_keywords]\n",
    "\n",
    "print(\"Training for the following Keywords: {}\".format(training_keywords))\n",
    "\n",
    "# obtain image ids and labels for images with these 5 keywords\n",
    "image_ids = []\n",
    "labels = []\n",
    "\n",
    "for index, key in enumerate(training_keywords):\n",
    "    for image_id in keyword_images[key]:\n",
    "        if image_id in image_ids:\n",
    "            labels[image_ids.index(image_id)][index] = 1\n",
    "        else:\n",
    "            image_ids.append(image_id)\n",
    "            labels.append(np.zeros(len(training_keywords), dtype=np.int))\n",
    "            labels[-1][index] = 1\n",
    "\n",
    "# Construct the LST file from the image ids and labels\n",
    "# The first column is the image index, the last is the image filename\n",
    "# and the second to last but one are the labels\n",
    "with open(\"image.lst\", \"w\") as fp:\n",
    "    sum_labels = labels[0]\n",
    "    for ind, image_id in enumerate(image_ids):\n",
    "        image_path = \"{}.jpg\".format(image_id)\n",
    "        label_h = labels[ind]\n",
    "        sum_labels += label_h\n",
    "        fp.write(str(ind) + \"\\t\")\n",
    "        for j in label_h:\n",
    "            fp.write(str(j) + \"\\t\")\n",
    "        fp.write(image_path)\n",
    "        fp.write(\"\\n\")\n",
    "    fp.close()\n",
    "print(sum_labels)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "training_keywords"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Step 3: Create the training and validation datasets\n",
    "Create training and validation set by splitting the LST file. Limit images to the top 150 images. Use 70% of the images for training and 30% of the images for validation."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "!shuf -n 150 image.lst > im.lst\n",
    "!head -n 105 im.lst > sstkimagestrain.lst\n",
    "!tail -n 45 im.lst > sstkimagesval.lst\n",
    "!head sstkimagestrain.lst\n",
    "!wc -l sstkimagestrain.lst\n",
    "!wc -l sstkimagesval.lst"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Step 4: Copy the training data to your SageMaker S3 Bucket\n",
    "Upload the data into the SageMaker S3 bucket. The images are uploaded under the train and validation prefixes. The LST files are uploaded under train_lst and validation_lst prefixes. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Four channels: train, validation, train_lst, and validation_lst\n",
    "s3_train = \"s3://{}/{}/train/\".format(sagemaker_bucket, sagemaker_bucket_prefix)\n",
    "s3_validation = \"s3://{}/{}/validation/\".format(sagemaker_bucket, sagemaker_bucket_prefix)\n",
    "s3_train_lst = \"s3://{}/{}/train_lst/\".format(sagemaker_bucket, sagemaker_bucket_prefix)\n",
    "s3_validation_lst = \"s3://{}/{}/validation_lst/\".format(sagemaker_bucket, sagemaker_bucket_prefix)\n",
    "\n",
    "\n",
    "s3_img_source = \"s3://{}/{}{}\".format(images_bucket, images_bucket_prefix, images_adx_directory)\n",
    "\n",
    "\n",
    "# upload the image files to train and validation channels\n",
    "!aws s3 sync $s3_img_source $s3_train\n",
    "!aws s3 sync $s3_img_source $s3_validation\n",
    "\n",
    "# upload the LST files to train_lst and validation_lst channels\n",
    "!aws s3 cp sstkimagestrain.lst $s3_train_lst --quiet\n",
    "!aws s3 cp sstkimagesval.lst $s3_validation_lst --quiet"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Training our Multi-Label Image Classification Model\n",
    "Now that we have prepared our training data, we are ready to train our image classification model. First, we will create a SageMaker Estimator object. This estimator will launch the training job.\n",
    "\n",
    "### Step 5: Set the training parameters\n",
    "There are two kinds of parameters that need to be set for training. The first 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. Here, we will use ml.p2.xlarge.\n",
    "* **Output path**: This the S3 folder in which the training output is stored"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "s3_output_location = \"s3://{}/{}/output\".format(sagemaker_bucket, sagemaker_bucket_prefix)\n",
    "multilabel_ic = sagemaker.estimator.Estimator(\n",
    "    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=sagemaker.Session(),\n",
    ")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Step 6: Set the algorithm parameters\n",
    "\n",
    "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.\n",
    "* **use_pretrained_model**: Set to 1 to use pretrained model for transfer learning.\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 dataset.\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\n",
    "* **resize**: Resize the image before using it for training. The images are resized so that the shortest side is of this parameter. If the parameter is not set, then the training data is used as such without resizing.\n",
    "* **epochs**: Number of training epochs\n",
    "* **learning_rate**: Learning rate for training\n",
    "* **num_training_samples**: This is the total number of training samples. \n",
    "* **use_weighted_loss**: This parameter is used to balance the influence of the positive and negative samples within the dataset.\n",
    "* **augmentation_type**: This parameter determines the type of augmentation used for training. It can take on three values, 'crop', 'crop_color' and 'crop_color_transform'\n",
    "* **precision_dtype**: The data type precision used during training. Using ``float16`` can lead to faster training with minimal drop in accuracy, particularly on P3 machines. By default, the parameter is set to ``float32``\n",
    "* **multi_label**: Set multi_label to 1 for multi-label processing\n",
    "\n",
    "You can find a detailed description of all the algorithm parameters at https://docs.aws.amazon.com/sagemaker/latest/dg/IC-Hyperparameter.html"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "multilabel_ic.set_hyperparameters(\n",
    "    num_layers=18,\n",
    "    use_pretrained_model=1,\n",
    "    image_shape=\"3,224,224\",\n",
    "    num_classes=5,\n",
    "    mini_batch_size=25,\n",
    "    resize=256,\n",
    "    epochs=5,\n",
    "    learning_rate=0.001,\n",
    "    num_training_samples=100,\n",
    "    use_weighted_loss=1,\n",
    "    augmentation_type=\"crop_color_transform\",\n",
    "    precision_dtype=\"float32\",\n",
    "    multi_label=1,\n",
    ")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Step 7: Specify the input data \n",
    "Set the data type and channels used for training. In this training, we use application/x-image content type that require individual images and LST file for data input. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "train_data = sagemaker.inputs.TrainingInput(\n",
    "    s3_train,\n",
    "    distribution=\"FullyReplicated\",\n",
    "    content_type=\"application/x-image\",\n",
    "    s3_data_type=\"S3Prefix\",\n",
    ")\n",
    "validation_data = sagemaker.inputs.TrainingInput(\n",
    "    s3_validation,\n",
    "    distribution=\"FullyReplicated\",\n",
    "    content_type=\"application/x-image\",\n",
    "    s3_data_type=\"S3Prefix\",\n",
    ")\n",
    "train_data_lst = sagemaker.inputs.TrainingInput(\n",
    "    s3_train_lst,\n",
    "    distribution=\"FullyReplicated\",\n",
    "    content_type=\"application/x-image\",\n",
    "    s3_data_type=\"S3Prefix\",\n",
    ")\n",
    "validation_data_lst = sagemaker.inputs.TrainingInput(\n",
    "    s3_validation_lst,\n",
    "    distribution=\"FullyReplicated\",\n",
    "    content_type=\"application/x-image\",\n",
    "    s3_data_type=\"S3Prefix\",\n",
    ")\n",
    "data_channels = {\n",
    "    \"train\": train_data,\n",
    "    \"validation\": validation_data,\n",
    "    \"train_lst\": train_data_lst,\n",
    "    \"validation_lst\": validation_data_lst,\n",
    "}"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Step 8: Train the model\n",
    "Start training by calling the fit method in the estimator."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "multilabel_ic.fit(inputs=data_channels, logs=True)"
   ],
   "outputs": [],
   "metadata": {
    "scrolled": true
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Inference\n",
    "\n",
    "### Step 9: Deploy the Model for Inference\n",
    "\n",
    "Once we have trained the model, we want to use it to perform inference. In this case, we will be predicting keywords for the image. \n",
    "\n",
    "First, let's deploy the model. You can deploy the created model by using the deploy method in the estimator."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from sagemaker.serializers import IdentitySerializer\n",
    "\n",
    "ic_classifier = multilabel_ic.deploy(\n",
    "    initial_instance_count=1,\n",
    "    instance_type=\"ml.m4.xlarge\",\n",
    "    serializer=IdentitySerializer(content_type=\"application/x-image\"),\n",
    ")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Step 10: Evaluate the model\n",
    "\n",
    "Next, we evaluate one of our images through the network for inference. The network outputs probabilities for each of the keywords that we are training on. As can be seen from this example, the network output is pretty good even with training for only 5 epochs."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import json\n",
    "from PIL import Image\n",
    "\n",
    "\n",
    "# The following image has not been used to train or validate the model yet. We will use it to test the model.\n",
    "file_name = \"1721370184.jpg\"\n",
    "print(\"Training on Image File: {}\".format(file_name))\n",
    "\n",
    "# Download and display the image\n",
    "s3 = boto3.resource(\"s3\")\n",
    "s3.Bucket(images_bucket).download_file(\n",
    "    (images_adx_directory + file_name), (\"./{}\".format(file_name))\n",
    ")\n",
    "with open(file_name, \"rb\") as image:\n",
    "    f = image.read()\n",
    "    b = bytearray(f)\n",
    "    # display the image\n",
    "    im = Image.open(image)\n",
    "    im.thumbnail([500, 500])\n",
    "    display(im)\n",
    "\n",
    "# Run the model prediction on the downloaded image\n",
    "results = ic_classifier.predict(b)\n",
    "prob = json.loads(results)\n",
    "for idx, val in enumerate(training_keywords):\n",
    "    print(\"{}:{} \".format(training_keywords[idx], prob[idx]), end=\"\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "After running the above lines of code, our notebook will display the image and print out the probabilities of each of the keywords that we are training on. From here, we can expand the amount of keywords that we train on, fine-tune our parameters, or add additional images to further improve the accuracy of our model.\n",
    "\n",
    "\n",
    "## Clean up\n",
    "You can use the following command to delete the SageMaker model endpoint. The endpoint that is created above is persistent and would consume resources till it is deleted. It is good to delete the endpoint when it is not being used."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ic_classifier.delete_endpoint()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook CI Test Results\n",
    "\n",
    "This notebook was tested in multiple regions. The test results are as follows, except for us-west-2 which is shown at the top of the notebook.\n",
    "\n",
    "![This us-east-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/us-east-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This us-east-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/us-east-2/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This us-west-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/us-west-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This ca-central-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ca-central-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This sa-east-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/sa-east-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This eu-west-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-west-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This eu-west-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-west-2/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This eu-west-3 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-west-3/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This eu-central-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-central-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This eu-north-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/eu-north-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This ap-southeast-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-southeast-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This ap-southeast-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-southeast-2/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This ap-northeast-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-northeast-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This ap-northeast-2 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-northeast-2/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n",
    "\n",
    "![This ap-south-1 badge failed to load. Check your device's internet connectivity, otherwise the service is currently unavailable](https://prod.us-west-2.tcx-beacon.docs.aws.dev/sagemaker-nb/ap-south-1/aws_marketplace|using_data|image_classification_with_shutterstock_image_datasets|image-classification-with-shutterstock-datasets.ipynb)\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "conda_python3",
   "language": "python",
   "name": "conda_python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  },
  "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.",
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}