notebooks/maximum_entropy_deep_irl.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4141fa558dfefe8c",
   "metadata": {},
   "source": [
    "# Maximum Entropy Deep Inverse Reinforcement Learning\n",
    "Based on the paper \"Maximum Entropy Deep Inverse Reinforcement Learning\" by Wulfmeier et al. [\\[1\\]](#references).\n",
    "\n",
    "[CS 285: Lecture 19, Control as Inference, Part 1](https://www.youtube.com/watch?v=MzVlYYGtg0M&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=77) --> Introduce the concept of computing the backward and forward pass, used later in the Maximum Entropy Inverse Reinforcement Learning paper [\\[2\\]](#references).\n",
    "[CS 285: Lecture 19, Control as Inference, Part 2](https://www.youtube.com/watch?v=1NgU3EKHlpY&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=78) -->\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\beta_t(s_t,a_t) = P(\\mathcal{O}_{t:T} | s_t, a_t) \\propto \\exp(r(s_t, a_t))\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\pi(s_t) = P(a_t | s_t, \\mathcal{O}_{1:T}) = \\frac{\\beta_t(s_t, a_t)}{\\beta_t(s_t)}\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\alpha_t(s_t) = P(s_t | \\mathcal{O}_{1:t-1})\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "Where $\\beta$ is the backward message, $\\pi$ the policy, $\\alpha$ the forward messages, $t:T$ means from time $t$ to the end of the trajectory, and where $\\mathcal{O}$ is the probability of optimality/observed.\n",
    "\n",
    "### Backward pass\n",
    "The backward pass is defined as the probability of the trajectory given the state and action at time $t$. And can be rewritten as a recursive function as shown by [CS 285: Lecture 19, Control as Inference, Part 2](https://www.youtube.com/watch?v=1NgU3EKHlpY&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=78):\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\beta_t(s_t,a_t) = P(\\mathcal{O}_t | s_t, a_t) \\mathbb{E}_{s_{t+1} \\sim P(s_{t+1} | s_t, a_t)}[\\beta_{t+1}(s_{t+1})]\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\beta_T(s_T) = \\mathbb{E}_{a_t \\sim P(a_t | s_t)}[\\beta_t(s_t, a_t)]\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "But this approach is not ideal as it modified the dynamics hence, the transition probabilities.\n",
    "\n",
    "### Compute the policy\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\pi(s_t) = P(a_t | s_t, \\mathcal{O}_{1:T}) = \\frac{\\beta_t(s_t, a_t)}{\\beta_t(s_t)}\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "Could be rewritten as the exponantial of the advantage function $\\mathcal{A}$ as shown in [CS 285: Lecture 19, Control as Inference, Part 2](https://www.youtube.com/watch?v=1NgU3EKHlpY&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=78) where we can add a temperature parameter $\\alpha$ where the policy approaches the greedy policy as $\\alpha$ approaches 0:\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\pi(a_t | s_t) = \\exp(\\frac{1}{\\alpha}Q_t(s_t, a_t) - \\frac{1}{\\alpha}V_t(s_t)) = \\exp(\\frac{1}{\\alpha}\\mathcal{A}_t(s_t, a_t))\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "### Forward pass\n",
    "The forward pass is defined as the probability of the state at time $t$ given the observations from time $1$ to $t-1$. And can be rewritten as a recursive function as shown by [CS 285: Lecture 19, Control as Inference, Part 2](https://www.youtube.com/watch?v=1NgU3EKHlpY&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=78):\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\alpha_t(s_t) = P(s_t | \\mathcal{0}_{1:t-1}) \\propto \\int \\frac{\\mathcal{P} \\mathcal{R} \\alpha_{t-1}(s_{t-1})}{P(\\mathcal{O}_{t-1} | \\mathcal{O}_{1:t-2})} ds_{t-1} da_{t-1}\n",
    "    \n",
    "\\end{equation}\n",
    "\n",
    "Where $\\mathcal{P}$ is the transition probabilities, $\\mathcal{R}$ the reward function, and $P(\\mathcal{O}_{t-1} | \\mathcal{O}_{1:t-2})$ is the probability of the observations at time $t-1$ given the observations from time $1$ to $t-2$.\n",
    "\n",
    "### Estimating the expectation\n",
    "[CS 285: Lecture 20, Inverse Reinforcement Learning, Part 2](https://www.youtube.com/watch?v=82Sr9YqeQNc&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=83) -->\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\mu_t(s_t, a_t) \\propto \\beta(s_t, a_t) \\alpha(s_t)\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "Where $\\mu_t$ is the state-action marginals.\n",
    "\n",
    "### Approximation in High Dimensional Spaces and in Continuous Spaces\n",
    "According to [CS 285: Lecture 20, Inverse Reinforcement Learning, Part 3](https://www.youtube.com/watch?v=OsO2nLfxZVQ&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=84) The previous techniques does not apply well to large and continuous state actions spaces problems, but it is also not robust to unknown dynamics. A solution to this problem is to use importance sampling to estimate the expectation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "18c832c4e3d2b7d0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:15:59.809522Z",
     "start_time": "2024-06-06T13:15:53.232608Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy\n",
    "import torch\n",
    "import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e811c37f05633e93",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## A small and simple Markov Decision Process (MDP)\n",
    "Let's define the following MDP like the one used in [toy_mdp.py](../src/maxent_deep_irl/environments/toy_mdp.py). It will be use as a toy example to test the different algorithms.\n",
    "\n",
    "<div style=\"text-align: center;\">\n",
    "    <img\n",
    "        style=\"display: block; margin-left: auto; margin-right: auto;\"\n",
    "        alt=\"Toy MDP\"\n",
    "        src=\"../assets/toy_mdp.png\">\n",
    "    </img>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "aa745b6bd802ed02",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:15:59.816725Z",
     "start_time": "2024-06-06T13:15:59.809522Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class ToyMDP():\n",
    "    def __init__(self):\n",
    "        self.n_states = 2\n",
    "        self.n_actions = 2\n",
    "\n",
    "        self.gamma = 0.5\n",
    "\n",
    "        # P(s' | s, a): dim(n_states, n_states, n_actions)\n",
    "        self.transition_probabilities = torch.tensor([\n",
    "            [ # State 0 (s')\n",
    "                # State 0, State 1 (s)\n",
    "                [0.5, 0.0], # Action 0\n",
    "                [0.0, 1.0]  # Action 1\n",
    "            ],\n",
    "            [ # State 1 (from)\n",
    "                # State 0, State 1 (to)\n",
    "                [0.5, 1.0], # Action 0\n",
    "                [1.0, 0.0]  # Action 1\n",
    "            ]\n",
    "        ])\n",
    "\n",
    "        self.reward = torch.tensor(\n",
    "            [3.0, -1.0]\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d3da8427d8c00fae",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:15:59.836732Z",
     "start_time": "2024-06-06T13:15:59.816725Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P(s'=0 | s=0, a=0) = 0.5\n",
      "P(s'=0 | s=0, a=1) = 0.0\n",
      "P(s'=0 | s=1, a=0) = 0.0\n",
      "P(s'=0 | s=1, a=1) = 1.0\n",
      "P(s'=1 | s=0, a=0) = 0.5\n",
      "P(s'=1 | s=0, a=1) = 1.0\n",
      "P(s'=1 | s=1, a=0) = 1.0\n",
      "P(s'=1 | s=1, a=1) = 0.0\n"
     ]
    }
   ],
   "source": [
    "mdp = ToyMDP()\n",
    "\n",
    "# P(s' | s, a)\n",
    "for s_prime in range(mdp.n_states):\n",
    "    for s in range(mdp.n_states):\n",
    "        for a in range(mdp.n_actions):\n",
    "            print(f\"P(s'={s_prime} | s={s}, a={a}) = {mdp.transition_probabilities[s_prime, s, a]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa2c96d4ef9dac04",
   "metadata": {},
   "source": [
    "## Soft value iteration\n",
    "\n",
    "Stochastic value iteration based on the paper \"Maximum Entropy Deep Inverse Reinforcement Learning\" by Wulfmeier et al. [\\[1\\]](#references). See also [CS 285: Lecture 19, Control as Inference, Part 3](https://www.youtube.com/watch?v=PAvT1Ypvmm4&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=79) by Sergey Levine.\n",
    "\n",
    "The main difference with the deterministic value iteration algorithm is that it use a _soft max_ instead of a _max_ to compute the value function. Where _soft max_ isn't the _softmax_ function used in classical machine learning but a smooth approximation of the _max_ function below used  as the _log-sum-exp_ function from PyTorch.\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\mathcal{Q}_t(s_t, a_t) = r(s_t, a_t) + \\mathbb{E}[V_{t+1}(s_{t+1})]\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    V_{t+1}(s_{t+1}) = \\log \\int \\exp(\\mathcal{Q}_t(s_t, a_t))da_t\n",
    "\n",
    "\\end{equation}\n",
    "\n",
    "Variation of the previous result could be used to add a temperature parameter to the value function as shown at the end of [CS 285: Lecture 19 Control as Inference, Part 3](https://www.youtube.com/watch?v=PAvT1Ypvmm4&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=79), when this temperature parameter tend to zero, the value function tend more toward an _hard max_ value function used in the deterministic value iteration algorithm. There's also another variant that apply a discount horizon to the action-value function $\\mathcal{Q}_t(s_t, a_t)$ which change the dynamics (transition probabilities) over time:\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\mathcal{Q}_t(s_t, a_t) = r(s_t, a_t) + \\gamma \\mathbb{E}[V_{t+1}(s_{t+1})]\n",
    "    \n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    V_t(s_t) = \\alpha \\log \\int \\exp(\\frac{1}{\\alpha}\\mathcal{Q}_t(s_t, a_t)) da_t\n",
    "    \n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "20ab21481f09c217",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:15:59.888786Z",
     "start_time": "2024-06-06T13:15:59.837741Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value function: tensor([5.0440, 1.6937])\n",
      "Policy:\n",
      "\tpi(0) = tensor([0.6980, 0.3020])\n",
      "\tpi(1) = tensor([0.1577, 0.8423])\n"
     ]
    }
   ],
   "source": [
    "def soft_value_iteration(transition_probabilities, reward, gamma, epsilon, max_iteration=1000):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        transition_probabilities dim(n_states, n_states, n_actions): A tensor representing the transition probabilities of the MDP.\n",
    "        reward dim(n_states): A tensor representing the reward of the MDP.\n",
    "        gamma: The discount factor gamma in [0, 1].\n",
    "        epsilon: A small threshold epsilon > 0 determining the accuracy of the estimation.\n",
    "\n",
    "    Returns:\n",
    "        value_function dim(n_states): The optimal value function.\n",
    "        policy dim(n_states): The optimal policy.\n",
    "    \"\"\"\n",
    "    n_states, _, n_actions = transition_probabilities.shape\n",
    "\n",
    "    V = torch.full((n_states,), -1E6)\n",
    "\n",
    "    for iteration in range(max_iteration):\n",
    "        Vt = V.clone()\n",
    "\n",
    "        Q = torch.zeros((n_states, n_actions))\n",
    "        for s in range(n_states):\n",
    "            for a in range(n_actions):\n",
    "                Q[s, a] = reward[s] + gamma * torch.sum(transition_probabilities[:, s, a] * Vt)\n",
    "\n",
    "        V = torch.logsumexp(Q, dim=1) # soft-max over actions\n",
    "\n",
    "        delta = torch.max(torch.abs(Vt - V))\n",
    "\n",
    "        if delta < epsilon:\n",
    "            break\n",
    "\n",
    "    pi = torch.exp(Q - V.reshape(-1, 1))\n",
    "\n",
    "    return pi, V\n",
    "\n",
    "\n",
    "# Test the value iteration algorithm\n",
    "toy_mdp = ToyMDP()\n",
    "policy, value_function = soft_value_iteration(toy_mdp.transition_probabilities, toy_mdp.reward, toy_mdp.gamma, epsilon=1e-5)\n",
    "\n",
    "print(f\"Value function: {value_function}\")\n",
    "print(f\"Policy:\")\n",
    "print(f\"\\tpi(0) = {policy[0]}\")\n",
    "print(f\"\\tpi(1) = {policy[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81a09633a18d2668",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Retrieve the optimal policy with soft value iteration\n",
    "As shown in the backard pass by [\\[2\\]](#references) and by [CS 285: Lecture 19, Control as Inference, Part 2](https://www.youtube.com/watch?v=1NgU3EKHlpY&list=PL_iWQOsE6TfVYGEGiAOMaOzzv41Jfm_Ps&index=78), the optimal policy can also be computed as:\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\pi(a_t | s_t) = \\frac{\\beta_t(s_t, a_t)}{\\beta_t(s_t)}\n",
    "\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ecf684377575aebe",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:15:59.900131Z",
     "start_time": "2024-06-06T13:15:59.888786Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pi(0) = tensor([0.9066, 0.0934])\n",
      "pi(1) = tensor([0.3555, 0.6445])\n"
     ]
    }
   ],
   "source": [
    "def policy_from_soft_value_iteration(transition_probabilities, reward, gamma, epsilon=1e-5, max_iteration=1000):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        transition_probabilities dim(n_states, n_states, n_actions): A tensor representing the transition probabilities of the MDP defined as P(s' | s, a) where the dimension should correspond to the tuple (s', s, a).\n",
    "        reward dim(n_states): A tensor representing the reward of the MDP per states.\n",
    "        gamma: The discount factor gamma in [0, 1].\n",
    "\n",
    "    Returns:\n",
    "        policy dim(n_states, n_actions): The optimal policy P(s | a).\n",
    "    \"\"\"\n",
    "    n_states, _, n_actions = transition_probabilities.shape\n",
    "\n",
    "    beta_s = torch.ones(n_states)\n",
    "\n",
    "    old_policy = torch.ones((n_states, n_actions)) / n_actions\n",
    "\n",
    "    for iteration in range(max_iteration):\n",
    "        beta_s_a = torch.sum(transition_probabilities * gamma * torch.exp(reward)[:, None, None] * beta_s[None, :, None], dim=1)\n",
    "        beta_s = torch.sum(beta_s_a, dim=1)\n",
    "\n",
    "        policy = beta_s_a / beta_s[:, None]\n",
    "\n",
    "        delta = torch.max(torch.abs(old_policy - policy))\n",
    "        if delta < epsilon:\n",
    "            break\n",
    "\n",
    "        old_policy = policy.clone()\n",
    "\n",
    "    return policy\n",
    "\n",
    "toy_mdp = ToyMDP()\n",
    "policy  = policy_from_soft_value_iteration(toy_mdp.transition_probabilities, toy_mdp.reward, toy_mdp.gamma)\n",
    "print(f\"pi(0) = {policy[0]}\")\n",
    "print(f\"pi(1) = {policy[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46eb43a17e1cbee1",
   "metadata": {},
   "source": [
    "## Policy propagation\n",
    "Algorithm 3 from the paper [\\[1\\]](#references) is implemented below. It could also be derived from the forward pass algorithm in [\\[2, 3\\]](#references)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "26021935af75c7da",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:16:49.018072Z",
     "start_time": "2024-06-06T13:16:48.993532Z"
    }
   },
   "outputs": [],
   "source": [
    "def propagate_policy(policy, transition_probabilities, trajectories, initial_state_distribution):\n",
    "    \"\"\"\n",
    "    Compute the expected state visiting frequencies by probabilistically traversing the MDP under the given policy.\n",
    "\n",
    "    Args:\n",
    "        policy dim(n_states, n_actions): The policy to propagate.\n",
    "        transition_probabilities dim(n_states, n_states, n_actions): A tensor representing the transition probabilities of the MDP.\n",
    "        epsilon: A small threshold epsilon > 0 determining the accuracy of the estimation.\n",
    "        n_trajectories: The number of trajectories to sample.\n",
    "    \"\"\"\n",
    "    \"\"\"\n",
    "    Propagate the policy through the environment dynamics as shown in the algorithm 3 of (Wulfmeir & al, 2016).\n",
    "\n",
    "    :param policy: The policy of shape (n_states, n_actions).\n",
    "    \"\"\"\n",
    "    n_states, _, n_actions = transition_probabilities.shape\n",
    "    n_trajectories = len(trajectories)\n",
    "\n",
    "    state_visitation_frequency = torch.zeros((n_trajectories, n_states))\n",
    "    state_visitation_frequency[0] = initial_state_distribution.probs\n",
    "\n",
    "    for t in range(1, n_trajectories):\n",
    "        new_state_visitation_frequency = state_visitation_frequency.clone()\n",
    "        new_state_visitation_frequency[t] = torch.sum(torch.sum(transition_probabilities * policy * state_visitation_frequency[t - 1].reshape(-1, 1), dim=1), dim=1)\n",
    "        state_visitation_frequency = new_state_visitation_frequency\n",
    "    state_visitation_frequency = state_visitation_frequency.sum(dim=0) / n_trajectories\n",
    "\n",
    "    return state_visitation_frequency"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "714cea1add958617",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Deep Neural Network\n",
    "\n",
    "Even though this title mentions a deep neural network, the paper [\\[1\\]](#references) explain that a sufficiently large neural network with at least one hidden layer can approximate the value function. Therefore, we will use a simple MLP with one hidden layer to approximate the value function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fe64295f74a08b7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:15:59.914452Z",
     "start_time": "2024-06-06T13:15:59.907282Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class RewardNet(torch.nn.Module):\n",
    "    def __init__(self, n_states):\n",
    "        super().__init__()\n",
    "\n",
    "        self.net = torch.nn.Sequential(\n",
    "            torch.nn.Linear(n_states, 8),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.Linear(8, 16),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.Linear(16, 1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.net(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9892098af7febd5a",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Maximum Entropy Deep Inverse Reinforcement Learning\n",
    "First we will use the `deterministic_value_iteration` function developed in [value_iteration.ipynb](value_iteration.ipynb) to compute the optimal value function. This will be used to retrieve the expected value differences as a metric to evaluate the training of the reward network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "fbbc4be1315a8607",
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from maxent_deep_irl import deterministic_value_iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63d8f05477c6a3b3",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "As shown in the algorithm 1 and in the section 3.1. Training procedure of ([Wulfmeir & al., 2016](#references)) we will need to retrieve the state-action frequency from the demonstrations which will also be used to retrieve the feature expectation like:\n",
    "\n",
    "\\begin{equation}\n",
    "\n",
    "    \\mu_{\\mathcal{D}} = \\sum^{\\mathcal{A}}_{a=1} \\mu^a_{\\mathcal{D}}\n",
    "\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5000502a7c92b8d1",
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def state_action_frequency(n_states, n_actions, trajectories):\n",
    "    \"\"\"\n",
    "    Compute the state-action frequency from the given trajectory as shown in the section 3.1. Training Procedure of (Wulfmeir & al, 2016).\n",
    "    \"\"\"\n",
    "\n",
    "    state_action_counts = torch.zeros(n_states, n_actions)\n",
    "    for trajectory in trajectories:\n",
    "        for state, action in trajectory:\n",
    "            state_action_counts[state, action] += 1\n",
    "\n",
    "    state_action_freq = state_action_counts.float() / len(trajectories)\n",
    "\n",
    "    # Scale the state-action frequency to sum to 1\n",
    "    state_action_freq /= state_action_freq.sum()\n",
    "\n",
    "    return state_action_freq\n",
    "\n",
    "def feature_expectation(demonstrations):\n",
    "    \"\"\"\n",
    "    Compute the feature expectation from the given trajectories.\n",
    "    \"\"\"\n",
    "    n_trajectories, n_steps, feature_dim = demonstrations.shape\n",
    "    feature_expectation = torch.zeros(feature_dim)\n",
    "\n",
    "    for trajectory in demonstrations:\n",
    "        for state, _ in trajectory:\n",
    "            feature_expectation[state] += 1.0\n",
    "\n",
    "    return feature_expectation / n_trajectories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e90585c622a13aa6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:15:59.925147Z",
     "start_time": "2024-06-06T13:15:59.915961Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def maxent_deep_irl(reward_net, optimizer, transition_probabilities, reward, initial_state_distribution, epochs, gamma):\n",
    "    \"\"\"\n",
    "    Train the reward network using the Maximum Entropy Deep Inverse Reinforcement Learning (MaxEnt Deep IRL) algorithm\n",
    "    as shown in the algorithm 1 of (Wulfmeir & al, 2016).\n",
    "\n",
    "    :return: The reward of shape (n_states,) and a dictionary of metrics accumulated during the training.\n",
    "    \"\"\"\n",
    "    n_states, _, n_actions = transition_probabilities.shape\n",
    "\n",
    "    optimal_value_function, _, _ = deterministic_value_iteration(transition_probabilities, reward, gamma, epsilon=1E-5)\n",
    "\n",
    "    state_action_freq = state_action_frequency(n_states, n_actions, demonstrations)\n",
    "    feature_expectation = state_action_freq.sum(dim=1)\n",
    "\n",
    "    features = torch.eye(n_states)\n",
    "\n",
    "    expected_value_differences = []\n",
    "    losses = []\n",
    "    policies = []\n",
    "    rewards = []\n",
    "    learned_value_function = None\n",
    "\n",
    "    for epoch in tqdm.tqdm(range(epochs), disable=False):\n",
    "        reward_estimation = reward_net(features).flatten()\n",
    "\n",
    "        policy, learned_value_function = soft_value_iteration(transition_probabilities, reward_estimation.detach(), gamma, epsilon=1E-5)\n",
    "        state_visitation_frequency = propagate_policy(policy, transition_probabilities, demonstrations, initial_state_distribution)\n",
    "\n",
    "        expected_value_difference = torch.abs(optimal_value_function - learned_value_function)\n",
    "\n",
    "        loss = -torch.sum(torch.log(policy + 1E-6) * state_action_freq, dim=0)\n",
    "        loss_gradient = feature_expectation - state_visitation_frequency\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        reward_estimation.backward(-loss_gradient)\n",
    "        optimizer.step()\n",
    "\n",
    "        expected_value_differences.append(expected_value_difference.detach().numpy())\n",
    "        losses.append(loss.detach().numpy())\n",
    "        policies.append(policy.detach().numpy())\n",
    "        rewards.append(reward_estimation.detach().numpy())\n",
    "\n",
    "    metrics = {\n",
    "        \"expected_value_differences\": expected_value_differences,\n",
    "        \"value_functions\": learned_value_function,\n",
    "        \"losses\": losses,\n",
    "        \"policies\": policies,\n",
    "        \"rewards\": rewards\n",
    "    }\n",
    "\n",
    "    reward = reward_net(features).flatten()\n",
    "    return reward, metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b4f6a04bcd79f40",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Value Iteration agent as expert demonstration\n",
    "We will use an agent based on the deterministic value iteration defined in [value_iteration.py](../src/maxent_deep_irl/value_iteration.py) to generate expert demonstrations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "aae9a63655e1653a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:16:03.774268Z",
     "start_time": "2024-06-06T13:15:59.925147Z"
    },
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class ValueIterationAgent:\n",
    "    def __init__(self, mdp, gamma=0.99, epsilon=1E-5, save_value_functions=False):\n",
    "        _, self.policy, self.value_functions = deterministic_value_iteration(\n",
    "            mdp.transition_probabilities,\n",
    "            mdp.reward,\n",
    "            gamma,\n",
    "            epsilon=epsilon,\n",
    "            save_value_functions=save_value_functions\n",
    "        )\n",
    "\n",
    "    def act(self, state):\n",
    "        return torch.argmax(self.policy[state])\n",
    "\n",
    "    def get_value_functions(self):\n",
    "        return self.value_functions\n",
    "\n",
    "    def get_policy(self):\n",
    "        return self.policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "37cf7576baed8dd8",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated 10 demonstrations\n",
      "Trajectory 1: [(1, 1), (0, 0), (0, 0), (1, 1), (0, 0), (0, 0), (1, 1), (0, 0), (0, 0), (1, 1)]\n",
      "Trajectory 2: [(0, 0), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0)]\n",
      "Trajectory 3: [(1, 1), (0, 0), (1, 1), (0, 0), (0, 0), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0)]\n",
      "Trajectory 4: [(1, 1), (0, 0), (0, 0), (0, 0), (1, 1), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0)]\n",
      "Trajectory 5: [(0, 0), (1, 1), (0, 0), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0)]\n",
      "Trajectory 6: [(1, 1), (0, 0), (1, 1), (0, 0), (0, 0), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0)]\n",
      "Trajectory 7: [(0, 0), (1, 1), (0, 0), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0)]\n",
      "Trajectory 8: [(0, 0), (1, 1), (0, 0), (1, 1), (0, 0), (0, 0), (0, 0), (1, 1), (0, 0), (1, 1)]\n",
      "Trajectory 9: [(1, 1), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0), (1, 1), (0, 0), (0, 0), (1, 1)]\n",
      "Trajectory 10: [(1, 1), (0, 0), (1, 1), (0, 0), (0, 0), (0, 0), (0, 0), (1, 1), (0, 0), (1, 1)]\n"
     ]
    }
   ],
   "source": [
    "def generate_demonstrations(agent, mdp, initial_state_distribution, n_trajectories, n_steps=10, seed=0):\n",
    "    torch.manual_seed(seed)\n",
    "    numpy.random.seed(seed)\n",
    "\n",
    "    demonstrations = []\n",
    "    for _ in range(n_trajectories):\n",
    "        trajectory = []\n",
    "\n",
    "        # Sample initial state\n",
    "        state = initial_state_distribution.sample().item()\n",
    "\n",
    "        for _ in range(n_steps):\n",
    "            action = agent.act(state).item()\n",
    "            trajectory.append((state, action))\n",
    "            state_probabilities = mdp.transition_probabilities[:, state, action]\n",
    "            state = torch.distributions.Categorical(state_probabilities).sample().item()\n",
    "\n",
    "        demonstrations.append(trajectory)\n",
    "\n",
    "    return demonstrations\n",
    "\n",
    "# Generate expert demonstrations\n",
    "mdp = ToyMDP()\n",
    "agent = ValueIterationAgent(mdp)\n",
    "\n",
    "initial_state_distribution = torch.ones(mdp.n_states) / mdp.n_states\n",
    "initial_state_distribution = torch.distributions.Categorical(initial_state_distribution)\n",
    "\n",
    "demonstrations = generate_demonstrations(agent, mdp, initial_state_distribution, n_trajectories=10, n_steps=10, seed=0)\n",
    "\n",
    "print(f\"Generated {len(demonstrations)} demonstrations\")\n",
    "for idx, demonstration in enumerate(demonstrations[:10]):\n",
    "    print(f\"Trajectory {idx + 1}: {demonstration}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dc963e59fb7c46e",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d9f87cabcc7061b2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-06T13:22:19.099134Z",
     "start_time": "2024-06-06T13:16:57.934936Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:00<00:00, 113.76it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real reward: tensor([ 3., -1.])\n",
      "Estimated reward: tensor([  7.7170, -11.4627], grad_fn=<ViewBackward0>)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "mdp = ToyMDP()\n",
    "\n",
    "expert_agent = ValueIterationAgent(mdp)\n",
    "\n",
    "initial_state_distribution = torch.ones(mdp.n_states) / mdp.n_states\n",
    "initial_state_distribution = torch.distributions.Categorical(initial_state_distribution)\n",
    "\n",
    "demonstrations = generate_demonstrations(expert_agent, mdp, initial_state_distribution, n_trajectories=100, n_steps=30, seed=0)\n",
    "\n",
    "reward_net = RewardNet(mdp.n_states)\n",
    "optimizer = torch.optim.Adam(reward_net.parameters(), lr=1E-2)\n",
    "\n",
    "rewards, metrics = maxent_deep_irl(reward_net, optimizer, mdp.transition_probabilities, mdp.reward, initial_state_distribution, epochs=100, gamma=mdp.gamma)\n",
    "\n",
    "print(f\"Real reward: {mdp.reward}\")\n",
    "print(f\"Estimated reward: {rewards}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7216b3d2f2c9750d",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVwAAADdCAYAAAD3jcrlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAARzUlEQVR4nO3de1SVdb7H8c8GBHS4KgKHQBALzVVtxgtomWjDjJfSnKnMWh7JW2emwWkOzqxJm2LStbLGQjMZmy6KnbDsMuh07DQ1qGOZZkfGGLuNmXjJA6IpIAUIe58/9ogRpmLy3bh5v9baa7kfnv08v8e27/Xjtx/I4Xa73QIAtDs/bw8AADoLggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILnzJixAiNGDGi+XlZWZkcDocKCgq8NibgJIILrysoKJDD4Wh+BAcHKyUlRdnZ2aqoqPD28IALJsDbAwBOmjdvnnr37q26ujq9/fbbWrZsmV577TXt3LlT3bp1O69jJiYm6quvvlKXLl0u8GiBtiO46DDGjBmjQYMGSZJmzJihHj16KC8vT2vXrtVtt912Xsc8OWMGOgKWFNBhXXfddZKkPXv2qLGxUfPnz1efPn0UFBSkpKQkzZ07V/X19Wc8xret4X788ceaOHGievbsqa5du6pv37669957JUkbNmyQw+FQUVFRq+OtWrVKDodDW7ZsuTAXiU6F4KLD2r17tySpR48emjFjhu6//34NGDBAixYtUkZGhhYsWKBJkya1+bilpaVKT0/X+vXrNXPmTD322GOaMGGCXn31VUmeD94SEhJUWFjY6rWFhYXq06ePhg4d+t0uDp0SSwroMKqqqnT48GHV1dVp8+bNmjdvnrp27ap+/frppz/9qWbMmKGnnnpKknTXXXcpOjpajzzyiDZs2KCRI0ee83lmzZolt9utkpIS9erVq3n7Qw89JMmzDDF58mTl5eWpqqpK4eHhkqTKykq98cYbzTNhoK2Y4aLDyMzMVM+ePZWQkKBJkyYpJCRERUVFeueddyRJOTk5LfafPXu2JGndunXnfI7Kykpt2rRJ06ZNaxFbyRPak6ZMmaL6+nq9/PLLzdtWr16txsZGTZ48uc3XBkjMcNGB5OfnKyUlRQEBAYqJiVHfvn3l5+enoqIi+fn56dJLL22xf2xsrCIiIrR3795zPsdnn30mSbriiivOuF+/fv00ePBgFRYWavr06ZI8ywlDhgxpNQ7gXBFcdBhpaWnNdymcztdnoBamTJmiu+++WwcOHFB9fb22bt2qpUuXmo4BvoUlBXR4iYmJcrlc2rVrV4vtFRUVOnbsmBITE8/5WMnJyZKknTt3nnXfSZMmyd/fX88//7wKCwvVpUsX3XrrrW0bPPA1BBcd3tixYyVJixcvbrE9Ly9PknT99def87F69uyp4cOHa/ny5dq3b1+Lr33z/6caFRWlMWPG6LnnnlNhYaFGjx6tqKio87gCwIMlBXR4TqdTWVlZevLJJ3Xs2DFlZGRo27ZtWrlypSZMmNCmOxQkacmSJRo2bJgGDBigO++8U71791ZZWZnWrVunHTt2tNh3ypQpuvnmmyVJ8+fPv1CXhE6K4OKi8PTTTys5OVkFBQUqKipSbGys5syZo9zc3DYfy+l0auvWrbrvvvu0bNky1dXVKTExURMnTmy177hx4xQZGSmXy6Xx48dfiEtBJ+Zwf/P7KADNGhsbFRcXp3HjxumZZ57x9nBwkWMNFziDNWvWqLKyUlOmTPH2UOADmOECp/Huu++qtLRU8+fPV1RUlEpKSrw9JPgAZrjAaSxbtkw/+9nPFB0drWeffdbbw4GPYIYLAEaY4QKAEYILAEZM78N1uVw6ePCgQkNDzX8uHgDag9vtVk1NjeLi4uTnd+Y5rGlwDx48qISEBMtTAoCJ/fv3Kz4+/oz7mAY3NDRUkvTe/myFhAVZnhqdUMyCR709BHQC1fVS0qJTfTsT0+CeXEYICQtSKMFFO+MtBkvnskzKh2YAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4ACRJ09ZIP3nB+8fwZQHeHkBnc6SyVo/cv0nF63brcEWtwiOD1d8ZrV/eP0yDr0lQvONBPV10k0ZP6OvtoeIiUFkr/W6D9NouqaJWigyWroqVfjtcuqZX2461aLTk/trz6wqk1Fgpb/SFHHHndl7Bzc/P18KFC1VeXi6n06nHH39caWlpF3psPunOm/6khoYmLVp5gxKTI1VZUavNxWU6euQrbw8NF6FbXpQamqTlE6TkSE90138mfXEeb6fw4As+PHxDm5cUVq9erZycHOXm5qqkpEROp1OjRo3SoUOH2mN8PqXqWJ3efWu/5j48UteMTFJ8Yri+nxan7DlX60fjUzQkKV+SNOPHryje8WDz87LdRzXtxpeUGrNYKSELdf3gFXrrr3uaj7to3lv6wRVPtjrfj1Kf1sL7/mZzcTB3rE56e5+0IFMa2VtKjJDSLpHuuVYa11f69RvS+FWn9n9sqxTwgPT6p6e29V0iPVPi+fPXlwOmrZE27ZWWvOt5TcADUtkxz9c+OOQ5buQCKWKBlLFC2v1Fy7E9+o4U/6gU/Xtp1jrpRFP7/B1cbNoc3Ly8PM2cOVNTp05V//799cQTT6hbt25avnx5e4zPp3wvJFDfCwnUX9b8U/X1ja2+vu69OyRJeStuUMn//aL5+ZfHG3Td2D56ofh2vf736RoxOll3jHtJn++rkiTdOs2pXR8d0Y73DjYfa+ffy/VR6SFNnHpVu18XvCMk0PNY+7F0mreThidKm/dJTS7P8017pahu0t/KPM8/r5Z2H5Uyklq/dtFoaUi8NGOAdGC255EQ5nnNyAIpKEB6M0vadqc0NVVqdJ167cYy6bMvpL9meWbeK9+XVu64gBd+EWtTcBsaGrR9+3ZlZmaeOoCfnzIzM7Vly5YLPjhfExDgp7yCG/TSyn+of0SeJlzzrB6au1Eflnq+O+jR83uSpLCIIEXHhjQ/7++M0eT/GKB+V0Qr+bLu+vX8DCX1idAbf94lSYqLD1PGqGS9uKK0+VyrV5RqSEYvJSZHGl8lrAT4SctvlP7rfanHw9K1y6V7i6XSCs/Xr02Uahqkv5dLbrf01l7pP4eeCu7fyqRLQqVLu7c+dniwFOgvdesixYZ4Hv5+0h/ek8KDpFU3SYPipJQe0h3fl/pGnXptZLC0ZKzUL0q6IUUae5m0fk/rc3RGbQru4cOH1dTUpJiYmBbbY2JiVF5e3mr/+vp6VVdXt3h0dtff1E/bD/5CK/58i0aMTtaWjXs1ZsAzerGg9FtfU3u8QfN/VawRl/9R/SMeVUrIQu366Ig+33fq7/P2mala+/yHqqtrVENDk9as+kC3TnNaXBK86Cf9pf2zpaJJ0qg+nogO/qNnRhkRLDljPNv+ccgT0JkDpR3l0vEGz4x3eFLbzvd+uTQsUeri/+379I/2xPmkfwuRDtW2/dp8UbveFrZgwQKFh4c3PxISEtrzdBeN4OAADf9hb/3yvmFa+06WbrnjKj2au+lb95//q2K9XvSJfvPgCL3y1r/rLzumq9+VPXWi4dTC2A/HXabAIH+9XvSJ3nx1lxpPuHT9zf0sLgdeFhwg/bCP9NsM6e3pUlaq9MBGz9eGJ3mCu6nMs8TQvat0eZRn7XfTXs+2tuja5ez7dPlGVRwOyeU+/b6dTZuCGxUVJX9/f1VUVLTYXlFRodjY2Fb7z5kzR1VVVc2P/fv3f7fR+qiU/lH6svaEJKlLFz81NbV8d763+YBuueMqjflxX11+ZbSiY0N0oKyqxT4BAX66OetKvbiiVC+uKNX4SZer67n864DPubynVNvg+XPGv9Zx1+85tVabkSSt3in988jp129PCvQ/tf570pXR0tt7+RDsfLUpuIGBgRo4cKCKi4ubt7lcLhUXF2vo0KGt9g8KClJYWFiLR2d29MiXmnhdoV55bqc+LD2kfXuO6b9f+kjLfr9VP7oxRZIUnxShzcVlOlR+XMeOeu7t6X1ZpP7nT5/ogx0V+vD9CmXfvlau00wZbpuRqs3ry7Tx9d0sJ3QCR76UMldKhaWedds9R6WXP5Ae2SyN/9dt3CfXcdf9s2VwV5V6vtVP6fHtx0+KkN793HN3wuEvPbPUn6dJ1fXS7a9I/3tQ2nVEeu596ZPD7XutvqLN9+Hm5OQoKytLgwYNUlpamhYvXqza2lpNnTq1PcbnU7qFBOr76XF6etE27d19VCdOuBSXEKrbZ6Yqe+7VkqT7H/2BHsj5q1Y9tUOxl4Rqa9nPlZuXqdnT1unGq1eqe1Q33fWbIaqprm91/OTLumvQ1fE69sVXGpB+ifXlwVhIoOc2sMe2em7LOuHy3EkwfYA051rPPpFdPbPSilrPh1iSJ8Iu99nXb3Oulqauka7Ml75qlD692xPhN7Ok37zp+cEIf4fkjJWubuMPWXRWDrfb3ebVlaVLlzb/4ENqaqqWLFmi9PT0s76uurpa4eHh+qhqtkLDgs5rwPh2brdbwy57Qll3DdCdOWf/7+HrYn/3oLeHgE6gul7q/pBUVVV11u/iz+snzbKzs5WdnX1eg0P7OFJZq7UvfKjK8uPcewt0UPwuBR/hjH5M3aO66uEnxyoisqu3hwPgNAiujzjgnuvtIQA4C349IwAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgBGCCwBGAixP5na7JUnHq+stT4tOqhtvMxg4mbOTfTsT0+DW1NRIkgYnLLU8LQC0u5qaGoWHh59xH4f7XLJ8gbhcLh08eFChoaFyOBxWp73oVVdXKyEhQfv371dYWJi3hwMfxnut7dxut2pqahQXFyc/vzOv0prOcP38/BQfH295Sp8SFhbGPwKY4L3WNmeb2Z7Eh2YAYITgAoARgnsRCAoKUm5uroKCgrw9FPg43mvty/RDMwDozJjhAoARggsARgguABghuABghOB2cPn5+UpKSlJwcLDS09O1bds2bw8JPmjTpk0aN26c4uLi5HA4tGbNGm8PyScR3A5s9erVysnJUW5urkpKSuR0OjVq1CgdOnTI20ODj6mtrZXT6VR+fr63h+LTuC2sA0tPT9fgwYO1dKnnl/24XC4lJCRo1qxZuueee7w8Ovgqh8OhoqIiTZgwwdtD8TnMcDuohoYGbd++XZmZmc3b/Pz8lJmZqS1btnhxZADOF8HtoA4fPqympibFxMS02B4TE6Py8nIvjQrAd0FwAcAIwe2goqKi5O/vr4qKihbbKyoqFBsb66VRAfguCG4HFRgYqIEDB6q4uLh5m8vlUnFxsYYOHerFkQE4X6a/gBxtk5OTo6ysLA0aNEhpaWlavHixamtrNXXqVG8PDT7m+PHj+vTTT5uf79mzRzt27FD37t3Vq1cvL47Mt3BbWAe3dOlSLVy4UOXl5UpNTdWSJUuUnp7u7WHBx2zcuFEjR45stT0rK0sFBQX2A/JRBBcAjLCGCwBGCC4AGCG4AGCE4AKAEYILAEYILgAYIbgAYITgAoARggsARgguABghuABghOACgJH/BzUlqq+r1A/aAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_value_function(value_function):\n",
    "    plt.figure()\n",
    "    plt.imshow(value_function.reshape(1, 2), cmap=\"hot\", interpolation=\"nearest\")\n",
    "    plt.title(\"Value function\")\n",
    "    plt.xticks(range(2))\n",
    "    plt.yticks(range(1))\n",
    "\n",
    "\n",
    "def plot_policy(policy):\n",
    "    action_symbols = [\"Stay\", \"Switch\"]\n",
    "    policy = policy.argmax(axis=1).reshape(1, 2)\n",
    "\n",
    "    fig, ax = plt.subplots(1, 1, figsize=(4, 4))\n",
    "    checkerboard_pattern = numpy.indices((1, 2)).sum(axis=0) % 2\n",
    "    ax.imshow(checkerboard_pattern, cmap=\"Wistia\")\n",
    "\n",
    "    ax.set_title(\"Policy\")\n",
    "    ax.set_xticks(range(2))\n",
    "    ax.set_yticks(range(1))\n",
    "\n",
    "    for i in range(2):\n",
    "        ax.text(i, 0, action_symbols[policy[0, i]], color=\"black\", ha=\"center\", va=\"center\")\n",
    "\n",
    "\n",
    "def plot_reward(reward, mdp):\n",
    "    fig, axes = plt.subplots(1, 2)\n",
    "\n",
    "    axes[0].imshow(mdp.reward.reshape(1, 2), cmap=\"hot\", interpolation=\"nearest\")\n",
    "    axes[0].set_title(\"Real reward\")\n",
    "    axes[0].set_xticks(range(2))\n",
    "    axes[0].set_yticks(range(1))\n",
    "\n",
    "    axes[1].imshow(reward.reshape(1, 2), cmap=\"hot\", interpolation=\"nearest\")\n",
    "    axes[1].set_title(\"Estimated reward\")\n",
    "    axes[1].set_xticks(range(2))\n",
    "    axes[1].set_yticks(range(1))\n",
    "\n",
    "\n",
    "def plot_metrics(metrics, mdp):\n",
    "    expected_value_differences = numpy.array(metrics[\"expected_value_differences\"])\n",
    "    losses = numpy.array(metrics[\"losses\"])\n",
    "    policies = metrics[\"policies\"]\n",
    "    rewards = numpy.array(metrics[\"rewards\"])\n",
    "    value_functions = metrics[\"value_functions\"]\n",
    "\n",
    "    plt.figure()\n",
    "    plt.plot(expected_value_differences)\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Expected value difference\")\n",
    "    plt.title(\"Expected value difference\")\n",
    "\n",
    "    plt.figure()\n",
    "    plt.plot(losses)\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.title(\"Loss\")\n",
    "\n",
    "    plt.figure()\n",
    "    for state in range(mdp.n_states):\n",
    "        plt.plot(rewards[:, state], label=f\"State {state}\")\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Reward\")\n",
    "    plt.title(\"Reward\")\n",
    "    plt.legend()\n",
    "\n",
    "    plot_value_function(value_functions)\n",
    "    plot_policy(policies[-1])\n",
    "    plot_reward(rewards[-1], mdp)\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "plot_metrics(metrics, mdp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89970177",
   "metadata": {},
   "source": [
    "## Going further\n",
    "For more complexe example take a look at the [Windy Gridworld example](../examples/windy_gridworld.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8e02c5bb3d96bd9",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "[1]&emsp; M. Wulfmeier, P. Ondruska, et I. Posner, «Maximum Entropy Deep Inverse Reinforcement Learning». arXiv, 11 mars 2016. doi: 10.48550/arXiv.1507.04888.\n",
    "\n",
    "[2]&emsp; B. D. Ziebart, A. Maas, J. A. Bagnell, and A. K. Dey, “Maximum entropy inverse reinforcement learning,” in Proceedings of the 23rd national conference on Artificial intelligence - Volume 3, in AAAI’08. Chicago, Illinois: AAAI Press, juillet 2008, pp. 1433–1438.\n",
    "\n",
    "[3]&emsp; K. M. Kitani, B. D. Ziebart, J. A. Bagnell, and M. Hebert, “Activity Forecasting,” in Computer Vision – ECCV 2012, A. Fitzgibbon, S. Lazebnik, P. Perona, Y. Sato, and C. Schmid, Eds., Berlin, Heidelberg: Springer, 2012, pp. 201–214. doi: 10.1007/978-3-642-33765-9_15."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}