03_Personalizer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Setup Personalizer Resource\n",
        "\n",
        "In the next step, we setup and tune an Azure Personalizer Resource to prioritize the recommendations for individual users based on envinonrmental context and user preferences.\n",
        "\n",
        "First, you must setup the Azure Personalizer Resource you will use by completing the following steps.\n",
        "\n",
        "\n",
        "**1.** Create an [Azure Personalizer Resource](https://ms.portal.azure.com/#create/Microsoft.CognitiveServicesPersonalizer). **NOTE:** If you have already have a Personalizer resource you want to reuse, make sure to clear the data in the Azure portal for the resource, following these [instructions](https://docs.microsoft.com/en-us/azure/cognitive-services/personalizer/how-to-manage-model#clear-data-for-your-learning-loop).\n",
        "\n",
        "**NOTE:** The \"Free F0\" Pricing Tier will be sufficient for this example.\n",
        "\n",
        "**2.** Go to the **Setup** page on your Personalizer resource in the Azure Portal and set the reward wait time of **10 minutes** as described [here](https://docs.microsoft.com/en-us/azure/cognitive-services/personalizer/how-to-settings#configure-rewards-for-the-feedback-loop) and the update model frequency setting to **15 seconds** as described [here](https://docs.microsoft.com/en-us/azure/cognitive-services/personalizer/how-to-settings#configure-model-update-frequency-for-model-training).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "# Simulation Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "When Personalizer is intialized, the suggestions are only successful between 20% to 30% of the time (indicated by the reward score of 1 meaning the suggestion matched the user's preference). After running many requests, the system improves.  This notebook simulates users interacting with a website to select groceries to purchase (10,000 orders are simulated) to prepare the Personalizer to make suggestions for our grocery customers. \n",
        "\n",
        "We will also show that we can run an offline evaluation based on the results of the simulations. This allows Personalizer to review the data and suggest a better learning policy. Then we will apply the new learning policy and run the notebook again with 4,000 requests and see if the loop performs better.\n",
        "\n",
        "This notebook is based off this [tutorial](https://docs.microsoft.com/en-us/azure/cognitive-services/personalizer/tutorial-use-azure-notebook-generate-loop-data).  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**How the simulation works**\n",
        "\n",
        "For setting up the simulation, we selected a set of recommendations from the \"Popular\" results of our Intelligent Recommendations service.  You can choose to use any of the recommendation dataset options, but limit the results to 50 or less items for use in Personalizer.    We have generated a sample set of foods and customer preferences for use in this example.\n",
        "\n",
        "In this notebook we will create a Personalizer loop _system_ which suggests a food based on the customers (eaters) and their preferences which are stored in a [customers dataset](data/eaters.json). Information about the foods available in a [foods dataset](data/foods.json).\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "A summary of the customer information is:\n",
        "\n",
        "|Customer Name|Weather|Flavor|\n",
        "|--|--|--|\n",
        "|Alice<br>Bob<br>Cathy<br>Dave|Sunny<br>Rainy<br>Snowy|Salty<br>Sweet<br>Plain| \n",
        "\n",
        "To help Personalizer make the correct food selection for each person, the system also knows details about the foods.\n",
        "\n",
        "|Temperature|Flavor Profile|Texture|Meal|\n",
        "|--|--|--|--|\n",
        "|Hot<br>Cold|Sweet<br>Savory|Crunchy<br>Soft<br>|Snack<br>Dessert|\n",
        "\n",
        "The purpose of the Personalizer loop is to find the best match between the customers and the foods they like as much of the time as possible. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Rank and reward calls**\n",
        "\n",
        "For each of the few thousand calls to the Personalizer service makes in our loop, the Azure notebook sends the **Rank** request to the REST API:\n",
        "\n",
        "* A unique ID for the Rank/Request event\n",
        "* Context - A random choice of the user, weather, and flavor desired - simulating a user on a website or mobile device looking for a purchase suggestion.\n",
        "* Features - _All_ the food data - from which Personalizer makes a suggestion\n",
        "\n",
        "The system receives the rank of the food choices, then compares that prediction with the customer's known choice for the same weather and flavor preference. If the known choice is the same as the predicted choice, the **Reward** of 1 is sent back to Personalizer. Otherwise the reward is 0. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Include the python modules**\n",
        "\n",
        "Include the required python modules."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "gather": {
          "logged": 1675376847927
        }
      },
      "outputs": [],
      "source": [
        "import json\n",
        "import matplotlib.pyplot as plt\n",
        "import random \n",
        "import requests\n",
        "import time\n",
        "import uuid\n",
        "import datetime"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Set Personalizer resource key and name**\n",
        "\n",
        "From the Azure portal, find your key and endpoint on the **Overview** page of your Personalizer resource. Change the value of `Your_Personalizer_url` to your Personalizer's Endpoint. Change the value of `Your_Personalizer_ResourceKey` to your Personalizer key (Go to \"Manage Keys\" and copy on of the values). "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "gather": {
          "logged": 1675376848213
        }
      },
      "outputs": [],
      "source": [
        "# Replace 'personalization_base_url' and 'resource_key' with your valid endpoint values.  You can view these from the Personalizer Resource Azure Portal Page.\n",
        "personalization_base_url = \"Your_Personalizer_url\"  \n",
        "resource_key = \"Your_Personalizer_ResourceKey\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Function: Current Date Time\n",
        "\n",
        "This function is used to note the start and end times of the iterative function, `iterations`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "gather": {
          "logged": 1675376848391
        }
      },
      "outputs": [],
      "source": [
        "# Print out current datetime\n",
        "def currentDateTime():\n",
        "    currentDT = datetime.datetime.now()\n",
        "    print (str(currentDT))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Function: Model Updated\n",
        "\n",
        "The `get_last_updated` function prints out the last modified date and time that the model was updated. \n",
        "\n",
        "The function uses a GET REST API to [get model properties](https://westus2.dev.cognitive.microsoft.com/docs/services/personalizer-api/operations/GetModelProperties). "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "gather": {
          "logged": 1675376848895
        }
      },
      "outputs": [],
      "source": [
        "# ititialize variable for model's last modified date\n",
        "modelLastModified = \"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "gather": {
          "logged": 1675376849079
        }
      },
      "outputs": [],
      "source": [
        "def get_last_updated(currentModifiedDate):\n",
        "    \n",
        "    print('-----checking model')\n",
        "    \n",
        "    # get model properties\n",
        "    response = requests.get(personalization_model_properties_url, headers = headers, params = None)\n",
        "    \n",
        "    print(response)\n",
        "    print(response.json())\n",
        "    \n",
        "    # get lastModifiedTime\n",
        "    lastModifiedTime = json.dumps(response.json()[\"lastModifiedTime\"])\n",
        "    \n",
        "    if (currentModifiedDate != lastModifiedTime):\n",
        "        currentModifiedDate = lastModifiedTime\n",
        "        print(f'-----model updated: {lastModifiedTime}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Function: Service Settings\n",
        "\n",
        "This function validates and returns the state of the service.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "gather": {
          "logged": 1675376849279
        }
      },
      "outputs": [],
      "source": [
        "def get_service_settings():\n",
        "    \n",
        "    print('-----checking service settings')\n",
        "    \n",
        "    # get learning policy\n",
        "    response = requests.get(personalization_model_policy_url, headers = headers, params = None)\n",
        "    \n",
        "    print(response)\n",
        "    print(response.json())\n",
        "    \n",
        "    # get service settings\n",
        "    response = requests.get(personalization_service_configuration_url, headers = headers, params = None)\n",
        "    \n",
        "    print(response)\n",
        "    print(response.json())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Construct URLs & Load Data\n",
        "\n",
        "Construct URLs for REST calls and read JSON data files to setup the customers and foods we will use in the simulation.\n",
        "\n",
        "The steps are:\n",
        "* build the URLs used for all API calls\n",
        "* sets the security header using your Personalizer resource key \n",
        "* sets the random seed for the Rank event ID\n",
        "* reads in the JSON data files\n",
        "* calls `get_last_updated` method - learning policy has been removed in example output\n",
        "* calls `get_service_settings` method\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1675376849606
        },
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "# build URLs\n",
        "personalization_rank_url = personalization_base_url + \"personalizer/v1.0/rank\"\n",
        "personalization_reward_url = personalization_base_url + \"personalizer/v1.0/events/\" #add \"{eventId}/reward\"\n",
        "personalization_model_properties_url = personalization_base_url + \"personalizer/v1.0/model/properties\"\n",
        "personalization_model_policy_url = personalization_base_url + \"personalizer/v1.0/configurations/policy\"\n",
        "personalization_service_configuration_url = personalization_base_url + \"personalizer/v1.0/configurations/service\"\n",
        "headers = {'Ocp-Apim-Subscription-Key' : resource_key, 'Content-Type': 'application/json'}\n",
        "\n",
        "# load user context (our customers' preferences)\n",
        "users = \"data/eaters.json\"\n",
        "\n",
        "# action features (the food choices available)\n",
        "snacks = \"data/foods.json\"\n",
        "\n",
        "# empty JSON for Rank request\n",
        "requestpath = \"data/example-rankrequest.json\"\n",
        "\n",
        "# initialize random\n",
        "random.seed(time.time())\n",
        "\n",
        "userpref = None \n",
        "rankactionsjsonobj = None \n",
        "actionfeaturesobj = None\n",
        "\n",
        "with open(users) as handle:\n",
        "    userpref = json.loads(handle.read())\n",
        "\n",
        "with open(snacks) as handle:\n",
        "    actionfeaturesobj = json.loads(handle.read())\n",
        "    \n",
        "with open(requestpath) as handle:\n",
        "    rankactionsjsonobj = json.loads(handle.read())  \n",
        "    \n",
        "get_last_updated(modelLastModified)\n",
        "get_service_settings()\n",
        "\n",
        "print(f'Customer count {len(userpref)}')\n",
        "print(f'Food count {len(actionfeaturesobj)}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Confirm first REST calls**\n",
        "\n",
        "This previous cell is the first cell that calls out to Personalizer. \n",
        "\n",
        "Make sure the REST status code in the output is `<Response [200]>`. If you get an error, such as 404, but you are sure your resource key and name are correct, reload the notebook.\n",
        "\n",
        "Verify that the output's `rewardWaitTime` and `modelExportFrequency` are both set to 15 seconds. \n",
        "\n",
        "Also, Make sure the count of customers and foods are both 4. If you get an error, check that you uploaded all 3 JSON files. \n",
        "    \n",
        "```console\n",
        "<Response [200]>\n",
        "{'rewardWaitTime': 'PT10M', 'defaultReward': 0.0, 'rewardAggregation': 'earliest', 'explorationPercentage': 0.2, 'modelExportFrequency': 'PT15S', 'logRetentionDays': 90, 'lastConfigurationEditDate': '2022-07-12T16:40:44', 'learningMode': 'Online'}\n",
        "Customer count 4\n",
        "Food count 4\n",
        "\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Set up a metric chart\n",
        "\n",
        "Later in this tutorial, the long running process of 10,000 requests is visible from the browser with an updating text box. It may be easier to see in a chart or as a total sum, when the long running process ends. To view this information, use the metrics provided with the resource. You can create the chart now that you have completed a request to the service, then refresh the chart periodically while the long running process is going.\n",
        "\n",
        "1. In the Azure portal, select your Personalizer resource.\n",
        "1. In the resource navigation, select **Metrics** underneath Monitoring. \n",
        "1. In the chart, select **Add metric**.\n",
        "1. The resource and metric namespace are already set. You only need to select the metric of **successful calls** and the aggregation of **sum**.\n",
        "1. Change the time filter to the last 4 hours.\n",
        "\n",
        "    You should see three successful calls in the chart. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Function: Generate Unique Event ID\n",
        "\n",
        "This function generates a unique ID for each rank call. The ID is used to identify the rank and reward call information. This value could come from a business process such as a web view ID or transaction ID."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "gather": {
          "logged": 1675376849807
        }
      },
      "outputs": [],
      "source": [
        "def add_event_id(rankjsonobj):\n",
        "    eventid = uuid.uuid4().hex\n",
        "    rankjsonobj[\"eventId\"] = eventid\n",
        "    return eventid"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "## Function: Randomly Choose Customer, Weather, Flavor\n",
        "\n",
        "This function selects a customer, the weather, and a flavor preference, then adds those items to the JSON object to send to the Rank request.\n",
        "\n",
        "**NOTE:** If you modify the number of users, preferences, what the preference are, update this function.\n",
        "\n",
        "A sample of the customers and their preferences is shown here - only some preferences are shown for brevity.\n",
        "\n",
        "```json\n",
        "{\n",
        "  \"Alice\": {\n",
        "    \"Sunny\": {\n",
        "      \"Plain\": \"ice cream\",\n",
        "      \"Salty\": \"sliced cheese\",\n",
        "      \"Sweet\": \"ice cream\"\n",
        "    }, ...\n",
        "  },\n",
        "    \"Bob\": {\n",
        "    \"Sunny\": {\n",
        "      \"Plain\": \"cocoa drinks\",\n",
        "      \"Salty\": \"sliced cheese\",\n",
        "      \"Sweet\": \"ice cream\"\n",
        "    }, ...\n",
        "  }\n",
        "  \"Cathy\": {\n",
        "    \"Sunny\": {\n",
        "      \"Plain\": \"popcorn\",\n",
        "      \"Salty\": \"ice cream\",\n",
        "      \"Sweet\": \"cocoa drinks\"\n",
        "    }..\n",
        "  }\n",
        "}\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "gather": {
          "logged": 1675376850154
        }
      },
      "outputs": [],
      "source": [
        "def add_random_user_and_contextfeatures(namesoption, flavoroption, weatheroption, rankjsonobj):   \n",
        "    name = namesoption[random.randint(0,3)]  # we have 4 users to select from randomly\n",
        "    flavor = flavoroption[random.randint(0,2)]  # we have 3 flavor choices\n",
        "    weather = weatheroption[random.randint(0,2)]  # we have 3 weather options\n",
        "    rankjsonobj['contextFeatures'] = [{'weather': weather, 'flavor': flavor, 'name': name}]\n",
        "    return [name, flavor, weather]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "## Function: Add Foods to Rank Request\n",
        "\n",
        "This function adds the list of foods to the JSON object (`rankjsonobj`) to send to the Rank request. \n",
        "\n",
        "An example of a single food item's features is: \n",
        "\n",
        "```json\n",
        "\n",
        "    {\n",
        "      \"id\": \"popcorn\",\n",
        "      \"features\": [\n",
        "        {\n",
        "          \"type\": \"hot\",\n",
        "          \"meal\": \"snack\",\n",
        "          \"texture\": \"crunchy\",\n",
        "          \"flavor\": \"savory\"\n",
        "            \n",
        "        }\n",
        "      ]\n",
        "    }\n",
        "\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "gather": {
          "logged": 1675376850622
        }
      },
      "outputs": [],
      "source": [
        "def add_action_features(rankjsonobj):\n",
        "    rankjsonobj[\"actions\"] = actionfeaturesobj"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "## Function: Get Reward"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This function is called after the Rank API is called, for each iteration.  It will compare the Rank API's prediction with known customer preferences (based on weather and flavor choice) to determine what Reward should be given (1 if it matches, 0 if it doesn't)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "gather": {
          "logged": 1675376850937
        }
      },
      "outputs": [],
      "source": [
        "def get_reward_from_simulated_data(name, weather, flavor, prediction):\n",
        "    if(userpref[name][weather][flavor] == str(prediction)):\n",
        "        return 1 \n",
        "    return 0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Function: Iterations\n",
        "\n",
        "The Iterations function runs the simulation by looping through calls to Rank and Reward as many times as configured (10,000 in this example).\n",
        "\n",
        "The Iterations function does the following:\n",
        "\n",
        "1.  Select a random Customer \n",
        "2.  Get the food list\n",
        "3.  Send the customer and food list to the Rank API. \n",
        "4.  Compares the prediction returned by the Rank API with the customer's known preferences and determines the reward (1 if it matches, 0 if not) \n",
        "5.  Send the reward score back to the Personalizer service. \n",
        "\n",
        "The loop runs for `num_requests` times - Personalizer needs a few thousand calls to Rank and Reward to create a model. \n",
        "\n",
        "**NOTE:** If changing the preference names, or adding/removing any, this function should be modified.\n",
        "\n",
        "An example of the JSON sent to the Rank API follows. The list of foods (actions) is not complete, for brevity, but all are sent. You can see the entire JSON for foods in `foods.json`.\n",
        "\n",
        "```json\n",
        "{\n",
        "\t'contextFeatures': [\n",
        "\t\t{\n",
        "\t\t\t'weather': 'Rainy', \n",
        "\t\t\t'flavor': 'Salty', \n",
        "\t\t\t'name': 'Dave'\n",
        "\t\t}\n",
        "\t], \n",
        "\t'actions': [\n",
        "\t\t{\n",
        "\t\t'id': 'popcorn', \n",
        "\t\t'features': [{'type': 'hot', 'meal': 'snack', 'texture': 'crunchy', 'flavor': 'savory'}]\n",
        "\t\t},\n",
        "\n",
        "\t\trest of the foods list are the actions to select from...\n",
        "\t\n",
        "\t], \n",
        "\t'excludedActions': [], \n",
        "\t'eventId': '3c86b4ba96204a66b811876bfb6439b4', 'deferActivation': False\n",
        "}\n",
        "```\n",
        "\n",
        "JSON response from the Rank API, indicating all 4 actions have equal probability.  In this case, it will select popcorn.\n",
        "\n",
        "```\n",
        "{\n",
        "\t'ranking': [\n",
        "\t\t{'id': 'popcorn', 'probability': 0.25}, \n",
        "\t\t{'id': 'sliced cheese', 'probability': 0.25}, \n",
        "\t\t{'id': 'cocoa drinks', 'probability': 0.25}, \n",
        "\t\t{'id': 'ice cream', 'probability': 0.25}\n",
        "\t], \n",
        "\t'eventId': '3c86b4ba96204a66b811876bfb6439b4', \n",
        "\t'rewardActionId': 'popcorn'\n",
        "}\n",
        "```\n",
        "\n",
        "Finally, each loop shows the random selection of user, weather, flavor choice, and what reward is determined. The reward of 1 indicates the Personalizer resource selected a food for the given user, weather, and flavor that matched their preferences.\n",
        "\n",
        "In this example, Dave's preferences match the selection of popcorn, so the Reward is 1.\n",
        "\n",
        "```console\n",
        "Customer: Dave\n",
        "Flavor Preference: Salty \n",
        "Weather: Rainy\n",
        "Suggestion: popcorn \n",
        "Reward: 1\n",
        "```\n",
        "\n",
        "The function uses:\n",
        "\n",
        "* Rank: a POST REST API to [get rank](https://westus2.dev.cognitive.microsoft.com/docs/services/personalizer-api/operations/Rank). \n",
        "* Reward: a POST REST API to [report reward](https://westus2.dev.cognitive.microsoft.com/docs/services/personalizer-api/operations/Reward)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "gather": {
          "logged": 1675376851262
        }
      },
      "outputs": [],
      "source": [
        "def iterations(n, modelCheck, jsonFormat):\n",
        "\n",
        "    i = 1\n",
        "    \n",
        "    # default reward value - assumes failed prediction\n",
        "    reward = 0\n",
        "\n",
        "    # Print out dateTime\n",
        "    #currentDateTime()\n",
        "\n",
        "    # collect results to aggregate in graph\n",
        "    total = 0\n",
        "    rewards = []\n",
        "    count = []\n",
        "\n",
        "    # default list of user, weather, time of day\n",
        "    namesopt = ['Dave','Alice', 'Bob', 'Cathy']\n",
        "    flavoropt = ['Salty', 'Sweet', 'Plain']\n",
        "    weatheropt = ['Sunny', 'Rainy', 'Snowy']\n",
        "\n",
        "   \n",
        "    while(i <= n):\n",
        "\n",
        "        # create unique id to associate with an event\n",
        "        eventid = add_event_id(jsonFormat)\n",
        "\n",
        "        # generate a random sample\n",
        "        [name, flavor, weather] = add_random_user_and_contextfeatures(namesopt, flavoropt, weatheropt, jsonFormat)\n",
        "\n",
        "        # add action features to rank\n",
        "        add_action_features(jsonFormat) \n",
        "\n",
        "        # show JSON to send to Rank\n",
        "        #print('To: ', jsonFormat)    \n",
        "\n",
        "        # choose an action - get prediction from Personalizer\n",
        "        response = requests.post(personalization_rank_url, headers = headers, params = None, json = jsonFormat)\n",
        "\n",
        "        # show Rank prediction \n",
        "        #print ('From: ',response.json())    \n",
        "\n",
        "        # compare personalization service recommendation with the simulated data to generate a reward value\n",
        "        prediction = json.dumps(response.json()[\"rewardActionId\"]).replace('\"','')\n",
        "        reward = get_reward_from_simulated_data(name, weather, flavor, prediction)\n",
        "\n",
        "        # show result for iteration\n",
        "        print(f'   {i} {currentDateTime()} {name} {weather} {flavor} {prediction} {reward} ')\n",
        "\n",
        "        # send the reward to the service \n",
        "        response = requests.post(personalization_reward_url + eventid + \"/reward\", headers = headers, params= None, json = { \"value\" : reward })\n",
        "\n",
        "        # for every N rank requests, compute total correct  \n",
        "        total = total + reward\n",
        "\n",
        "        # every N iteration, get last updated model date and time\n",
        "        if(i % modelCheck == 0):\n",
        "\n",
        "            print(\"**** 10% of loop found\")\n",
        "            get_last_updated(modelLastModified) \n",
        "\n",
        "        # aggregate so chart is easier to read\n",
        "        if(i % 100 == 0):\n",
        "            print(\"**** aggregating rewards\")\n",
        "            rewards.append(total)\n",
        "            count.append(i)\n",
        "            total = 0\n",
        "\n",
        "        i = i + 1\n",
        "        \n",
        "    # Print out dateTime\n",
        "    #currentDateTime()\n",
        "    \n",
        "    return [count, rewards]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "# Run Simulation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Run for 10,000 iterations\n",
        "\n",
        "Run the Personalizer loop for 10,000 iterations. This is a long running event - at least an hour, can be more depending on your resources. Do not close the browser running the notebook, you will continue to see results scroll while it runs. Refresh the metrics chart in the Azure portal periodically to see the total calls to the service. When you have around 20,000 calls, a rank and reward call for each iteration of the loop, the iterations are done. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1675377725959
        }
      },
      "outputs": [],
      "source": [
        "# max iterations\n",
        "num_requests = 10000\n",
        "\n",
        "# check last mod date N% of time - currently 10%\n",
        "lastModCheck = int(num_requests * .10)\n",
        "\n",
        "jsonTemplate = rankactionsjsonobj\n",
        "\n",
        "# main iterations\n",
        "[count, rewards] = iterations(num_requests, lastModCheck, jsonTemplate)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Example of output:\n",
        "\n",
        "```json\n",
        "2023-02-02 22:27:32.234434\n",
        "   1 None Dave Sunny Salty ice cream 0 \n",
        "2023-02-02 22:27:32.327635\n",
        "   2 None Dave Sunny Sweet ice cream 0 \n",
        "2023-02-02 22:27:32.465137\n",
        "   3 None Bob Sunny Salty cocoa drinks 0 \n",
        "2023-02-02 22:27:32.602612\n",
        "   4 None Cathy Sunny Plain ice cream 0 \n",
        "2023-02-02 22:27:32.705047\n",
        "   5 None Cathy Rainy Plain ice cream 0 \n",
        "2023-02-02 22:27:32.785077\n",
        "   6 None Alice Sunny Sweet ice cream 1 \n",
        "2023-02-02 22:27:32.865338\n",
        "   7 None Bob Rainy Plain sliced cheese 0 \n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Function: Chart Results\n",
        "\n",
        "Create a chart from the `count` and `rewards` tracked in the simulation to see if there was improvement."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "gather": {
          "logged": 1675377726177
        }
      },
      "outputs": [],
      "source": [
        "def createChart(x, y):\n",
        "    plt.plot(x, y)\n",
        "    plt.xlabel(\"Batch of rank events\")\n",
        "    plt.ylabel(\"Correct recommendations per batch\")\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Review Results of Simulation\n",
        "\n",
        "Run the `createChart` function with the accumlated values from the iterations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "gather": {
          "logged": 1675377726484
        }
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "createChart(count, rewards) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This chart shows the success of the model for the current default learning policy. \n",
        "\n",
        "The ideal target that by the end of the test, the loop is averaging a success rate that is close to one hundred percent minus the exploration. The default setting of exploration is 20%. \n",
        "\n",
        "`100-20=80`\n",
        "\n",
        "This exploration setting is found in the Azure portal, for the Personalizer resource, in the Configurations tab, under the RESOURCE MANAGEMENT section "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "# Offline Evaluation  (Optional)\n",
        "\n",
        "To run this option you will likely need to be in the non-free pricing tier to have enough transactions available to run this."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Run an offline evaluation\n",
        "\n",
        "In order to find a better learning policy, based on your data to the Rank API, run an [offline evaluation](https://docs.microsoft.com/en-us/azure/cognitive-services/personalizer/concepts-offline-evaluation) in the portal for your Personalizer loop.\n",
        "\n",
        "1. In the Azure portal, open the Personalizer resource's **Optimize** page.\n",
        "1. Under **Manual Evaluations**, select **+ Create Evaluation**.\n",
        "1. Enter the required data of evaluation name, and date range for the loop evaluation. The date range should include the days you are focusing on for your evaluation (in our case, the current day(s) you ran the 10,000 iterations).  You may need to type the date in as the datepicker defaults to the current day. \n",
        "\n",
        "    The purpose of running this offline evaluation is to determine if there is a better learning policy for the features and actions used in this loop. To find that better learning policy, make sure **Optimization discovery** is turned on.\n",
        "\n",
        "1. Select **OK** to begin the evaluation. \n",
        "1. This **Evaluations** page lists the new evaluation and its current status. Depending on how much data you have, this evaluation can take some time. You can come back to this page after a few minutes to see the results. \n",
        "1. When the evaluation is completed, select the evaluation then select **Compare the score of your application with other potential learning settings**. This shows the available learning policies and how they would behave with the data. \n",
        "1. Select the top-most learning policy in the table and select **Apply**. This applies the _best_ learning policy to your model and retrains. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Configure for new Learning Policy\n",
        "\n",
        "\n",
        "Before running again, change the update model frequency to 5 minutes.\n",
        "\n",
        "1. In the Azure portal, still on the Personalizer resource, selec the Configurations tab, under the Resource Management section. \n",
        "1. Change the **model update frequency**  to 5 minutes and select **Save**.\n",
        "\n",
        "Learn more about the [reward wait time](https://docs.microsoft.com/en-us/azure/cognitive-services/personalizer/concept-rewards#reward-wait-time) and [model update frequency](https://docs.microsoft.com/en-us/azure/cognitive-services/personalizer/how-to-settings#model-update-frequency)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "Then verify the new learning policy and times are set."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1675377726763
        }
      },
      "outputs": [],
      "source": [
        "get_service_settings()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Verify that the output's `modelExportFrequency` are both set to 5 minutes. \n",
        "    \n",
        "```console\n",
        "-----checking service settings\n",
        "<Response [200]>\n",
        "{}...'arguments': '--cb_explore_adf --epsilon 0.20000000298023224 --dsjson --cb_type mtr --marginal i -q Fi -q Fj -l 0.1 --power_t 0'}\n",
        "<Response [200]>\n",
        "{'rewardWaitTime': 'PT10M', 'defaultReward': 0.0, 'rewardAggregation': 'earliest', 'explorationPercentage': 0.2, 'modelExportFrequency': 'PT5M', 'logRetentionDays': 90, 'lastConfigurationEditDate': '2022-07-12T18:26:32', 'learningMode': 'Online'}\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Run 4,000 iterations with new Learning Policy\n",
        "\n",
        "Run the loop again, but for only 4,000 iterations. Refresh the metrics chart in the Azure portal periodically to see the total calls to the service.  This is a long running event. Do not close the browser running the notebook. Refresh the metrics chart in the Azure portal periodically to see the total calls to the service. When you have around 8,000 calls showing in the chart, a rank and a reward call for each iteration of the loop, the iterations are done. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "gather": {
          "logged": 1675378054329
        }
      },
      "outputs": [],
      "source": [
        "# max iterations\n",
        "num_requests = 4000\n",
        "\n",
        "# check last mod date N% of time - currently 10%\n",
        "lastModCheck2 = int(num_requests * .10)\n",
        "\n",
        "jsonTemplate2 = rankactionsjsonobj\n",
        "\n",
        "# main iterations\n",
        "[count2, rewards2] = iterations(num_requests, lastModCheck2, jsonTemplate2)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Example of output:\n",
        "\n",
        "```json\n",
        "2023-02-02 22:45:19.879721\n",
        "   2396 None Cathy Snowy Sweet ice cream 0 \n",
        "2023-02-02 22:45:19.950750\n",
        "   2397 None Bob Sunny Plain ice cream 0 \n",
        "2023-02-02 22:45:20.014116\n",
        "   2398 None Dave Snowy Salty popcorn 0 \n",
        "2023-02-02 22:45:20.084015\n",
        "   2399 None Bob Sunny Sweet ice cream 1 \n",
        "2023-02-02 22:45:20.151643\n",
        "   2400 None Cathy Rainy Salty ice cream 0 \n",
        "**** 10% of loop found\n",
        "-----checking model\n",
        "<Response [200]>\n",
        "{'creationTime': '2023-02-01T21:48:39+00:00', 'lastModifiedTime': '2023-02-02T17:50:17+00:00'}\n",
        "-----model updated: \"2023-02-02T17:50:17+00:00\"\n",
        "**** aggregating rewards\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Review Results\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "gather": {
          "logged": 1675378054808
        },
        "scrolled": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "createChart(count2,rewards2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The second chart should show a visible increase in Rank predictions aligning with user preferences fairly early in the iterations run, proving it's a better learning policy for us to use with our grocery recommender, at least for now!  You will want to continue to monitor the performance over time as more users interact with the system to determine if changes should be made."
      ]
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.5"
    },
    "microsoft": {
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      }
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}