sagemaker_keras_text_classification.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Text Classification Using Keras & TensorFlow on Amazon SageMaker\n",
        "\n",
        "Full lab guide can be found here: https://github.com/aws-samples/amazon-sagemaker-keras-text-classification"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": ["# Lab 1: Data Exploration"]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "import re\n",
        "import numpy as np\n",
        "import os\n",
        "\n",
        "from tensorflow.python.keras.preprocessing.text import Tokenizer\n",
        "from tensorflow.python.keras.preprocessing.sequence import pad_sequences\n",
        "from tensorflow.python.keras.utils import to_categorical"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "column_names = [\"TITLE\", \"URL\", \"PUBLISHER\", \"CATEGORY\", \"STORY\", \"HOSTNAME\", \"TIMESTAMP\"]\n",
        "news_dataset = pd.read_csv(os.path.join('./data', 'newsCorpora.csv'), names=column_names, header=None, delimiter='\\t')\n",
        "news_dataset.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": ["news_dataset.groupby(['CATEGORY']).size()"]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "![STOP HERE](images/sm-keras-stop-sign.jpg)\n",
        "\n",
        "## Stop here. Please switch back to the [lab guide](https://github.com/aws-samples/amazon-sagemaker-keras-text-classification) on Github and complete labs 1, 2 and 3. You will come back to this notebook later in Lab 4.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Lab 4: Training and Hosting your Algorithm in Amazon SageMaker\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Building and registering the container\n",
        "\n",
        "The following shell code shows how to build the container image using `docker build` and push the container image to ECR using `docker push`. \n",
        "\n",
        "This code looks for an ECR repository in the account you're using and the current default region (if you're using a SageMaker notebook instance, this will be the region where the notebook instance was created). If the repository doesn't exist, the script will create it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "%%sh\n",
        "\n",
        "# The name of our algorithm\n",
        "algorithm_name=sagemaker-keras-text-classification\n",
        "\n",
        "cd container\n",
        "\n",
        "chmod +x sagemaker_keras_text_classification/train\n",
        "chmod +x sagemaker_keras_text_classification/serve\n",
        "\n",
        "account=$(aws sts get-caller-identity --query Account --output text)\n",
        "\n",
        "# Get the region defined in the current configuration (default to us-west-2 if none defined)\n",
        "region=$(aws configure get region)\n",
        "region=${region:-us-west-2}\n",
        "\n",
        "fullname=\"${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest\"\n",
        "\n",
        "# If the repository doesn't exist in ECR, create it.\n",
        "\n",
        "aws ecr describe-repositories --repository-names \"${algorithm_name}\" > /dev/null 2>&1\n",
        "\n",
        "if [ $? -ne 0 ]\n",
        "then\n",
        "    aws ecr create-repository --repository-name \"${algorithm_name}\" > /dev/null\n",
        "fi\n",
        "\n",
        "# Get the login command from ECR and execute it directly\n",
        "$(aws ecr get-login --region ${region} --no-include-email)\n",
        "\n",
        "# Build the docker image locally with the image name and then push it to ECR\n",
        "# with the full name.\n",
        "\n",
        "# On a SageMaker Notebook Instance, the docker daemon may need to be restarted in order\n",
        "# to detect your network configuration correctly.  (This is a known issue.)\n",
        "if [ -d \"/home/ec2-user/SageMaker\" ]; then\n",
        "  sudo service docker restart\n",
        "fi\n",
        "\n",
        "docker build  -t ${algorithm_name} .\n",
        "docker tag ${algorithm_name} ${fullname}\n",
        "\n",
        "docker push ${fullname}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Once you have your container packaged, you can use it to train and serve models. Let's do that with the algorithm we made above.\n",
        "\n",
        "## Set up the environment\n",
        "\n",
        "Here we specify a bucket to use and the role that will be used for working with SageMaker."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [],
      "source": [
        "# S3 prefix\n",
        "prefix = 'sagemaker-keras-text-classification'\n",
        "\n",
        "# Define IAM role\n",
        "import boto3\n",
        "import re\n",
        "\n",
        "import os\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sagemaker import get_execution_role\n",
        "\n",
        "role = get_execution_role()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Create the session\n",
        "\n",
        "The session remembers our connection parameters to SageMaker. We'll use it to perform all of our SageMaker operations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "import sagemaker as sage\n",
        "from time import gmtime, strftime\n",
        "\n",
        "sess = sage.Session()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Upload the data for training\n",
        "\n",
        "When training large models with huge amounts of data, you'll typically use big data tools, like Amazon Athena, AWS Glue, or Amazon EMR, to create your data in S3.  \n",
        "\n",
        "We can use use the tools provided by the SageMaker Python SDK to upload the data to a default bucket. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "WORK_DIRECTORY = 'data'\n",
        "\n",
        "data_location = sess.upload_data(WORK_DIRECTORY, key_prefix=prefix)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Create an estimator and fit the model\n",
        "\n",
        "In order to use SageMaker to fit our algorithm, we'll create an `Estimator` that defines how to use the container to to train. This includes the configuration we need to invoke SageMaker training:\n",
        "\n",
        "* The __container name__. This is constucted as in the shell commands above.\n",
        "* The __role__. As defined above.\n",
        "* The __instance count__ which is the number of machines to use for training.\n",
        "* The __instance type__ which is the type of machine to use for training.\n",
        "* The __output path__ determines where the model artifact will be written.\n",
        "* The __session__ is the SageMaker session object that we defined above.\n",
        "\n",
        "Then we use fit() on the estimator to train against the data that we uploaded above."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [],
      "source": [
        "account = sess.boto_session.client('sts').get_caller_identity()['Account']\n",
        "region = sess.boto_session.region_name\n",
        "image = '{}.dkr.ecr.{}.amazonaws.com/sagemaker-keras-text-classification'.format(account, region)\n",
        "\n",
        "tree = sage.estimator.Estimator(image,\n",
        "                       role, 1, 'ml.c5.2xlarge',\n",
        "                       output_path=\"s3://{}/output\".format(sess.default_bucket()),\n",
        "                       sagemaker_session=sess)\n",
        "\n",
        "tree.fit(data_location)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Deploy the model\n",
        "\n",
        "Deploying the model to SageMaker hosting just requires a `deploy` call on the fitted model. This call takes an instance count, instance type, and optionally serializer and deserializer functions. These are used when the resulting predictor is created on the endpoint."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [],
      "source": [
        "from sagemaker.predictor import json_serializer\n",
        "predictor = tree.deploy(1, 'ml.m5.xlarge', serializer=json_serializer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [],
      "source": [
        "request = { \"input\": \"‘Deadpool 2’ Has More Swearing, Slicing and Dicing from Ryan Reynolds\"}\n",
        "print(predictor.predict(request).decode('utf-8'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Optional cleanup\n",
        "\n",
        "When you're done with the endpoint, you'll want to clean it up."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true
      },
      "outputs": [],
      "source": ["sess.delete_endpoint(predictor.endpoint)"]
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "conda_tensorflow_p36",
      "display_name": "conda_tensorflow_p36",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.5",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}