LinUCB_LinTS_NeurEpsGreedy.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Week 7 - AI Lab\n",
        "\n",
        "Author: Khushee Kapoor\n",
        "\n",
        "Registration Number: 200968052"
      ],
      "metadata": {
        "id": "_g4X6xFSEnmz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Problem Formulation: \n",
        "\n",
        "- State: The state of the system can be defined as the user's historical movie watching behavior, preferences, and any other relevant information such as age, gender, etc.\n",
        "\n",
        "- Action: The action space consists of the recommended movies that the user can choose to watch.\n",
        "\n",
        "- Reward: The reward function can be designed to optimize the user's satisfaction with the recommended movies. For example, the reward function can be based on the user's rating of the recommended movie, where a higher rating results in a higher reward. Alternatively, the reward function can be designed to maximize the user's engagement or diversity of the recommended movies.\n",
        "\n",
        "- Environment: The environment consists of the movie recommendation system that takes the user's state and action as input and generates a recommendation as output.\n",
        "\n",
        "- Policy: The policy defines the movie recommendation algorithm used to suggest the next movie for the user. The goal is to optimize the policy to maximize the cumulative reward over time.\n",
        "\n",
        "The objective of the reinforcement learning algorithm in this context is to learn the optimal policy that recommends movies to the user, taking into account the user's preferences and historical behavior. The algorithm should aim to maximize the user's satisfaction or engagement with the recommended movies over time."
      ],
      "metadata": {
        "id": "9GzgaP63GFCM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "First, we set up tensorflow agents in the jupyter environment."
      ],
      "metadata": {
        "id": "UW3sLWE6Evkl"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TE5sTYsXMmct"
      },
      "outputs": [],
      "source": [
        "# importing libraries and setting up tensorflow agents\n",
        "import tensorflow as tf\n",
        "!pip install tf_agents\n",
        "import tf_agents\n",
        "from tf_agents.bandits.environments import movielens_py_environment\n",
        "from tf_agents.environments import tf_py_environment\n",
        "from tf_agents.bandits.environments import environment_utilities\n",
        "from tf_agents.bandits.metrics import tf_metrics as tf_bandit_metrics\n",
        "from tf_agents.bandits.agents import lin_ucb_agent\n",
        "from tf_agents.bandits.agents import linear_thompson_sampling_agent as lin_ts_agent\n",
        "from tf_agents.networks import q_network\n",
        "from tf_agents.bandits.agents import neural_epsilon_greedy_agent as eps_greedy_agent\n",
        "from tf_agents.bandits.agents.examples.v2 import trainer\n",
        "from tf_agents.replay_buffers import tf_uniform_replay_buffer\n",
        "from tf_agents.drivers import driver\n",
        "from tf_agents.drivers import dynamic_step_driver\n",
        "from tf_agents.policies import random_tf_policy\n",
        "import functools\n",
        "import os\n",
        "import numpy as np\n",
        "from matplotlib import pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we import the data from kaggle. We are using the MovieLens 100K data, on which the MoviePyEnvironment is based."
      ],
      "metadata": {
        "id": "fNtUFpwqE3zp"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GpKC9rWjWzRT"
      },
      "outputs": [],
      "source": [
        "# importing the data\n",
        "! pip install kaggle\n",
        "! mkdir ~/.kaggle\n",
        "! cp kaggle.json ~/.kaggle/\n",
        "! chmod 600 ~/.kaggle/kaggle.json\n",
        "! kaggle datasets download prajitdatta/movielens-100k-dataset\n",
        "!unzip /content/movielens-100k-dataset.zip"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we set the values of the common hyperparameters between all the three concextual agents. These include:\n",
        "- Batch Size: number of observations generated per call\n",
        "- Training Loops: we set to 500 instead of given 20000 to avoid crashing the notebook\n",
        "- Rank K: to use in matrix factorization\n",
        "- Number of Actions: that the model will output\n",
        "- Data Path: to access the data\n",
        "- Root Diretory: to store the checkpoints"
      ],
      "metadata": {
        "id": "l38cegIaFIDL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "iwpoCR81e1ad"
      },
      "outputs": [],
      "source": [
        "# initializing the hyperparameters\n",
        "BATCH_SIZE = 8\n",
        "TRAINING_LOOPS = 500\n",
        "STEPS_PER_LOOP = 2\n",
        "RANK_K = 20\n",
        "NUM_ACTIONS = 20\n",
        "\n",
        "data_path = '/content/ml-100k/u.data'\n",
        "root_dir = '/content/checkpoints'"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we set up the MovieLensPyEnvironment usign the above hyperparameters and wrap it in a TensorFlow environment."
      ],
      "metadata": {
        "id": "V3eTU1XjG-6G"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "iCJiJxxMeus8"
      },
      "outputs": [],
      "source": [
        "# setting up the MovieLensPyEnvironment\n",
        "env = movielens_py_environment.MovieLensPyEnvironment(\n",
        "        data_path,\n",
        "        RANK_K,\n",
        "        BATCH_SIZE,\n",
        "        num_movies=NUM_ACTIONS,\n",
        "        csv_delimiter='\\t')\n",
        "environment = tf_py_environment.TFPyEnvironment(env)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we declare two partial functions that use the Movielens environment to compute the optimal reward and optimal action for the given state.\n",
        "\n",
        "- optimal_reward_fn: This is a partial function that computes the optimal reward for a given state using the Movielens environment. The function is created using the functools.partial method, which is a way to create a new function with a fixed set of arguments based on an existing function. In this case, the compute_optimal_reward_with_movielens_environment function is used as the base function, and the environment argument is passed in as a fixed argument. This partial function can be used to calculate the optimal reward for any state in the Movielens environment.\n",
        "\n",
        "- optimal_action_fn: This is a partial function that computes the optimal action for a given state using the Movielens environment. Like optimal_reward_fn, the function is created using the functools.partial method, with the compute_optimal_action_with_movielens_environment function as the base function and the environment argument passed in as a fixed argument. This partial function can be used to calculate the optimal action (i.e., recommended movie) for any state in the Movielens environment.\n",
        "\n",
        "These two partial functions are useful for evaluating the performance of a recommendation model trained using Reinforcement Learning. By comparing the rewards and actions produced by the model with the optimal values computed by these functions, we can determine how well the model is performing and whether it is learning to make good recommendations."
      ],
      "metadata": {
        "id": "LBhpQWWiH6kO"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "ScwEK6JOeqLM"
      },
      "outputs": [],
      "source": [
        "# partial function to evaluate reward function with optimal reward\n",
        "optimal_reward_fn = functools.partial(\n",
        "      environment_utilities.compute_optimal_reward_with_movielens_environment,\n",
        "      environment=environment)\n",
        "\n",
        "# partial function to evaluate action function with optimal action\n",
        "optimal_action_fn = functools.partial(\n",
        "      environment_utilities.compute_optimal_action_with_movielens_environment,\n",
        "      environment=environment)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we create an instance of the LinearUCBAgent class, which implements the LinUCB algorithm for contextual bandit problems. The hyperparameters used in this instance are:\n",
        "\n",
        "- time_step_spec: This specifies the format of the input data that the agent receives from the environment at each time step. It includes the observation, reward, and discount, among other things.\n",
        "\n",
        "- action_spec: This specifies the format of the actions that the agent can choose from. In this case, the agent can select one of the movies to recommend from the set of available actions.\n",
        "\n",
        "- tikhonov_weight: This is a regularization hyperparameter that controls the amount of weight given to the L2 regularization term in the linear regression used by the LinUCB algorithm. It is used to prevent overfitting of the linear model to the data. In this case, the Tikhonov weight is set to 0.001.\n",
        "\n",
        "- alpha: This is the exploration hyperparameter that we discussed earlier. It controls the tradeoff between exploration and exploitation in the LinUCB algorithm. In this case, the alpha value is set to the AGENT_ALPHA hyperparameter. This is a hyperparameter that determines the strength of the agent's exploration strategy. It controls the amount of weight given to the uncertainty term in the exploration-exploitation tradeoff of the LinUCB algorithm. In this case, the alpha value is set to 10.0, which means that the agent is relatively more exploratory than exploitative. Higher values of alpha result in more exploration, which can be useful when the agent is first learning about the environment, but may be less effective as the agent becomes more experienced.\n",
        "\n",
        "- dtype: This specifies the data type of the variables used in the linear regression. In this case, tf.float32 is used.\n",
        "\n",
        "- accepts_per_arm_features: This specifies whether the agent expects to receive per-arm features as input. In this case, it is set to False, meaning that the agent does not use per-arm features. Per-arm features are additional information that can be used to describe each of the available actions (movies) and can be useful for improving the quality of the recommendations."
      ],
      "metadata": {
        "id": "Z8rQGkK_IwC1"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "o9ZOYyTHeln9"
      },
      "outputs": [],
      "source": [
        "# creating the LinUCB agent\n",
        "AGENT_ALPHA = 10.0\n",
        "linucb = lin_ucb_agent.LinearUCBAgent(\n",
        "        time_step_spec=environment.time_step_spec(),\n",
        "        action_spec=environment.action_spec(),\n",
        "        tikhonov_weight=0.001,\n",
        "        alpha=AGENT_ALPHA,\n",
        "        dtype=tf.float32,\n",
        "        accepts_per_arm_features=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we create an instance of the LinearThompsonSamplingAgent class, which implements the linear Thompson sampling algorithm for contextual bandit problems. This algorithm is similar to the LinUCB algorithm but uses a Bayesian approach to sample from the posterior distribution over the model parameters.\n",
        "\n",
        "- time_step_spec: This parameter specifies the format of the input data that the agent receives from the environment at each time step. It includes the observation, reward, and discount, among other things.\n",
        "\n",
        "- action_spec: This parameter specifies the format of the actions that the agent can choose from. In this case, the agent can select one of the movies to recommend from the set of available actions.\n",
        "\n",
        "- dtype: This parameter specifies the data type of the variables used in the linear regression. In this case, tf.float32 is used.\n",
        "\n",
        "- accepts_per_arm_features: This parameter specifies whether the agent expects to receive per-arm features as input. In this case, it is set to False, meaning that the agent does not use per-arm features. Per-arm features are additional information that can be used to describe each of the available actions (movies) and can be useful for improving the quality of the recommendations."
      ],
      "metadata": {
        "id": "6l57SamsJa5L"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "y5lYd5ncecO3"
      },
      "outputs": [],
      "source": [
        "# creating the LinTS agent\n",
        "lints = lin_ts_agent.LinearThompsonSamplingAgent(\n",
        "        time_step_spec=environment.time_step_spec(),\n",
        "        action_spec=environment.action_spec(),\n",
        "        dtype=tf.float32,\n",
        "        accepts_per_arm_features=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we initialize the following hyperparameters: \n",
        "\n",
        "- EPSILON: This is the probability of the agent choosing a random action instead of the greedy action (the action with the highest estimated reward). It controls the level of exploration versus exploitation in the agent's decision-making process.\n",
        "\n",
        "- LAYERS: This is a tuple that specifies the number of hidden layers and the number of units in each layer of the Q-network used by the agent to estimate the rewards of different actions.\n",
        "\n",
        "- LR: This is the learning rate used by the optimizer to update the Q-network parameters during training.\n",
        "\n",
        "We use the above for the following:\n",
        "\n",
        "Network: This is an instance of the QNetwork class, which defines the architecture of the Q-network used by the agent to estimate the rewards of different actions based on the observed states.\n",
        "\n",
        "NeuralEpsilonGreedyAgent: This is an instance of the NeuralEpsilonGreedyAgent class, which implements the epsilon-greedy algorithm using a neural network as the Q-function approximator.\n",
        "- time_step_spec: This parameter specifies the format of the input data that the agent receives from the environment at each time step. It includes the observation, reward, and discount, among other things.\n",
        "\n",
        "- action_spec: This parameter specifies the format of the actions that the agent can choose from. In this case, the agent can select one of the movies to recommend from the set of available actions.\n",
        "\n",
        "- reward_network: This parameter specifies the Q-network used by the agent to estimate the rewards of different actions based on the observed states.\n",
        "\n",
        "- optimizer: This parameter specifies the optimizer used to update the Q-network parameters during training. In this case, the Adam optimizer is used with a learning rate of LR.\n",
        "\n",
        "- emit_policy_info: This parameter specifies what policy information should be included in the data emitted by the agent during training. In this case, it includes the mean of the predicted rewards.\n",
        "\n",
        "- info_fields_to_inherit_from_greedy: This parameter specifies what policy information should be inherited from the greedy policy. In this case, it includes the mean of the predicted rewards.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "0U1jNXC3J504"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "-yIoG3hveO7T"
      },
      "outputs": [],
      "source": [
        "# creating the NeurEpsilon Greedy Agent\n",
        "EPSILON = 0.05\n",
        "LAYERS = (50, 50, 50)\n",
        "LR = 0.005\n",
        "\n",
        "network = q_network.QNetwork(\n",
        "          input_tensor_spec=environment.time_step_spec().observation,\n",
        "          action_spec=environment.action_spec(),\n",
        "          fc_layer_params=LAYERS)\n",
        "\n",
        "neureps = eps_greedy_agent.NeuralEpsilonGreedyAgent(\n",
        "        time_step_spec=environment.time_step_spec(),\n",
        "        action_spec=environment.action_spec(),\n",
        "        reward_network=network,\n",
        "        optimizer=tf.compat.v1.train.AdamOptimizer(learning_rate=LR),\n",
        "        epsilon=EPSILON,\n",
        "        emit_policy_info='predicted_rewards_mean',\n",
        "        info_fields_to_inherit_from_greedy=['predicted_rewards_mean'])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we define the following metrics:\n",
        "- RegretMetric: This is a metric that measures the difference between the total reward obtained by the bandit agent and the total reward that would have been obtained by always choosing the optimal action at each time step. It computes the cumulative regret over the course of the training process.\n",
        "- SuboptimalArmsMetric: This is a metric that measures the proportion of time steps where the agent chooses a suboptimal action (an action other than the optimal action). It is a useful metric for evaluating the level of exploration versus exploitation in the agent's decision-making process."
      ],
      "metadata": {
        "id": "L62nhElUiD7i"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "3rd3WbM8YKC-"
      },
      "outputs": [],
      "source": [
        "# defining the regret metric\n",
        "regret_metric = tf_bandit_metrics.RegretMetric(optimal_reward_fn)\n",
        "suboptimal_arms_metric = tf_bandit_metrics.SuboptimalArmsMetric(optimal_action_fn)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We then define a function to train the agent."
      ],
      "metadata": {
        "id": "x00Fi93xiTTE"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "Eo8_Pb5LeLrP"
      },
      "outputs": [],
      "source": [
        "def train(agent):\n",
        "\n",
        "  if agent == 'LinUCB':\n",
        "    agent = linucb\n",
        "  elif agent == 'LinTS':\n",
        "    agent = lints\n",
        "  elif agent == 'NeurEps':\n",
        "    agent = neureps\n",
        "\n",
        "\n",
        "  replay_buffer = tf_uniform_replay_buffer.TFUniformReplayBuffer(\n",
        "    data_spec=agent.policy.trajectory_spec,\n",
        "    batch_size=BATCH_SIZE,\n",
        "    max_length=STEPS_PER_LOOP)\n",
        "\n",
        "  observers = [replay_buffer.add_batch, regret_metric]\n",
        "\n",
        "  driver = dynamic_step_driver.DynamicStepDriver(\n",
        "      env=environment,\n",
        "      policy=agent.collect_policy,\n",
        "      num_steps=STEPS_PER_LOOP * BATCH_SIZE,\n",
        "      observers=observers)\n",
        "\n",
        "  regret_values = []\n",
        "\n",
        "  for _ in range(TRAINING_LOOPS):\n",
        "    driver.run()\n",
        "    loss_info = agent.train(replay_buffer.gather_all())\n",
        "    replay_buffer.clear()\n",
        "    regret_values.append(regret_metric.result())\n",
        "\n",
        "  return regret_values, agent"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We first train the LinUCB agent and plot the regret values."
      ],
      "metadata": {
        "id": "3NKbQGQ6jCFI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# plotting the regret values of the LinUCB agent\n",
        "regret_values_linucb, linucb_agent = train('LinUCB')\n",
        "plt.plot(regret_values_linucb)\n",
        "plt.title('Regret over Timesteps LinUCB')\n",
        "plt.xlabel('Number of Iterations')\n",
        "plt.ylabel('Average Regret')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 384
        },
        "id": "86QsVmXrwGau",
        "outputId": "c74b9d45-f5ec-4638-e370-54d71ddb4b34"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:From <ipython-input-10-eb5acd4db2a6>:28: ReplayBuffer.gather_all (from tf_agents.replay_buffers.replay_buffer) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use `as_dataset(..., single_deterministic_pass=True)` instead.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Average Regret')"
            ]
          },
          "metadata": {},
          "execution_count": 11
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, the regret decreases over time. We also find the cummulative regret using the sum function."
      ],
      "metadata": {
        "id": "s0FPfJ87jQq0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# summation of regret values\n",
        "sum(regret_values_linucb)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "s9_uNF-nHH36",
        "outputId": "dc59f370-d68b-426e-a7bc-c34ad616e478"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=215.5>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, the cummulative regret is 215.5"
      ],
      "metadata": {
        "id": "6l6120kfjS4f"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we train the LinTS agent and plot the regret values."
      ],
      "metadata": {
        "id": "OH2wGddGjjcL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# plotting the regret values of the LinTS agent\n",
        "regret_values_lints, lints_agent = train('LinTS')\n",
        "plt.plot(regret_values_lints)\n",
        "plt.title('Regret over Timesteps LinTS')\n",
        "plt.xlabel('Number of Iterations')\n",
        "plt.ylabel('Average Regret')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "id": "GCWNNymFMuv1",
        "outputId": "eae61e22-47c7-442c-f8d8-e3ac401d31bd"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Average Regret')"
            ]
          },
          "metadata": {},
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, the regret decreases over time. We also find the cummualitve regret using the sum function."
      ],
      "metadata": {
        "id": "giBPypPgjrZt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# summation of regret values\n",
        "sum(regret_values_lints)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "UyIyFOF4HLQc",
        "outputId": "2373d1a9-d6d6-420c-bdeb-eb72aa3f1c5c"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=76.5>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, the cummulative regret is 76.5"
      ],
      "metadata": {
        "id": "vanCBtJij9sK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, we train the LinTS agent and plot the regret values."
      ],
      "metadata": {
        "id": "hkhg8KmykBzA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# plotting the regret values if NeurEpsilon Greedy agent\n",
        "regret_values_neureps, neureps_agent = train('NeurEps')\n",
        "plt.plot(regret_values_neureps)\n",
        "plt.title('Regret over Timesteps NeurEps')\n",
        "plt.xlabel('Number of Iterations')\n",
        "plt.ylabel('Average Regret')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "id": "aBX-7qrMNaIK",
        "outputId": "f8ebaace-e433-43ae-8d36-9220b6809476"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Average Regret')"
            ]
          },
          "metadata": {},
          "execution_count": 15
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, the regret decreases over time. We also find the cummualitve regret using the sum function."
      ],
      "metadata": {
        "id": "YcHlBC34nOlf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# summation of regret values\n",
        "sum(regret_values_neureps)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "H_qhKAyUHVUS",
        "outputId": "ed52dd3e-07f3-4bd6-fcd8-96ad8876c356"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=888.875>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, the cummulative regret is 888.875."
      ],
      "metadata": {
        "id": "lqy4q8uknU1r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "From the values of the cummulative regret, we can infer that the **best agent in LinTS as it has the least cummulative regret**."
      ],
      "metadata": {
        "id": "G9XC1vrWnb1X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we write a Recommendation policy, which when given a new observation request (i.e. a user vector), the policy will produce actions, which are the recommended movies.\n",
        "\n",
        "First, it creates a TimeStep object that represents the current time step in the RL environment, with the given observation and initial values for the step type, reward, and discount.\n",
        "\n",
        "Then, it uses the agent's policy to select an action for the given time step. The action method of the policy returns an ActionStep object that contains the recommended action.\n",
        "\n",
        "Finally, the function returns the recommended action as a numpy array. The [0] index is used to extract the scalar value from the one-element numpy array."
      ],
      "metadata": {
        "id": "OvfIRYuanziJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# recommendation policy\n",
        "def recommend_movies(agent, observation):\n",
        "    time_step = tf_agents.trajectories.time_step.TimeStep(\n",
        "        step_type=tf.constant([[2]], dtype=tf.int32),\n",
        "        reward=tf.constant([[0.0]], dtype=tf.float32),\n",
        "        discount=tf.constant([[1.0]], dtype=tf.float32),\n",
        "        observation=observation)\n",
        "    \n",
        "    action_step = agent.policy.action(time_step)\n",
        "    return action_step.action.numpy()[0]"
      ],
      "metadata": {
        "id": "zrY-_6q4HXeP"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To test out the policy, we input a random observation vector and get the recommended movie id in return. We use the LinTS agent to check it out, as the it was best performer as per our analysis."
      ],
      "metadata": {
        "id": "EHS60l4voNk9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# testing out the policy\n",
        "observation = np.array([1, 25, 35, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1])\n",
        "observation = np.expand_dims(observation, axis=0)\n",
        "recommend_movies(lints_agent, observation=observation)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "YtXEbpAOhqnq",
        "outputId": "08ad3d7b-1214-4aa2-b70f-70861d05a67f"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, for the given vector, we get the movie id recommendation 13."
      ],
      "metadata": {
        "id": "2O-pE7SwoWM1"
      }
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}