2_Hypergrid_env.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Tikquuss/GflowNets_Tutorial/blob/main/2_Hypergrid_env.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "khW_f8B3FcUH"
      },
      "source": [
        "@Author TODO\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZazpM4GzYJQx"
      },
      "source": [
        "In the  hyper-grid domain, the states are the cells of a n-dimensional hypercubic grid of side length $H$. The agent starts at coordinate $s = (0, 0, ..., 0)$ and is only allowed to increase one coordinate (up to H, upon which the episode terminates). A stop action indicates to terminate the trajectory. There are many action sequences that lead to the same coordinate, making this Markov Decision Process a Directed Acyclic Graph. The reward for ending the trajectory in $x$ is some $R(x) \\ge 0$ (see below for examples of reward functions).\n",
        "\n",
        "In short, the non-terminal states form a n-dimensional hypergrid with side length $H$ : $\\{ (s_0, ..., s_{n-1}) \\ | \\ s_i \\in \\{0, ..., H\\}, 0 \\leq i \\leq n-1 \\}$.\n",
        "\n",
        "\n",
        "\n",
        "In each state $s = (s_0, ..., s_{n-1})$, we have $n+1$ possible actions:\n",
        "- either choose a stop action and return the state as terminal $x = T(s, stop\\_action) = s$, and then compute $R(x)$ \n",
        "- or we choose one of its $n$ coordinates $i$, and increment it : $s' = T(s, i) = (s_0, ..., s_i + 1, ..., s_{n-1})$\n",
        "\n",
        "\n",
        "> Example : ndim=2 (H=2, ...)\n",
        "```\n",
        "|  ...   |   ...  | ...    | ...\n",
        "................................\n",
        "| (0, 2) | (1, 2) | (2, 2) | ...\n",
        "................................\n",
        "| (0, 1) | (1, 1) | (2, 1) | ...\n",
        "................................\n",
        "| (0, 0) | (1, 0) | (2, 0) | ...\n",
        "................................\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "$$R(x) = R_0 + R_1 \\prod_{i=1}^{n} \\mathbb{I} (0.25 < |x_i/H - 0.5|) + R_2 \\prod_{i=1}^{n} \\mathbb{I} (0.3 < |x_i/H - 0.5| < 0.4), \\ R_0 <<< R_1 < R_2$$\n",
        "\n",
        "$$R_{cos}(x) = R_0 + R_1 \\prod_{i=1}^{n} \\big(cos(50\\times|x_i/H - 0.5|)+1 \\big) \\times f_{\\mathcal{N}} \\big(5\\times|x_i/H - 0.5|\\big) \\text{, } R_0 << R_1  \\text{ and } f_{\\mathcal{N}} \\text{ the standard normal p.d.f}$$\n",
        "\n",
        "$$\\dots$$\n",
        "\n",
        "$$\\text{Any reward function with full support or with large enough support on the grid domain.}$$\n",
        "\n",
        "We pave the hypercube and choose the reward values to give to each pavement. The mathematical trick is the following: \n",
        "* scale each point using the application from $[0, H]$ to $[0, 1]$ : $x \\mapsto \\frac{x}{H}$\n",
        "- calculate the distance of each point (coordinates) from the center of the hypercube: $|\\frac{x}{H}-0.5|$\n",
        "- and use this distance to create the paving and assign different reward values to the paving stones. \n",
        "\n",
        "In the first function above, the paving is at three levels : in $]0.3, 0.4[^n$ (not in terms of coordinates, but in terms of absolute distance from the center $(1/2, ..., 1/2)$ of the hypercube) the reward is equal to $R_0+R_1+R_2$ (higher mode), between $(]0.25, 0.3[ \\ U \\ ]0.4, 1[)^n$ the reward is equal to $R_0+R_1$, between  $[0, 0.25]^n$ the reward is equal to $R_0 <<< R_1 < R_2$ (the desert of probability).\n",
        "\n",
        "For the function with cosine, the paving is not strict, but smooth. \n",
        "* For the term with cosine, noted that $0 \\le 50 \\times |\\frac{x}{H}-0.5| \\le 25 ∼ 8\\pi$, and that the function $x \\mapsto cos(x) + 1$ varies from $2$ to $0$ between $[2k\\pi, (2k+1)\\pi]$ and from $0$ to $2$ between $[(2k+1)\\pi, 2(k+1)\\pi]$ for all $k \\in \\mathbb{N}$. So for this term the deserts of reward are $(2k+1)\\pi $ and the high modes are $2k\\pi$ ($k \\le 4$), from the deserts to the high modes the reward function in $cos$ is continuously increasing\n",
        "* For the term with $f_{\\mathcal{N}}$, noted that $0 \\le 5 \\times |x/H-0.5| \\le 2.5$, and that $f_{\\mathcal{N}(0, 1)}$ grows from $0.5$ to $0.99$ on this interval. Its high mode is therefore $0$, and the further away from $0$ (and thus from the center of the hypercube), the more it decreases.\n",
        "\n",
        "By multiplying these two terms, instead of having peaks at regular intervals as with the $cos$ term, we have lower and lower peaks when we move away from the center of the hypercube. \n",
        "\n",
        "I did a plot for $n=2$ below."
      ],
      "metadata": {
        "id": "VQA1t9q3KhQG"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CvM9Yb0QbjRD"
      },
      "source": [
        "# Env"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Grid domain"
      ],
      "metadata": {
        "id": "E66NIJ3AMZRS"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K35bNEEUb5WW"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "\n",
        "def build_grid(ndim, H):\n",
        "    \"\"\"\n",
        "    > Example : ndim=2 (H=2, ...)\n",
        "    ```\n",
        "    |  ...   |   ...  | ...    | ...\n",
        "    ---------------------------------\n",
        "    | (0, 2) | (1, 2) | (2, 2) | ...\n",
        "    ---------------------------------\n",
        "    | (0, 1) | (1, 1) | (2, 1) | ...\n",
        "    ---------------------------------\n",
        "    | (0, 0) | (1, 0) | (2, 0) | ...\n",
        "    ---------------------------------\n",
        "    ```\n",
        "    \"\"\"\n",
        "    # We have (H+1)^ndim points, each point being of dimension ndim.\n",
        "    grid_shape = (H+1,)*ndim+(ndim,) # (H+1, ..., H+1, ndim)\n",
        "    grid = torch.zeros(grid_shape)\n",
        "    for i in range(ndim):\n",
        "        grid_i = torch.linspace(start=0, end=H, steps=H+1)\n",
        "        for _ in range(i): grid_i = grid_i.unsqueeze(1)\n",
        "        grid[...,i] = grid_i\n",
        "    #return grid.view((H+1)**ndim,-1) # ((H+1)*ndim, ndim)\n",
        "    return grid"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d8MBwxw-Hcbv"
      },
      "source": [
        "## Reward function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Huqpm4c_HU9N"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from scipy.stats import norm\n",
        "\n",
        "def get_reward_function(H, R0, r_cos = False, R1 = 0.5, R2 = 2):\n",
        "    \"\"\" \n",
        "    x ~ (bs, n), 0 < r0 << r1 < r2\n",
        "    R1 : 1e-1, 1e-2, 1e-3 ...\n",
        "    \"\"\"\n",
        "    def R(x) :\n",
        "        ax = abs(x/H - 0.5)\n",
        "        return R0 + (0.25 < ax).prod(-1) * R1  + ((0.3 < ax) * (ax < 0.4)).prod(-1) * R2\n",
        "        #ax = abs(x/H*2 - 1)\n",
        "        #return R0 + (0.5 < ax).prod(-1) * R1  + ((0.6 < ax) * (ax < 0.8)).prod(-1) * R2\n",
        "\n",
        "    def R_cos(x) :\n",
        "        ax = abs(x/H - 0.5)\n",
        "        return R0 + ((np.cos(ax * 50) + 1) * norm.pdf(ax * 5)).prod(-1) * R1\n",
        "\n",
        "    return R if not r_cos else R_cos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IQF1Hzmnw4OY"
      },
      "source": [
        "##  sanity check"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wOzuGGRIgD2j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9c7fccf1-442a-42bb-f40e-47a37f4336a6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True,  True,  True,  True])"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "R0, R1, R2 = 1e-2, 0.5, 2\n",
        "R = get_reward_function(H=8, R0=R0, r_cos=False, R1=R1, R2=R2)\n",
        "s_f = np.array([[4, 4], [0,0], [8, 8], [1,1]])\n",
        "R(s_f) == np.array([R0, R0+R1, R0+R1, R0+R1+R2])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-Zg7jpxxw6te",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "12d14add-82a4-4afe-cf46-febe0e03156c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[[0., 0.],\n",
              "          [1., 0.],\n",
              "          [2., 0.],\n",
              "          [3., 0.],\n",
              "          [4., 0.],\n",
              "          [5., 0.],\n",
              "          [6., 0.],\n",
              "          [7., 0.],\n",
              "          [8., 0.]],\n",
              " \n",
              "         [[0., 1.],\n",
              "          [1., 1.],\n",
              "          [2., 1.],\n",
              "          [3., 1.],\n",
              "          [4., 1.],\n",
              "          [5., 1.],\n",
              "          [6., 1.],\n",
              "          [7., 1.],\n",
              "          [8., 1.]],\n",
              " \n",
              "         [[0., 2.],\n",
              "          [1., 2.],\n",
              "          [2., 2.],\n",
              "          [3., 2.],\n",
              "          [4., 2.],\n",
              "          [5., 2.],\n",
              "          [6., 2.],\n",
              "          [7., 2.],\n",
              "          [8., 2.]],\n",
              " \n",
              "         [[0., 3.],\n",
              "          [1., 3.],\n",
              "          [2., 3.],\n",
              "          [3., 3.],\n",
              "          [4., 3.],\n",
              "          [5., 3.],\n",
              "          [6., 3.],\n",
              "          [7., 3.],\n",
              "          [8., 3.]],\n",
              " \n",
              "         [[0., 4.],\n",
              "          [1., 4.],\n",
              "          [2., 4.],\n",
              "          [3., 4.],\n",
              "          [4., 4.],\n",
              "          [5., 4.],\n",
              "          [6., 4.],\n",
              "          [7., 4.],\n",
              "          [8., 4.]],\n",
              " \n",
              "         [[0., 5.],\n",
              "          [1., 5.],\n",
              "          [2., 5.],\n",
              "          [3., 5.],\n",
              "          [4., 5.],\n",
              "          [5., 5.],\n",
              "          [6., 5.],\n",
              "          [7., 5.],\n",
              "          [8., 5.]],\n",
              " \n",
              "         [[0., 6.],\n",
              "          [1., 6.],\n",
              "          [2., 6.],\n",
              "          [3., 6.],\n",
              "          [4., 6.],\n",
              "          [5., 6.],\n",
              "          [6., 6.],\n",
              "          [7., 6.],\n",
              "          [8., 6.]],\n",
              " \n",
              "         [[0., 7.],\n",
              "          [1., 7.],\n",
              "          [2., 7.],\n",
              "          [3., 7.],\n",
              "          [4., 7.],\n",
              "          [5., 7.],\n",
              "          [6., 7.],\n",
              "          [7., 7.],\n",
              "          [8., 7.]],\n",
              " \n",
              "         [[0., 8.],\n",
              "          [1., 8.],\n",
              "          [2., 8.],\n",
              "          [3., 8.],\n",
              "          [4., 8.],\n",
              "          [5., 8.],\n",
              "          [6., 8.],\n",
              "          [7., 8.],\n",
              "          [8., 8.]]]), torch.Size([9, 9, 2]))"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "ndim, H = 2, 8\n",
        "grid = build_grid(ndim, H)\n",
        "grid, grid.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y7JmngdEyN3Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8f665ede-0e1b-4b74-c25e-ec9f945fc8ed"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.5100, 0.5100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.5100, 0.5100],\n",
              "        [0.5100, 2.5100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 2.5100, 0.5100],\n",
              "        [0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100],\n",
              "        [0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100],\n",
              "        [0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100],\n",
              "        [0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100],\n",
              "        [0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100],\n",
              "        [0.5100, 2.5100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 2.5100, 0.5100],\n",
              "        [0.5100, 0.5100, 0.0100, 0.0100, 0.0100, 0.0100, 0.0100, 0.5100, 0.5100]])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "R0, R1, R2 = 1e-2, 0.5, 2\n",
        "R = get_reward_function(H=H, R0=R0, r_cos=False, R1=R1, R2=R2)\n",
        "all_rewards = R(grid)\n",
        "all_rewards"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E_OvUqV4ij4r",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "191120e5-ebed-42ce-f4ce-21a0e51f29ea"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.01234862, 0.01234862, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.01234862, 0.01234862, 0.01234862,\n",
              "       0.09124463, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.09124463, 0.01234862, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.01234862, 0.09124463,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.00748982,\n",
              "       0.09124463, 0.01234862, 0.01234862, 0.01234862, 0.00748982,\n",
              "       0.00748982, 0.00748982, 0.00748982, 0.00748982, 0.01234862,\n",
              "       0.01234862], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "true_dist = all_rewards.flatten().softmax(0).cpu().numpy()\n",
        "true_dist"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7K3NeIhUIa0b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "037cedd0-740e-4b12-8c5a-92b131344ec6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0., 0.],\n",
              "        [1., 0.],\n",
              "        [2., 0.],\n",
              "        [3., 0.],\n",
              "        [4., 0.],\n",
              "        [5., 0.],\n",
              "        [6., 0.],\n",
              "        [7., 0.],\n",
              "        [8., 0.],\n",
              "        [0., 1.],\n",
              "        [1., 1.],\n",
              "        [2., 1.],\n",
              "        [3., 1.],\n",
              "        [4., 1.],\n",
              "        [5., 1.],\n",
              "        [6., 1.],\n",
              "        [7., 1.],\n",
              "        [8., 1.],\n",
              "        [0., 2.],\n",
              "        [1., 2.],\n",
              "        [2., 2.],\n",
              "        [3., 2.],\n",
              "        [4., 2.],\n",
              "        [5., 2.],\n",
              "        [6., 2.],\n",
              "        [7., 2.],\n",
              "        [8., 2.],\n",
              "        [0., 3.],\n",
              "        [1., 3.],\n",
              "        [2., 3.],\n",
              "        [3., 3.],\n",
              "        [4., 3.],\n",
              "        [5., 3.],\n",
              "        [6., 3.],\n",
              "        [7., 3.],\n",
              "        [8., 3.],\n",
              "        [0., 4.],\n",
              "        [1., 4.],\n",
              "        [2., 4.],\n",
              "        [3., 4.],\n",
              "        [4., 4.],\n",
              "        [5., 4.],\n",
              "        [6., 4.],\n",
              "        [7., 4.],\n",
              "        [8., 4.],\n",
              "        [0., 5.],\n",
              "        [1., 5.],\n",
              "        [2., 5.],\n",
              "        [3., 5.],\n",
              "        [4., 5.],\n",
              "        [5., 5.],\n",
              "        [6., 5.],\n",
              "        [7., 5.],\n",
              "        [8., 5.],\n",
              "        [0., 6.],\n",
              "        [1., 6.],\n",
              "        [2., 6.],\n",
              "        [3., 6.],\n",
              "        [4., 6.],\n",
              "        [5., 6.],\n",
              "        [6., 6.],\n",
              "        [7., 6.],\n",
              "        [8., 6.],\n",
              "        [0., 7.],\n",
              "        [1., 7.],\n",
              "        [2., 7.],\n",
              "        [3., 7.],\n",
              "        [4., 7.],\n",
              "        [5., 7.],\n",
              "        [6., 7.],\n",
              "        [7., 7.],\n",
              "        [8., 7.],\n",
              "        [0., 8.],\n",
              "        [1., 8.],\n",
              "        [2., 8.],\n",
              "        [3., 8.],\n",
              "        [4., 8.],\n",
              "        [5., 8.],\n",
              "        [6., 8.],\n",
              "        [7., 8.],\n",
              "        [8., 8.]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "grid.view((H+1)**ndim,-1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t1SvIX6eIWcn"
      },
      "source": [
        "## Plots\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S4hL7XSrbVI-"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from scipy.interpolate import griddata\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib import cm\n",
        "import matplotlib.ticker as ticker\n",
        "\n",
        "def plot(x, y, z) :\n",
        "    \"\"\"https://stackoverflow.com/a/30539444/11814682\"\"\"\n",
        "    xyz = {'x': x, 'y': y, 'z': z}\n",
        "    # put the data into a pandas DataFrame (this is what my data looks like)\n",
        "    df = pd.DataFrame(xyz, index=range(len(xyz['x']))) \n",
        "\n",
        "    # re-create the 2D-arrays\n",
        "    x1 = np.linspace(df['x'].min(), df['x'].max(), len(df['x'].unique()))\n",
        "    y1 = np.linspace(df['y'].min(), df['y'].max(), len(df['y'].unique()))\n",
        "    x2, y2 = np.meshgrid(x1, y1)\n",
        "    z2 = griddata((df['x'], df['y']), df['z'], (x2, y2), method='cubic')\n",
        "\n",
        "    fig = plt.figure()\n",
        "    ax = fig.gca(projection='3d')\n",
        "    surf = ax.plot_surface(x2, y2, z2, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)\n",
        "    #surf = ax.plot_surface(x2, y2, z2 / z.sum() - 1.5, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)\n",
        "    ax.set_zlim(-1.01, 1.01)\n",
        "\n",
        "    ax.zaxis.set_major_locator(ticker.LinearLocator(10))\n",
        "    ax.zaxis.set_major_formatter(ticker.FormatStrFormatter('%.02f'))\n",
        "\n",
        "    fig.colorbar(surf, shrink=0.5, aspect=5)\n",
        "    plt.title('2D grid domain')\n",
        "\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7nSn8rG-ybyA"
      },
      "outputs": [],
      "source": [
        "H = 100\n",
        "N = 100\n",
        "x, y = np.linspace(start = 0, stop = H, num=N), np.linspace(start = 0, stop = H, num=N)\n",
        "xy = np.array(np.meshgrid(x, y)).T.reshape(-1,2) # (N*N,2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pWep961BygCl",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "outputId": "92664b5d-4568-4575-e3fd-22dba9538f78"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(None, None)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "R0, R1, R2 = 1e-2, 0.5, 1\n",
        "R = get_reward_function(H=H, R0=R0, r_cos=False, R1=R1, R2=R2)\n",
        "z = R(xy)\n",
        "x, y = xy[:,0], xy[:,1]\n",
        "plot(x, y, z), plot(x, y, z / z.sum())#, plot(x, y, z / np.log(z))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7VmfNG56IgsW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "outputId": "1a1dd725-24a3-4cf7-fdf6-74174e4b8379"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(None, None)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "R0, R1 = 1e-2, 1\n",
        "R = get_reward_function(H=H, R0=R0, r_cos=True, R1=R1)\n",
        "z = R(xy)\n",
        "x, y = xy[:,0], xy[:,1]\n",
        "plot(x, y, z), plot(x, y, z / z.sum())#, plot(x, y, z / np.log(z))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q8AJNkOFSnYD"
      },
      "source": [
        "# Gflownet agents"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YFyjvY51Smm-"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "import tqdm\n",
        "import pickle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g8qMFhXjnJ7o",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "22cedf7c-86ca-4612-c196-d7178ea059b2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total reward tensor(210.8900)\n"
          ]
        }
      ],
      "source": [
        "#H =  4 # horizon\n",
        "#H =  8 # horizon\n",
        "H =  32 # horizon\n",
        "#H =  100 # horizon\n",
        "ndim = 2\n",
        "#ndim = 4\n",
        "#ndim = 6\n",
        "#ndim = 8\n",
        "\n",
        "grid = build_grid(ndim, H) # (H, ...., H, ndim)\n",
        "grid = grid.view((H+1)**ndim,-1) # ((H+1)**ndim, ndim)\n",
        "\n",
        "R0, R1, R2 = 1e-2, 0.5, 2\n",
        "reward_function = get_reward_function(H=H, R0=R0, r_cos=False, R1=R1, R2=R2)\n",
        "#R0, R1 = 1e-2, 1\n",
        "#reward_function = get_reward_function(H, R0=R0, r_cos=True, R1=R1)\n",
        "\n",
        "all_rewards = reward_function(grid)\n",
        "#print('total reward', all_rewards.view(-1).logsumexp(0))\n",
        "print('total reward', all_rewards.view(-1).sum(0))\n",
        "true_dist = all_rewards.flatten().softmax(0).cpu().numpy()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "## For debugging\n",
        "\n",
        "Once our model is trained, we will generate some terminal states, display their rewards and see if they match the figure below\n",
        "\n"
      ],
      "metadata": {
        "id": "f4Bj2MzEb9SR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ar = all_rewards.reshape((H+1,)*ndim)"
      ],
      "metadata": {
        "id": "HmSriDYPb-_Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "  print(ar)"
      ],
      "metadata": {
        "id": "FAh5FWo9cAeA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9f386537-ed22-40b6-fdcb-b2fb01a61aed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[0.5100, 0.5100, 0.5100,  ..., 0.5100, 0.5100, 0.5100],\n",
            "        [0.5100, 0.5100, 0.5100,  ..., 0.5100, 0.5100, 0.5100],\n",
            "        [0.5100, 0.5100, 0.5100,  ..., 0.5100, 0.5100, 0.5100],\n",
            "        ...,\n",
            "        [0.5100, 0.5100, 0.5100,  ..., 0.5100, 0.5100, 0.5100],\n",
            "        [0.5100, 0.5100, 0.5100,  ..., 0.5100, 0.5100, 0.5100],\n",
            "        [0.5100, 0.5100, 0.5100,  ..., 0.5100, 0.5100, 0.5100]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    plt.imshow(ar)\n",
        "else :\n",
        "    plt.imshow(ar[0,0])"
      ],
      "metadata": {
        "id": "muInUYalcD5M",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "outputId": "9f1a99ef-f8db-487a-8a22-f6d1e4b0bb65"
      },
      "execution_count": null,
      "outputs": [
        {
          "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": "code",
      "source": [
        "if ndim == 4 :\n",
        "    plt.imshow(ar.sum((0,1)),vmin=0);plt.show()"
      ],
      "metadata": {
        "id": "jqPj4YVzb6RB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Utils\n",
        "\n"
      ],
      "metadata": {
        "id": "xAZpA_gfcIuZ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KClCuI9ZjrCu"
      },
      "outputs": [],
      "source": [
        "def make_mlp(l, act=torch.nn.LeakyReLU(), tail=[]):\n",
        "    return torch.nn.Sequential(*(sum(\n",
        "        [[torch.nn.Linear(i, o)] + ([act] if n < len(l)-2 else [])\n",
        "         for n, (i, o) in enumerate(zip(l, l[1:]))], []) + tail))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hglj70P0yyH1"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "**Re-execute the following cells each time H changes**\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1KptIGzLyWJd"
      },
      "outputs": [],
      "source": [
        "def one_hot_embedding(states, num_classes = H+1):\n",
        "    # states : (bs, ndim) -> (bs, embedding_dim), embedding_dim = num_classes x ndim\n",
        "    assert num_classes >= H + 1\n",
        "    return torch.nn.functional.one_hot(states, num_classes).view(states.shape[0],-1).float()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TLOWUN2g2vVS"
      },
      "source": [
        "The following function allows to associate a unique index to each state of the grid environment.\\\n",
        "Given that a coordinate can take $H+1$ values (from $0$ to $H$), it is enough to write them in this base to ensure the uniqueness.\\\n",
        "$$Index \\bigg(s = (s_i)_{i=0}^{ndim-1} \\bigg) = \\sum_{i=0}^{ndim-1} s_i (H+1)^i $$\n",
        "To find a state given its index, just invoke `grid[index]`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T_7z0-7S2SP-"
      },
      "outputs": [],
      "source": [
        "base_coordinates = (H+1)**torch.arange(ndim) # [(H+1)^0, ..., (H+1)^(ndim-1)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2sTWaeES2PGg"
      },
      "outputs": [],
      "source": [
        "def get_state_index(states):\n",
        "    \"\"\"\n",
        "    This function allows to associate a unique index to each state of the grid environment.\n",
        "    To find a state given its index, just invoke grid[state_index]\n",
        "    > params : \n",
        "        * states ~ Tensor(num_states, ndim), batch_size can be zero (for single state)\n",
        "    \"\"\"\n",
        "    state_index = (states*base_coordinates).sum().item()\n",
        "    return state_index # (num_states,)\n",
        "\n",
        "def get_state(indexes) :\n",
        "    \"\"\"\n",
        "    This function allows to find a state given its index\n",
        "    > params : \n",
        "        * indexes  ~ LongTensor(num_states,) or int (for single state)\n",
        "    \"\"\"\n",
        "    return grid[indexes] # (num_states, ndim)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DS_8OrQ64p6B"
      },
      "source": [
        "sanity check"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2ifBm2hK4tHB"
      },
      "outputs": [],
      "source": [
        "for i, states in enumerate(grid) :\n",
        "    assert i == get_state_index(states)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JylqGi9nyrLm"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eqh1pjOY_gRq"
      },
      "outputs": [],
      "source": [
        "from typing import List\n",
        "\n",
        "def get_modes_founds_old(first_visit : List[int], threshold : float = R2, max_steps : int = None) :\n",
        "    \"\"\"Calculates the modes (R >= threshold) found for each episode\n",
        "    \"\"\"\n",
        "    n = max_steps if max_steps is not None else n_train_steps\n",
        "    xs = range(n)\n",
        "    #modes_founds = [(reward_function(torch.stack([get_state(s) for s in list(set(np.where(first_visit == i)[0]))])) >= threshold).sum() for i in xs]\n",
        "    modes_founds = [0]*n\n",
        "    for i in xs :\n",
        "        states_i = list(set(np.where((0 <= first_visit) & (first_visit <= i))[0]))\n",
        "        states_i = get_state(torch.LongTensor(states_i))\n",
        "        r = reward_function(states_i)\n",
        "        modes_founds[i] = (r >= threshold).sum().item()\n",
        "    \n",
        "    return modes_founds, [(i+1)*batch_size for i in xs]\n",
        "\n",
        "def get_modes_founds(first_visit : List[int], modes : List[bool], max_steps : int = None) :\n",
        "    \"\"\"\n",
        "    Calculates the modes (R >= threshold) found for each episode.\n",
        "    Make sure first_visit and all_rewards have same shape\n",
        "    * ```modes = all_rewards >= threshold```\n",
        "    \"\"\"\n",
        "    n = max_steps if max_steps is not None else n_train_steps\n",
        "    ### numpy\n",
        "    # #modes_founds = ((first_visit<np.arange(n_train_steps).unsqueeze(1)) - (first_visit==-1)) * batch_size\n",
        "    # first_visit = first_visit[modes] # (n_modes,)\n",
        "    # modes_founds = (0 <= first_visit) & (first_visit <= np.arange(n)[...,np.newaxis]) # (n, n_modes)\n",
        "    # pytorch\n",
        "    first_visit = torch.from_numpy(first_visit)[modes] # (n_modes,)\n",
        "    modes_founds = (0 <= first_visit) & (first_visit <= torch.arange(n).unsqueeze(1)) # (n, n_modes)\n",
        "\n",
        "    return modes_founds.sum(1), np.arange(1, n+1)*batch_size"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JTGgqRae6Hw-"
      },
      "source": [
        "## Paramaters\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hd5CP3S_dBNU"
      },
      "outputs": [],
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YGRmRS6Yoi08"
      },
      "outputs": [],
      "source": [
        "n_hid = 256\n",
        "n_layers = 2\n",
        "\n",
        "batch_size = 128\n",
        "\n",
        "minus_inf = -1e8\n",
        "\n",
        "# set PB to uniform distribution (and learn just PF) or not \n",
        "uniform_PB = False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cDnpwMYfvNgV"
      },
      "outputs": [],
      "source": [
        "#n_train_steps = 50000\n",
        "n_train_steps = 5000\n",
        "#n_train_steps = 1000\n",
        "#n_train_steps = 50"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2SNWpaimSv3C"
      },
      "source": [
        "## Trajectory Balance objective\n",
        "\n",
        "$$ \n",
        "\\mathcal{L}_{TB} \\big(\\tau = (s_0, ..., s_n = x) \\big) = \\bigg( log \\frac{Z_{\\theta} \\prod_{t=1}^{n} P_{F} (s_t | s_{t-1}; \\theta) }{R(x) \\prod_{t=1}^{n} P_{B} (s_{t-1} | s_t; \\theta) } \\bigg)^2\n",
        "\\\\= \\bigg[ log(Z_{\\theta}) + \\sum_{t=1}^{n} \\bigg( - log\\big( P_{B} (s_{t-1} | s_t; \\theta)\\big) + log\\big(P_{F} (s_t | s_{t-1}; \\theta)\\big) \\bigg) - log \\big(R(x)\\big) \\bigg]^2\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Lm-JHa4E1ee_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "beda056c-881f-40a8-85ec-2f01a0be64e0"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Sequential(\n",
              "  (0): Linear(in_features=66, out_features=256, bias=True)\n",
              "  (1): LeakyReLU(negative_slope=0.01)\n",
              "  (2): Linear(in_features=256, out_features=256, bias=True)\n",
              "  (3): LeakyReLU(negative_slope=0.01)\n",
              "  (4): Linear(in_features=256, out_features=5, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ],
      "source": [
        "input_dim = ndim*(H+1) # embedding dim\n",
        "output_dim = 2*ndim+1 # ndim + 1 for P_F (+1 for stop action) and ndim for P_B \n",
        "model_TB = make_mlp([input_dim] + [n_hid] * n_layers + [output_dim]).to(device)\n",
        "logZ_TB = torch.zeros((1,)).to(device) # log (initial state flow), Z = 1\n",
        "optimizer = torch.optim.Adam([ {'params':model_TB.parameters(), 'lr':0.001}, {'params':[logZ_TB], 'lr':0.1} ])\n",
        "logZ_TB.requires_grad_()\n",
        "\n",
        "model_TB"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2tW5HHfX3oCZ"
      },
      "outputs": [],
      "source": [
        "losses_TB = []\n",
        "rewards_TB = []\n",
        "logZ_TB_list = []\n",
        "all_visited_TB = []\n",
        "first_visit_TB = -1 * np.ones_like(true_dist)\n",
        "l1log_TB = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_AIYVboU30Ho",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d6e1e4b-aded-4bf8-f208-f9f807cec741"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  0%|          | 2/5000 [00:00<11:29,  7.25it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 5.628333568572998 logZ = 0.09999999403953552 R = 0.52953124\n",
            "L1 = 0.001778725696686156\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  2%|▏         | 102/5000 [00:17<10:21,  7.88it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 1.78291807025671 logZ = 4.135488986968994 R = 0.86250013\n",
            "L1 = 0.0013702014601213934\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  4%|▍         | 202/5000 [00:31<11:26,  6.99it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.5742632935196161 logZ = 5.280782699584961 R = 1.2209768\n",
            "L1 = 0.000986035780049603\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  6%|▌         | 302/5000 [00:46<12:27,  6.29it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.04529868707060814 logZ = 5.328988552093506 R = 1.3409374\n",
            "L1 = 0.0008484788044541983\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  8%|▊         | 402/5000 [01:01<11:56,  6.42it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.01844014646951109 logZ = 5.328639984130859 R = 1.3551171\n",
            "L1 = 0.0008142327996237067\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 10%|█         | 502/5000 [01:16<11:20,  6.61it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.010433530427981168 logZ = 5.33644962310791 R = 1.3458202\n",
            "L1 = 0.0008219010561917563\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 12%|█▏        | 602/5000 [01:31<10:56,  6.70it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.011155250065494329 logZ = 5.329713821411133 R = 1.3734764\n",
            "L1 = 0.0008319790157654365\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 14%|█▍        | 702/5000 [01:46<11:10,  6.41it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.008212211115751416 logZ = 5.3406596183776855 R = 1.3804686\n",
            "L1 = 0.0008397900719583341\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 16%|█▌        | 802/5000 [02:02<11:01,  6.34it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.012371844133595005 logZ = 5.340714454650879 R = 1.3629686\n",
            "L1 = 0.0008446476940957603\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 18%|█▊        | 902/5000 [02:17<10:38,  6.42it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.008148455801419914 logZ = 5.338907241821289 R = 1.3625779\n",
            "L1 = 0.0008492869687980526\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 20%|██        | 1002/5000 [02:32<09:47,  6.81it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.011026920803124085 logZ = 5.329413414001465 R = 1.355703\n",
            "L1 = 0.0008521966287347992\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 22%|██▏       | 1102/5000 [02:47<09:55,  6.55it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.016485069857444613 logZ = 5.3343424797058105 R = 1.3725389\n",
            "L1 = 0.0008548253445309211\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 24%|██▍       | 1202/5000 [03:02<09:24,  6.72it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.01704291391884908 logZ = 5.347470760345459 R = 1.3616796\n",
            "L1 = 0.0008563711822690463\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 26%|██▌       | 1302/5000 [03:17<10:09,  6.06it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.016078759199008346 logZ = 5.330785751342773 R = 1.3592967\n",
            "L1 = 0.0008578448085068254\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 28%|██▊       | 1402/5000 [03:32<08:55,  6.72it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.01280792518693488 logZ = 5.34039306640625 R = 1.3674998\n",
            "L1 = 0.0008593743401128751\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 30%|███       | 1502/5000 [03:48<09:31,  6.13it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.019414019254036248 logZ = 5.346449851989746 R = 1.3490623\n",
            "L1 = 0.0008601265313698846\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 32%|███▏      | 1602/5000 [04:03<08:45,  6.47it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.014356851861812174 logZ = 5.348987579345703 R = 1.3586327\n",
            "L1 = 0.0008653938401551512\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 34%|███▍      | 1702/5000 [04:19<08:21,  6.58it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.01011250057257712 logZ = 5.359898567199707 R = 1.351992\n",
            "L1 = 0.0008779099099439482\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 36%|███▌      | 1802/5000 [04:34<08:25,  6.32it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.008463301360607148 logZ = 5.346924304962158 R = 1.3449998\n",
            "L1 = 0.0008784057777125432\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 38%|███▊      | 1902/5000 [04:49<08:15,  6.25it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.005478061276953668 logZ = 5.343153476715088 R = 1.3550389\n",
            "L1 = 0.0008769089916703025\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 40%|████      | 2002/5000 [05:05<08:02,  6.21it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0031735188351012765 logZ = 5.354211807250977 R = 1.3458202\n",
            "L1 = 0.0008760458144434891\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 42%|████▏     | 2102/5000 [05:20<07:27,  6.48it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.002414415905368514 logZ = 5.359030723571777 R = 1.345078\n",
            "L1 = 0.0008743102772534064\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 44%|████▍     | 2202/5000 [05:35<07:20,  6.35it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0014351527384133078 logZ = 5.353431701660156 R = 1.3358202\n",
            "L1 = 0.0008729512322579978\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 46%|████▌     | 2302/5000 [05:51<07:07,  6.30it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0012332153940224088 logZ = 5.352160453796387 R = 1.3472655\n",
            "L1 = 0.0008720329586124514\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 48%|████▊     | 2402/5000 [06:06<06:57,  6.23it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00131919666135218 logZ = 5.355493545532227 R = 1.3470702\n",
            "L1 = 0.0008706279999347654\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 50%|█████     | 2502/5000 [06:22<06:31,  6.38it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0013849276874680072 logZ = 5.349582195281982 R = 1.3568358\n",
            "L1 = 0.0008697097262892192\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 52%|█████▏    | 2602/5000 [06:37<06:13,  6.43it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0011863567828550004 logZ = 5.352218151092529 R = 1.3421874\n",
            "L1 = 0.0008685894324416526\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 54%|█████▍    | 2702/5000 [06:52<05:41,  6.73it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0011416754854144528 logZ = 5.34600305557251 R = 1.3425779\n",
            "L1 = 0.0008670100017713128\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 56%|█████▌    | 2802/5000 [07:07<05:38,  6.50it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0019052506890147925 logZ = 5.348293304443359 R = 1.342539\n",
            "L1 = 0.0008664957685298069\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 58%|█████▊    | 2902/5000 [07:23<05:31,  6.33it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0014822547981748358 logZ = 5.35621452331543 R = 1.3526951\n",
            "L1 = 0.0008656325913029933\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 60%|██████    | 3002/5000 [07:38<05:11,  6.42it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0023967039538547396 logZ = 5.353648662567139 R = 1.3404295\n",
            "L1 = 0.0008647326831303577\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 62%|██████▏   | 3102/5000 [07:54<05:09,  6.13it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.005494735561078414 logZ = 5.348416805267334 R = 1.3426951\n",
            "L1 = 0.0008640990743149307\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 64%|██████▍   | 3202/5000 [08:09<04:52,  6.16it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.005218944337684661 logZ = 5.349833011627197 R = 1.3469529\n",
            "L1 = 0.0008638695059035443\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 66%|██████▌   | 3302/5000 [08:25<04:28,  6.33it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0058119719568639995 logZ = 5.346216678619385 R = 1.3516796\n",
            "L1 = 0.0008636583029650685\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 68%|██████▊   | 3402/5000 [08:40<04:17,  6.22it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0025849097920581697 logZ = 5.35282039642334 R = 1.3396873\n",
            "L1 = 0.0008632634452974836\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 70%|███████   | 3502/5000 [08:55<03:44,  6.67it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0024502310279058293 logZ = 5.351184844970703 R = 1.3424608\n",
            "L1 = 0.0008632634452974836\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 72%|███████▏  | 3602/5000 [09:10<03:31,  6.62it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0015901357040274888 logZ = 5.348814964294434 R = 1.3441795\n",
            "L1 = 0.0008634654654995037\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 74%|███████▍  | 3702/5000 [09:26<03:18,  6.53it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0011742146176402456 logZ = 5.355237007141113 R = 1.3625389\n",
            "L1 = 0.000863667485701524\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 76%|███████▌  | 3802/5000 [09:41<03:03,  6.52it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0021212736348388715 logZ = 5.349887371063232 R = 1.3365624\n",
            "L1 = 0.0008634195518172265\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 78%|███████▊  | 3902/5000 [09:55<02:49,  6.49it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.003614989003399387 logZ = 5.356720447540283 R = 1.3418748\n",
            "L1 = 0.0008635389273911474\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 80%|████████  | 4002/5000 [10:10<02:28,  6.71it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.002977787685813382 logZ = 5.347593307495117 R = 1.3455858\n",
            "L1 = 0.0008633828208714046\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 82%|████████▏ | 4102/5000 [10:25<02:16,  6.56it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0042907516693230716 logZ = 5.345900535583496 R = 1.358164\n",
            "L1 = 0.0008638603231670887\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 84%|████████▍ | 4202/5000 [10:40<02:05,  6.36it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.002906727121444419 logZ = 5.342167377471924 R = 1.3398045\n",
            "L1 = 0.0008643929218815057\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 86%|████████▌ | 4302/5000 [10:56<01:46,  6.57it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.002412941889488138 logZ = 5.364588260650635 R = 1.3480858\n",
            "L1 = 0.0008644112873544166\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 88%|████████▊ | 4402/5000 [11:10<01:31,  6.53it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.004100368832005188 logZ = 5.349205017089844 R = 1.343203\n",
            "L1 = 0.0008640164296868317\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 90%|█████████ | 4502/5000 [11:25<01:16,  6.49it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0015340748731978238 logZ = 5.342836380004883 R = 1.349453\n",
            "L1 = 0.0008640898915784755\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 92%|█████████▏| 4602/5000 [11:41<01:03,  6.27it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.001327568173292093 logZ = 5.354628562927246 R = 1.3407811\n",
            "L1 = 0.0008639888814774652\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 94%|█████████▍| 4702/5000 [11:56<00:44,  6.63it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0017095171532128005 logZ = 5.352619171142578 R = 1.3485936\n",
            "L1 = 0.0008641082570513863\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 96%|█████████▌| 4802/5000 [12:11<00:31,  6.29it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0033637633302714674 logZ = 5.3555073738098145 R = 1.3414452\n",
            "L1 = 0.0008635756583369694\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 98%|█████████▊| 4902/5000 [12:26<00:15,  6.33it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0077345301583409305 logZ = 5.345482349395752 R = 1.3267968\n",
            "L1 = 0.0008634379172901373\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5000/5000 [12:41<00:00,  6.57it/s]\n"
          ]
        }
      ],
      "source": [
        "for it in tqdm.trange(n_train_steps):\n",
        "    \n",
        "    # TB loss for each trajectory\n",
        "    loss_TB = torch.zeros((batch_size,)).to(device)\n",
        "    loss_TB += logZ_TB # see the equation above\n",
        "    # finished trajectories\n",
        "    dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "    # s_0\n",
        "    states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "    # actions chosen at each step : we can choose the coordinate to increment (0 ... ndim-1), or choose to return the current state as terminal (ndim)\n",
        "    actions = None # (current_batch_size,)\n",
        "\n",
        "    while torch.any(~dones):\n",
        "\n",
        "        ### Forward pass ### \n",
        "        current_batch_size = (~dones).sum()\n",
        "        non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "        embed = one_hot_embedding(non_terminal_states) # (current_batch_size, input_dim)\n",
        "        logits = model_TB(embed) # (current_batch_size, output_dim) \n",
        "        \n",
        "        ### Backward Policy ### \n",
        "        PB_logits = logits[...,ndim+1:2*ndim+1] # (current_batch_size, ndim)\n",
        "        PB_logits = PB_logits * (0 if uniform_PB else 1) # (current_batch_size, ndim)\n",
        "        # Being in a edge cell -- (a zero coordinate), we can't move backward\n",
        "        edge_mask = (non_terminal_states == 0).float() # (current_batch_size, ndim)\n",
        "        logPB = (PB_logits + minus_inf*edge_mask).log_softmax(1) # (current_batch_size, ndim)\n",
        "        # add -logPB to the loss\n",
        "        if actions is not None: \n",
        "            \"\"\"\n",
        "            Gather along the parents' dimension (1) to select the logPB of the previously chosen actions, while avoiding the actions leading \n",
        "            to terminal states (action==ndim). The reason of using the previous chosen actions is that PB is calculated on the same trajectory as PF\n",
        "            See below for the calculation of `action`. We avoid actions leading to terminal states because a terminal state can't be parent of another \n",
        "            state\n",
        "            \"\"\"\n",
        "            loss_TB[~dones] -= logPB.gather(1, actions[actions != ndim].unsqueeze(1)).squeeze(1)\n",
        "\n",
        "        ### Forward Policy ### \n",
        "        PF_logits = logits[...,:ndim+1] # (current_batch_size, ndim+1) \n",
        "        # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "        edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "        # but any cell can be a terminal cell\n",
        "        stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "        # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "        PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "        # logPF (with mask)\n",
        "        logPF = (PF_logits + minus_inf*PF_mask).log_softmax(1) # (current_batch_size, ndim+1)\n",
        "        # choose next states\n",
        "        sample_temperature = 1\n",
        "        #exp_weight = 0.\n",
        "        #sample_ins_probs = (1-exp_weight)*(logPF/sample_temperature).softmax(1) + exp_weight*(1-PF_mask) / (1-PF_mask+0.0000001).sum(1).unsqueeze(1) # (current_batch_size, ndim+1)\n",
        "        sample_ins_probs = (logPF/sample_temperature).softmax(1) # (current_batch_size, ndim+1)\n",
        "        #actions = torch.distributions.categorical.Categorical(probs = sample_ins_probs).sample() # (current_batch_size,)\n",
        "        #actions = torch.multinomial(probs = sample_ins_probs, 1).squeeze(1) # (current_batch_size,) # (current_batch_size,)\n",
        "        actions = sample_ins_probs.multinomial(1) # (current_batch_size,)\n",
        "        # add logPF to the loss : gather along the children's dimension (1) to select the logPF for the chosen actions\n",
        "        loss_TB[~dones] += logPF.gather(1, actions).squeeze(1)\n",
        "\n",
        "        ### select terminal states ### \n",
        "        terminates = (actions==ndim).squeeze(1)\n",
        "        for state in non_terminal_states[terminates]: \n",
        "            state_index = get_state_index(state.cpu())\n",
        "            if first_visit_TB[state_index]<0: first_visit_TB[state_index] = it\n",
        "            all_visited_TB.append(state_index)\n",
        "        \n",
        "        # Update dones\n",
        "        dones[~dones] |= terminates\n",
        "\n",
        "        # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "        with torch.no_grad():\n",
        "            non_terminates = actions[~terminates]\n",
        "            states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "        \n",
        "    R = reward_function(states.float())\n",
        "    loss_TB -= R.log()\n",
        "    loss = (loss_TB**2).sum()/batch_size\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    losses_TB.append(loss.item())\n",
        "    rewards_TB.append(R.mean().cpu())\n",
        "    logZ_TB_list.append(logZ_TB.item())\n",
        "\n",
        "    if it%100==0: \n",
        "        print('\\nloss =', np.array(losses_TB[-100:]).mean(), 'logZ =', logZ_TB.item(), \"R =\", np.array(rewards_TB[-100:]).mean())\n",
        "        emp_dist = np.bincount(all_visited_TB[-200000:], minlength=len(true_dist)).astype(float)\n",
        "        emp_dist /= emp_dist.sum()\n",
        "        l1 = np.abs(true_dist-emp_dist).mean()\n",
        "        print('L1 =', l1)\n",
        "        l1log_TB.append((len(all_visited_TB), l1))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### samples"
      ],
      "metadata": {
        "id": "Tl-ijptUXCX2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#model_TB, logZ_TB, losses_TB, rewards_TB, logZ_TB_list, all_visited_TB, first_visit_TB, l1log_TB = data[\"TB\"]"
      ],
      "metadata": {
        "id": "Ap8HubYzWRbG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "samples_TB = np.zeros((H+1,)*ndim)"
      ],
      "metadata": {
        "id": "khlWcXktVTfw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for it in tqdm.trange(500):\n",
        "    # finished trajectories\n",
        "    dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "    # s_0\n",
        "    states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "    # actions chosen at each step : we can choose the coordinate to increment (0 ... ndim-1), or choose to return the current state as terminal (ndim)\n",
        "    actions = None # (current_batch_size,)\n",
        "\n",
        "    while torch.any(~dones):\n",
        "\n",
        "        ### Forward pass ### \n",
        "        current_batch_size = (~dones).sum()\n",
        "        non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "        embed = one_hot_embedding(non_terminal_states) # (current_batch_size, input_dim)\n",
        "        with torch.no_grad():\n",
        "            logits = model_TB(embed) # (current_batch_size, output_dim) \n",
        "        \n",
        "        ### Forward Policy ### \n",
        "        PF_logits = logits[...,:ndim+1] # (current_batch_size, ndim+1) \n",
        "        # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "        edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "        # but any cell can be a terminal cell\n",
        "        stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "        # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "        PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "        # logPF (with mask)\n",
        "        logPF = (PF_logits + minus_inf*PF_mask).log_softmax(1) # (current_batch_size, ndim+1)\n",
        "        # choose next states\n",
        "        sample_temperature = 1\n",
        "        #exp_weight = 0.\n",
        "        #sample_ins_probs = (1-exp_weight)*(logPF/sample_temperature).softmax(1) + exp_weight*(1-PF_mask) / (1-PF_mask+0.0000001).sum(1).unsqueeze(1) # (current_batch_size, ndim+1)\n",
        "        sample_ins_probs = (logPF/sample_temperature).softmax(1) # (current_batch_size, ndim+1)\n",
        "        #actions = torch.distributions.categorical.Categorical(probs = sample_ins_probs).sample() # (current_batch_size,)\n",
        "        #actions = torch.multinomial(probs = sample_ins_probs, 1).squeeze(1) # (current_batch_size,) # (current_batch_size,)\n",
        "        actions = sample_ins_probs.multinomial(1) # (current_batch_size,)\n",
        "        \n",
        "        ### select terminal states ### \n",
        "        terminates = (actions==ndim).squeeze(1)\n",
        "        \n",
        "        # Update dones\n",
        "        dones[~dones] |= terminates\n",
        "        \n",
        "        # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "        with torch.no_grad():\n",
        "            non_terminates = actions[~terminates]\n",
        "            states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "    \n",
        "    if ndim == 8 :\n",
        "        for a,b,c,d,e,f,g,h in states: samples_TB[a,b,c,d,e,f,g,h]+=1\n",
        "    if ndim == 6 :\n",
        "        for a,b,c,d,e,f in states: samples_TB[a,b,c,d,e,f]+=1\n",
        "    if ndim == 4 :\n",
        "        for a,b,c,d in states: samples_TB[a,b,c,d]+=1\n",
        "    elif ndim == 2 :\n",
        "        for a,b in states: samples_TB[a,b]+=1"
      ],
      "metadata": {
        "id": "90YqlU5sVrcf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aea4eaed-1038-40f4-99aa-a904ceed612f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 500/500 [00:28<00:00, 17.58it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    print(samples_TB / samples_TB.sum())"
      ],
      "metadata": {
        "id": "fkFt2bknWnZ7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "277cfe39-9f22-4c54-f75f-b388c6c398fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.00259375 0.00201563 0.00245313 ... 0.00254688 0.00253125 0.00196875]\n",
            " [0.00234375 0.00198438 0.00253125 ... 0.00228125 0.002375   0.00253125]\n",
            " [0.00239062 0.00242187 0.00215625 ... 0.00253125 0.00232812 0.00265625]\n",
            " ...\n",
            " [0.00276562 0.00245313 0.00214063 ... 0.00226562 0.00251563 0.00285937]\n",
            " [0.00226562 0.0023125  0.00257813 ... 0.00264063 0.002375   0.0020625 ]\n",
            " [0.00235937 0.002375   0.00245313 ... 0.00264063 0.00192187 0.00254688]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    plt.imshow(samples_TB)\n",
        "elif ndim == 4 :\n",
        "    plt.imshow(samples_TB[0,0])\n",
        "elif ndim == 6:  \n",
        "    plt.imshow(samples_TB[0,0,0,0])\n",
        "elif ndim == 8:  \n",
        "    plt.imshow(samples_TB[0,0,0,0,0,0])"
      ],
      "metadata": {
        "id": "qSj-PCCBWsOa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "outputId": "77b91ef3-1ed1-4fa0-b2eb-c77909cab33f"
      },
      "execution_count": null,
      "outputs": [
        {
          "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": "code",
      "source": [
        "if ndim == 4 :\n",
        "    tmp = samples_TB.sum((2,3))+samples_TB.sum((0,1))+samples_TB.sum((0,2))+samples_TB.sum((1,3))+samples_TB.sum((2,3))+samples_TB.sum((0,3))\n",
        "    plt.imshow(tmp,vmin=0);plt.show()\n",
        "    plt.imshow(samples_TB.sum((1,3)),vmin=0);plt.show()"
      ],
      "metadata": {
        "id": "e8mhX3YgWmBE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4PbkKf2BZCA2"
      },
      "source": [
        "## Detailed balance objective\n",
        "\n",
        "$$ \n",
        "\\mathcal{L}_{DB} \\big(s, s' \\big) = \\left\\{\n",
        "    \\begin{array}{ll}\n",
        "        \\bigg( log \\frac{F_{\\theta}(s) P_{F} (s' | s; \\theta)}{R(s') P_{B} (s | s'; \\theta) } \\bigg)^2 & \\mbox{if } s' \\mbox{ terminal} \\\\\n",
        "        \\bigg( log \\frac{F_{\\theta}(s) P_{F} (s' | s; \\theta) }{F_{\\theta}(s') P_{B} (s | s'; \\theta) } \\bigg)^2 & \\mbox{else.}\n",
        "    \\end{array}\n",
        "\\right. \n",
        "\\\\= \\left\\{\n",
        "    \\begin{array}{ll}\n",
        "        \\bigg[ log(F_{\\theta} (s)) - log\\big( P_{B} (s' | s; \\theta)\\big) + log\\big(P_{F} (s | s'; \\theta)\\big) - log(R(s'))  \\bigg]^2 & \\mbox{if } s' \\mbox{ terminal} \\\\\n",
        "        \\bigg[ log(F_{\\theta} (s)) - log(F_{\\theta} (s')) - log\\big( P_{B} (s' | s; \\theta)\\big) + log\\big(P_{F} (s | s'; \\theta)\\big) \\bigg]^2 & \\mbox{else.}\n",
        "    \\end{array}\n",
        "\\right. \n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EtFFbSQbZR2p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "597c9c02-de52-4ccf-9ed3-bb4754ee7b41"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Sequential(\n",
              "  (0): Linear(in_features=66, out_features=256, bias=True)\n",
              "  (1): LeakyReLU(negative_slope=0.01)\n",
              "  (2): Linear(in_features=256, out_features=256, bias=True)\n",
              "  (3): LeakyReLU(negative_slope=0.01)\n",
              "  (4): Linear(in_features=256, out_features=6, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ],
      "source": [
        "input_dim = ndim*(H+1) # embedding dim\n",
        "output_dim = 2*ndim+2 # ndim + 1 for P_F (+1 for stop action), ndim for P_B, and 1 for F\n",
        "model_DB = make_mlp([input_dim] + [n_hid] * n_layers + [output_dim]).to(device)\n",
        "logZ_DB = torch.zeros((1,)).to(device) # log (initial state flow), Z = 1\n",
        "optimizer = torch.optim.Adam([{'params':model_DB.parameters(), 'lr':0.001}])\n",
        "\n",
        "model_DB"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SBcj3XsFeMTc"
      },
      "outputs": [],
      "source": [
        "losses_DB = []\n",
        "rewards_DB = []\n",
        "logZ_DB_list = []\n",
        "all_visited_DB = []\n",
        "first_visit_DB = -1 * np.ones_like(true_dist)\n",
        "l1log_DB = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fGVdJs21Uqys",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ab7c84b-87de-4324-8f0b-30c7959c7278"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  0%|          | 6/5000 [00:00<03:24, 24.46it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 1.558149814605713 logZ = 0.009096775203943253 R = 0.53734374\n",
            "L1 = 0.0017672830119218482\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  2%|▏         | 102/5000 [00:15<15:26,  5.29it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 1.5978898778557777 logZ = 4.348416805267334 R = 0.673672\n",
            "L1 = 0.0012334472556907936\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  4%|▍         | 201/5000 [00:34<16:15,  4.92it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.18652499176561832 logZ = 4.8478617668151855 R = 1.0249221\n",
            "L1 = 0.001126958386272558\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  6%|▌         | 302/5000 [00:54<15:50,  4.94it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.05439641799777746 logZ = 5.2593536376953125 R = 1.2181252\n",
            "L1 = 0.000991876756069694\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  8%|▊         | 401/5000 [01:15<15:21,  4.99it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.01430265350267291 logZ = 5.3503031730651855 R = 1.3126172\n",
            "L1 = 0.0009097025461818147\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 10%|█         | 501/5000 [01:35<15:17,  4.90it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.008057421322446317 logZ = 5.354135513305664 R = 1.3220311\n",
            "L1 = 0.0008761998705329709\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 12%|█▏        | 601/5000 [01:55<15:20,  4.78it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.015733420285396277 logZ = 5.328025817871094 R = 1.3427342\n",
            "L1 = 0.0008574659068625308\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 14%|█▍        | 701/5000 [02:16<15:27,  4.63it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.011471149037824944 logZ = 5.347069263458252 R = 1.3582029\n",
            "L1 = 0.000843843818232374\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 16%|█▌        | 801/5000 [02:37<14:15,  4.91it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.010416160633321852 logZ = 5.344133377075195 R = 1.349453\n",
            "L1 = 0.0008401615167739673\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 18%|█▊        | 901/5000 [02:58<13:52,  4.93it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.009269262327579781 logZ = 5.342678070068359 R = 1.3547654\n",
            "L1 = 0.000843633751120317\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 20%|██        | 1001/5000 [03:18<14:04,  4.74it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.01088442777749151 logZ = 5.354400634765625 R = 1.3515624\n",
            "L1 = 0.000846276813930687\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 22%|██▏       | 1101/5000 [03:39<14:05,  4.61it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.007162615957204252 logZ = 5.344970703125 R = 1.3472655\n",
            "L1 = 0.0008481009292110141\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 24%|██▍       | 1201/5000 [03:59<12:41,  4.99it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.003673955469275825 logZ = 5.350367546081543 R = 1.3394139\n",
            "L1 = 0.0008497049055437277\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 26%|██▌       | 1301/5000 [04:20<12:01,  5.13it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0018475863302592189 logZ = 5.354638576507568 R = 1.3610154\n",
            "L1 = 0.0008510292205823001\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 28%|██▊       | 1401/5000 [04:40<11:56,  5.02it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.001489284207636956 logZ = 5.3502044677734375 R = 1.3428905\n",
            "L1 = 0.0008518367620088186\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 30%|███       | 1501/5000 [05:00<12:36,  4.62it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.003605639754823642 logZ = 5.33585262298584 R = 1.3527733\n",
            "L1 = 0.0008530815647146582\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 32%|███▏      | 1601/5000 [05:20<11:46,  4.81it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0018282278343394864 logZ = 5.350903511047363 R = 1.343906\n",
            "L1 = 0.0008593424168310006\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 34%|███▍      | 1701/5000 [05:40<10:54,  5.04it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0002275919979729224 logZ = 5.350683212280273 R = 1.3239452\n",
            "L1 = 0.0008695168888236544\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 36%|███▌      | 1801/5000 [06:01<11:30,  4.63it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00020419184511411004 logZ = 5.351454734802246 R = 1.3459374\n",
            "L1 = 0.0008705269898337554\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 38%|███▊      | 1901/5000 [06:22<10:57,  4.71it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00024960504211776427 logZ = 5.351078033447266 R = 1.3455858\n",
            "L1 = 0.0008699117464912393\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 40%|████      | 2001/5000 [06:43<10:56,  4.57it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.005133612420468126 logZ = 5.34847354888916 R = 1.3527342\n",
            "L1 = 0.0008685343360229199\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 42%|████▏     | 2101/5000 [07:03<09:59,  4.83it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0001838398546897224 logZ = 5.349673748016357 R = 1.3577342\n",
            "L1 = 0.0008673130320743432\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 44%|████▍     | 2201/5000 [07:24<10:04,  4.63it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00014523008885589662 logZ = 5.351068019866943 R = 1.3708593\n",
            "L1 = 0.0008668630779880255\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 46%|████▌     | 2301/5000 [07:45<09:14,  4.87it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0001370188236614922 logZ = 5.353616714477539 R = 1.3533201\n",
            "L1 = 0.000865807063295647\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 48%|████▊     | 2401/5000 [08:06<09:16,  4.67it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00028443042509024963 logZ = 5.35156774520874 R = 1.356992\n",
            "L1 = 0.0008650265306969327\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 50%|█████     | 2502/5000 [08:26<08:02,  5.18it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0038922064879443495 logZ = 5.351993560791016 R = 1.3304296\n",
            "L1 = 0.000864043977896198\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 52%|█████▏    | 2601/5000 [08:46<08:03,  4.96it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00021207222358498256 logZ = 5.354257106781006 R = 1.3353124\n",
            "L1 = 0.0008634746482359593\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 54%|█████▍    | 2701/5000 [09:06<07:45,  4.94it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0002172535903082462 logZ = 5.352587699890137 R = 1.3539451\n",
            "L1 = 0.0008637593130660787\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 56%|█████▌    | 2801/5000 [09:26<07:30,  4.89it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0001616606804964249 logZ = 5.352258682250977 R = 1.356953\n",
            "L1 = 0.0008633369071891273\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 58%|█████▊    | 2901/5000 [09:46<07:18,  4.79it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0036030125458637484 logZ = 5.330056190490723 R = 1.3474607\n",
            "L1 = 0.000863272628033939\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 60%|██████    | 3001/5000 [10:06<06:35,  5.06it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0006821482342638774 logZ = 5.352264881134033 R = 1.3455467\n",
            "L1 = 0.0008629787804673642\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 62%|██████▏   | 3101/5000 [10:26<06:30,  4.86it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0003058544273517327 logZ = 5.346927165985107 R = 1.3454686\n",
            "L1 = 0.0008628043084747105\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 64%|██████▍   | 3201/5000 [10:46<06:22,  4.71it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0002586584474192932 logZ = 5.353536605834961 R = 1.3523046\n",
            "L1 = 0.0008629879632038197\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 66%|██████▌   | 3301/5000 [11:07<06:01,  4.70it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0014043758802654337 logZ = 5.344907283782959 R = 1.334453\n",
            "L1 = 0.0008627675775288886\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 68%|██████▊   | 3401/5000 [11:27<05:34,  4.78it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0017434642088483088 logZ = 5.352102756500244 R = 1.3336327\n",
            "L1 = 0.0008628318566840769\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 70%|███████   | 3501/5000 [11:47<05:05,  4.90it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0007338421609892976 logZ = 5.347777843475342 R = 1.348164\n",
            "L1 = 0.0008626573846914229\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 72%|███████▏  | 3601/5000 [12:07<04:56,  4.73it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0005994742873008363 logZ = 5.34981632232666 R = 1.3496482\n",
            "L1 = 0.0008629695977309088\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 74%|███████▍  | 3701/5000 [12:27<04:17,  5.04it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.003936654790304601 logZ = 5.354252338409424 R = 1.351328\n",
            "L1 = 0.0008632818107703946\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 76%|███████▌  | 3801/5000 [12:47<04:20,  4.61it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00018561675016826485 logZ = 5.349576473236084 R = 1.3496873\n",
            "L1 = 0.0008633001762433055\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 78%|███████▊  | 3901/5000 [13:07<03:45,  4.88it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 8.100669769191882e-05 logZ = 5.351441383361816 R = 1.3623827\n",
            "L1 = 0.0008637593130660787\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 80%|████████  | 4001/5000 [13:27<03:22,  4.92it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00026025110943010075 logZ = 5.355762004852295 R = 1.341328\n",
            "L1 = 0.0008641266225242972\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 82%|████████▏ | 4101/5000 [13:48<03:02,  4.93it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0012871249768068083 logZ = 5.349803447723389 R = 1.3530468\n",
            "L1 = 0.0008647051349209914\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 84%|████████▍ | 4202/5000 [14:08<02:41,  4.93it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0038215151819167657 logZ = 5.312457084655762 R = 1.3365233\n",
            "L1 = 0.000864319459989862\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 86%|████████▌ | 4301/5000 [14:28<02:30,  4.64it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.002909785158772138 logZ = 5.350497722625732 R = 1.3258983\n",
            "L1 = 0.0008642276326253072\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 88%|████████▊ | 4401/5000 [14:49<02:01,  4.92it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00010216062222752954 logZ = 5.351162433624268 R = 1.3500389\n",
            "L1 = 0.0008640072469503761\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 90%|█████████ | 4501/5000 [15:10<01:47,  4.63it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 4.0082650275508056e-05 logZ = 5.35001277923584 R = 1.3295311\n",
            "L1 = 0.000863906236849366\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 92%|█████████▏| 4601/5000 [15:31<01:23,  4.77it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 4.930838425934781e-05 logZ = 5.3515825271606445 R = 1.3514061\n",
            "L1 = 0.0008646224902928922\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 94%|█████████▍| 4701/5000 [15:52<01:05,  4.59it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.00018226934609629096 logZ = 5.3550028800964355 R = 1.3412498\n",
            "L1 = 0.0008640990743149307\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 96%|█████████▌| 4801/5000 [16:13<00:42,  4.66it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.0006074682602775283 logZ = 5.354378700256348 R = 1.3378905\n",
            "L1 = 0.0008640531606326535\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 98%|█████████▊| 4901/5000 [16:34<00:22,  4.40it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.003557727971347049 logZ = 5.353166580200195 R = 1.3350389\n",
            "L1 = 0.0008637501303296232\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5000/5000 [16:55<00:00,  4.92it/s]\n"
          ]
        }
      ],
      "source": [
        "for it in tqdm.trange(n_train_steps):\n",
        "    \n",
        "    # DB loss for each state of each trajectory : a trajectory can have a maximum length (#states) of `(H+1) + H + ... + H = (H+1) + (ndim-1)*H`\n",
        "    loss_DB = torch.zeros((batch_size, H+1+(ndim-1)*H)).to(device)\n",
        "    # finished trajectories\n",
        "    dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "    # s_0\n",
        "    states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "    # actions chosen at each step : we can choose the coordinate to increment (0 ... ndim-1), or choose to return the current state as terminal (ndim)\n",
        "    actions = None # (current_batch_size,)\n",
        "\n",
        "    i = 0\n",
        "    while torch.any(~dones):\n",
        "\n",
        "        ### Forward pass ### \n",
        "        current_batch_size = (~dones).sum()\n",
        "        non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "        embed = one_hot_embedding(non_terminal_states) # (current_batch_size, input_dim)\n",
        "        logits = model_DB(embed) # (current_batch_size, output_dim) \n",
        "\n",
        "        ### logF ### \n",
        "        logF = logits[...,2*ndim+1] # (current_batch_size,)\n",
        "        loss_DB[~dones,i] += logF # add logF(s_i) to the loss L(s_i, s_{i+1})\n",
        "        if i>0: loss_DB[~dones,i-1] -= logF # add -logF(s_i) to the loss L(s_{i-1}, s_i)\n",
        "        #else : logZ_DB[:] = logF.mean().item() # initial state : Z = F(s_0)\n",
        "        else: logZ_DB[:] = logF[0].item() # initial state : Z = F(s_0)\n",
        "        \n",
        "        ### Backward Policy ### \n",
        "        PB_logits = logits[...,ndim+1:2*ndim+1] # (current_batch_size, ndim)\n",
        "        PB_logits = PB_logits * (0 if uniform_PB else 1) # (current_batch_size, ndim)\n",
        "        # Being in a edge cell -- (a zero coordinate), we can't move backward\n",
        "        edge_mask = (non_terminal_states == 0).float() # (current_batch_size, ndim)\n",
        "        logPB = (PB_logits + minus_inf*edge_mask).log_softmax(1) # (current_batch_size, ndim)\n",
        "        # add -logPB(s_{i-1} | s_i) to the loss L(s_{i-1}, s_i)\n",
        "        if actions is not None: \n",
        "            \"\"\"\n",
        "            Gather along the parents' dimension (1) to select the logPB of the previously chosen actions, while avoiding the actions leading \n",
        "            to terminal states (action==ndim). The reason of using the previous chosen actions () is that PB is calculated on the same trajectory as PF\n",
        "            See below for the calculation of `action`. We avoid actions leading to terminal states because a terminal state can't be parent of another \n",
        "            state\n",
        "            \"\"\"\n",
        "            loss_DB[~dones,i-1] -= logPB.gather(1, actions[actions!=ndim].unsqueeze(1)).squeeze(1)\n",
        "    \n",
        "        ### Forward Policy ### \n",
        "        PF_logits = logits[...,:ndim+1] # (current_batch_size, ndim+1) \n",
        "        # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "        edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "        # but any cell can be a terminal cell\n",
        "        stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "        # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "        PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "        # logPF (with mask)\n",
        "        logPF = (PF_logits + minus_inf*PF_mask).log_softmax(1) # (current_batch_size, ndim+1)\n",
        "        # choose next states\n",
        "        sample_temperature = 1\n",
        "        #exp_weight= 0.\n",
        "        #sample_ins_probs = (1-exp_weight)*(logPF/sample_temperature).softmax(1) + exp_weight*(1-PF_mask) / (1-PF_mask+0.0000001).sum(1).unsqueeze(1) # (current_batch_size, ndim+1)\n",
        "        sample_ins_probs = (logPF/sample_temperature).softmax(1) # (current_batch_size, ndim+1)\n",
        "        #actions = torch.distributions.categorical.Categorical(probs = sample_ins_probs).sample() # (current_batch_size,)\n",
        "        #actions = torch.multinomial(probs = sample_ins_probs, 1).squeeze(1) # (current_batch_size,) # (current_batch_size,)\n",
        "        actions = sample_ins_probs.multinomial(1) # (current_batch_size,)\n",
        "        # add logPF(s_i | s_{i+1}) to the loss L(s_i, s_{i+1}) : gather along the children's dimension (1) to select the logPF for the chosen actions\n",
        "        loss_DB[~dones,i] += logPF.gather(1, actions).squeeze(1)\n",
        "\n",
        "        ### select terminal states ### \n",
        "        terminates = (actions==ndim).squeeze(1)\n",
        "        for state in non_terminal_states[terminates]: \n",
        "            state_index = get_state_index(state.cpu())\n",
        "            if first_visit_DB[state_index]<0: first_visit_DB[state_index] = it\n",
        "            all_visited_DB.append(state_index)\n",
        "\n",
        "        # Add reward for terminal state\n",
        "        termination_mask = ~dones\n",
        "        termination_mask[~dones] &= terminates\n",
        "        R_x = reward_function(non_terminal_states[terminates].float()) \n",
        "        loss_DB[termination_mask,i] -= (R_x + 1e-8).log()\n",
        "        \n",
        "        # Update dones\n",
        "        dones[~dones] |= terminates\n",
        "\n",
        "        # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "        with torch.no_grad():\n",
        "            non_terminates = actions[~terminates]\n",
        "            states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "            \n",
        "        i += 1\n",
        "\n",
        "    #lens = states.sum(1)+1 # number of actions taken for each trajectory\n",
        "    #loss = (loss_DB**2).sum()/lens.sum() \n",
        "    loss = (loss_DB**2).sum(dim=1).sum()/batch_size\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    losses_DB.append(loss.item())\n",
        "    R = reward_function(states.float())\n",
        "    rewards_DB.append(R.mean().cpu())\n",
        "    logZ_DB_list.append(logZ_DB.item())\n",
        "\n",
        "    if it%100==0: \n",
        "        print('\\nloss =', np.array(losses_DB[-100:]).mean(), 'logZ =', logZ_DB.item(), \"R =\", np.array(rewards_DB[-100:]).mean())\n",
        "        emp_dist = np.bincount(all_visited_DB[-200000:], minlength=len(true_dist)).astype(float)\n",
        "        emp_dist /= emp_dist.sum()\n",
        "        l1 = np.abs(true_dist-emp_dist).mean()\n",
        "        print('L1 =', l1)\n",
        "        l1log_DB.append((len(all_visited_DB), l1))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### samples"
      ],
      "metadata": {
        "id": "AxJvxFOOXKoP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#model_DB, logZ_DB, losses_DB, rewards_DB, logZ_DB_list, all_visited_DB, first_visit_DB, l1log_DB = data[\"TB\"]"
      ],
      "metadata": {
        "id": "Lxf4RPFYXMQ-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "samples_DB = np.zeros((H+1,)*ndim)"
      ],
      "metadata": {
        "id": "rQ2QcZQUXNh2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for it in tqdm.trange(500):\n",
        "    # finished trajectories\n",
        "    dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "    # s_0\n",
        "    states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "    # actions chosen at each step : we can choose the coordinate to increment (0 ... ndim-1), or choose to return the current state as terminal (ndim)\n",
        "    actions = None # (current_batch_size,)\n",
        "\n",
        "    while torch.any(~dones):\n",
        "\n",
        "        ### Forward pass ### \n",
        "        current_batch_size = (~dones).sum()\n",
        "        non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "        embed = one_hot_embedding(non_terminal_states) # (current_batch_size, input_dim)\n",
        "        with torch.no_grad():\n",
        "            logits = model_DB(embed) # (current_batch_size, output_dim) \n",
        "        \n",
        "        ### Forward Policy ### \n",
        "        PF_logits = logits[...,:ndim+1] # (current_batch_size, ndim+1) \n",
        "        # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "        edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "        # but any cell can be a terminal cell\n",
        "        stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "        # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "        PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "        # logPF (with mask)\n",
        "        logPF = (PF_logits + minus_inf*PF_mask).log_softmax(1) # (current_batch_size, ndim+1)\n",
        "        # choose next states\n",
        "        sample_temperature = 1\n",
        "        #exp_weight= 0.\n",
        "        #sample_ins_probs = (1-exp_weight)*(logPF/sample_temperature).softmax(1) + exp_weight*(1-PF_mask) / (1-PF_mask+0.0000001).sum(1).unsqueeze(1) # (current_batch_size, ndim+1)\n",
        "        sample_ins_probs = (logPF/sample_temperature).softmax(1) # (current_batch_size, ndim+1)\n",
        "        #actions = torch.distributions.categorical.Categorical(probs = sample_ins_probs).sample() # (current_batch_size,)\n",
        "        #actions = torch.multinomial(probs = sample_ins_probs, 1).squeeze(1) # (current_batch_size,) # (current_batch_size,)\n",
        "        actions = sample_ins_probs.multinomial(1) # (current_batch_size,)\n",
        "\n",
        "        ### select terminal states ### \n",
        "        terminates = (actions==ndim).squeeze(1)\n",
        "\n",
        "        # Add reward for terminal state\n",
        "        termination_mask = ~dones\n",
        "        termination_mask[~dones] &= terminates\n",
        "        \n",
        "        # Update dones\n",
        "        dones[~dones] |= terminates\n",
        "\n",
        "        # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "        with torch.no_grad():\n",
        "            non_terminates = actions[~terminates]\n",
        "            states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "            \n",
        "    if ndim == 8 :\n",
        "        for a,b,c,d,e,f,g,h in states: samples_DB[a,b,c,d,e,f,g,h]+=1  \n",
        "    if ndim == 6 :\n",
        "        for a,b,c,d,e,f in states: samples_DB[a,b,c,d,e,f]+=1         \n",
        "    if ndim == 4 :\n",
        "        for a,b,c,d in states: samples_DB[a,b,c,d]+=1\n",
        "    elif ndim == 2 :\n",
        "        for a,b in states: samples_DB[a,b]+=1"
      ],
      "metadata": {
        "id": "8LAd9E_7XXPB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5589fe59-2659-448f-9d4d-e28873a94e17"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 500/500 [00:30<00:00, 16.18it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    print(samples_DB / samples_DB.sum())"
      ],
      "metadata": {
        "id": "W2EyvbWWYgma",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "28349ba9-8f83-4605-8e2c-9e81d0c5ce67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.00248438 0.00248438 0.00221875 ... 0.00245313 0.00253125 0.00226562]\n",
            " [0.00229687 0.00232812 0.00232812 ... 0.00235937 0.002375   0.00242187]\n",
            " [0.0025     0.00264063 0.00260938 ... 0.00260938 0.00217188 0.00246875]\n",
            " ...\n",
            " [0.00229687 0.00242187 0.00251563 ... 0.00264063 0.0024375  0.002375  ]\n",
            " [0.00209375 0.00254688 0.002625   ... 0.00279687 0.00275    0.0025625 ]\n",
            " [0.0025     0.002375   0.00234375 ... 0.002625   0.0028125  0.00223437]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    plt.imshow(samples_DB)\n",
        "elif ndim == 4 :\n",
        "    plt.imshow(samples_DB[0,0])\n",
        "elif ndim == 6:  \n",
        "    plt.imshow(samples_DB[0,0,0,0])\n",
        "elif ndim == 8:\n",
        "    plt.imshow(samples_DB[0,0,0,0,0,0])"
      ],
      "metadata": {
        "id": "doESWla2YiB7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "outputId": "9a5b040b-973f-4898-8124-45b271cbc264"
      },
      "execution_count": null,
      "outputs": [
        {
          "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": "code",
      "source": [
        "if ndim == 4 :\n",
        "    tmp = samples_DB.sum((2,3))+samples_DB.sum((0,1))+samples_DB.sum((0,2))+samples_DB.sum((1,3))+samples_DB.sum((2,3))+samples_DB.sum((0,3))\n",
        "    plt.imshow(tmp,vmin=0);plt.show()\n",
        "    plt.imshow(samples_DB.sum((1,3)),vmin=0);plt.show()"
      ],
      "metadata": {
        "id": "ZLiDLS3qYfXP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ur9c77EudOEo"
      },
      "source": [
        "## Flow matching objective\n",
        "\n",
        "$$\n",
        "\\mathcal{L}_{FM} \\big(s\\big) = \\left\\{\n",
        "    \\begin{array}{ll}\n",
        "        \\bigg[ log \\bigg( \\epsilon + \\sum_{s'' \\rightarrow s} exp \\text{ } F_{\\theta}^{log}(s'', s) \\bigg) - log \\bigg( \\epsilon + R(s) \\bigg) \\bigg]^2 & \\mbox{if } s \\mbox{ terminal} \\\\\n",
        "        \\bigg[ log \\bigg( \\epsilon + \\sum_{s'' \\rightarrow s} exp \\text{ } F_{\\theta} ^{log}(s'', s) \\bigg) - log \\bigg( \\epsilon +  \\sum_{s \\rightarrow s'} exp \\text{ } F_{\\theta}^{log}(s, s') \\bigg) \\bigg]^2 & \\mbox{else (s non-initial)}\n",
        "    \\end{array}\n",
        "\\right. \n",
        "$$\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GsiKBgv0azN3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ed32c219-b865-4796-d807-7057f71b5ea6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0.0100)"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ],
      "source": [
        "epsilon = all_rewards.min()\n",
        "#epsilon = 1e-6\n",
        "epsilon"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PSKrCmcLrFrj"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "The following functions allow, in a given state, to find all its parents, to evaluate the model on these parents, and to consider the flow from the parents to the current state."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hOnGql_p4O5R"
      },
      "outputs": [],
      "source": [
        "def get_parents(state) :\n",
        "    \"\"\"\n",
        "    Return the parents of a given state, and the trasitions leading from the parents to the current state\n",
        "    For `state = [3., 1.]`, `parents = [[2., 1.], [3., 0.]]` and `transitions = [0, 1]`\n",
        "    \"\"\"\n",
        "    assert state.sum() != 0.\n",
        "    parents, transitions = [], []\n",
        "    np = 0\n",
        "    for i in range(ndim) :\n",
        "        sp = state + 0\n",
        "        if sp[i] > 0 :\n",
        "            sp[i] -= 1\n",
        "            np += 1\n",
        "            # if sp.max() == H: # can't have a terminal parent\n",
        "            #     np -= 1\n",
        "            #     continue\n",
        "            parents.append(sp)\n",
        "            transitions.append(i)\n",
        "    if np == 0 : return None, None\n",
        "    return torch.stack(parents), torch.LongTensor(transitions)\n",
        "\n",
        "def get_inflow_old(state, model) :\n",
        "    \"\"\"Return the in flow of a given state\"\"\"\n",
        "    parents, transitions = get_parents(state)\n",
        "    embed = one_hot_embedding(parents.long()) # (n_parents, embedding_dim)\n",
        "    logF = model(embed) # (n_parents, ndim+1)\n",
        "    return logF.gather(1, transitions.unsqueeze(1).to(device)).exp().sum()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "brT7wz8X45P6"
      },
      "source": [
        "It is better to store the parents of each state to accelerate the training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "heevMh_d4PyZ"
      },
      "outputs": [],
      "source": [
        "all_parents = {get_state_index(state.long()) : get_parents(state) for state in grid if state.sum() != 0.}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tSpBgIEarE1g"
      },
      "outputs": [],
      "source": [
        "def get_inflow(state, model, stop_action = False) :\n",
        "    \"\"\"Return the in flow of a given state\"\"\"\n",
        "    if stop_action:\n",
        "        #parents, transitions = state.unsqueeze(0), torch.LongTensor([ndim])         \n",
        "        # Any state can be a parent of the terminal state : the corresponding action is always ndim\n",
        "        parents = grid.clone()\n",
        "        transitions = torch.LongTensor([ndim]*grid.size(0)) \n",
        "    else :\n",
        "        state_id = get_state_index(state.long().cpu())\n",
        "        parents, transitions = all_parents.get(state_id, (None, None))\n",
        "    if parents is not None :\n",
        "        embed = one_hot_embedding(parents.long()) # (n_parents, embedding_dim)\n",
        "        logF = model(embed.to(device)) # (n_parents, ndim+1)\n",
        "        return logF.gather(1, transitions.unsqueeze(1).to(device)).exp().sum()\n",
        "    #else : return torch.tensor(0.)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# for debugging\n",
        "def parents_flow(non_terminal_states, actions, model):\n",
        "    a = actions[actions!=ndim]\n",
        "    parents = []\n",
        "    print(non_terminal_states.shape, a.shape)\n",
        "    print(non_terminal_states, actions)\n",
        "    for n, i in zip(non_terminal_states, a) :\n",
        "        s = n+0\n",
        "        s[i]-=1\n",
        "        parents.append(s)\n",
        "    parents = torch.stack(parents)\n",
        "    print(parents)\n",
        "    embed = one_hot_embedding(parents.long()) # (n_parents, embedding_dim)\n",
        "    logF = model(embed.to(device)) # (n_parents, ndim+1)\n",
        "    return logF.gather(1, a.unsqueeze(1).to(device)).exp().sum(dim=1)"
      ],
      "metadata": {
        "id": "Il70AnjGvonD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n_2XxX4IrrAc"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V9R1AZzjkKPB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "988d02fd-052e-4ad8-99c0-fed589db98d2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Sequential(\n",
              "  (0): Linear(in_features=66, out_features=256, bias=True)\n",
              "  (1): LeakyReLU(negative_slope=0.01)\n",
              "  (2): Linear(in_features=256, out_features=256, bias=True)\n",
              "  (3): LeakyReLU(negative_slope=0.01)\n",
              "  (4): Linear(in_features=256, out_features=3, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ],
      "source": [
        "input_dim = ndim*(H+1) # embedding dim\n",
        "output_dim = ndim+1 # ndim + 1 for F (+1 for stop action)\n",
        "model_FM = make_mlp([input_dim] + [n_hid] * n_layers + [output_dim]).to(device)\n",
        "logZ_FM = torch.zeros((1,)).to(device) # log (initial state flow), Z = 1\n",
        "optimizer = torch.optim.Adam([{'params':model_FM.parameters(), 'lr':0.001}])\n",
        "\n",
        "model_FM"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fuA_CNgJtY_D"
      },
      "outputs": [],
      "source": [
        "losses_FM = []\n",
        "rewards_FM = []\n",
        "logZ_FM_list = []\n",
        "all_visited_FM = []\n",
        "first_visit_FM = -1 * np.ones_like(true_dist)\n",
        "l1log_FM = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZvhX6Fry2aOi"
      },
      "outputs": [],
      "source": [
        "# #batch_size = 128\n",
        "# #batch_size = 8\n",
        "# #epsilon = 1e-2\n",
        "# for it in tqdm.trange(n_train_steps): \n",
        "# #for it in tqdm.trange(1000):    \n",
        "#     # FM loss for each state of each trajectory : a trajectory can have a maximum length (#states) of `(H+1) + H + ... + H = (H+1) + (ndim-1)*H`\n",
        "#     loss_FM = torch.zeros((batch_size, H+1+(ndim-1)*H +1)).to(device) # +1 for s_f\n",
        "#     # finished trajectories\n",
        "#     dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "#     # s_0\n",
        "#     states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "#     # actions chosen at each step : we can choose the coordinate to increment (0 ... ndim-1), or choose to return the current state as terminal (ndim)\n",
        "#     actions = None # (current_batch_size,)\n",
        "\n",
        "#     current_batch_size = (~dones).sum()\n",
        "#     non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "\n",
        "#     i = 0\n",
        "#     while True:\n",
        "#         if actions is not None :\n",
        "#             ### select terminals and non-terminal actions ### \n",
        "#             # non-terminals\n",
        "#             terminates = (actions==ndim).squeeze(1)\n",
        "#             termination_mask = ~dones\n",
        "#             termination_mask[~dones] &= terminates\n",
        "#             # terminals\n",
        "#             non_terminates = (actions!=ndim).squeeze(1)\n",
        "#             non_termination_mask = ~dones\n",
        "#             non_termination_mask[~dones] &= non_terminates\n",
        "\n",
        "#             ### In Flow : non-initial and non-terminal state ### \n",
        "#             if non_terminates.any(): \n",
        "#                 #inFlow = torch.stack([get_inflow(state, model_FM) for state in non_terminal_states[non_terminates]]) # (current_batch_size,)\n",
        "#                 #inFlow = torch.tensor(0.) if i==0 else parents_flow(non_terminal_states[non_terminates], actions, model_FM)\n",
        "#                 inFlow = logPF.gather(1, actions[actions!=ndim].unsqueeze(1)).exp().sum(dim=1)\n",
        "#                 loss_FM[non_termination_mask,i] += (epsilon + inFlow).log()  \n",
        "\n",
        "#             ### In Flow : terminal state ###\n",
        "#             if terminates.any():\n",
        "#                 # add log_sumF(., s_i) to the loss L(s_i)   \n",
        "#                 inFlow = torch.stack([get_inflow(state, model_FM, stop_action=True) for state in non_terminal_states[terminates]]) # (current_batch_size,)\n",
        "#                 loss_FM[termination_mask,i] += (epsilon + inFlow).log() \n",
        "\n",
        "#             ### Out Flow for non-terminal states : add -log_sumF(s_i, .) to the loss L(s_i) ###\n",
        "#             #outFlow = logF[non_terminates].exp().sum(dim=-1)\n",
        "#             outFlow = logPF[non_terminates].exp().sum(dim=-1)\n",
        "#             loss_FM[non_termination_mask,i] -= (epsilon + outFlow).log()\n",
        "\n",
        "#             ### Out Flow for terminal states : Add -reward for terminal state ###\n",
        "#             R_x = reward_function(non_terminal_states[terminates].float())\n",
        "#             loss_FM[termination_mask,i] -= (epsilon + R_x).log()\n",
        "\n",
        "#             ### select terminal states ### \n",
        "#             for state in non_terminal_states[terminates]: \n",
        "#                 state_index = get_state_index(state.cpu())\n",
        "#                 if first_visit_FM[state_index]<0: first_visit_FM[state_index] = it\n",
        "#                 all_visited_FM.append(state_index)\n",
        "\n",
        "#             # Update dones\n",
        "#             dones[~dones] |= terminates\n",
        "\n",
        "#             # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "#             with torch.no_grad():\n",
        "#                 non_terminates = actions[~terminates]\n",
        "#                 states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "\n",
        "#             i += 1\n",
        "\n",
        "#         if torch.any(~dones) :\n",
        "#             ### Forward pass ### \n",
        "#             current_batch_size = (~dones).sum()\n",
        "#             non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "#             embed = one_hot_embedding(non_terminal_states) # (current_batch_size, input_dim)\n",
        "#             logF = model_FM(embed) # (current_batch_size, output_dim = ndim+1) \n",
        "\n",
        "#             ### Forward Policy : tempered version of the state-action flow F ### \n",
        "#             # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "#             edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "#             # but any cell can be a terminal cell\n",
        "#             stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "#             # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "#             PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "#             # logPF (with mask)\n",
        "#             logPF = (logF + minus_inf*PF_mask).log_softmax(1) # (current_batch_size, ndim+1)\n",
        "#             # choose next states\n",
        "#             sample_temperature = 1\n",
        "#             #exp_weight= 0.\n",
        "#             #PF = (1-exp_weight)*(logPF/sample_temperature).softmax(1) + exp_weight*(1-PF_mask) / (1-PF_mask+0.0000001).sum(1).unsqueeze(1) # (current_batch_size, ndim+1)\n",
        "#             PF = (logPF/sample_temperature).softmax(1) # (current_batch_size, ndim+1)\n",
        "#             #actions = torch.distributions.categorical.Categorical(probs = PF).sample() # (current_batch_size,)\n",
        "#             #actions = torch.multinomial(probs = PF, 1).squeeze(1) # (current_batch_size,) # (current_batch_size,)\n",
        "#             actions = PF.multinomial(1) # (current_batch_size,)\n",
        "#         else :\n",
        "#             break\n",
        "\n",
        "#         if i==0 :\n",
        "#             # initial state\n",
        "#             #all_init_flow = logF.exp().sum(dim=1) # (current_batch_size,)\n",
        "#             all_init_flow = logPF.exp().sum(dim=1) # (current_batch_size,)\n",
        "#             #logZ_FM[:] = all_init_flow.mean().item() \n",
        "#             logZ_FM[:] = all_init_flow[0].item() # initial state)\n",
        "\n",
        "#     loss_FM = loss_FM[:,1:] # remove L(s_0)\n",
        "#     loss = (loss_FM**2).sum(dim=1).sum()/batch_size\n",
        "\n",
        "#     optimizer.zero_grad()\n",
        "#     loss.backward()\n",
        "#     optimizer.step()\n",
        "\n",
        "#     losses_FM.append(loss.item())\n",
        "#     R = reward_function(states.float())\n",
        "#     rewards_FM.append(R.mean().cpu())\n",
        "#     logZ_FM_list.append(logZ_FM.item())\n",
        "\n",
        "#     if it%100==0: \n",
        "#         print('\\nloss =', np.array(losses_FM[-100:]).mean(), 'logZ =', logZ_FM.item(), \"R =\", np.array(rewards_FM[-100:]).mean())\n",
        "#         emp_dist = np.bincount(all_visited_FM[-200000:], minlength=len(true_dist)).astype(float)\n",
        "#         emp_dist /= emp_dist.sum()\n",
        "#         l1 = np.abs(true_dist-emp_dist).mean()\n",
        "#         print('L1 =', l1)\n",
        "#         l1log_FM.append((len(all_visited_FM), l1))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for it in tqdm.trange(n_train_steps): \n",
        "#for it in tqdm.trange(100):    \n",
        "    # FM loss for each state of each trajectory : a trajectory can have a maximum length (#states) of `(H+1) + H + ... + H = (H+1) + (ndim-1)*H`\n",
        "    loss_FM = torch.zeros((batch_size, H+1+(ndim-1)*H)).to(device)\n",
        "    # finished trajectories\n",
        "    dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "    # s_0\n",
        "    states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "    # actions chosen at each step : we can choose the coordinate to increment (0 ... ndim-1), or choose to return the current state as terminal (ndim)\n",
        "    actions = None # (current_batch_size,)\n",
        "\n",
        "    i = 0\n",
        "    while torch.any(~dones):\n",
        "\n",
        "        ### Forward pass ### \n",
        "        current_batch_size = (~dones).sum()\n",
        "        non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "        embed = one_hot_embedding(non_terminal_states) # (current_batch_size, input_dim)\n",
        "        logF = model_FM(embed) # (current_batch_size, output_dim = ndim+1) \n",
        "\n",
        "        ### Forward Policy : tempered version of the state-action flow F ### \n",
        "        # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "        edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "        # but any cell can be a terminal cell\n",
        "        stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "        # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "        PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "        # logPF (with mask)\n",
        "        logPF = (logF + minus_inf*PF_mask).log_softmax(1) # (current_batch_size, ndim+1)\n",
        "        # choose next states\n",
        "        sample_temperature = 1\n",
        "        #exp_weight= 0.\n",
        "        #PF = (1-exp_weight)*(logPF/sample_temperature).softmax(1) + exp_weight*(1-PF_mask) / (1-PF_mask+0.0000001).sum(1).unsqueeze(1) # (current_batch_size, ndim+1)\n",
        "        PF = (logPF/sample_temperature).softmax(1) # (current_batch_size, ndim+1)\n",
        "        #actions = torch.distributions.categorical.Categorical(probs = PF).sample() # (current_batch_size,)\n",
        "        #actions = torch.multinomial(probs = PF, 1).squeeze(1) # (current_batch_size,) # (current_batch_size,)\n",
        "        actions = PF.multinomial(1) # (current_batch_size,)\n",
        "        \n",
        "        ### Out Flow for non-terminal states : add -log_sumF(s_i, .) to the loss L(s_i) ###\n",
        "        non_terminates = (actions!=ndim).squeeze(1)\n",
        "        termination_mask = ~dones\n",
        "        termination_mask[~dones] &= non_terminates\n",
        "        #outFlow = logF[non_terminates].exp().sum(dim=-1)\n",
        "        outFlow = logPF[non_terminates].exp().sum(dim=-1)\n",
        "        loss_FM[termination_mask,i] -= (epsilon + outFlow).log()\n",
        "\n",
        "        ### In Flow : non-initial and non-terminal state ###\n",
        "        if i!=0 :\n",
        "            # add log_sumF(., s_i) to the loss L(s_i)\n",
        "            #inFlow = torch.stack([get_inflow(state, model_FM) for state in non_terminal_states]) # (current_batch_size,)\n",
        "            #loss_FM[~dones,i] += (epsilon + inFlow).log()    \n",
        "            if non_terminates.any(): \n",
        "                inFlow = torch.stack([get_inflow(state, model_FM) for state in non_terminal_states[non_terminates]]) # (current_batch_size,)\n",
        "                loss_FM[termination_mask,i] += (epsilon + inFlow).log()      \n",
        "        else :\n",
        "            # initial state\n",
        "            #all_init_flow = logF.exp().sum(dim=1) # (current_batch_size,)\n",
        "            all_init_flow = logPF.exp().sum(dim=1) # (current_batch_size,)\n",
        "            #logZ_FM[:] = all_init_flow.mean().item() \n",
        "            logZ_FM[:] = all_init_flow[0].item() # initial state)\n",
        "\n",
        "        ### select terminal states ### \n",
        "        terminates = (actions==ndim).squeeze(1)\n",
        "        for state in non_terminal_states[terminates]: \n",
        "            state_index = get_state_index(state.cpu())\n",
        "            if first_visit_FM[state_index]<0: first_visit_FM[state_index] = it\n",
        "            all_visited_FM.append(state_index)\n",
        "\n",
        "        # Add -reward for terminal state : Out Flow for terminal states\n",
        "        termination_mask = ~dones\n",
        "        termination_mask[~dones] &= terminates\n",
        "        R_x = reward_function(non_terminal_states[terminates].float())\n",
        "        loss_FM[termination_mask,i] -= (epsilon + R_x).log()\n",
        "\n",
        "        ### In Flow : terminal state ###\n",
        "        if i!=0 and terminates.any():\n",
        "            # add log_sumF(., s_i) to the loss L(s_i)   \n",
        "            inFlow = torch.stack([get_inflow(state, model_FM, stop_action=True) for state in non_terminal_states[terminates]]) # (current_batch_size,)\n",
        "            #print(inFlow, \"===========\", non_terminal_states[terminates])\n",
        "            loss_FM[termination_mask,i] += (epsilon + inFlow).log()           \n",
        "\n",
        "        # Update dones\n",
        "        dones[~dones] |= terminates\n",
        "\n",
        "        # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "        with torch.no_grad():\n",
        "            non_terminates = actions[~terminates]\n",
        "            states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "\n",
        "        i += 1\n",
        "    \n",
        "    loss_FM = loss_FM[:,1:] # remove L(s_0)\n",
        "    loss = (loss_FM**2).sum(dim=1).sum()/batch_size\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    losses_FM.append(loss.item())\n",
        "    R = reward_function(states.float())\n",
        "    rewards_FM.append(R.mean().cpu())\n",
        "    logZ_FM_list.append(logZ_FM.item())\n",
        "\n",
        "    if it%100==0: \n",
        "        print('\\nloss =', np.array(losses_FM[-100:]).mean(), 'logZ =', logZ_FM.item(), \"R =\", np.array(rewards_FM[-100:]).mean())\n",
        "        emp_dist = np.bincount(all_visited_FM[-200000:], minlength=len(true_dist)).astype(float)\n",
        "        emp_dist /= emp_dist.sum()\n",
        "        l1 = np.abs(true_dist-emp_dist).mean()\n",
        "        print('L1 =', l1)\n",
        "        l1log_FM.append((len(all_visited_FM), l1))"
      ],
      "metadata": {
        "id": "c6srvFCHXtGQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 571
        },
        "outputId": "4c601024-98a2-4a6a-91f7-556a8003b6e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  0%|          | 1/5000 [00:01<2:10:45,  1.57s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 37.468482971191406 logZ = 1.0000001192092896 R = 0.52171874\n",
            "L1 = 0.0017865315214705144\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  2%|▏         | 101/5000 [08:47<8:20:33,  6.13s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 10.02450667567551 logZ = 1.0 R = 0.5090625\n",
            "L1 = 0.0016239106400398762\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  4%|▍         | 201/5000 [19:05<8:11:16,  6.14s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.13829539590980858 logZ = 1.0 R = 0.5062109\n",
            "L1 = 0.0016876384215197093\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  6%|▌         | 301/5000 [29:17<7:50:04,  6.00s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "loss = 0.12635590753518045 logZ = 0.9999999403953552 R = 0.5059375\n",
            "L1 = 0.0017137194048126839\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  7%|▋         | 374/5000 [36:40<7:33:41,  5.88s/it]\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-53-a3c5dfabac54>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     51\u001b[0m             \u001b[0;31m#loss_FM[~dones,i] += (epsilon + inFlow).log()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     52\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mnon_terminates\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m                 \u001b[0minFlow\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mget_inflow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel_FM\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstate\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnon_terminal_states\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnon_terminates\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# (current_batch_size,)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     54\u001b[0m                 \u001b[0mloss_FM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtermination_mask\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mepsilon\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0minFlow\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m         \u001b[0;32melse\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-53-a3c5dfabac54>\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     51\u001b[0m             \u001b[0;31m#loss_FM[~dones,i] += (epsilon + inFlow).log()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     52\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mnon_terminates\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m                 \u001b[0minFlow\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mget_inflow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel_FM\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstate\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mnon_terminal_states\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnon_terminates\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# (current_batch_size,)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     54\u001b[0m                 \u001b[0mloss_FM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtermination_mask\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mepsilon\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0minFlow\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m         \u001b[0;32melse\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-48-aab68f6527cf>\u001b[0m in \u001b[0;36mget_inflow\u001b[0;34m(state, model, stop_action)\u001b[0m\n\u001b[1;32m     10\u001b[0m         \u001b[0mparents\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtransitions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mall_parents\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mparents\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m         \u001b[0membed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mone_hot_embedding\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparents\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlong\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# (n_parents, embedding_dim)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m         \u001b[0mlogF\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0membed\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# (n_parents, ndim+1)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mlogF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgather\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtransitions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-19-ad28d0d6b1c3>\u001b[0m in \u001b[0;36mone_hot_embedding\u001b[0;34m(states, num_classes)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;31m# states : (bs, ndim) -> (bs, embedding_dim), embedding_dim = num_classes x ndim\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mnum_classes\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0mH\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctional\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mone_hot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstates\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_classes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mview\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstates\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#loss_FM[:,1:], loss_FM.shape"
      ],
      "metadata": {
        "id": "zBS86NsgK-PF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#loss_FM[loss_FM != 0].shape"
      ],
      "metadata": {
        "id": "haFjpnJ3LeKq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### samples"
      ],
      "metadata": {
        "id": "8XV5z82DY7rv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#model_FM, logZ_FM, losses_FM, rewards_FM, logZ_FM_list, all_visited_FM, first_visit_FM, l1log_FM = data[\"FM\"]"
      ],
      "metadata": {
        "id": "UXEM4Gx6ZJ0p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "samples_FM = np.zeros((H+1,)*ndim)"
      ],
      "metadata": {
        "id": "OemU8ZouZAJd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# #batch_size = 128\n",
        "# #batch_size = 8\n",
        "# #batch_size = 1\n",
        "# epsilon = 1e-2\n",
        "# for it in tqdm.trange(100):    \n",
        "#     # finished trajectories\n",
        "#     dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "#     # s_0\n",
        "#     states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "#     # actions chosen at each step : we can choose the coordinate to increment (0 ... ndim-1), or choose to return the current state as terminal (ndim)\n",
        "#     actions = None # (current_batch_size,)\n",
        "\n",
        "#     current_batch_size = (~dones).sum()\n",
        "#     non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "\n",
        "#     i = 0\n",
        "#     while torch.any(~dones):\n",
        "\n",
        "#         if actions is not None :  \n",
        "#             ### select terminal states ### \n",
        "#             terminates = (actions==ndim).squeeze(1)\n",
        "\n",
        "#             # Update dones\n",
        "#             dones[~dones] |= terminates\n",
        "\n",
        "#             # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "#             with torch.no_grad():\n",
        "#                 non_terminates = actions[~terminates]\n",
        "#                 states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "#             i += 1\n",
        "\n",
        "#         if torch.any(~dones) :\n",
        "#             ### Forward pass ### \n",
        "#             current_batch_size = (~dones).sum()\n",
        "#             non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "#             embed = one_hot_embedding(non_terminal_states) # (current_batch_size, input_dim)\n",
        "#             logF = model_FM(embed) # (current_batch_size, output_dim = ndim+1) \n",
        "\n",
        "#             ### Forward Policy : tempered version of the state-action flow F ### \n",
        "#             # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "#             edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "#             # but any cell can be a terminal cell\n",
        "#             stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "#             # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "#             PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "#             # logPF (with mask)\n",
        "#             logPF = (logF + minus_inf*PF_mask).log_softmax(1) # (current_batch_size, ndim+1)\n",
        "#             # choose next states\n",
        "#             sample_temperature = 1\n",
        "#             #exp_weight= 0.\n",
        "#             #PF = (1-exp_weight)*(logPF/sample_temperature).softmax(1) + exp_weight*(1-PF_mask) / (1-PF_mask+0.0000001).sum(1).unsqueeze(1) # (current_batch_size, ndim+1)\n",
        "#             PF = (logPF/sample_temperature).softmax(1) # (current_batch_size, ndim+1)\n",
        "#             #actions = torch.distributions.categorical.Categorical(probs = PF).sample() # (current_batch_size,)\n",
        "#             #actions = torch.multinomial(probs = PF, 1).squeeze(1) # (current_batch_size,) # (current_batch_size,)\n",
        "#             actions = PF.multinomial(1) # (current_batch_size,)\n",
        "#         else :\n",
        "#             break\n",
        "\n",
        "#     if ndim == 8 :\n",
        "#         for a,b,c,d,e,f,g,h in states: samples_FM[a,b,c,d,e,f,g,h]+=1  \n",
        "#     if ndim == 6 :\n",
        "#         for a,b,c,d,e,f in states: samples_FM[a,b,c,d,e,f]+=1         \n",
        "#     if ndim == 4 :\n",
        "#         for a,b,c,d in states: samples_FM[a,b,c,d]+=1\n",
        "#     elif ndim == 2 :\n",
        "#         for a,b in states: samples_FM[a,b]+=1"
      ],
      "metadata": {
        "id": "CqEWCjIVY95J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for it in tqdm.trange(500):    \n",
        "    # finished trajectories\n",
        "    dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "    # s_0\n",
        "    states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "    # actions chosen at each step : we can choose the coordinate to increment (0 ... ndim-1), or choose to return the current state as terminal (ndim)\n",
        "    actions = None # (current_batch_size,)\n",
        "\n",
        "    while torch.any(~dones):\n",
        "\n",
        "        ### Forward pass ### \n",
        "        current_batch_size = (~dones).sum()\n",
        "        non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "        embed = one_hot_embedding(non_terminal_states) # (current_batch_size, input_dim)\n",
        "        with torch.no_grad():\n",
        "            logF = model_FM(embed) # (current_batch_size, output_dim = ndim+1) \n",
        "\n",
        "        ### Forward Policy : tempered version of the flow F ### \n",
        "        # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "        edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "        # but any cell can be a terminal cell\n",
        "        stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "        # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "        PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "        # logPF (with mask)\n",
        "        logPF = (logF + minus_inf*PF_mask).log_softmax(1) # (current_batch_size, ndim+1)\n",
        "        # choose next states\n",
        "        sample_temperature = 1\n",
        "        #exp_weight= 0.\n",
        "        #PF = (1-exp_weight)*(logPF/sample_temperature).softmax(1) + exp_weight*(1-PF_mask) / (1-PF_mask+0.0000001).sum(1).unsqueeze(1) # (current_batch_size, ndim+1)\n",
        "        PF = (logPF/sample_temperature).softmax(1) # (current_batch_size, ndim+1)\n",
        "        #actions = torch.distributions.categorical.Categorical(probs = PF).sample() # (current_batch_size,)\n",
        "        #actions = torch.multinomial(probs = PF, 1).squeeze(1) # (current_batch_size,) # (current_batch_size,)\n",
        "        actions = PF.multinomial(1) # (current_batch_size,)\n",
        "        \n",
        "        ### select terminal states ### \n",
        "        terminates = (actions==ndim).squeeze(1)\n",
        "\n",
        "        # Update dones\n",
        "        dones[~dones] |= terminates\n",
        "\n",
        "        # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "        with torch.no_grad():\n",
        "            non_terminates = actions[~terminates]\n",
        "            states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "\n",
        "    if ndim == 8 :\n",
        "        for a,b,c,d,e,f,g,h in states: samples_FM[a,b,c,d,e,f,g,h]+=1  \n",
        "    if ndim == 6 :\n",
        "        for a,b,c,d,e,f in states: samples_FM[a,b,c,d,e,f]+=1         \n",
        "    if ndim == 4 :\n",
        "        for a,b,c,d in states: samples_FM[a,b,c,d]+=1\n",
        "    elif ndim == 2 :\n",
        "        for a,b in states: samples_FM[a,b]+=1"
      ],
      "metadata": {
        "id": "aroKVi88X5Cf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15a44a6e-7fc3-4b33-b47c-c19b394aea4b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 500/500 [00:38<00:00, 13.11it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    print(samples_FM / samples_FM.sum())"
      ],
      "metadata": {
        "id": "wQQlppHYZSBb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f639ab2b-6deb-4de5-8069-4d4b8af3a37d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1.18906250e-02 1.10937500e-03 1.06250000e-03 ... 0.00000000e+00\n",
            "  0.00000000e+00 0.00000000e+00]\n",
            " [5.93750000e-04 7.81250000e-05 9.37500000e-05 ... 0.00000000e+00\n",
            "  0.00000000e+00 0.00000000e+00]\n",
            " [5.78125000e-04 7.81250000e-05 7.81250000e-05 ... 0.00000000e+00\n",
            "  0.00000000e+00 0.00000000e+00]\n",
            " ...\n",
            " [0.00000000e+00 0.00000000e+00 0.00000000e+00 ... 0.00000000e+00\n",
            "  0.00000000e+00 2.18750000e-04]\n",
            " [0.00000000e+00 0.00000000e+00 0.00000000e+00 ... 4.68750000e-05\n",
            "  4.68750000e-05 3.75000000e-04]\n",
            " [0.00000000e+00 0.00000000e+00 0.00000000e+00 ... 3.90625000e-04\n",
            "  3.12500000e-04 9.64609375e-01]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    plt.imshow(samples_FM)\n",
        "elif ndim == 4 :\n",
        "    plt.imshow(samples_FM[0,0])\n",
        "elif ndim == 6:  \n",
        "    plt.imshow(samples_FM[0,0,0,0])\n",
        "elif ndim == 8:\n",
        "    plt.imshow(samples_FM[0,0,0,0,0,0])"
      ],
      "metadata": {
        "id": "lK-QZmMhZT8-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "outputId": "df583edc-a651-4c57-8f4c-6d232eb425ff"
      },
      "execution_count": null,
      "outputs": [
        {
          "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": "code",
      "source": [
        "if ndim == 4 :\n",
        "    tmp = samples_FM.sum((2,3))+samples_FM.sum((0,1))+samples_FM.sum((0,2))+samples_FM.sum((1,3))+samples_FM.sum((2,3))+samples_FM.sum((0,3))\n",
        "    plt.imshow(tmp,vmin=0);plt.show()\n",
        "    plt.imshow(samples_FM.sum((1,3)),vmin=0);plt.show()"
      ],
      "metadata": {
        "id": "PRMbBzt0ZQgo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**This implementation has a problem. Refer to this official implementation for the moment : https://github.com/GFNOrg/gflownet**"
      ],
      "metadata": {
        "id": "wYr96X4XYsCu"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AYh5lqX1ZBVL"
      },
      "source": [
        "## Random (uniform) agent"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Yl3jqdTYdMe3"
      },
      "outputs": [],
      "source": [
        "rewards_random = []\n",
        "all_visited_random = []\n",
        "first_visit_random = -1 * np.ones_like(true_dist)\n",
        "l1log_random = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ns2X5pc-EfGM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c46f0b25-d77e-49f4-8deb-5a758525f4c5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  1%|          | 28/5000 [00:00<00:37, 134.30it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.56078124\n",
            "L1 = 0.0017376550792586453\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  3%|▎         | 126/5000 [00:00<00:37, 131.04it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5359375\n",
            "L1 = 0.0017140249790238\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  4%|▍         | 225/5000 [00:01<00:35, 135.30it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53457034\n",
            "L1 = 0.0017120312267684093\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  7%|▋         | 326/5000 [00:02<00:34, 135.06it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5333203\n",
            "L1 = 0.0017131362376799882\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  9%|▊         | 427/5000 [00:03<00:32, 139.30it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53375\n",
            "L1 = 0.0017138316416154418\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 10%|█         | 524/5000 [00:03<00:34, 128.66it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53515625\n",
            "L1 = 0.0017128747780434097\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 12%|█▏        | 621/5000 [00:04<00:33, 131.85it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5325781\n",
            "L1 = 0.0017133583968721338\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 14%|█▍        | 722/5000 [00:05<00:32, 132.68it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5310938\n",
            "L1 = 0.00171384731158422\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 16%|█▋        | 823/5000 [00:06<00:30, 138.75it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53367186\n",
            "L1 = 0.0017139454605933197\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 18%|█▊        | 922/5000 [00:06<00:30, 135.15it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5351953\n",
            "L1 = 0.0017140058983620959\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 20%|██        | 1024/5000 [00:07<00:30, 128.63it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5348828\n",
            "L1 = 0.0017140972617286539\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 22%|██▏       | 1124/5000 [00:08<00:29, 133.16it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5376172\n",
            "L1 = 0.0017138592651584348\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 24%|██▍       | 1221/5000 [00:09<00:29, 129.75it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5371875\n",
            "L1 = 0.0017134339137385257\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 26%|██▋       | 1320/5000 [00:09<00:27, 131.94it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5285938\n",
            "L1 = 0.0017138569713190084\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 28%|██▊       | 1425/5000 [00:10<00:25, 137.99it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5313672\n",
            "L1 = 0.0017141991526914114\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 31%|███       | 1526/5000 [00:11<00:24, 139.57it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5396094\n",
            "L1 = 0.0017139126426295094\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 32%|███▎      | 1625/5000 [00:12<00:25, 129.99it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53378904\n",
            "L1 = 0.0017138104823922876\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 34%|███▍      | 1722/5000 [00:12<00:25, 126.34it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5339453\n",
            "L1 = 0.0017137348756498057\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 36%|███▋      | 1820/5000 [00:13<00:24, 127.43it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5342187\n",
            "L1 = 0.001713679779231073\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 38%|███▊      | 1919/5000 [00:14<00:23, 132.44it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5319922\n",
            "L1 = 0.0017137165101768948\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 40%|████      | 2019/5000 [00:15<00:22, 132.19it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5326172\n",
            "L1 = 0.001713900164906004\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 42%|████▏     | 2117/5000 [00:15<00:22, 127.14it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5359766\n",
            "L1 = 0.0017139277131153702\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 44%|████▍     | 2211/5000 [00:16<00:23, 117.49it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5358203\n",
            "L1 = 0.0017138358857508155\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 46%|████▋     | 2321/5000 [00:17<00:20, 129.16it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5326953\n",
            "L1 = 0.0017135625485079902\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 48%|████▊     | 2417/5000 [00:18<00:19, 130.52it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.530625\n",
            "L1 = 0.0017135858070156797\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 50%|█████     | 2516/5000 [00:19<00:19, 128.28it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5366797\n",
            "L1 = 0.0017137348756498054\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 52%|█████▏    | 2615/5000 [00:19<00:18, 126.86it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5342969\n",
            "L1 = 0.0017135971346029736\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 54%|█████▍    | 2713/5000 [00:20<00:18, 124.15it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5313672\n",
            "L1 = 0.0017138267030143604\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 57%|█████▋    | 2827/5000 [00:21<00:16, 132.85it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5324219\n",
            "L1 = 0.0017137624238591721\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 58%|█████▊    | 2913/5000 [00:22<00:16, 128.49it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53339845\n",
            "L1 = 0.0017136155000758845\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 60%|██████    | 3014/5000 [00:22<00:15, 128.89it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5359766\n",
            "L1 = 0.0017133583834551315\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 62%|██████▏   | 3117/5000 [00:23<00:13, 136.06it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53414065\n",
            "L1 = 0.001713330835245765\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 64%|██████▍   | 3216/5000 [00:24<00:13, 129.87it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5328125\n",
            "L1 = 0.0017135144899748744\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 66%|██████▌   | 3312/5000 [00:25<00:14, 119.62it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53292966\n",
            "L1 = 0.0017139552613247367\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 68%|██████▊   | 3424/5000 [00:26<00:12, 123.23it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53324217\n",
            "L1 = 0.00171382670301436\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 71%|███████   | 3527/5000 [00:26<00:10, 134.10it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53777343\n",
            "L1 = 0.0017134502108196864\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 73%|███████▎  | 3626/5000 [00:27<00:10, 128.40it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53160155\n",
            "L1 = 0.0017134777590290524\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 75%|███████▍  | 3727/5000 [00:28<00:09, 135.40it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5358203\n",
            "L1 = 0.0017136063173394292\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 77%|███████▋  | 3826/5000 [00:29<00:08, 133.56it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5351172\n",
            "L1 = 0.0017134410280832308\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 79%|███████▊  | 3929/5000 [00:29<00:07, 134.30it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5358203\n",
            "L1 = 0.0017130186222062793\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 80%|████████  | 4016/5000 [00:30<00:07, 131.88it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53457034\n",
            "L1 = 0.0017130278049427349\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 82%|████████▏ | 4116/5000 [00:31<00:06, 127.96it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53378904\n",
            "L1 = 0.0017127064091667936\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 84%|████████▍ | 4215/5000 [00:31<00:06, 128.03it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53414065\n",
            "L1 = 0.0017126421300116053\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 86%|████████▋ | 4316/5000 [00:32<00:05, 135.04it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53621095\n",
            "L1 = 0.001712763650436365\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 88%|████████▊ | 4414/5000 [00:33<00:04, 129.09it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53578126\n",
            "L1 = 0.0017127544676999095\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 91%|█████████ | 4527/5000 [00:34<00:03, 132.06it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5358203\n",
            "L1 = 0.0017125319371741395\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 92%|█████████▏| 4618/5000 [00:34<00:02, 139.67it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5319531\n",
            "L1 = 0.0017127177367540873\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 94%|█████████▍| 4722/5000 [00:35<00:02, 137.77it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53589845\n",
            "L1 = 0.0017128922087467416\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 96%|█████████▋| 4821/5000 [00:36<00:01, 132.19it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.53621095\n",
            "L1 = 0.0017125962163293282\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 98%|█████████▊| 4919/5000 [00:37<00:00, 125.92it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "R = 0.5360547\n",
            "L1 = 0.0017125227544376844\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5000/5000 [00:37<00:00, 132.16it/s]\n"
          ]
        }
      ],
      "source": [
        "for it in tqdm.trange(n_train_steps):\n",
        "\n",
        "    # finished trajectories\n",
        "    dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "    # s_0\n",
        "    states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "\n",
        "    while torch.any(~dones) : #and i <= max_length_traj :\n",
        "        # Forward pass\n",
        "        current_batch_size = (~dones).sum()\n",
        "        non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "        \n",
        "        ### Uniform Forward Policy ### \n",
        "        PF_logits = torch.ones(current_batch_size, ndim+1).to(device) # (current_batch_size, ndim+1) \n",
        "        # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "        edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "        # but any cell can be a terminal cell\n",
        "        stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "        # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "        PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "        # PF (with mask)\n",
        "        PF = (PF_logits + minus_inf*PF_mask).softmax(1) # (current_batch_size, ndim+1)\n",
        "        # choose next states\n",
        "        #actions = torch.from_numpy(np.random.choice(np.arange(ndim+1), size=(current_batch_size,1), p = PF))\n",
        "        actions = PF.multinomial(1)\n",
        "        #if i == max_length_traj : actions = torch.LongTensor(current_batch_size,1).fill_(ndim)\n",
        "        # select terminal states\n",
        "        terminates = (actions==ndim).squeeze(1)\n",
        "        for state in non_terminal_states[terminates]: \n",
        "            state_index = get_state_index(state.cpu())\n",
        "            if first_visit_random[state_index]<0: first_visit_random[state_index] = it\n",
        "            all_visited_random.append(state_index)\n",
        "        # Update dones\n",
        "        dones[~dones] |= terminates\n",
        "\n",
        "        # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "        with torch.no_grad():\n",
        "            non_terminates = actions[~terminates]\n",
        "            states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "\n",
        "    R = reward_function(states.float())\n",
        "    rewards_random.append(R.mean().cpu())\n",
        "    if it%100==0: \n",
        "        print(\"\\nR =\", np.array(rewards_random[-100:]).mean())\n",
        "        emp_dist = np.bincount(all_visited_random[-200000:], minlength=len(true_dist)).astype(float)\n",
        "        emp_dist /= emp_dist.sum()\n",
        "        l1 = np.abs(true_dist-emp_dist).mean()\n",
        "        print('L1 =', l1)\n",
        "        l1log_random.append((len(all_visited_random), l1))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### samples"
      ],
      "metadata": {
        "id": "HUtnGHiTZzux"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "samples_random = np.zeros((H+1,)*ndim)"
      ],
      "metadata": {
        "id": "H-eBidKMZ2bV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for it in tqdm.trange(500):\n",
        "\n",
        "    # finished trajectories\n",
        "    dones = torch.full((batch_size,), False, dtype=torch.bool).to(device)\n",
        "    # s_0\n",
        "    states = torch.zeros((batch_size, ndim), dtype=torch.long).to(device)\n",
        "\n",
        "    while torch.any(~dones) : #and i <= max_length_traj :\n",
        "        # Forward pass\n",
        "        current_batch_size = (~dones).sum()\n",
        "        non_terminal_states = states[~dones] # (current_batch_size, ndim)\n",
        "        \n",
        "        ### Uniform Forward Policy ### \n",
        "        PF_logits = torch.ones(current_batch_size, ndim+1).to(device) # (current_batch_size, ndim+1) \n",
        "        # Being in a edge cell ++ (a coordinate that is H), we can't move forward\n",
        "        edge_mask = (non_terminal_states == H).float() # (current_batch_size, ndim)\n",
        "        # but any cell can be a terminal cell\n",
        "        stop_action_mask = torch.zeros((current_batch_size, 1), device=device) # (current_batch_size, 1)\n",
        "        # Being in a edge cell, we can't move forward, but any cell can be a terminal cell\n",
        "        PF_mask = torch.cat([edge_mask, stop_action_mask], 1) # (current_batch_size, ndim+1)\n",
        "        # PF (with mask)\n",
        "        PF = (PF_logits + minus_inf*PF_mask).softmax(1) # (current_batch_size, ndim+1)\n",
        "        # choose next states\n",
        "        #actions = torch.from_numpy(np.random.choice(np.arange(ndim+1), size=(current_batch_size,1), p = PF))\n",
        "        actions = PF.multinomial(1)\n",
        "        #if i == max_length_traj : actions = torch.LongTensor(current_batch_size,1).fill_(ndim)\n",
        "        # select terminal states\n",
        "        terminates = (actions==ndim).squeeze(1)\n",
        " \n",
        "        # Update dones\n",
        "        dones[~dones] |= terminates\n",
        "\n",
        "        # Update non completed trajectories : $s = (s^0, ..., s^i, ..., s^{n-1}) \\rightarrow s' = (s^0, ..., s^i + 1, ..., s^{n-1})$\n",
        "        with torch.no_grad():\n",
        "            non_terminates = actions[~terminates]\n",
        "            states[~dones] = states[~dones].scatter_add(1, non_terminates, torch.ones(non_terminates.shape, dtype=torch.long, device=device))\n",
        "\n",
        "    if ndim == 8 :\n",
        "        for a,b,c,d,e,f,g,h in states: samples_random[a,b,c,d,e,f,g,h]+=1  \n",
        "    if ndim == 6 :\n",
        "        for a,b,c,d,e,f in states: samples_random[a,b,c,d,e,f]+=1         \n",
        "    if ndim == 4 :\n",
        "        for a,b,c,d in states: samples_random[a,b,c,d]+=1\n",
        "    elif ndim == 2 :\n",
        "        for a,b in states: samples_random[a,b]+=1"
      ],
      "metadata": {
        "id": "s4s7MyvSaOdE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b339e877-a00b-4646-e77c-2a67db055e91"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 500/500 [00:02<00:00, 182.55it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    print(samples_random / samples_random.sum())"
      ],
      "metadata": {
        "id": "xEwhQAO-alyd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fb15768-5528-4748-8f4b-5a359137338b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.33409375 0.1101875  0.03796875 ... 0.         0.         0.        ]\n",
            " [0.11054688 0.07403125 0.03682813 ... 0.         0.         0.        ]\n",
            " [0.03571875 0.03742188 0.02507812 ... 0.         0.         0.        ]\n",
            " ...\n",
            " [0.         0.         0.         ... 0.         0.         0.        ]\n",
            " [0.         0.         0.         ... 0.         0.         0.        ]\n",
            " [0.         0.         0.         ... 0.         0.         0.        ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "if ndim == 2 :\n",
        "    plt.imshow(samples_random)\n",
        "elif ndim == 4 :\n",
        "    plt.imshow(samples_random[0,0])\n",
        "elif ndim == 6:  \n",
        "    plt.imshow(samples_random[0,0,0,0])\n",
        "elif ndim == 8:\n",
        "    plt.imshow(samples_random[0,0,0,0,0,0])"
      ],
      "metadata": {
        "id": "FcoZjxAxan3D",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "outputId": "c956a559-2fb7-43c4-f282-4cf1111b7361"
      },
      "execution_count": null,
      "outputs": [
        {
          "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": "code",
      "source": [
        "if ndim == 4 :\n",
        "    tmp = samples_random.sum((2,3))+samples_random.sum((0,1))+samples_random.sum((0,2))+samples_random.sum((1,3))+samples_random.sum((2,3))+samples_random.sum((0,3))\n",
        "    plt.imshow(tmp,vmin=0);plt.show()\n",
        "    plt.imshow(samples_random.sum((1,3)),vmin=0);plt.show()"
      ],
      "metadata": {
        "id": "fzTaQRbyZ9E7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Saves models"
      ],
      "metadata": {
        "id": "3XxLoeGvcQk5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = {\n",
        "    \"TB\" : [model_TB, logZ_TB, losses_TB, rewards_TB, logZ_TB_list, all_visited_TB, first_visit_TB, l1log_TB],\n",
        "    \"DB\" : [model_DB, logZ_DB, losses_DB, rewards_DB, logZ_DB_list, all_visited_DB, first_visit_DB, l1log_DB],\n",
        "    \"FM\" : [model_FM, logZ_FM, losses_FM, rewards_FM, logZ_FM_list, all_visited_FM, first_visit_FM, l1log_FM],\n",
        "    \"random\" : [None, None, None, rewards_random, None, all_visited_random, first_visit_random, l1log_random],\n",
        "}\n",
        "\n",
        "torch.save(data, \"/content/data_gfn.pth\")"
      ],
      "metadata": {
        "id": "mt4B-_etcSrR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5hRDhCYseBJF"
      },
      "source": [
        "## Plot"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Rdbrc2xkeC_C",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 973
        },
        "outputId": "b28e38c3-83c7-48b8-c205-f2976a3f4974"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f1255ca4190>"
            ]
          },
          "metadata": {},
          "execution_count": 72
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1728x1152 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "figsize=(6*4,4*4)\n",
        "#fig, (ax1, ax2, ax3, ax4)  = plt.subplots(4, 1, sharex=False, sharey=False, figsize = figsize)\n",
        "fig, (ax1, ax2, ax3)  = plt.subplots(3, 1, sharex=False, sharey=False, figsize = figsize)\n",
        "fig.suptitle(\"Flownet agent : TB, DB, FM and Random angent\")\n",
        "\n",
        "## loss\n",
        "xs_TB = list(range(len(losses_TB)))\n",
        "ax1.plot(xs_TB, losses_TB, label=\"TB\")\n",
        "#-\n",
        "xs_DB = list(range(len(losses_DB)))\n",
        "ax1.plot(xs_DB, losses_DB, label=\"DB\")\n",
        "#-\n",
        "xs_FM = list(range(len(losses_FM)))\n",
        "ax1.plot(xs_FM, losses_FM, label=\"FM\")\n",
        "#-\n",
        "ax1.set(xlabel='episodes', ylabel='loss')\n",
        "ax1.set_title('loss per episodes : do not compare')\n",
        "ax1.legend()\n",
        "\n",
        "## rewards\n",
        "ax2.plot(xs_TB, rewards_TB, label=\"TB\")\n",
        "ax2.plot(xs_DB, rewards_DB, label=\"DB\")\n",
        "ax2.plot(xs_FM, rewards_FM, label=\"FM\")\n",
        "xs_random = list(range(len(rewards_random)))\n",
        "ax2.plot(xs_random, rewards_random, label=\"random\")\n",
        "ax2.set(xlabel='episodes', ylabel='reward')\n",
        "ax2.set_title('reward per episodes')\n",
        "ax2.legend()\n",
        "\n",
        "## empirical loss\n",
        "xs = [a[0] for a in l1log_TB]\n",
        "emp_loss_TB = [a[1] for a in l1log_TB]\n",
        "ax3.plot(xs, emp_loss_TB, label=\"TB\")\n",
        "#-\n",
        "xs = [a[0] for a in l1log_DB]\n",
        "emp_loss_DB = [a[1] for a in l1log_DB]\n",
        "ax3.plot(xs, emp_loss_DB, label=\"DB\")\n",
        "#-\n",
        "xs = [a[0] for a in l1log_FM]\n",
        "emp_loss_FM = [a[1] for a in l1log_FM]\n",
        "ax3.plot(xs, emp_loss_FM, label=\"FM\")\n",
        "#-\n",
        "xs = [a[0] for a in l1log_random]\n",
        "emp_loss_random = [a[1] for a in l1log_random]\n",
        "ax3.plot(xs, emp_loss_random, label=\"random\")\n",
        "#-\n",
        "ax3.set(xlabel='#states visited', ylabel='empirical loss')\n",
        "ax3.set_title('empirical loss per #state visited')\n",
        "ax3.legend()\n",
        "\n",
        "\n",
        "# ## empiciral loss\n",
        "# xs = list(range(len(emp_loss_TB)))\n",
        "# ax4.plot(xs, emp_loss_TB, label=\"TB\")\n",
        "# #-\n",
        "# xs = list(range(len(emp_loss_DB)))\n",
        "# ax4.plot(xs, emp_loss_DB, label=\"DB\")\n",
        "# #-\n",
        "# xs = list(range(len(emp_loss_FM)))\n",
        "# ax4.plot(xs, emp_loss_FM, label=\"FM\")\n",
        "# #-\n",
        "# xs = list(range(len(emp_loss_random)))\n",
        "# ax4.plot(xs, emp_loss_random, label=\"random\")\n",
        "# #-\n",
        "# ax4.set(xlabel='#states visited', ylabel='empirical loss')\n",
        "# ax4.set_title('empirical loss per epoch')\n",
        "# ax4.legend()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MgRtXWYlHTUp"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sO1cdi-foPIi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "53104755-78a5-429d-bdda-bbe377d06070"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(36)\n"
          ]
        }
      ],
      "source": [
        "#threshold = R0+R1 if H < 8 else R0+R1+R2\n",
        "threshold = all_rewards.max()\n",
        "\n",
        "modes = all_rewards >= threshold\n",
        "n_modes = modes.sum()\n",
        "print(n_modes)\n",
        "\n",
        "max_steps = None\n",
        "#max_steps = 1000\n",
        "\n",
        "# modes_founds_TB, xs_TB = get_modes_founds_old(first_visit_TB, threshold, max_steps)\n",
        "# modes_founds_DB, xs_DB = get_modes_founds_old(first_visit_DB, threshold, max_steps)\n",
        "# modes_founds_FM, xs_FM = get_modes_founds_old(first_visit_FM, threshold, max_steps)\n",
        "# modes_founds_random, xs_random = get_modes_founds_old(first_visit_random, threshold, max_steps)\n",
        "\n",
        "modes_founds_TB, xs_TB = get_modes_founds(first_visit_TB, modes, max_steps)\n",
        "modes_founds_DB, xs_DB = get_modes_founds(first_visit_DB, modes, max_steps)\n",
        "modes_founds_FM, xs_FM = get_modes_founds(first_visit_FM, modes, max_steps)\n",
        "modes_founds_random, xs_random = get_modes_founds(first_visit_random, modes, max_steps) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9igd35fCtGe5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 747
        },
        "outputId": "38ba05da-e969-49f4-c515-d716460f2890"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f1253b27e50>"
            ]
          },
          "metadata": {},
          "execution_count": 76
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x864 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "figsize=(5*4,3*4)\n",
        "fig, ax1 = plt.subplots(1, 1, sharex=False, sharey=False, figsize = figsize)\n",
        "\n",
        "ax1.plot(xs_TB, modes_founds_TB, label=\"TB\")\n",
        "ax1.plot(xs_DB, modes_founds_DB, label=\"DB\")\n",
        "#ax1.plot(xs_FM, modes_founds_FM, label=\"FM\")\n",
        "ax1.plot(xs_random, modes_founds_random, label=\"random\")\n",
        "ax1.set(xlabel='#states visited', ylabel='mode founds')\n",
        "ax1.set_title(f'n = {ndim}, horizon={H}, n_modes = {n_modes}')\n",
        "ax1.legend()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pdlp1PWJh6M2"
      },
      "source": [
        "# Load pretrained models and sample with\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "thISsNDJh68X"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "data = torch.load(\"/content/data_gfn.pth\", map_location=device)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Run the samples sections above"
      ],
      "metadata": {
        "id": "WMP5PRhmcl31"
      }
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "2_Hypergrid_env.ipynb",
      "toc_visible": true,
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}