6-azureml-movie-recommendation/sar_movielens_with_azureml.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "<i>Copyright (c) Microsoft Corporation. All rights reserved.</i>\n\n<i>Licensed under the MIT License.</i>"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Train a recommender system with Azure Machine Learning\n---\n\nThis tutorial will walk you through how to train a SAR recommender algorithm for the [Movielens dataset](https://grouplens.org/datasets/movielens/) on [Azure Machine Learning service](https://docs.microsoft.com/azure/machine-learning/service/overview-what-is-azure-ml) and deploy it to a web service. It demonstrates how to use the power of the cloud to manage data, switch to powerful GPU machines, and monitor runs while training a model. You can read more about recommenders on Azure Machine Learning service [here](https://azure.microsoft.com/en-us/blog/building-recommender-systems-with-azure-machine-learning-service/)\n\nIn this tutorial you will: \n- Connect to an Azure Machine Learning service workspace\n- Access movielens data from a datastore\n- Connect to CPU and GPU machines from [Azure Machine Learning Compute](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-set-up-training-targets#amlcompute)\n- Create a training script using the recommender repo's [util functions](https://github.com/Microsoft/Recommenders/tree/master/reco_utils) for SAR and add logging information\n- Submit the training job to AzureML, and monitor the run with a Jupyter widget\n- Test an existing model with new user data\n- **Optional part 2:** Deploy the model to a web service using Azure Container Instance. \n\n\n## Details of SAR\n    \nSAR is a fast scalable adaptive algorithm for personalized recommendations based on user transaction history. It produces easily explainable / interpretable recommendations and handles \"cold item\" and \"semi-cold user\" scenarios. SAR is a kind of neighborhood based algorithm (as discussed in [Recommender Systems by Aggarwal](https://dl.acm.org/citation.cfm?id=2931100)) which is intended for ranking top items for each user. \n\nSAR recommends items that are most ***similar*** to the ones that the user already has an existing ***affinity*** for. Two items are ***similar*** if the users who have interacted with one item are also likely to have interacted with another. A user has an ***affinity*** to an item if they have interacted with it in the past.\n\n### Advantages of SAR:\n- High accuracy for an easy to train and deploy algorithm\n- Fast training, only requiring simple counting to construct matrices used at prediction time. \n- Fast scoring, only involving multiplication of the similarity matric with an affinity vector\n---\n\n**Note: If you run into any issues, please try running `!pip install --upgrade azureml-sdk`**"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "import sys\nimport os\nimport shutil\nimport numpy as np\n\nfrom reco_utils.dataset import movielens\nfrom reco_utils.azureml.azureml_utils import get_or_create_workspace\n\nimport azureml\nfrom azureml.core import Workspace, Run, Experiment\nfrom azureml.core.compute import ComputeTarget, AmlCompute\nfrom azureml.train.estimator import Estimator\nfrom azureml.widgets import RunDetails",
      "execution_count": 1,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Connect to an AzureML workspace\n\nAn [AzureML Workspace](https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.workspace.workspace?view=azure-ml-py) is an Azure resource that organizes and coordinates the actions of many other Azure resources to assist in executing and sharing machine learning workflows. In particular, an Azure ML Workspace coordinates storage, databases, and compute resources providing added functionality for machine learning experimentation, deployment, inferencing, and the monitoring of deployed models.\n\nA workspace has already been created for you and a [configuration file](././home/nbuser/library/config.json). Simply load it with ```ws = Workspace.from_config()```. You may be asked to login. Please follow the prompts to \n\n**More information on creating your own workspace can be found in this [this tutorial](https://docs.microsoft.com/en-us/azure/machine-learning/service/setup-create-workspace#portal)."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "ws = Workspace.from_config()",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Found the config file in: /home/nbuser/library/config.json\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Visualize the data\n\nLet's take a look at the data itself. We use a sample of 100k data points from the Movielens dataset. This data has the UserId, MovieId, and Rating that a user provided, along with the timestamp and title of the movie."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# download dataset\ndata = movielens.load_pandas_df(\n    size='100k',\n    header=['UserId','MovieId','Rating','Timestamp'],\n    title_col='Title'\n)\ndata.head()",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": "4.93MB [00:01, 4.19MB/s]                            \n",
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "execution_count": 10,
          "data": {
            "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>UserId</th>\n      <th>MovieId</th>\n      <th>Rating</th>\n      <th>Timestamp</th>\n      <th>Title</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>196</td>\n      <td>242</td>\n      <td>3.0</td>\n      <td>881250949</td>\n      <td>Kolya (1996)</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>63</td>\n      <td>242</td>\n      <td>3.0</td>\n      <td>875747190</td>\n      <td>Kolya (1996)</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>226</td>\n      <td>242</td>\n      <td>5.0</td>\n      <td>883888671</td>\n      <td>Kolya (1996)</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>154</td>\n      <td>242</td>\n      <td>3.0</td>\n      <td>879138235</td>\n      <td>Kolya (1996)</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>306</td>\n      <td>242</td>\n      <td>5.0</td>\n      <td>876503793</td>\n      <td>Kolya (1996)</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
            "text/plain": "   UserId  MovieId  Rating  Timestamp         Title\n0     196      242     3.0  881250949  Kolya (1996)\n1      63      242     3.0  875747190  Kolya (1996)\n2     226      242     5.0  883888671  Kolya (1996)\n3     154      242     3.0  879138235  Kolya (1996)\n4     306      242     5.0  876503793  Kolya (1996)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#### Take some time to play with the data\nAbove we looked at the first 5 rows in the Movielens dataset. Spend some time looking at the rest of the data to understand it. \n\nHere are a few things you can try. For more, check out this [Python data science cheat sheet](https://s3.amazonaws.com/dq-blog-files/pandas-cheat-sheet.pdf)\n- `data.head(n)` | First n rows of the DataFrame\n- `data.tail(n)` | Last n rows of the DataFrame\n- `data.shape` | Number of rows and columns\n- `data.info()` | Index, Datatype and Memory information\n- `data.describe()` | Summary statistics for numerical columns\n- `data['Title'].value_counts(dropna=False)` | View unique values and counts\n- `data.groupby(\"Title\").agg(np.mean)` | Find the average across all columns for every unique Title"
    },
    {
      "metadata": {
        "slideshow": {
          "slide_type": "subslide"
        }
      },
      "cell_type": "markdown",
      "source": "### Access data from a datastore\n\nEvery workspace comes with a default [datastore](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-access-data) (and you can register more) which is backed by the Azure blob storage account associated with the workspace. We can use it to transfer data from local to the cloud, and access it from the compute target. The data files are uploaded into a directory named `data` at the root of the datastore.\n\nFor this lab, we have already downloaded the data and uploaded it to the datastore for you. Simply choose the data set size `100k`, `1m`, `10m`, or `20m`. \n\n**Note: For data sizes over 1m, you will need to utilize a GPU machine.**\n\n#### Running this lab at home?\n<details><summary> Learn how to do this on your own</summary>\n<p>\nOutside of this tutorial, you will need to run the following code to set up the datastore and upload the movielens dataset to it:\n</p>\n    \n```\nDATA_DIR = 'aml_data'\nTARGET_DIR = 'movielens'\nos.makedirs(DATA_DIR, exist_ok=True)\n# # download dataset\ndata = movielens.load_pandas_df(\n       size=MOVIELENS_DATA_SIZE,\n       header=['UserId','MovieId','Rating','Timestamp'],\n       title_col='Title'\n       )\n# # upload dataset to workspace datastore\ndata_file_name = \"movielens_\" + MOVIELENS_DATA_SIZE + \"_data.pkl\"\ndata.to_pickle(os.path.join(DATA_DIR, data_file_name))\nds = ws.get_default_datastore()\nds.upload(src_dir=DATA_DIR, target_path=TARGET_DIR, overwrite=True, show_progress=True) \n```\n</details>"
    },
    {
      "metadata": {
        "tags": [
          "parameters"
        ],
        "trusted": true
      },
      "cell_type": "code",
      "source": "# top k items to recommend\nTOP_K = 10\n\n# Select Movielens data size: 100k, 1m, 10m, or 20m\nMOVIELENS_DATA_SIZE = '100k'",
      "execution_count": 23,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "data_file_name = \"movielens_\" + MOVIELENS_DATA_SIZE + \"_data.pkl\"\nds = ws.get_default_datastore()",
      "execution_count": 24,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Create or Attach Azure Machine Learning Compute \n\nWe've created cpu and gpu clustesr as our **remote compute target**. You can read [Set up compute targets for model training](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-set-up-training-targets) to learn more about setting up compute targets on different locations. \nAccording to Azure [Pricing calculator](https://azure.microsoft.com/en-us/pricing/calculator/), with example VM size `STANDARD_D2_V2`, it costs a few dollars to run this notebook, which is well covered by Azure new subscription credit. For billing and pricing questions, please contact [Azure support](https://azure.microsoft.com/en-us/support/options/).\n\n**Note**:\n- 10m and 20m dataset requires more capacity than `STANDARD_D2_V2`, such as `STANDARD_NC6` or `STANDARD_NC12`. See list of all available VM sizes [here](https://docs.microsoft.com/en-us/azure/templates/Microsoft.Compute/2018-10-01/virtualMachines?toc=%2Fen-us%2Fazure%2Fazure-resource-manager%2Ftoc.json&bc=%2Fen-us%2Fazure%2Fbread%2Ftoc.json#hardwareprofile-object).\n- As with other Azure services, there are limits on certain resources (for eg. AmlCompute quota) associated with the Azure Machine Learning service. Please read [these instructions](https://docs.microsoft.com/en-us/azure/azure-supportability/resource-manager-core-quotas-request) on the default limits and how to request more quota.\n---\n#### Learn more about Azure Machine Learning Compute\n<details>\n    <summary>Click to learn more about compute types</summary>\n    \n[Azure Machine Learning Compute](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-set-up-training-targets#amlcompute) is managed compute infrastructure that allows the user to easily create single to multi-node compute of the appropriate VM Family. It is created within your workspace region and is a resource that can be used by other users in your workspace. It autoscales by default to the max_nodes, when a job is submitted, and executes in a containerized environment packaging the dependencies as specified by the user.\n\nSince it is managed compute, job scheduling and cluster management are handled internally by Azure Machine Learning service.\n\nYou can provision a persistent AmlCompute resource by simply defining two parameters thanks to smart defaults. By default it autoscales from 0 nodes and provisions dedicated VMs to run your job in a container. This is useful when you want to continously re-use the same target, debug it between jobs or simply share the resource with other users of your workspace.\n\nIn addition to vm_size and max_nodes, you can specify:\n- **min_nodes**: Minimum nodes (default 0 nodes) to downscale to while running a job on AmlCompute\n- **vm_priority**: Choose between 'dedicated' (default) and 'lowpriority' VMs when provisioning AmlCompute. Low Priority VMs use Azure's excess capacity and are thus cheaper but risk your run being pre-empted\n- **idle_seconds_before_scaledown**: Idle time (default 120 seconds) to wait after run completion before auto-scaling to min_nodes\n- **vnet_resourcegroup_name**: Resource group of the existing VNet within which AmlCompute should be provisioned\n- **vnet_name**: Name of VNet\n- **subnet_name**: Name of SubNet within the VNet\n\nTo create your own compute run the following code:\n\n```\nfrom azureml.core.compute import ComputeTarget, AmlCompute\nfrom azureml.core.compute_target import ComputeTargetException\n\n# Choose a name for your CPU cluster\ncpu_cluster_name = \"cpucluster\"\n\n# Verify that cluster does not exist already\ntry:\n    compute_target = ComputeTarget(workspace=ws, name=CLUSTER_NAME)\n    print('Found existing cluster, use it.')\nexcept ComputeTargetException:\n    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2',\n                                                           max_nodes=4)\n    compute_target = ComputeTarget.create(ws, CLUSTER_NAME, compute_config)\n\ncompute_target.wait_for_completion(show_output=True)\n```\n</details>\n---"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "CLUSTER_NAME = 'cpucluster'\n# CLUSTER_NAME = 'gpucluster'\n\ncompute_target = ComputeTarget(workspace=ws, name=CLUSTER_NAME)\nprint(\"Found existing compute target \\nName: \" + compute_target.name + \"\\nRegion:\" + compute_target.cluster_location)",
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Found existing compute target \nName: cpucluster\nRegion:eastus\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Prepare training script\n### 1. Create a directory\nCreate a directory that will contain all the necessary code from your local machine that you will need access to on the remote resource. This includes the training script, and any additional files your training script depends on."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "SCRIPT_FOLDER = './movielens-sar'\nos.makedirs(SCRIPT_FOLDER, exist_ok=True)",
      "execution_count": 26,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### 2.  Create a training script\nTo submit the job to the cluster, first create a training script. Run the following code to create the training script called `train.py` in the directory you just created. This training adds a regularization rate to the training algorithm, so produces a slightly different model than the local version.\n\nThis code takes what is in the local quickstart and convert it to one single training script. We use run.log() to record parameters to the run. We will be able to review and compare these measures in the Azure Portal at a later time."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "%%writefile $SCRIPT_FOLDER/train.py\n\nimport argparse\nimport os\nimport numpy as np\nimport pandas as pd\nimport itertools\nimport logging\nimport time\n\nfrom azureml.core import Run\nfrom sklearn.externals import joblib\n\nfrom reco_utils.dataset import movielens\nfrom reco_utils.dataset.python_splitters import python_random_split\nfrom reco_utils.evaluation.python_evaluation import map_at_k, ndcg_at_k, precision_at_k, recall_at_k\nfrom reco_utils.recommender.sar.sar_singlenode import SARSingleNode\n\nTARGET_DIR = 'movielens'\nOUTPUT_FILE_NAME = 'outputs/movielens_sar_model.pkl'\nMODEL_FILE_NAME = 'movielens_sar_model.pkl'\n\n# get hold of the current run\nrun = Run.get_context()\n\n# let user feed in 2 parameters, the location of the data files (from datastore), and the regularization rate of the logistic regression model\nparser = argparse.ArgumentParser()\nparser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point')\nparser.add_argument('--data-file', type=str, dest='data_file', help='data file name')\nparser.add_argument('--top-k', type=int, dest='top_k', default=10, help='top k items to recommend')\nparser.add_argument('--data-size', type=str, dest='data_size', default=10, help='Movielens data size: 100k, 1m, 10m, or 20m')\nargs = parser.parse_args()\n\nrun.log(\"top-k\",args.top_k)\nrun.log(\"data-size\", args.data_size)\ndata_pickle_path = os.path.join(args.data_folder, args.data_file)\n\ndata = pd.read_pickle(path=data_pickle_path)\n\ntrain, test = python_random_split(data,0.75)\n\n# instantiate the SAR algorithm and set the index\nheader = {\n    \"col_user\": \"UserId\",\n    \"col_item\": \"MovieId\",\n    \"col_rating\": \"Rating\",\n    \"col_timestamp\": \"Timestamp\",\n}\n\nlogging.basicConfig(level=logging.DEBUG, \n                    format='%(asctime)s %(levelname)-8s %(message)s')\n\nmodel = SARSingleNode(\n    remove_seen=True, similarity_type=\"jaccard\", \n    time_decay_coefficient=30, time_now=None, timedecay_formula=True, **header\n)\n\n# train the SAR model\nstart_time = time.time()\n\nmodel.fit(train)\n\ntrain_time = time.time() - start_time\nrun.log(name=\"Training time\", value=train_time)\n\nstart_time = time.time()\n\ntop_k = model.recommend_k_items(test)\n\ntest_time = time.time() - start_time\nrun.log(name=\"Prediction time\", value=test_time)\n\n# TODO: remove this call when the model returns same type as input\ntop_k['UserId'] = pd.to_numeric(top_k['UserId'])\ntop_k['MovieId'] = pd.to_numeric(top_k['MovieId'])\n\n# evaluate\neval_map = map_at_k(test, top_k, col_user=\"UserId\", col_item=\"MovieId\", \n                    col_rating=\"Rating\", col_prediction=\"prediction\", \n                    relevancy_method=\"top_k\", k=args.top_k)\neval_ndcg = ndcg_at_k(test, top_k, col_user=\"UserId\", col_item=\"MovieId\", \n                      col_rating=\"Rating\", col_prediction=\"prediction\", \n                      relevancy_method=\"top_k\", k=args.top_k)\neval_precision = precision_at_k(test, top_k, col_user=\"UserId\", col_item=\"MovieId\", \n                                col_rating=\"Rating\", col_prediction=\"prediction\", \n                                relevancy_method=\"top_k\", k=args.top_k)\neval_recall = recall_at_k(test, top_k, col_user=\"UserId\", col_item=\"MovieId\", \n                          col_rating=\"Rating\", col_prediction=\"prediction\", \n                          relevancy_method=\"top_k\", k=args.top_k)\n\nrun.log(\"map\", eval_map)\nrun.log(\"ndcg\", eval_ndcg)\nrun.log(\"precision\", eval_precision)\nrun.log(\"recall\", eval_recall)\n# run.log_table(\"topk\", top_k.to_dict())\n\n# automatic upload of everything in ./output folder doesn't work for very large model file\n# model file has to be saved to a temp location, then uploaded by upload_file function\njoblib.dump(value=model, filename=MODEL_FILE_NAME)\n\nrun.upload_file(OUTPUT_FILE_NAME, MODEL_FILE_NAME)",
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Overwriting ./movielens-sar/train.py\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### 3. Copy the reco_utils\nYou will need to copy the utility functions over for the project directory as well so that the training script can access them."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# copy dependent python files\nUTILS_DIR = './movielens-sar/reco_utils/'\n# use ignore_errors=True in case the directory already exists from a previous run\nshutil.rmtree(UTILS_DIR, ignore_errors=True)\nshutil.copytree('reco_utils/', UTILS_DIR)",
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 28,
          "data": {
            "text/plain": "'./movielens-sar/reco_utils/'"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Run training script\n### 1. Create an estimator\nAn [estimator](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-train-ml-models) object is used to submit the run. You can create and use a generic Estimator to submit a training script using any learning framework you choose (such as scikit-learn) you want to run on any compute target, whether it's your local machine, a single VM in Azure, or a GPU cluster in Azure. \n\nCreate your estimator by running the following code to define:  \n* The name of the estimator object, `est`\n* The directory that contains your scripts. All the files in this directory are uploaded into the cluster nodes for execution. \n* The compute target.  In this case you will use the AmlCompute already created. You can switch between the cpu and gpu machines.\n* The training script name, train.py\n* Parameters required from the training script \n* Python packages needed for training\n* Connect to the data files in the datastore\n\nIn this tutorial, this target is AmlCompute. All files in the script folder are uploaded into the cluster nodes for execution. `ds.as_mount()` mounts a datastore on the remote compute and returns the folder. See documentation [here](https://docs.microsoft.com/en-us/azure/machine-learning/service/how-to-access-data#access-datastores-during-training)."
    },
    {
      "metadata": {
        "tags": [
          "configure estimator"
        ],
        "trusted": true
      },
      "cell_type": "code",
      "source": "script_params = {\n    '--data-folder': ds.as_mount(),\n    '--data-file': 'movielens/' + data_file_name,\n    '--top-k': TOP_K,\n    '--data-size': MOVIELENS_DATA_SIZE\n}\n\nest = Estimator(source_directory=SCRIPT_FOLDER,\n                script_params=script_params,\n                compute_target=compute_target,\n                entry_script='train.py',\n                conda_packages=['pandas', 'tqdm'],\n                pip_packages=['sklearn'],\n                use_gpu=False)",
      "execution_count": 29,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### 2. Submit the job to the cluster\nAn [experiment](https://docs.microsoft.com/en-us/python/api/overview/azure/ml/intro?view=azure-ml-py#experiment) is a logical container in an AzureML Workspace. It hosts run records which can include run metrics and output artifacts from your experiments. We access an experiment from our AzureML workspace by name, which will be created if it doesn't exist.\n\nThen, run the experiment by submitting the estimator object.\n\n#### Monitor and view the results\n\nYou can monitor the remote run with a Jupyter widget. The widget watches the progress of the run. Like the run submission, the widget is asynchronous and provides live updates every 10-15 seconds until the job completes.\n\nYou can click the link at the bottom of the widget to view all the details of the run in the Azure Portal. \n\nWhen the run is complete, you can view the metrics with `run.get_metrics()`."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# create experiment\nEXPERIMENT_NAME = 'movielens-sar'\nexp = Experiment(workspace=ws, name=EXPERIMENT_NAME)\n\nrun = exp.submit(config=est)\nRunDetails(run).show()",
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "3d7828e4514c42b49191aeb95e12803a",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": "_UserRunWidget(widget_settings={'childWidgetDisplay': 'popup', 'send_telemetry': False, 'log_level': 'INFO', '…"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "run.wait_for_completion()",
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 31,
          "data": {
            "text/plain": "{'runId': 'movielens-sar_1556835154_3063adc6',\n 'target': 'cpucluster',\n 'status': 'Finalizing',\n 'startTimeUtc': '2019-05-02T22:14:46.831402Z',\n 'properties': {'azureml.runsource': 'experiment',\n  'AzureML.DerivedImageName': 'azureml/azureml_84ff80366a174fee5d7bb70637ad1d55',\n  'ContentSnapshotId': '5442c926-d519-4bb9-beca-b0188cad1308'},\n 'runDefinition': {'script': 'train.py',\n  'arguments': ['--data-folder',\n   '$AZUREML_DATAREFERENCE_workspaceblobstore',\n   '--data-file',\n   'movielens/movielens_100k_data.pkl',\n   '--top-k',\n   '10',\n   '--data-size',\n   '100k'],\n  'sourceDirectoryDataStore': None,\n  'framework': 'Python',\n  'communicator': 'None',\n  'target': 'cpucluster',\n  'dataReferences': {'workspaceblobstore': {'dataStoreName': 'workspaceblobstore',\n    'mode': 'Mount',\n    'pathOnDataStore': None,\n    'pathOnCompute': None,\n    'overwrite': False}},\n  'jobName': None,\n  'autoPrepareEnvironment': True,\n  'maxRunDurationSeconds': None,\n  'nodeCount': 1,\n  'environment': {'name': 'Experiment movielens-sar Environment',\n   'version': 'Autosave_2019-05-02T22:07:20Z_ec4d8ee6',\n   'python': {'interpreterPath': 'python',\n    'userManagedDependencies': False,\n    'condaDependencies': {'name': 'project_environment',\n     'dependencies': ['python=3.6.2',\n      {'pip': ['azureml-defaults', 'sklearn']},\n      'pandas',\n      'tqdm']},\n    'baseCondaEnvironment': None},\n   'environmentVariables': {'EXAMPLE_ENV_VAR': 'EXAMPLE_VALUE'},\n   'docker': {'baseImage': 'mcr.microsoft.com/azureml/base:0.2.2',\n    'enabled': True,\n    'sharedVolumes': True,\n    'preparation': None,\n    'gpuSupport': False,\n    'shmSize': '1g',\n    'arguments': [],\n    'baseImageRegistry': {'address': None,\n     'username': None,\n     'password': None}},\n   'spark': {'repositories': ['https://mmlspark.azureedge.net/maven'],\n    'packages': [{'group': 'com.microsoft.ml.spark',\n      'artifact': 'mmlspark_2.11',\n      'version': '0.12'}],\n    'precachePackages': True}},\n  'history': {'outputCollection': True, 'snapshotProject': True},\n  'spark': {'configuration': {'spark.app.name': 'Azure ML Experiment',\n    'spark.yarn.maxAppAttempts': '1'}},\n  'amlCompute': {'name': None,\n   'vmSize': None,\n   'vmPriority': None,\n   'retainCluster': False,\n   'clusterMaxNodeCount': 1},\n  'tensorflow': {'workerCount': 1, 'parameterServerCount': 1},\n  'mpi': {'processCountPerNode': 1},\n  'hdi': {'yarnDeployMode': 'Cluster'},\n  'containerInstance': {'region': None, 'cpuCores': 2, 'memoryGb': 3.5},\n  'exposedPorts': None},\n 'logFiles': {'azureml-logs/60_control_log.txt': 'https://pyconazureml3674024112.blob.core.windows.net/azureml/ExperimentRun/dcid.movielens-sar_1556835154_3063adc6/azureml-logs/60_control_log.txt?sv=2018-03-28&sr=b&sig=SIWtuhpociKFeJIlOwyUPLA6I7CSjFahvMlms1IiaUY%3D&st=2019-05-02T22%3A05%3A06Z&se=2019-05-03T06%3A15%3A06Z&sp=r',\n  'azureml-logs/80_driver_log.txt': 'https://pyconazureml3674024112.blob.core.windows.net/azureml/ExperimentRun/dcid.movielens-sar_1556835154_3063adc6/azureml-logs/80_driver_log.txt?sv=2018-03-28&sr=b&sig=9Rdjl38%2B4NCZB%2FpRSy9H%2F9HUKW10SnXwU5REJPrNDQc%3D&st=2019-05-02T22%3A05%3A06Z&se=2019-05-03T06%3A15%3A06Z&sp=r',\n  'azureml-logs/azureml.log': 'https://pyconazureml3674024112.blob.core.windows.net/azureml/ExperimentRun/dcid.movielens-sar_1556835154_3063adc6/azureml-logs/azureml.log?sv=2018-03-28&sr=b&sig=ufLKFvdfyejFflftFK4o33dfalWY3EaFl0AiD%2FaslnI%3D&st=2019-05-02T22%3A05%3A06Z&se=2019-05-03T06%3A15%3A06Z&sp=r'}}"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Test the Model locally\n\nWe can download the model from the run and test it locally. Below we view the popular items based on User Ratings. We can also as well as enter new data to find most similar items. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "from sklearn.externals import joblib\nrun.download_file('outputs/movielens_sar_model.pkl')\nmodelTest =joblib.load('movielens_sar_model.pkl')",
      "execution_count": 32,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "scrolled": true
      },
      "cell_type": "code",
      "source": "modelTest.get_popularity_based_topk(top_k = 30, sort_top_k=True).join(data[['MovieId', 'Title']].drop_duplicates().set_index('MovieId'), \n                                on='MovieId', \n                                how='inner')",
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 33,
          "data": {
            "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>MovieId</th>\n      <th>prediction</th>\n      <th>Title</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>50</td>\n      <td>442.0</td>\n      <td>Star Wars (1977)</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>258</td>\n      <td>389.0</td>\n      <td>Contact (1997)</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>100</td>\n      <td>386.0</td>\n      <td>Fargo (1996)</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>294</td>\n      <td>369.0</td>\n      <td>Liar Liar (1997)</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>181</td>\n      <td>363.0</td>\n      <td>Return of the Jedi (1983)</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>286</td>\n      <td>356.0</td>\n      <td>English Patient, The (1996)</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>288</td>\n      <td>355.0</td>\n      <td>Scream (1996)</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>1</td>\n      <td>354.0</td>\n      <td>Toy Story (1995)</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>121</td>\n      <td>322.0</td>\n      <td>Independence Day (ID4) (1996)</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>300</td>\n      <td>322.0</td>\n      <td>Air Force One (1997)</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>174</td>\n      <td>310.0</td>\n      <td>Raiders of the Lost Ark (1981)</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>98</td>\n      <td>308.0</td>\n      <td>Silence of the Lambs, The (1991)</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>127</td>\n      <td>306.0</td>\n      <td>Godfather, The (1972)</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>117</td>\n      <td>290.0</td>\n      <td>Rock, The (1996)</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>237</td>\n      <td>284.0</td>\n      <td>Jerry Maguire (1996)</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>56</td>\n      <td>284.0</td>\n      <td>Pulp Fiction (1994)</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>7</td>\n      <td>282.0</td>\n      <td>Twelve Monkeys (1995)</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>222</td>\n      <td>282.0</td>\n      <td>Star Trek: First Contact (1996)</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>172</td>\n      <td>281.0</td>\n      <td>Empire Strikes Back, The (1980)</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>79</td>\n      <td>264.0</td>\n      <td>Fugitive, The (1993)</td>\n    </tr>\n    <tr>\n      <th>20</th>\n      <td>313</td>\n      <td>262.0</td>\n      <td>Titanic (1997)</td>\n    </tr>\n    <tr>\n      <th>21</th>\n      <td>405</td>\n      <td>251.0</td>\n      <td>Mission: Impossible (1996)</td>\n    </tr>\n    <tr>\n      <th>22</th>\n      <td>204</td>\n      <td>250.0</td>\n      <td>Back to the Future (1985)</td>\n    </tr>\n    <tr>\n      <th>23</th>\n      <td>151</td>\n      <td>250.0</td>\n      <td>Willy Wonka and the Chocolate Factory (1971)</td>\n    </tr>\n    <tr>\n      <th>24</th>\n      <td>168</td>\n      <td>244.0</td>\n      <td>Monty Python and the Holy Grail (1974)</td>\n    </tr>\n    <tr>\n      <th>25</th>\n      <td>173</td>\n      <td>243.0</td>\n      <td>Princess Bride, The (1987)</td>\n    </tr>\n    <tr>\n      <th>26</th>\n      <td>210</td>\n      <td>242.0</td>\n      <td>Indiana Jones and the Last Crusade (1989)</td>\n    </tr>\n    <tr>\n      <th>27</th>\n      <td>269</td>\n      <td>241.0</td>\n      <td>Full Monty, The (1997)</td>\n    </tr>\n    <tr>\n      <th>28</th>\n      <td>423</td>\n      <td>239.0</td>\n      <td>E.T. the Extra-Terrestrial (1982)</td>\n    </tr>\n    <tr>\n      <th>29</th>\n      <td>257</td>\n      <td>239.0</td>\n      <td>Men in Black (1997)</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
            "text/plain": "    MovieId  prediction                                         Title\n0        50       442.0                              Star Wars (1977)\n1       258       389.0                                Contact (1997)\n2       100       386.0                                  Fargo (1996)\n3       294       369.0                              Liar Liar (1997)\n4       181       363.0                     Return of the Jedi (1983)\n5       286       356.0                   English Patient, The (1996)\n6       288       355.0                                 Scream (1996)\n7         1       354.0                              Toy Story (1995)\n8       121       322.0                 Independence Day (ID4) (1996)\n9       300       322.0                          Air Force One (1997)\n10      174       310.0                Raiders of the Lost Ark (1981)\n11       98       308.0              Silence of the Lambs, The (1991)\n12      127       306.0                         Godfather, The (1972)\n13      117       290.0                              Rock, The (1996)\n14      237       284.0                          Jerry Maguire (1996)\n15       56       284.0                           Pulp Fiction (1994)\n16        7       282.0                         Twelve Monkeys (1995)\n17      222       282.0               Star Trek: First Contact (1996)\n18      172       281.0               Empire Strikes Back, The (1980)\n19       79       264.0                          Fugitive, The (1993)\n20      313       262.0                                Titanic (1997)\n21      405       251.0                    Mission: Impossible (1996)\n22      204       250.0                     Back to the Future (1985)\n23      151       250.0  Willy Wonka and the Chocolate Factory (1971)\n24      168       244.0        Monty Python and the Holy Grail (1974)\n25      173       243.0                    Princess Bride, The (1987)\n26      210       242.0     Indiana Jones and the Last Crusade (1989)\n27      269       241.0                        Full Monty, The (1997)\n28      423       239.0             E.T. the Extra-Terrestrial (1982)\n29      257       239.0                           Men in Black (1997)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Test out an existing webservice \n\nWe just saw what the most popular rated movies were for the MovieLens dataset. Now let's try adding our own data and get the most similar movies based on the similarity matrix fit during training.\n\nYou will walk through rating 5 popular movies and will then call an existing webservice trained on 100k dataset to see what the most similar movies are."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "%run existing-widget.ipynb",
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "a54f5584bdfa4c609c1f0edfdf825434",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": "Label(value='Here are the recommended movies based on your ratings.', style=DescriptionStyle(description_width…"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>MovieId</th>\n      <th>UserId</th>\n      <th>prediction</th>\n      <th>Title</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>50</td>\n      <td>0</td>\n      <td>4.768659</td>\n      <td>Star Wars (1977)</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>174</td>\n      <td>0</td>\n      <td>4.622387</td>\n      <td>Raiders of the Lost Ark (1981)</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>172</td>\n      <td>0</td>\n      <td>4.573981</td>\n      <td>Empire Strikes Back, The (1980)</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>181</td>\n      <td>0</td>\n      <td>4.544265</td>\n      <td>Return of the Jedi (1983)</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>79</td>\n      <td>0</td>\n      <td>4.511800</td>\n      <td>Fugitive, The (1993)</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>121</td>\n      <td>0</td>\n      <td>4.502742</td>\n      <td>Independence Day (ID4) (1996)</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>98</td>\n      <td>0</td>\n      <td>4.411063</td>\n      <td>Silence of the Lambs, The (1991)</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>1</td>\n      <td>0</td>\n      <td>4.405902</td>\n      <td>Toy Story (1995)</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>69</td>\n      <td>0</td>\n      <td>4.343179</td>\n      <td>Forrest Gump (1994)</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>204</td>\n      <td>0</td>\n      <td>4.331141</td>\n      <td>Back to the Future (1985)</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
            "text/plain": "   MovieId  UserId  prediction                             Title\n0       50       0    4.768659                  Star Wars (1977)\n1      174       0    4.622387    Raiders of the Lost Ark (1981)\n2      172       0    4.573981   Empire Strikes Back, The (1980)\n3      181       0    4.544265         Return of the Jedi (1983)\n4       79       0    4.511800              Fugitive, The (1993)\n5      121       0    4.502742     Independence Day (ID4) (1996)\n6       98       0    4.411063  Silence of the Lambs, The (1991)\n7        1       0    4.405902                  Toy Story (1995)\n8       69       0    4.343179               Forrest Gump (1994)\n9      204       0    4.331141         Back to the Future (1985)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Congrats! You're finished with the lab!\nYou can go through and change the data set sizes and cpu vs gpu clusters to test out different models.\n\n## Optional part 2: Deploy the model to a web service\nOpen the [deploy_with_azureml.ipynb](deploy_with_azureml.ipynb) notebook to deploy this model to a web service. "
    }
  ],
  "metadata": {
    "celltoolbar": "Tags",
    "kernelspec": {
      "name": "python36",
      "display_name": "Python 3.6",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.6",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}