sagemaker-deployment/Tutorials/Boston Housing - XGBoost (Hyperparameter Tuning) - Low Level.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting Boston Housing Prices\n",
    "\n",
    "## Using XGBoost in SageMaker (Hyperparameter Tuning)\n",
    "\n",
    "_Deep Learning Nanodegree Program | Deployment_\n",
    "\n",
    "---\n",
    "\n",
    "As an introduction to using SageMaker's Low Level API for hyperparameter tuning, we will look again at the [Boston Housing Dataset](https://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html) to predict the median value of a home in the area of Boston Mass.\n",
    "\n",
    "The documentation reference for the API used in this notebook is the [SageMaker Developer's Guide](https://docs.aws.amazon.com/sagemaker/latest/dg/)\n",
    "\n",
    "## General Outline\n",
    "\n",
    "Typically, when using a notebook instance with SageMaker, you will proceed through the following steps. Of course, not every step will need to be done with each project. Also, there is quite a lot of room for variation in many of the steps, as you will see throughout these lessons.\n",
    "\n",
    "1. Download or otherwise retrieve the data.\n",
    "2. Process / Prepare the data.\n",
    "3. Upload the processed data to S3.\n",
    "4. Train a chosen model.\n",
    "5. Test the trained model (typically using a batch transform job).\n",
    "6. Deploy the trained model.\n",
    "7. Use the deployed model.\n",
    "\n",
    "In this notebook we will only be covering steps 1 through 5 as we are only interested in creating a tuned model and testing its performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 0: Setting up the notebook\n",
    "\n",
    "We begin by setting up all of the necessary bits required to run our notebook. To start that means loading all of the Python modules we will need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import os\n",
    "\n",
    "import time\n",
    "from time import gmtime, strftime\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.datasets import load_boston\n",
    "import sklearn.model_selection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the modules above, we need to import the various bits of SageMaker that we will be using. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sagemaker\n",
    "from sagemaker import get_execution_role\n",
    "from sagemaker.amazon.amazon_estimator import get_image_uri\n",
    "\n",
    "# This is an object that represents the SageMaker session that we are currently operating in. This\n",
    "# object contains some useful information that we will need to access later such as our region.\n",
    "session = sagemaker.Session()\n",
    "\n",
    "# This is an object that represents the IAM role that we are currently assigned. When we construct\n",
    "# and launch the training job later we will need to tell it what IAM role it should have. Since our\n",
    "# use case is relatively simple we will simply assign the training job the role we currently have.\n",
    "role = get_execution_role()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: Downloading the data\n",
    "\n",
    "Fortunately, this dataset can be retrieved using sklearn and so this step is relatively straightforward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "boston = load_boston()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: Preparing and splitting the data\n",
    "\n",
    "Given that this is clean tabular data, we don't need to do any processing. However, we do need to split the rows in the dataset up into train, test and validation sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First we package up the input data and the target variable (the median value) as pandas dataframes. This\n",
    "# will make saving the data to a file a little easier later on.\n",
    "\n",
    "X_bos_pd = pd.DataFrame(boston.data, columns=boston.feature_names)\n",
    "Y_bos_pd = pd.DataFrame(boston.target)\n",
    "\n",
    "# We split the dataset into 2/3 training and 1/3 testing sets.\n",
    "X_train, X_test, Y_train, Y_test = sklearn.model_selection.train_test_split(X_bos_pd, Y_bos_pd, test_size=0.33)\n",
    "\n",
    "# Then we split the training set further into 2/3 training and 1/3 validation sets.\n",
    "X_train, X_val, Y_train, Y_val = sklearn.model_selection.train_test_split(X_train, Y_train, test_size=0.33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3: Uploading the data files to S3\n",
    "\n",
    "When a training job is constructed using SageMaker, a container is executed which performs the training operation. This container is given access to data that is stored in S3. This means that we need to upload the data we want to use for training to S3. In addition, when we perform a batch transform job, SageMaker expects the input data to be stored on S3. We can use the SageMaker API to do this and hide some of the details.\n",
    "\n",
    "### Save the data locally\n",
    "\n",
    "First we need to create the test, train and validation csv files which we will then upload to S3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is our local data directory. We need to make sure that it exists.\n",
    "data_dir = '../data/boston'\n",
    "if not os.path.exists(data_dir):\n",
    "    os.makedirs(data_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We use pandas to save our test, train and validation data to csv files. Note that we make sure not to include header\n",
    "# information or an index as this is required by the built in algorithms provided by Amazon. Also, for the train and\n",
    "# validation data, it is assumed that the first entry in each row is the target variable.\n",
    "\n",
    "X_test.to_csv(os.path.join(data_dir, 'test.csv'), header=False, index=False)\n",
    "\n",
    "pd.concat([Y_val, X_val], axis=1).to_csv(os.path.join(data_dir, 'validation.csv'), header=False, index=False)\n",
    "pd.concat([Y_train, X_train], axis=1).to_csv(os.path.join(data_dir, 'train.csv'), header=False, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Upload to S3\n",
    "\n",
    "Since we are currently running inside of a SageMaker session, we can use the object which represents this session to upload our data to the 'default' S3 bucket. Note that it is good practice to provide a custom prefix (essentially an S3 folder) to make sure that you don't accidentally interfere with data uploaded from some other notebook or project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "prefix = 'boston-xgboost-tuning-LL'\n",
    "\n",
    "test_location = session.upload_data(os.path.join(data_dir, 'test.csv'), key_prefix=prefix)\n",
    "val_location = session.upload_data(os.path.join(data_dir, 'validation.csv'), key_prefix=prefix)\n",
    "train_location = session.upload_data(os.path.join(data_dir, 'train.csv'), key_prefix=prefix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: Train and construct the XGBoost model\n",
    "\n",
    "Now that we have the training and validation data uploaded to S3, we can construct our XGBoost model and train it. Unlike in the previous notebooks, instead of training a single model, we will use SageMakers hyperparameter tuning functionality to train multiple models and use the one that performs the best on the validation set.\n",
    "\n",
    "### Set up the training job\n",
    "\n",
    "First, we will set up a training job for our model. This is very similar to the way in which we constructed the training job in previous notebooks. Essentially this describes the *base* training job from which SageMaker will create refinements by changing some hyperparameters during the hyperparameter tuning job."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will need to know the name of the container that we want to use for training. SageMaker provides\n",
    "# a nice utility method to construct this for us.\n",
    "container = get_image_uri(session.boto_region_name, 'xgboost')\n",
    "\n",
    "# We now specify the parameters we wish to use for our training job\n",
    "training_params = {}\n",
    "\n",
    "# We need to specify the permissions that this training job will have. For our purposes we can use\n",
    "# the same permissions that our current SageMaker session has.\n",
    "training_params['RoleArn'] = role\n",
    "\n",
    "# Here we describe the algorithm we wish to use. The most important part is the container which\n",
    "# contains the training code.\n",
    "training_params['AlgorithmSpecification'] = {\n",
    "    \"TrainingImage\": container,\n",
    "    \"TrainingInputMode\": \"File\"\n",
    "}\n",
    "\n",
    "# We also need to say where we would like the resulting model artifacts stored.\n",
    "training_params['OutputDataConfig'] = {\n",
    "    \"S3OutputPath\": \"s3://\" + session.default_bucket() + \"/\" + prefix + \"/output\"\n",
    "}\n",
    "\n",
    "# We also need to set some parameters for the training job itself. Namely we need to describe what sort of\n",
    "# compute instance we wish to use along with a stopping condition to handle the case that there is\n",
    "# some sort of error and the training script doesn't terminate.\n",
    "training_params['ResourceConfig'] = {\n",
    "    \"InstanceCount\": 1,\n",
    "    \"InstanceType\": \"ml.m4.xlarge\",\n",
    "    \"VolumeSizeInGB\": 5\n",
    "}\n",
    "    \n",
    "training_params['StoppingCondition'] = {\n",
    "    \"MaxRuntimeInSeconds\": 86400\n",
    "}\n",
    "\n",
    "# Next we set the algorithm specific hyperparameters. In this case, since we are setting up\n",
    "# a training job which will serve as the base training job for the eventual hyperparameter\n",
    "# tuning job, we only specify the _static_ hyperparameters. That is, the hyperparameters that\n",
    "# we do _not_ want SageMaker to change.\n",
    "training_params['StaticHyperParameters'] = {\n",
    "    \"gamma\": \"4\",\n",
    "    \"subsample\": \"0.8\",\n",
    "    \"objective\": \"reg:linear\",\n",
    "    \"early_stopping_rounds\": \"10\",\n",
    "    \"num_round\": \"200\"\n",
    "}\n",
    "\n",
    "# Now we need to tell SageMaker where the data should be retrieved from.\n",
    "training_params['InputDataConfig'] = [\n",
    "    {\n",
    "        \"ChannelName\": \"train\",\n",
    "        \"DataSource\": {\n",
    "            \"S3DataSource\": {\n",
    "                \"S3DataType\": \"S3Prefix\",\n",
    "                \"S3Uri\": train_location,\n",
    "                \"S3DataDistributionType\": \"FullyReplicated\"\n",
    "            }\n",
    "        },\n",
    "        \"ContentType\": \"csv\",\n",
    "        \"CompressionType\": \"None\"\n",
    "    },\n",
    "    {\n",
    "        \"ChannelName\": \"validation\",\n",
    "        \"DataSource\": {\n",
    "            \"S3DataSource\": {\n",
    "                \"S3DataType\": \"S3Prefix\",\n",
    "                \"S3Uri\": val_location,\n",
    "                \"S3DataDistributionType\": \"FullyReplicated\"\n",
    "            }\n",
    "        },\n",
    "        \"ContentType\": \"csv\",\n",
    "        \"CompressionType\": \"None\"\n",
    "    }\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set up the tuning job\n",
    "\n",
    "Now that the *base* training job has been set up, we can describe the tuning job that we would like SageMaker to perform. In particular, like in the high level notebook, we will specify which hyperparameters we wish SageMaker to change and what range of values they may take on.\n",
    "\n",
    "In addition, we specify the *number* of models to construct (`max_jobs`) and the number of those that can be trained in parallel (`max_parallel_jobs`). In the cell below we have chosen to train `20` models, of which we ask that SageMaker train `3` at a time in parallel. Note that this results in a total of `20` training jobs being executed which can take some time, in this case almost a half hour. With more complicated models this can take even longer so be aware!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We need to construct a dictionary which specifies the tuning job we want SageMaker to perform\n",
    "tuning_job_config = {\n",
    "    # First we specify which hyperparameters we want SageMaker to be able to vary,\n",
    "    # and we specify the type and range of the hyperparameters.\n",
    "    \"ParameterRanges\": {\n",
    "    \"CategoricalParameterRanges\": [],\n",
    "    \"ContinuousParameterRanges\": [\n",
    "        {\n",
    "            \"MaxValue\": \"0.5\",\n",
    "            \"MinValue\": \"0.05\",\n",
    "            \"Name\": \"eta\"\n",
    "        },\n",
    "    ],\n",
    "    \"IntegerParameterRanges\": [\n",
    "        {\n",
    "            \"MaxValue\": \"12\",\n",
    "            \"MinValue\": \"3\",\n",
    "            \"Name\": \"max_depth\"\n",
    "        },\n",
    "        {\n",
    "            \"MaxValue\": \"8\",\n",
    "            \"MinValue\": \"2\",\n",
    "            \"Name\": \"min_child_weight\"\n",
    "        }\n",
    "    ]},\n",
    "    # We also need to specify how many models should be fit and how many can be fit in parallel\n",
    "    \"ResourceLimits\": {\n",
    "        \"MaxNumberOfTrainingJobs\": 20,\n",
    "        \"MaxParallelTrainingJobs\": 3\n",
    "    },\n",
    "    # Here we specify how SageMaker should update the hyperparameters as new models are fit\n",
    "    \"Strategy\": \"Bayesian\",\n",
    "    # And lastly we need to specify how we'd like to determine which models are better or worse\n",
    "    \"HyperParameterTuningJobObjective\": {\n",
    "        \"MetricName\": \"validation:rmse\",\n",
    "        \"Type\": \"Minimize\"\n",
    "    }\n",
    "  }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execute the tuning job\n",
    "\n",
    "Now that we've built the data structures that describe the tuning job we want SageMaker to execute, it is time to actually start the job."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'HyperParameterTuningJobArn': 'arn:aws:sagemaker:eu-west-1:177473201433:hyper-parameter-tuning-job/tuning-job2019-01-15-15-20-30',\n",
       " 'ResponseMetadata': {'RequestId': '2d8f8a74-9ac2-4aed-8c27-ecfcc6101311',\n",
       "  'HTTPStatusCode': 200,\n",
       "  'HTTPHeaders': {'x-amzn-requestid': '2d8f8a74-9ac2-4aed-8c27-ecfcc6101311',\n",
       "   'content-type': 'application/x-amz-json-1.1',\n",
       "   'content-length': '130',\n",
       "   'date': 'Tue, 15 Jan 2019 15:20:29 GMT'},\n",
       "  'RetryAttempts': 0}}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First we need to choose a name for the job. This is useful for if we want to recall information about our\n",
    "# tuning job at a later date. Note that SageMaker requires a tuning job name and that the name needs to\n",
    "# be unique, which we accomplish by appending the current timestamp.\n",
    "tuning_job_name = \"tuning-job\" + strftime(\"%Y-%m-%d-%H-%M-%S\", gmtime())\n",
    "\n",
    "# And now we ask SageMaker to create (and execute) the training job\n",
    "session.sagemaker_client.create_hyper_parameter_tuning_job(HyperParameterTuningJobName = tuning_job_name,\n",
    "                                                           HyperParameterTuningJobConfig = tuning_job_config,\n",
    "                                                           TrainingJobDefinition = training_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tuning job has now been created by SageMaker and is currently running. Since we need the output of the tuning job, we may wish to wait until it has finished. We can do so by asking SageMaker to output the logs generated by the tuning job and continue doing so until the job terminates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "................................................................................................................................................................................................................................................................................!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'HyperParameterTuningJobName': 'tuning-job2019-01-15-15-20-30',\n",
       " 'HyperParameterTuningJobArn': 'arn:aws:sagemaker:eu-west-1:177473201433:hyper-parameter-tuning-job/tuning-job2019-01-15-15-20-30',\n",
       " 'HyperParameterTuningJobConfig': {'Strategy': 'Bayesian',\n",
       "  'HyperParameterTuningJobObjective': {'Type': 'Minimize',\n",
       "   'MetricName': 'validation:rmse'},\n",
       "  'ResourceLimits': {'MaxNumberOfTrainingJobs': 20,\n",
       "   'MaxParallelTrainingJobs': 3},\n",
       "  'ParameterRanges': {'IntegerParameterRanges': [{'Name': 'max_depth',\n",
       "     'MinValue': '3',\n",
       "     'MaxValue': '12'},\n",
       "    {'Name': 'min_child_weight', 'MinValue': '2', 'MaxValue': '8'}],\n",
       "   'ContinuousParameterRanges': [{'Name': 'eta',\n",
       "     'MinValue': '0.05',\n",
       "     'MaxValue': '0.5'}],\n",
       "   'CategoricalParameterRanges': []}},\n",
       " 'TrainingJobDefinition': {'StaticHyperParameters': {'_tuning_objective_metric': 'validation:rmse',\n",
       "   'early_stopping_rounds': '10',\n",
       "   'gamma': '4',\n",
       "   'num_round': '200',\n",
       "   'objective': 'reg:linear',\n",
       "   'subsample': '0.8'},\n",
       "  'AlgorithmSpecification': {'TrainingImage': '685385470294.dkr.ecr.eu-west-1.amazonaws.com/xgboost:1',\n",
       "   'TrainingInputMode': 'File',\n",
       "   'MetricDefinitions': [{'Name': 'train:mae',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\]#011train-mae:(\\\\S+).*'},\n",
       "    {'Name': 'validation:auc',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-auc:(\\\\S+)'},\n",
       "    {'Name': 'train:merror',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\]#011train-merror:(\\\\S+).*'},\n",
       "    {'Name': 'train:auc', 'Regex': '.*\\\\[[0-9]+\\\\]#011train-auc:(\\\\S+).*'},\n",
       "    {'Name': 'validation:mae',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-mae:(\\\\S+)'},\n",
       "    {'Name': 'validation:error',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-error:(\\\\S+)'},\n",
       "    {'Name': 'validation:merror',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-merror:(\\\\S+)'},\n",
       "    {'Name': 'validation:logloss',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-logloss:(\\\\S+)'},\n",
       "    {'Name': 'train:rmse', 'Regex': '.*\\\\[[0-9]+\\\\]#011train-rmse:(\\\\S+).*'},\n",
       "    {'Name': 'train:logloss',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\]#011train-logloss:(\\\\S+).*'},\n",
       "    {'Name': 'train:mlogloss',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\]#011train-mlogloss:(\\\\S+).*'},\n",
       "    {'Name': 'validation:rmse',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-rmse:(\\\\S+)'},\n",
       "    {'Name': 'validation:ndcg',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-ndcg:(\\\\S+)'},\n",
       "    {'Name': 'train:error', 'Regex': '.*\\\\[[0-9]+\\\\]#011train-error:(\\\\S+).*'},\n",
       "    {'Name': 'validation:mlogloss',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-mlogloss:(\\\\S+)'},\n",
       "    {'Name': 'train:ndcg', 'Regex': '.*\\\\[[0-9]+\\\\]#011train-ndcg:(\\\\S+).*'},\n",
       "    {'Name': 'train:map', 'Regex': '.*\\\\[[0-9]+\\\\]#011train-map:(\\\\S+).*'},\n",
       "    {'Name': 'validation:map',\n",
       "     'Regex': '.*\\\\[[0-9]+\\\\].*#011validation-map:(\\\\S+)'}]},\n",
       "  'RoleArn': 'arn:aws:iam::177473201433:role/service-role/AmazonSageMaker-ExecutionRole-20190101T164676',\n",
       "  'InputDataConfig': [{'ChannelName': 'train',\n",
       "    'DataSource': {'S3DataSource': {'S3DataType': 'S3Prefix',\n",
       "      'S3Uri': 's3://sagemaker-eu-west-1-177473201433/boston-xgboost-tuning-LL/train.csv',\n",
       "      'S3DataDistributionType': 'FullyReplicated'}},\n",
       "    'ContentType': 'csv',\n",
       "    'CompressionType': 'None'},\n",
       "   {'ChannelName': 'validation',\n",
       "    'DataSource': {'S3DataSource': {'S3DataType': 'S3Prefix',\n",
       "      'S3Uri': 's3://sagemaker-eu-west-1-177473201433/boston-xgboost-tuning-LL/validation.csv',\n",
       "      'S3DataDistributionType': 'FullyReplicated'}},\n",
       "    'ContentType': 'csv',\n",
       "    'CompressionType': 'None'}],\n",
       "  'OutputDataConfig': {'S3OutputPath': 's3://sagemaker-eu-west-1-177473201433/boston-xgboost-tuning-LL/output'},\n",
       "  'ResourceConfig': {'InstanceType': 'ml.m4.xlarge',\n",
       "   'InstanceCount': 1,\n",
       "   'VolumeSizeInGB': 5},\n",
       "  'StoppingCondition': {'MaxRuntimeInSeconds': 86400},\n",
       "  'EnableNetworkIsolation': False},\n",
       " 'HyperParameterTuningJobStatus': 'Completed',\n",
       " 'CreationTime': datetime.datetime(2019, 1, 15, 15, 20, 30, 593000, tzinfo=tzlocal()),\n",
       " 'HyperParameterTuningEndTime': datetime.datetime(2019, 1, 15, 15, 43, 25, 915000, tzinfo=tzlocal()),\n",
       " 'LastModifiedTime': datetime.datetime(2019, 1, 15, 15, 43, 25, 915000, tzinfo=tzlocal()),\n",
       " 'TrainingJobStatusCounters': {'Completed': 20,\n",
       "  'InProgress': 0,\n",
       "  'RetryableError': 0,\n",
       "  'NonRetryableError': 0,\n",
       "  'Stopped': 0},\n",
       " 'ObjectiveStatusCounters': {'Succeeded': 20, 'Pending': 0, 'Failed': 0},\n",
       " 'BestTrainingJob': {'TrainingJobName': 'tuning-job2019-01-15-15-20-30-016-5098a855',\n",
       "  'TrainingJobArn': 'arn:aws:sagemaker:eu-west-1:177473201433:training-job/tuning-job2019-01-15-15-20-30-016-5098a855',\n",
       "  'CreationTime': datetime.datetime(2019, 1, 15, 15, 37, 9, tzinfo=tzlocal()),\n",
       "  'TrainingStartTime': datetime.datetime(2019, 1, 15, 15, 39, 12, tzinfo=tzlocal()),\n",
       "  'TrainingEndTime': datetime.datetime(2019, 1, 15, 15, 39, 55, tzinfo=tzlocal()),\n",
       "  'TrainingJobStatus': 'Completed',\n",
       "  'TunedHyperParameters': {'eta': '0.06792654971151404',\n",
       "   'max_depth': '3',\n",
       "   'min_child_weight': '2'},\n",
       "  'FinalHyperParameterTuningJobObjectiveMetric': {'MetricName': 'validation:rmse',\n",
       "   'Value': 2.842989921569824},\n",
       "  'ObjectiveStatus': 'Succeeded'},\n",
       " 'ResponseMetadata': {'RequestId': '3795f8fe-9db0-48d4-aeab-ce76d02cda62',\n",
       "  'HTTPStatusCode': 200,\n",
       "  'HTTPHeaders': {'x-amzn-requestid': '3795f8fe-9db0-48d4-aeab-ce76d02cda62',\n",
       "   'content-type': 'application/x-amz-json-1.1',\n",
       "   'content-length': '4251',\n",
       "   'date': 'Tue, 15 Jan 2019 15:43:26 GMT'},\n",
       "  'RetryAttempts': 0}}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.wait_for_tuning_job(tuning_job_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build the model\n",
    "\n",
    "Now that the tuning job has finished, SageMaker has fit a number of models, the results of which are stored in a data structure which we can access using the name of the tuning job."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuning_job_info = session.sagemaker_client.describe_hyper_parameter_tuning_job(HyperParameterTuningJobName=tuning_job_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Among the pieces of information included in the `tuning_job_info` object is the name of the training job which performed best out of all of the models that SageMaker fit to our data. Using this training job name we can get access to the resulting model artifacts, from which we can construct a model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We begin by asking SageMaker to describe for us the results of the best training job. The data\n",
    "# structure returned contains a lot more information than we currently need, try checking it out\n",
    "# yourself in more detail.\n",
    "best_training_job_name = tuning_job_info['BestTrainingJob']['TrainingJobName']\n",
    "training_job_info = session.sagemaker_client.describe_training_job(TrainingJobName=best_training_job_name)\n",
    "\n",
    "model_artifacts = training_job_info['ModelArtifacts']['S3ModelArtifacts']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just like when we created a training job, the model name must be unique\n",
    "model_name = best_training_job_name + \"-model\"\n",
    "\n",
    "# We also need to tell SageMaker which container should be used for inference and where it should\n",
    "# retrieve the model artifacts from. In our case, the xgboost container that we used for training\n",
    "# can also be used for inference.\n",
    "primary_container = {\n",
    "    \"Image\": container,\n",
    "    \"ModelDataUrl\": model_artifacts\n",
    "}\n",
    "\n",
    "# And lastly we construct the SageMaker model\n",
    "model_info = session.sagemaker_client.create_model(\n",
    "                                ModelName = model_name,\n",
    "                                ExecutionRoleArn = role,\n",
    "                                PrimaryContainer = primary_container)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5: Testing the model\n",
    "\n",
    "Now that we have fit our model to the training data, using the validation data to avoid overfitting, we can test our model. To do this we will make use of SageMaker's Batch Transform functionality. In other words, we need to set up and execute a batch transform job, similar to the way that we constructed the training job earlier.\n",
    "\n",
    "### Set up the batch transform job\n",
    "\n",
    "Just like when we were training our model, we first need to provide some information in the form of a data structure that describes the batch transform job which we wish to execute.\n",
    "\n",
    "We will only be using some of the options available here but to see some of the additional options please see the SageMaker documentation for [creating a batch transform job](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateTransformJob.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just like in each of the previous steps, we need to make sure to name our job and the name should be unique.\n",
    "transform_job_name = 'boston-xgboost-batch-transform-' + strftime(\"%Y-%m-%d-%H-%M-%S\", gmtime())\n",
    "\n",
    "# Now we construct the data structure which will describe the batch transform job.\n",
    "transform_request = \\\n",
    "{\n",
    "    \"TransformJobName\": transform_job_name,\n",
    "    \n",
    "    # This is the name of the model that we created earlier.\n",
    "    \"ModelName\": model_name,\n",
    "    \n",
    "    # This describes how many compute instances should be used at once. If you happen to be doing a very large\n",
    "    # batch transform job it may be worth running multiple compute instances at once.\n",
    "    \"MaxConcurrentTransforms\": 1,\n",
    "    \n",
    "    # This says how big each individual request sent to the model should be, at most. One of the things that\n",
    "    # SageMaker does in the background is to split our data up into chunks so that each chunks stays under\n",
    "    # this size limit.\n",
    "    \"MaxPayloadInMB\": 6,\n",
    "    \n",
    "    # Sometimes we may want to send only a single sample to our endpoint at a time, however in this case each of\n",
    "    # the chunks that we send should contain multiple samples of our input data.\n",
    "    \"BatchStrategy\": \"MultiRecord\",\n",
    "    \n",
    "    # This next object describes where the output data should be stored. Some of the more advanced options which\n",
    "    # we don't cover here also describe how SageMaker should collect output from various batches.\n",
    "    \"TransformOutput\": {\n",
    "        \"S3OutputPath\": \"s3://{}/{}/batch-bransform/\".format(session.default_bucket(),prefix)\n",
    "    },\n",
    "    \n",
    "    # Here we describe our input data. Of course, we need to tell SageMaker where on S3 our input data is stored, in\n",
    "    # addition we need to detail the characteristics of our input data. In particular, since SageMaker may need to\n",
    "    # split our data up into chunks, it needs to know how the individual samples in our data file appear. In our\n",
    "    # case each line is its own sample and so we set the split type to 'line'. We also need to tell SageMaker what\n",
    "    # type of data is being sent, in this case csv, so that it can properly serialize the data.\n",
    "    \"TransformInput\": {\n",
    "        \"ContentType\": \"text/csv\",\n",
    "        \"SplitType\": \"Line\",\n",
    "        \"DataSource\": {\n",
    "            \"S3DataSource\": {\n",
    "                \"S3DataType\": \"S3Prefix\",\n",
    "                \"S3Uri\": test_location,\n",
    "            }\n",
    "        }\n",
    "    },\n",
    "    \n",
    "    # And lastly we tell SageMaker what sort of compute instance we would like it to use.\n",
    "    \"TransformResources\": {\n",
    "            \"InstanceType\": \"ml.m4.xlarge\",\n",
    "            \"InstanceCount\": 1\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execute the batch transform job\n",
    "\n",
    "Now that we have created the request data structure, it is time to as SageMaker to set up and run our batch transform job. Just like in the previous steps, SageMaker performs these tasks in the background so that if we want to wait for the transform job to terminate (and ensure the job is progressing) we can ask SageMaker to wait of the transform job to complete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform_response = session.sagemaker_client.create_transform_job(**transform_request)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".....................................!\n"
     ]
    }
   ],
   "source": [
    "transform_desc = session.wait_for_transform_job(transform_job_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyze the results\n",
    "\n",
    "Now that the transform job has completed, the results are stored on S3 as we requested. Since we'd like to do a bit of analysis in the notebook we can use some notebook magic to copy the resulting output from S3 and save it locally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform_output = \"s3://{}/{}/batch-bransform/\".format(session.default_bucket(),prefix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed 2.3 KiB/2.3 KiB (18.6 KiB/s) with 1 file(s) remaining\r",
      "download: s3://sagemaker-eu-west-1-177473201433/boston-xgboost-tuning-LL/batch-bransform/test.csv.out to ../data/boston/test.csv.out\r\n"
     ]
    }
   ],
   "source": [
    "!aws s3 cp --recursive $transform_output $data_dir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see how well our model works we can create a simple scatter plot between the predicted and actual values. If the model was completely accurate the resulting scatter plot would look like the line $x=y$. As we can see, our model seems to have done okay but there is room for improvement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_pred = pd.read_csv(os.path.join(data_dir, 'test.csv.out'), header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Median Price vs Predicted Price')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(Y_test, Y_pred)\n",
    "plt.xlabel(\"Median Price\")\n",
    "plt.ylabel(\"Predicted Price\")\n",
    "plt.title(\"Median Price vs Predicted Price\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optional: Clean up\n",
    "\n",
    "The default notebook instance on SageMaker doesn't have a lot of excess disk space available. As you continue to complete and execute notebooks you will eventually fill up this disk space, leading to errors which can be difficult to diagnose. Once you are completely finished using a notebook it is a good idea to remove the files that you created along the way. Of course, you can do this from the terminal or from the notebook hub if you would like. The cell below contains some commands to clean up the created files from within the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First we will remove all of the files contained in the data_dir directory\n",
    "!rm $data_dir/*\n",
    "\n",
    "# And then we delete the directory itself\n",
    "!rmdir $data_dir"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_pytorch_p36",
   "language": "python",
   "name": "conda_pytorch_p36"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}