Update example for TF/MXNet batch transform notebooks (aws#347)

This change is for making a more realistic example input for
the batch transform jobs in our example notebooks.

Author: laurenyu

sagemaker-python-sdk/mxnet_mnist/mxnet_mnist_with_batch_transform.ipynb

@@ -29,14 +29,18 @@
     "from sagemaker import get_execution_role\n",
     "from sagemaker.session import Session\n",
     "\n",
+    "sagemaker_session = Session()\n",
+    "region = sagemaker_session.boto_session.region_name\n",
+    "sample_data_bucket = 'sagemaker-sample-data-{}'.format(region)\n",
+    "\n",
     "# S3 bucket for saving files. Feel free to redefine this variable to the bucket of your choice.\n",
-    "bucket = Session().default_bucket()\n",
+    "bucket = sagemaker_session.default_bucket()\n",
     "\n",
     "# Bucket location where your custom code will be saved in the tar.gz format.\n",
-    "custom_code_upload_location = 's3://{}/customcode/mxnet'.format(bucket)\n",
+    "custom_code_upload_location = 's3://{}/mxnet-mnist-example/code'.format(bucket)\n",
     "\n",
     "# Bucket location where results of model training are saved.\n",
-    "model_artifacts_location = 's3://{}/artifacts'.format(bucket)\n",
+    "model_artifacts_location = 's3://{}/mxnet-mnist-example/artifacts'.format(bucket)\n",
     "\n",
     "# IAM execution role that gives SageMaker access to resources in your AWS account.\n",
     "# We can use the SageMaker Python SDK to get the role from our notebook environment. \n",
@@ -111,11 +115,9 @@
    "outputs": [],
    "source": [
     "%%time\n",
-    "import boto3\n",
     "\n",
-    "region = boto3.Session().region_name\n",
-    "train_data_location = 's3://sagemaker-sample-data-{}/mxnet/mnist/train'.format(region)\n",
-    "test_data_location = 's3://sagemaker-sample-data-{}/mxnet/mnist/test'.format(region)\n",
+    "train_data_location = 's3://{}/mxnet/mnist/train'.format(sample_data_bucket)\n",
+    "test_data_location = 's3://{}/mxnet/mnist/test'.format(sample_data_bucket)\n",
     "\n",
     "mnist_estimator.fit({'train': train_data_location, 'test': test_data_location})"
    ]
@@ -126,7 +128,7 @@
    "source": [
     "### SageMaker's transformer class\n",
     "\n",
-    "After training, we use our MXNet estimator object to create a `Transformer` by invoking the `transformer()` method. This method takes arguments for configuring our options with the batch transform job; these do not need to be the same values as the one we used for the training job.\n",
+    "After training, we use our MXNet estimator object to create a `Transformer` by invoking the `transformer()` method. This method takes arguments for configuring our options with the batch transform job; these do not need to be the same values as the one we used for the training job. The method also creates a SageMaker Model to be used for the batch transform jobs.\n",
     "\n",
     "The `Transformer` class is responsible for running batch transform jobs, which will deploy the trained model to an endpoint and send requests for performing inference."
    ]
@@ -148,23 +150,7 @@
     "\n",
     "Now we can perform some inference with the model we've trained by running a batch transform job. The request handling behavior of the Endpoint deployed during the transform job is determined by the `mnist.py` script.\n",
     "\n",
-    "For demonstration purposes, we will be using an image of a '7' that's already saved in S3:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "transform_data_location = 's3://sagemaker-sample-data-{}/batch-transform/mnist'.format(region)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Just for fun, we can print out what the image looks like. First we'll create a temporary directory:"
+    "For demonstration purposes, we're going to use input data that contains 1000 MNIST images, located in the public SageMaker sample data S3 bucket. To create the batch transform job, we simply call `transform()` on our transformer with information about the input data."
    ]
   },
   {
@@ -173,19 +159,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
+    "input_file_path = 'batch-transform/mnist-1000-samples'\n",
     "\n",
-    "tmp_dir = '/tmp/data'\n",
-    "\n",
-    "if not os.path.exists(tmp_dir):\n",
-    "    os.makedirs(tmp_dir)"
+    "transformer.transform('s3://{}/{}'.format(sample_data_bucket, input_file_path), content_type='text/csv')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "And now we'll print out the image:"
+    "Now we wait for the batch transform job to complete. We have a convenience method, `wait()`, that will block until the batch transform job has completed. We can call that here to see if the batch transform job is still running; the cell will finish running when the batch transform job has completed."
    ]
   },
   {
@@ -194,33 +177,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from numpy import genfromtxt\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "plt.rcParams[\"figure.figsize\"] = (2,10)\n",
-    "     \n",
-    "def show_digit(img, caption='', subplot=None):\n",
-    "    if subplot==None:\n",
-    "        _,(subplot)=plt.subplots(1,1)\n",
-    "    imgr=img.reshape((28,28))\n",
-    "    subplot.axis('off')\n",
-    "    subplot.imshow(imgr, cmap='gray')\n",
-    "    plt.title(caption)\n",
-    "     \n",
-    "input_data_file = '/tmp/data/mnist_data.csv'\n",
-    "\n",
-    "s3 = boto3.resource('s3')\n",
-    "s3.Bucket('sagemaker-sample-data-{}'.format(region)).download_file('batch-transform/mnist/data.csv', input_data_file)\n",
-    "\n",
-    "input_data = genfromtxt(input_data_file, delimiter=',')\n",
-    "show_digit(input_data)"
+    "transformer.wait()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now we can use the Transformer to classify the handwritten digit:"
+    "### Downloading the results\n",
+    "\n",
+    "The batch transform job uploads its predictions to S3. Since we did not specify `output_path` when creating the Transformer, one was generated based on the batch transform job name:"
    ]
   },
   {
@@ -229,14 +195,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "transformer.transform(transform_data_location, content_type='text/csv')"
+    "print(transformer.output_path)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now we wait for the batch transform job to complete. We have a convenience method, `wait()`, that will block until the batch transform job has completed. We can call that here to see if the batch transform job is still running; the cell will finish running when the batch transform job has completed."
+    "The output here will be a list of predictions, where each prediction is a list of probabilities, one for each possible label. Since we read the output as a string, we use `ast.literal_eval()` to turn it into a list and find the maximum element of the list gives us the predicted label. Here we define a convenience method to take the output and produce the predicted label."
    ]
   },
   {
@@ -245,16 +211,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "transformer.wait()"
+    "import ast\n",
+    "\n",
+    "def predicted_label(transform_output):\n",
+    "    output = ast.literal_eval(transform_output)\n",
+    "    probabilities = output[0]\n",
+    "    return probabilities.index(max(probabilities))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Downloading the results\n",
-    "\n",
-    "The batch transform job uploads its predictions to S3. Since we did not specify `output_path` when creating the Transformer, one was generated based on the batch transform job name:"
+    "Now let's download the first ten results from S3:"
    ]
   },
   {
@@ -263,41 +232,53 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(transformer.output_path)"
+    "import json\n",
+    "from urllib.parse import urlparse\n",
+    "\n",
+    "import boto3\n",
+    "\n",
+    "parsed_url = urlparse(transformer.output_path)\n",
+    "bucket_name = parsed_url.netloc\n",
+    "prefix = parsed_url.path[1:]\n",
+    "\n",
+    "s3 = boto3.resource('s3')\n",
+    "\n",
+    "predictions = []\n",
+    "for i in range(10):\n",
+    "    file_key = '{}/data-{}.csv.out'.format(prefix, i)\n",
+    "\n",
+    "    output_obj = s3.Object(bucket_name, file_key)\n",
+    "    output = output_obj.get()[\"Body\"].read().decode('utf-8')\n",
+    "    \n",
+    "    predictions.append(predicted_label(output))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We use that to download the results from S3:"
+    "For demonstration purposes, we're also going to download the corresponding original input data so that we can see how the model did with its predictions."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "import json\n",
-    "from urllib.parse import urlparse\n",
-    "     \n",
-    "parsed_url = urlparse(transformer.output_path)\n",
-    "bucket_name = parsed_url.netloc\n",
-    "file_key = '{}/data.csv.out'.format(parsed_url.path[1:])\n",
-    "     \n",
-    "s3 = boto3.resource('s3')\n",
-    "output_obj = s3.Object(bucket_name, file_key)\n",
-    "output = output_obj.get()[\"Body\"].read().decode('utf-8')"
+    "import os\n",
+    "\n",
+    "tmp_dir = '/tmp/data'\n",
+    "\n",
+    "if not os.path.exists(tmp_dir):\n",
+    "    os.makedirs(tmp_dir)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The output here is a list of predictions, where each prediction is a list of probabilities, one for each possible label. Since we read the output as a string, we use `ast.literal_eval()` to turn it into a list:"
+    "And now we'll print out the images:"
    ]
   },
   {
@@ -306,17 +287,42 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import ast\n",
+    "from numpy import genfromtxt\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.rcParams['figure.figsize'] = (2,10)\n",
     "\n",
-    "output = ast.literal_eval(output)\n",
-    "probabilities = output[0]"
+    "def show_digit(img, caption='', subplot=None):\n",
+    "    if subplot == None:\n",
+    "        _,(subplot) = plt.subplots(1,1)\n",
+    "    imgr = img.reshape((28,28))\n",
+    "    subplot.axis('off')\n",
+    "    subplot.imshow(imgr, cmap='gray')\n",
+    "    plt.title(caption)\n",
+    "\n",
+    "for i in range(10):\n",
+    "    input_file_name = 'data-{}.csv'.format(i)\n",
+    "    input_file_key = '{}/{}'.format(input_file_path, input_file_name)\n",
+    "    \n",
+    "    s3.Bucket(sample_data_bucket).download_file(input_file_key, os.path.join(tmp_dir, input_file_name))\n",
+    "    input_data = genfromtxt(os.path.join(tmp_dir, input_file_name), delimiter=',')\n",
+    "\n",
+    "    show_digit(input_data)"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "scrolled": true
+   },
    "source": [
-    "Now that we have the list of probabilities, finding the maximum element of the list gives us the predicted label:"
+    "Here, we can see the original labels are:\n",
+    "\n",
+    "```\n",
+    "7, 2, 1, 0, 4, 1, 4, 9, 5, 9\n",
+    "```\n",
+    "\n",
+    "Now let's print out the predictions to compare:"
    ]
   },
   {
@@ -325,8 +331,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "prediction = probabilities.index(max(probabilities))\n",
-    "print('Prediction is {}'.format(prediction))"
+    "print(predictions)"
    ]
   }
  ],