FAB_ellis_paper/MoG/SFNsipynb.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SFNsipynb",
      "provenance": [],
      "collapsed_sections": [
        "HxpTtT39vjme",
        "ki415udbcZ8r"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b8-uB0g0iVaH"
      },
      "source": [
        "# Testing SFNs\n",
        "We follow the code from https://github.com/noegroup/stochastic_normalizing_flows/blob/main/experiment1_doublewell.ipynb"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vJeeC_vDkpqL"
      },
      "source": [
        "# Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HxpTtT39vjme"
      },
      "source": [
        "## Setup Library"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EezLugqNhYuv",
        "outputId": "c40ba97c-81d9-42b9-af0e-10a49133e6da"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive', force_remount=True)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i5nnb19ThRNw",
        "outputId": "a2b4aa36-bd42-42e8-df45-f36b83e7adbc"
      },
      "source": [
        "!rm -r stochastic_normalizing_flows\n",
        "!git clone https://github.com/noegroup/stochastic_normalizing_flows"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rm: cannot remove 'stochastic_normalizing_flows': No such file or directory\n",
            "Cloning into 'stochastic_normalizing_flows'...\n",
            "remote: Enumerating objects: 147, done.\u001b[K\n",
            "remote: Counting objects: 100% (147/147), done.\u001b[K\n",
            "remote: Compressing objects: 100% (128/128), done.\u001b[K\n",
            "remote: Total 147 (delta 17), reused 136 (delta 11), pack-reused 0\u001b[K\n",
            "Receiving objects: 100% (147/147), 12.69 MiB | 28.13 MiB/s, done.\n",
            "Resolving deltas: 100% (17/17), done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UCTSlvawRuji",
        "outputId": "5aa83b45-749a-4030-9255-c5e0d91ebafd"
      },
      "source": [
        "!pip install nflows"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting nflows\n",
            "  Downloading nflows-0.14.tar.gz (45 kB)\n",
            "\u001b[K     |████████████████████████████████| 45 kB 1.6 MB/s \n",
            "\u001b[?25hRequirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from nflows) (3.2.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from nflows) (1.19.5)\n",
            "Requirement already satisfied: tensorboard in /usr/local/lib/python3.7/dist-packages (from nflows) (2.6.0)\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from nflows) (1.9.0+cu111)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from nflows) (4.62.3)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->nflows) (0.10.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->nflows) (1.3.2)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->nflows) (2.8.2)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->nflows) (2.4.7)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from cycler>=0.10->matplotlib->nflows) (1.15.0)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (2.23.0)\n",
            "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (0.12.0)\n",
            "Requirement already satisfied: google-auth<2,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (1.35.0)\n",
            "Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (1.41.0)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (3.3.4)\n",
            "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (57.4.0)\n",
            "Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (0.6.1)\n",
            "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (1.8.0)\n",
            "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (1.0.1)\n",
            "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (0.4.6)\n",
            "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (0.37.0)\n",
            "Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard->nflows) (3.17.3)\n",
            "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard->nflows) (4.7.2)\n",
            "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard->nflows) (4.2.4)\n",
            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard->nflows) (0.2.8)\n",
            "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard->nflows) (1.3.0)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard->nflows) (4.8.1)\n",
            "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<2,>=1.6.3->tensorboard->nflows) (0.4.8)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard->nflows) (3.0.4)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard->nflows) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard->nflows) (2021.5.30)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard->nflows) (2.10)\n",
            "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard->nflows) (3.1.1)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->markdown>=2.6.8->tensorboard->nflows) (3.7.4.3)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->markdown>=2.6.8->tensorboard->nflows) (3.6.0)\n",
            "Building wheels for collected packages: nflows\n",
            "  Building wheel for nflows (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for nflows: filename=nflows-0.14-py3-none-any.whl size=53671 sha256=ec4793f39c669fe51fb2349e046e351bd0a6e1d08c2aca38fa66b2ca3d0c6f0d\n",
            "  Stored in directory: /root/.cache/pip/wheels/c0/b6/52/0092eedabce8f7faa35b92522393fbdc1ec5ede99b0ec820d5\n",
            "Successfully built nflows\n",
            "Installing collected packages: nflows\n",
            "Successfully installed nflows-0.14\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rhW8JqY2hfNq",
        "outputId": "d93bec03-9e8e-499e-ccc9-9d5aeb8dd97a"
      },
      "source": [
        "import os\n",
        "os.listdir()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['.config', 'drive', 'stochastic_normalizing_flows', 'sample_data']"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ezDqLz1Vju7x"
      },
      "source": [
        "os.chdir(\"stochastic_normalizing_flows\")"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wZ11rlIa6HIU",
        "outputId": "9415f13f-a745-461a-f5d9-b21d1ea39fd0"
      },
      "source": [
        "!cd bgtorch && python setup.py develop && cd ..\n",
        "!cd snf_code && python setup.py develop && cd .."
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "running develop\n",
            "running egg_info\n",
            "creating bgtorch.egg-info\n",
            "writing bgtorch.egg-info/PKG-INFO\n",
            "writing dependency_links to bgtorch.egg-info/dependency_links.txt\n",
            "writing top-level names to bgtorch.egg-info/top_level.txt\n",
            "writing manifest file 'bgtorch.egg-info/SOURCES.txt'\n",
            "writing manifest file 'bgtorch.egg-info/SOURCES.txt'\n",
            "running build_ext\n",
            "Creating /usr/local/lib/python3.7/dist-packages/bgtorch.egg-link (link to .)\n",
            "Adding bgtorch 0.1 to easy-install.pth file\n",
            "\n",
            "Installed /content/stochastic_normalizing_flows/bgtorch\n",
            "Processing dependencies for bgtorch==0.1\n",
            "Finished processing dependencies for bgtorch==0.1\n",
            "running develop\n",
            "running egg_info\n",
            "writing snf_code.egg-info/PKG-INFO\n",
            "writing dependency_links to snf_code.egg-info/dependency_links.txt\n",
            "writing top-level names to snf_code.egg-info/top_level.txt\n",
            "writing manifest file 'snf_code.egg-info/SOURCES.txt'\n",
            "running build_ext\n",
            "Creating /usr/local/lib/python3.7/dist-packages/snf-code.egg-link (link to .)\n",
            "Adding snf-code 0.1 to easy-install.pth file\n",
            "\n",
            "Installed /content/stochastic_normalizing_flows/snf_code\n",
            "Processing dependencies for snf-code==0.1\n",
            "Finished processing dependencies for snf-code==0.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ZeQHd1Ovfsf"
      },
      "source": [
        "## Setup problem"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "grWNpMOQQGGv"
      },
      "source": [
        "After running the above setups, reload the notebook. Then proceed below"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "II3qv2ajviQo"
      },
      "source": [
        "import torch\n",
        "torch.set_default_dtype(torch.float64)\n",
        "from bgtorch.utils.types import assert_numpy"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D0AotqPmRTRB"
      },
      "source": [
        "from bgtorch.nn.training import KLTrainer"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UHmy3TJ9vnVT"
      },
      "source": [
        "from bgtorch.nn import DenseNet\n",
        "from bgtorch.nn.flow import (\n",
        "    SequentialFlow, \n",
        "    CouplingFlow, \n",
        "    AffineFlow, \n",
        "    SplitFlow,\n",
        "    MergeFlow,\n",
        "    InverseFlow, \n",
        "    SwapFlow\n",
        ")\n",
        "from bgtorch.nn.flow.transformer import AffineTransformer"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Umt71Otevpsj"
      },
      "source": [
        "from bgtorch import BoltzmannGenerator"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DeBSoShfvr5_"
      },
      "source": [
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "import matplotlib as mpl"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QJLPjguuvt77"
      },
      "source": [
        "plt.rcParams.update({'font.size': 16})"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-adVQQywwbw0"
      },
      "source": [
        "from bgtorch.distribution import NormalDistribution"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HPSm2QrTRZ6R"
      },
      "source": [
        "from snf_code import InterpolatedEnergy, RNVP, boltzmann_generator_RNVP_MC\n",
        "from snf_code.analysis import sample_energy, statistical_efficiency\n",
        "from snf_code.imagetools import boltzmann_generator_NSF_MC"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WSq4suuhwk__"
      },
      "source": [
        "def sample_flow(flow, x0, inverse=False):\n",
        "    blocks = flow._blocks\n",
        "    samples = [x0]\n",
        "    x = [x0]\n",
        "    if inverse:\n",
        "        blocks = blocks[::-1]\n",
        "    for block in blocks:\n",
        "        *x, ddlogp = block(*x, inverse=inverse)\n",
        "        if not (isinstance(block, SplitFlow) or isinstance(block, SwapFlow) or isinstance(block, MergeFlow)):\n",
        "            #print(block)\n",
        "            x_np = [xi.detach().numpy() for xi in x]\n",
        "            samples.append(np.hstack(x_np))\n",
        "    if inverse:\n",
        "        samples = samples[::-1]\n",
        "    return samples"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pk3qrIMIb3Rk"
      },
      "source": [
        "# MoG Problem"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ki415udbcZ8r"
      },
      "source": [
        "## Problem defn"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YUzi2sdTdEHN"
      },
      "source": [
        "def quadratic_function(x, seed=0):\n",
        "    # example function that we may want to calculate expectations over\n",
        "    torch.manual_seed(seed)\n",
        "    x_shift = 2*torch.randn(x.shape[-1]).to(x.device)\n",
        "    A = 2*torch.rand((x.shape[-1], x.shape[-1])).to(x.device)\n",
        "    b = torch.rand(x.shape[-1]).to(x.device)\n",
        "    x = x + x_shift\n",
        "    return torch.einsum(\"bi,ij,bj->b\", x, A, x) + torch.einsum(\"i,bi->b\", b, x)"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nfBs23ggcZN6"
      },
      "source": [
        "class MoG(torch.nn.Module):\n",
        "    # mog with random mean and var\n",
        "    def __init__(self, dim : int =2, n_mixes: int =5,\n",
        "                 min_cov: float=0.5, loc_scaling: float=3.0, diagonal_covariance=True,\n",
        "                 cov_scaling=1.0, uniform_component_probs = False):\n",
        "        super(MoG, self).__init__()\n",
        "        self.dim = dim\n",
        "        self.n_mixes = n_mixes\n",
        "        self.distributions = []\n",
        "        locs = []\n",
        "        scale_trils = []\n",
        "        for i in range(n_mixes):\n",
        "            loc = torch.randn(dim)*loc_scaling\n",
        "            if diagonal_covariance:\n",
        "                scale_tril = torch.diag(torch.rand(dim)*cov_scaling + min_cov)\n",
        "            else:\n",
        "                # https://stackoverflow.com/questions/58176501/how-do-you-generate-positive-definite-matrix-in-pytorch\n",
        "                Sigma_k = torch.rand(dim, dim) * cov_scaling + min_cov\n",
        "                Sigma_k = torch.mm(Sigma_k, Sigma_k.t())\n",
        "                Sigma_k.add_(torch.eye(dim))\n",
        "                scale_tril = torch.tril(Sigma_k)\n",
        "            locs.append(loc[None, :])\n",
        "            scale_trils.append(scale_tril[None, :, :])\n",
        "\n",
        "        locs = torch.cat(locs)\n",
        "        scale_trils = torch.cat(scale_trils)\n",
        "        if uniform_component_probs:\n",
        "             self.register_buffer(\"cat_probs\", torch.ones(n_mixes))\n",
        "        else:\n",
        "            self.register_buffer(\"cat_probs\", torch.rand(n_mixes))\n",
        "        self.register_buffer(\"locs\", locs)\n",
        "        self.register_buffer(\"scale_trils\", scale_trils)\n",
        "        self.distribution = self.get_distribution\n",
        "        self.expectation_function = quadratic_function\n",
        "        #self.true_expectation = MC_estimate_true_expectation(self, self.expectation_function, int(1e6)).item()\n",
        "        #print(f\"true expectation is {self.true_expectation}\")\n",
        "\n",
        "    def to(self, device):\n",
        "        super(MoG, self).to(device)\n",
        "        self.distribution = self.get_distribution\n",
        "\n",
        "    @property\n",
        "    def get_distribution(self):\n",
        "        mix = torch.distributions.Categorical(self.cat_probs)\n",
        "        com = torch.distributions.MultivariateNormal(self.locs, scale_tril=self.scale_trils)\n",
        "        return torch.distributions.MixtureSameFamily(mixture_distribution=mix, component_distribution=com)\n",
        "\n",
        "    def log_prob(self, x: torch.Tensor):\n",
        "        return self.distribution.log_prob(x)\n",
        "\n",
        "    def energy(self, x, temperature=None):\n",
        "      return - self.log_prob(x)[:, None]\n",
        "\n",
        "    def sample(self, shape=(1,)):\n",
        "        return self.distribution.sample(shape)\n",
        "\n",
        "    @torch.no_grad()\n",
        "    def performance_metrics(self, train_class, x_samples, log_w,\n",
        "                            n_batches_stat_aggregation=10):\n",
        "        samples_per_batch = x_samples.shape[0] // n_batches_stat_aggregation\n",
        "        expectations = []\n",
        "        for i, batch_number in enumerate(range(n_batches_stat_aggregation)):\n",
        "            if i != n_batches_stat_aggregation - 1:\n",
        "                log_w_batch = log_w[batch_number * samples_per_batch:(batch_number + 1) * samples_per_batch]\n",
        "                x_samples_batch = x_samples[batch_number * samples_per_batch:(batch_number + 1) * samples_per_batch]\n",
        "            else:\n",
        "                log_w_batch = log_w[batch_number * samples_per_batch:]\n",
        "                x_samples_batch = x_samples[batch_number * samples_per_batch:]\n",
        "            expectation = train_class.AIS_train.\\\n",
        "                estimate_expectation_given_samples_and_log_w(self.expectation_function,\n",
        "                                                             x_samples_batch, log_w_batch).item()\n",
        "            expectations.append(expectation)\n",
        "        bias_normed = np.abs(np.mean(expectations) - self.true_expectation) / self.true_expectation\n",
        "        std_normed = np.std(expectations) / self.true_expectation\n",
        "        summary_dict = {\"bias_normed\": bias_normed, \"std_normed\": std_normed}\n",
        "        long_dict = {}\n",
        "        return summary_dict, long_dict"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wDY7z0r7eHBR"
      },
      "source": [
        "## Let's go"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gdrqOS6vcBmD"
      },
      "source": [
        "seed=2\n",
        "dim=2"
      ],
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mkMTsJGEbtwB"
      },
      "source": [
        "assert seed == 2\n",
        "assert dim == 2\n",
        "torch.set_default_dtype(torch.float64)\n",
        "torch.manual_seed(seed)\n",
        "target = MoG(dim=dim, n_mixes=5, min_cov=1, loc_scaling=10)"
      ],
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 287
        },
        "id": "B3zYqqB-cvlb",
        "outputId": "e04dccf6-0901-4ea3-826b-db2d299e95c9"
      },
      "source": [
        "samples = target.sample((1000,)).detach().numpy()\n",
        "plt.plot(samples[:, 0], samples[:, 1], \"o\")"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fb6e4040810>]"
            ]
          },
          "metadata": {},
          "execution_count": 43
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fUYNdlNDe8s6",
        "outputId": "2e89cc34-f470-4d95-cfd0-c87cfdae3af8"
      },
      "source": [
        "target.energy(target.sample((100,))).shape"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([100, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3WqEJND2dXHL"
      },
      "source": [
        "prior = NormalDistribution(2)\n",
        "bg_unbiased_MC2 = boltzmann_generator_RNVP_MC(prior, target, n_transform=3, shift_nhidden=[64, 64], scale_nhidden=[64, 64],\n",
        "                                                 nrelax=20, stepsize=0.25, stochastic=True, diffuse_at_0=True)\n",
        "trainer = KLTrainer(bg_unbiased_MC2, train_likelihood=False, train_energy=True,\n",
        "                        optim=torch.optim.Adam(bg_unbiased_MC2.parameters(), lr=0.005))"
      ],
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 287
        },
        "id": "jdZFy4ZjeONm",
        "outputId": "dee13b05-3fb9-4463-c184-662db788d462"
      },
      "source": [
        "samples = bg_unbiased_MC2.sample(1000).detach().numpy()\n",
        "plt.plot(samples[:, 0], samples[:, 1], \"or\")\n",
        "samples = target.sample((1000,)).detach().numpy()\n",
        "plt.plot(samples[:, 0], samples[:, 1], \"ob\")"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fb6e3fc9fd0>]"
            ]
          },
          "metadata": {},
          "execution_count": 51
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rN4RxJmVeRqI",
        "outputId": "17cc37c5-20b0-4e45-d431-e3069b951ea4"
      },
      "source": [
        "trainer.train(1000, data=None, batchsize=128, w_likelihood=0.0, w_energy=1.0, n_print=50)"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\tKLL: 7.3955\t\n",
            "51\tKLL: 3.7429\t\n",
            "101\tKLL: 3.7867\t\n",
            "151\tKLL: 3.7497\t\n",
            "201\tKLL: 3.7126\t\n",
            "251\tKLL: 3.8047\t\n",
            "301\tKLL: 3.4136\t\n",
            "351\tKLL: 3.8328\t\n",
            "401\tKLL: 3.7245\t\n",
            "451\tKLL: 3.6594\t\n",
            "501\tKLL: 3.4685\t\n",
            "551\tKLL: 3.5546\t\n",
            "601\tKLL: 3.5764\t\n",
            "651\tKLL: 3.6816\t\n",
            "701\tKLL: 3.5806\t\n",
            "751\tKLL: 3.5604\t\n",
            "801\tKLL: 3.6782\t\n",
            "851\tKLL: 3.7960\t\n",
            "901\tKLL: 3.5422\t\n",
            "951\tKLL: 3.7097\t\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 287
        },
        "id": "TANPjtUKf0Nc",
        "outputId": "1dd643ae-5264-42c7-9b9b-0c185aba2c98"
      },
      "source": [
        "samples = bg_unbiased_MC2.sample(1000).detach().numpy()\n",
        "plt.plot(samples[:, 0], samples[:, 1], \"or\")\n",
        "samples = target.sample((1000,)).detach().numpy()\n",
        "plt.plot(samples[:, 0], samples[:, 1], \"ob\")"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fb6e3dbe410>]"
            ]
          },
          "metadata": {},
          "execution_count": 53
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD9CAYAAABTJWtQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2dfYwk513nP0/3zsTu2eSSrU3gpGR6FgWR2LoDlJUuR7gLx+YUYqEQUM7HuHezdg4Pnr3zGYIEwhPlcrobgw4JWBn8MgYnZru1gACRS+QLHAmJzKuyJkHg8Hq3M7PoclnvrM/27vhltvu5P6qru7r6eeqlu167fx/p0cxUV1VXV9c83+f5vT1Ka40gCIIgANSKvgBBEAShPIgoCIIgCANEFARBEIQBIgqCIAjCABEFQRAEYcChoi9gWo4ePapXVlaKvgxBEIRK8fTTT1/RWr8xuL3yorCyssKFCxeKvgxBEIRKoZTaMW0X85EgCIIwQERBEARBGCCiIAiCIAwQURAEQRAGiCgIgiAIA0QUBGGW6XRgZQVqNfdnp1P0FQklR0RBEGaVTgfW1mBnB7R2f66tmYVBxEPoI6IgCLPKxgbs749u2993t/tJIh7CzCOiIAizyu5uvO1xxUOYC0QUBGGW8JuBapZ/7+Xl0b/jiocwF4goCMKscOYMnDo1NAN1u+P7NBqwuTm6LSgS/u3ia5g7RBQEYRbodOCRR1wxCFKvg1LQbMLWFrRao69vbrpi4afRgNtuE1/DHCKiIAizwMaGWRAAej23bW+PCwK427a2XNHwi8eTT6bva5CZR+kRURCEWSDM/m8zD/lptVzR8ItHHF9DoJPvnPkDe58vUU6VQERBEGYBW8ev1LgPIQqvo7fNPLz3CnTynZ3vYO3hb7f3+RLlVAlEFARhFjD5BZSCe+4xm4xsZhx/R29iYQGuXXOPO316pJPf4AH2WRrZfaTPlyinSiCiIAgVp9OBlY0Wtf1rrNQv0eEO1y9w7hw89JD5AJsZxzSa93AcV2j29ozRTbuYZyuDPj8sykkoDSIKglBhRvp3FDvdN7PW6NDZ3DbPEMBuxvnhH7aP2pWCw4fh1Vet17KM+dhBn2+Lckpq3hIyRURBECrMRGZ6W8d//Xq4HyHCzLPJ/TS4PrJtpM+3RTnZxEsoBBEFQagwE5npk5prvJ79yJHQ3VqcZ2vpR8P7fFOUk1AqRBQEocJMZKaPY66p1wHoqBYr+89QO7nKyt7TdFgNPax1/TG2WaF3riN9fkURURCECpPITO9FHJ08GX3ibpcz/CKn9K+wwwqaGjs0WeOxSGGQ/INqI6IgCBXGZKY/fdr1KYxEmwZCTTusssJFanRZ4eJYR9/hDh7hHnSgi9hniQ0eiL4wyT+oLlrrSrd3vOMdWhAEl3Zb60ZDa9dj7LZGQ+u2c+9gQ5tV3eDa6D5c021WBwc0uTjyur8puoPzNLmoFV3d5OLw+MGOaqLrbzbdQ5tN928hG4AL2tCnFt6pT9tEFARhSNN50diRN7k4+MPW4Te5OOiJoWsVBU8AgsKi6Gr8AlGv23t1Q+9vFTQRhkywiYJyX6sux48f1xcuXCj6MgSheDodaidXx0w+AIoePVzncY2uZR9NTys6HTh1smfcBzRtWmzwADusWC+lwXW2uJtW41OufQtcc9LurhvF9MILcHDgO6DBys1fZ2fv8Ni5mk03UElIF6XU01rr48Ht4lMQhFlhY8OeQMYl3++WfZrKO41FEKCG25Hbspc9Br6H/X24777RDOq9vVFBANjfZ3evYTyXVMHIl1KIglLqLUqp31BKPa+UekEp9VtKKcl9F4Qk7O6aE8i4ziY/Ofjbus9bH4eVFXZ2eta36LHIBg9YhWXkcjzh2Nuzl87wEZkRLeRC4aKglGoAnwfeBpwGTgHfDPy+Umop7FhBEHwsL7sJZNxNk20UPRye5Wb2OUV7EGUU3KfJtmvq+dy/o7PzHYAKfZtdlo3CEqRGzxrdZGLT+VmpglEGTI6GPBtwH9AF3urbdgy4AXwk6nhxNAtCn4Cn1hZltM6D1qihsKijYetp6GqHyyEO6Z49usnU+h5liT7KD8rqaFZKfQ64SWv9rsD2LwJord8ddrw4mgXBh1fpdGeHFbbZoWnYSeOfDQycwpy3OqHtjJ4rjCbbbHPM/WNxEV77Wrh61bUPbW5K+nPOlNnRfCvwl4btzwC35HwtglBdfIIAsMtbLDuOduL7LHGaX6HDaixfQdi5whj4GJpNePxxuHJlrAaSdbVOWcYzN8ogCkeA5wzbrwJvyPlaBKHUhHaaH/7wyOI4STr4LodY4zFu4zPUOYg+YAIG1+MviuT7QJ3Da6yd3B9f5uHMH8gynnlisinl2YBXgZ82bP+vwA3LMWvABeDC8vJy2qY2QSiGCIN6aHKX44zZ6U0+hTj+gho3Eh6T0KfQ/zDtpbtHfBuuj2L8XHUOzP6IsOQ4IRLKmtEMfB141LD9IeDZqOPF0SzMBKYeXymt19cHuzSb5g642dTW3rnNqq5zkEInP6kwdPvv33dqL93tCsLCnXqBl0KFJJajWlKeJ8YmCmUwHz2D61cIcgvw1ZyvRRCKwbRajtbwyCMDM0nctRP8xe42eIA1HjGEj+YTYLLIAV0OATV2WOHDrzxM574/5b6D/8YBNwX2tvsngoX4Bp9x/0VWTr9bLElpYlKKPBvwI7jhp9/k27YCHAA/FnW8zBSEmUAp+5C72dRaR8wU+sfHDUNd58HQkXmUOSjO6N72mmueSvLebvMX4hv7jDJhSAwlnik8BmwDn1JKfZ9S6v3Ap4BLwKNFXpgg5EZY2u7uLnQ6bF77j/blLt3BFBs8wD6jOZ/7LPEk38s2xziHu5bCw5xJeIGK8dmFNmwLHjOOV4MpKV6pDuNnlErdqVG4KGitrwPfDfwtcA7oABeB79ZaXyvy2gQhNzY33QURTBw5AmtrtPYeHM1Edq4Nl7tsNgF7TaJdlumwyhqP9QvZ1UgSTuoS3F8xeReS9L3h2tI30Fm40/4ZpUZSKhSevDYtkrwmzAxnzrg+BP//ZKMBN9/s1g8K4i8f2j92Rf9vY/XSJu5+YZVN80djE4d63f3Y1wLDwgbXuZl99njj2DFSTTUZZU5eEwQB4KGH4Ny50WXUtrbcrF8Mq6Xt9IsAdDrwxBOgNbfxGUxmntv4TGRl07x5DS8BweJ7msM3HfDEE+A448d4ZiOrGU2YHpOjoUpNHM3CzNNsWnIOetpxRldVs9Uucrgcs65Rnq2nHS5rh8vjdZhuuaW/aI/Z4dxmVTfVjtRImgJK7GgWhNlnmjINm5tsqJ8ec66CYm8P1vZ+alCF1DYb2OMob13cJa9Q1Hgo9ngjL9HgHh4CGFZz/eq3WjOyj7BHi/Ns6ya9c52RBGlhesSnIAhZ0+m4ZRn8eQiNBpw+DU8+6XpII4rC1ZRGhzhnvWJzK1y0+g0UmgYvcp3XTfNpAI3Cu55oh7HCtoqbfR9Fj7fzF3yVf0LQyr3IKzzOXbQ4L46EKRCfgiAUhSkxbX/fdSrHrOfjrYpmw4suusYSttmARnETr7DIK5N8Ch8qVKCC7/p2/sJ6TcO9amN/f5V/iqmLepXXDBPZQkKOsqyhN9P1+Uw2pSo18SkIpScsMS3YPAN5jEXtgz6DeHWOuobyEtn7DtI+p5fI5iX2BQmtEzUlWZ47TxCfgiAURJL1JHd24K67xmYQLTpsbXkROaOjbi8SZ9znME6dnqG8RNYkz0mIYuBv8EKOAkP3jfuuGSdnaSS42SZ+s5I8J6IgCFmzucnYOpO2RDUwLmrPxgatlrsEQZuTY0tpXsUQvzmGpjthNnGZUPTc0FvHcX0wns/GJ6S7ew3jsWkkuMWtQVVVRBQEIWtaLTffwJ9/cM8940IRhq/HaTX/kG2O0aPONsdocT7m2gnxHMPlweYbqfEEd9G5/bfdDYahu+1+JJm02bCdI41zlwERBUHIg1YLtrfpnOuxwja1Rx5i5eavx1rQHnBLXXgYSmJscn8KDuS0mDaiUXOYF1jkJese+yyx8evf5v5hGKJvcn9mCW6mid9MJc+ZHA1VauJoFqqC0UHJ9fAF7QeeZGf0ZLjVQv2VT5d4PmcHcpKW1NncizxG0XVvar1u3KHt3Bu2ZtHU32VW584LyrrIzrRNREGoCtbS11yM7iWVGjlXe/FOY4Zz9Tr/yVudA91euHNk44hQOi/aO+tZ6NWnxCYKh4qeqQjCvGB1UMaoSdThDjbUNrssc+TQizx345cMJair5C+Yni6HWDv4BeAVWpwfVIH1orB29g6ztubuO5ITGEwm9HJExnacT8SnIAg5YXVQRjiJO6yyph9lhxU0NfZu/KOQNQl0xN9Zk68w7bPESTqscJH7OBu5zkKnAyun3+2u2MbFoU9nlmJKp0REQRBywuig5Dqb3D+60XGGkUr1unFRmfjkLQpZYvssih1W2OOo8VVvhjaIXO2+Gd1fHnSNxwbC0Nl51+xmKSdAREEQcmIkMtWXY9Di/OiOt9/u1vPp9aDXS1jyOjhSrzFentrELIiHeZbizdCMSWf9tZ87rLKmHotbdWSmkYJ4glAEnQ6cOuX2QEHqdVcQlpfh2jVW9i5MuTiOZn78DaOftaH22TrXoNVyZwCm263osaz+gR09Lr6zXG9PCuIJQplotcw9FEC3OxyuvvACm/WPjcXcC2YcrgyzvdUuW/f82cB3bPXp1P8Pu/otxtdmJUs5CSIKglAEnY47I4ji4IDW659ky/nJ/pKayWb2ih4OVya6xKrR4DpnuY/b+Aw1euzot3B66zs5c8Z93Zp09sSbrVVow7KUZ7ZSqilOtUpN8hSEyhFV8jQkR8GW62DLGVjnQd1m1bqKWbnbaM7DIi8bKrz2Bs3hsj7BZ425Euvrw1tvSk9IWvl0FiqlIslrglASkvXsbkJW/ZJW/eU3F+o3Yneq3hKXVUxsW+S6rnOgoafrHAwEzktOc7hsEYnxc9Xr/XvfbruZzoYEtyT5bNZExGaWD0662ERBHM2CkDc2j6eBYEIWwCKv8lqe5yoOR9jrh2LaHcmHOOAGhyz76NBj00OzyEu8SrwigIobaOqMOI25PhKtFbbKnPEK2h06d/0eawe/MHI/G4s32Hr8UKK8NavTWrkxAlXA5mgWURCEvFlZcZ3IcXa1dHze8psAii7FuwejxcXhWV6iETPnwnw+/+eu0Y1c5tOjzg1usGC/n81kUUa2r7BK0UoSfSQIZcHm8XSGayJ0WO13YE3jKfy5Cw57mVxmMqJnG1dx2OLuvsO8B6FOc/P5/J/bngkePK9mjUfGjh85b8Ioo1mulCqiIAh502rB6dPD6KN63f377FloNAYmI3dEa4mK4dLg91d4TfbXnAILvMx9nO0L3WQmK78QGMtjc50T/C41urjioFniRd7FH40dP3LehGshmJbI2NqajdJJYj4ShLwJFmQDd5i5tQW4tXl2um+2Hr7IK7yWF2L7FMrDtP4LTZvWSAZ4h1U2eIBdlllmd1AyJOiH8fwRxtcm8CnMAuJTEISyEGGQtvuhNQ5XeIHXFrDOchnooZ03wV64uewol9njjWPbPX/EiJA4+2yePTx3ggDiUxCE8hCxyK/NlFGnyx5HpxQE2yBQh7w2ybnSx3FqrOxdoEZ3tMKpjw6r9sJ4fX9Ci/NsO8fptc+zfSUlQZihTDYRBUHIm4hFfjc3MZS10HStYaVJUJgcsev8Im1aCcpp2E1Bi7yEilWELxnPP8+gfHiwwqnHBg9Yr2vEn7C3l17Fu0H51RmppmdKXqhSk+Q1oXLESIf1J1i5CVzxk77chK64Gcw9fYLPDja0WdUOl6dIdnOzqNd5MJcs6uCqdfb37JmXPQ1km020IFtFM9mQjGZBKBFh9Ra8TkapiI6uLwL1G9px+qfiYr/UQ5IOeZj5rEE3uZhKR50sk3oyEVJ0RzbYrt3hsuUEauQrCdNqq2D0v6ewc5cREQVBKDumXkmpkE66p5u13WHn1G7rtmpNPEJvcE2v8+DEHfRoB9/VihspnCu8BWcKbVbH1q5ucM08SwCtDx8e9Pa2++wJgFUwZKZQriaiIMwMls6l7dxr7+i80Wi/15p2lB9PULwidNl09Pb3HN22yMvGzt5fH6nJRd1eujv85AsLWmOfkXkzA2u/X9HqeCIKglB2QswQI0XcfKaewWjUcUI7Nq9jTcfOP40gdFMTFKtJaMJmnSn077tNMLTWEzojisUmChJ9JAhlISQqqXX2n7HduJUedbY55iZweXUVOp1B7L699INbSO+7+Z8pRAZNEwGlJjheG7dexS0L4pUECQtVjYMpQ3qRV7jGEtpyzUeO9H9ptYZLqG5vVzu12aQUVWoyUxBmhiSeTsfRA+9yvT7Y32RTHxnZYi+7nc+aC+mZnbwZUyIfQkSLLs092hxHV3KWoLW2zhQK79SnbSIKwkwR6GDa60+N9zcRi/SER/3Yt6/z4FgHu8jLMUNU0/AzhB0/+prX8YeZfGK9ab0+8CmMbCNeFJaiV0l/gtZaREEQqoZ14uDcG9nZJXU4e/b5YUfr5Ud0B3/bjo3qoNNoDpeNPhWrrT8Qqmpq7jVva0VPN+uXdJs7RjzKcZ3uIz6egSo1i358IhFREISK0fcdTzQKds0q18c6sLDOzb+6WXDGYOsg6xwMOsQo01VU5xolOqYXJ50pGD+j0nr9xF9FnjvWNZY8R0FrbRUFcTQLQglxfcfa+JptTYAB9Tqt9dez1W7QZBtFD4dnqYU6mBVdDvEw/56TtMcWwtHUxhzUC7zM63mOU7RZ4SIAp/lEQke2pql2cbhi/ijc4DSfYIMHjI5kW/lsr1qqjQ0eGP+MGh7+3Leg+u9zG58ZO7eyrAOxz1K/xEafpLW4y4RJKarUZKYgVJII52TYMs6x7eV9Z/R0I3h/6444YRd5eWy07PofTMeOh8M2uDbIIbA5jE/wWfNxvlH5WF5CDCdznIxvL5lveO5t3V5/yh457JmsxKcwXQO2YVCi0d8+EOd4EQWhcsRIdrJ1PNYaPra2sKCbbKcgCKNiFJZlbeswRzrv2q5urz818kGDnXtY/aS4wmgSjCRZ24P3UWrw/VgT2bhoDw4oIWUXhc8C7wy0N8Q5XkRBqBwxyiLYdkmSsDV0/k4fBuqNzqPPad7ur4fUVDvDDjPEaR5m04/rSB6fIbklOOJ/dneG0zx8ZSQy2KbpVUpuLrsotCc9XkRBqBwxCqitr5s6WDdsNK4gpGMyGjqT45zT4bI1b8BoIjpkLlWhCY/+aTovjuRnJBWVSVrj0MuRxfGqVAZJREEQykKcmYLzonmXmGaTZB1ivMifqHMGZxNBG39T7cT/TCGFABXdWGG5yWYE8Vrz8JXQr9Z2XBnLYZRdFJ4H9oFXgD+J60/QWkRBqCAxMpdD4+/7I+QwB2vYugIOz2qHywOHcY1XDCIxHn8fdk5/TkPSkb/NFGQqBKjoDmdLdseLbrOaUYZ2T7dP/PLod9nv5NtLd9t9IM0Y33vOlFkUHgQ+BPwL4IPAF/qO5pNxjhdRECpJ2IgxrIyzzzZvLe/gOPbj65dGNoSOxll1s3375TRsDuuo6KCo9zLOFPqzpsFtihlZlKYfxdYWedmNmlpfH+nkrffS81GXzLaUiygA77FEEgXbF0LOUQe+BFwK2WcNuABcWF5ezvbOCULeKBVZ08fawdZ2tW40zMc3tJu169sYNpquc+Bm+zb7TlTumCipzd9hj13T4oFuL9ypxy+0PXZPonrrNP0oUa3JxbFrCruXoZ+hoES3vEShAbwtRluOOM+P98XjH0e9p8wUhJmjP6KcxDzkN8WMHF+/ZBytxvU9eOU1gtcUp/zFSMft3DucIDkvDn0DntM4MGtqt107fpyZQpZlNsLus9dsORpLS6Pf67jCNHN+wFxKaz4yXtRQFL4xal8RBWHmiCh4F9YBWh3RgcV4/DWOYsfsOy+OXVdURzxyPcGKr1HrVLfdiJ8oofFavgv/jPtc7Il7IYUMxacQSxAOAU8DO3H2F1EQZpJ22178CIspJqxYnm802l5/SjdUkrpIeqgrwSquJ37ZcC7fMd6I2nHG/CZR12nbxTVrjc4c0llGNHnzi1RoCK33sST6KFIAVoFf7Tua/xXwg8BT/VnCD8Y5h4iCMNN4nYjXK/uFYeFO3XRejC6rHRiNRnW2biRRaH89trRDrWbpDOuXzB1fWE/bJ4YbYdAp2645j9asX3Id8bVduziWsD5eWUXhncDnga8DB8D/A34PeG/cc4goCHND3FFmxH5RtXussxDP8mOYaSwuji9LMDjGdD22xLN6fXCdtlyNsU4542ijWNfQ9BIOzc1x0n4YpqeUopBGE1EQhGSE1u7p/zHiUHZeHOpKu21NQnMcgxbZZi5hPaz3VoY8BXOzz27ybIFF8EQUimoiCoKQDGM/vTgeQjoyDPZoNqMXsfcTVu7V1HwzBS801xMnW8ev6Opb+IqefLaQ/SxD0S2FH8GPTRRkPQVBmDNaLdjagmYTlHJ/bj1+iBbnzQfs7Ax/391lmV3jbsYlBHbN+1rpdkdO2OI82xyjR50n+JBxrQZNjb/hVkAle68Bkx4Xn2V2XX3Y2YG1NXfBjJIioiAIc0irBdvb0Ou5P1stoF437+zfvrxsXthG7bO5aTjWttiM7b2azeHvm5vQaAyvmfOG5W1culjOVwLGFv3Z34eNjeIuKAIRBUEQXPyjdNv2zU1ajU+xxd2DVd2aapete/7MFZYggY4dcP9eWzNv9ytLcEpTr9O0zFLyGO3HxXF8szC22eLu8VmYf/ZVNkw2pSo18SkIM02ece1xM26TXpNt/4Tnaa8/pR2eTeADKCBvIZiLFiPKqigQR7MgVIy8M2BtmdTBxLMMCdOPqKAlTwiGJTjyzXA23qqwgwpGREEQqkboQs3NbDpqWyZ1DuUYwjQwbhCTV8JbcaOQmcLYrbJmCtYLj0KyiYJyX6sux48f1xcuXCj6MgQhfWo1twux0Wi4NnejMX8KVlbMNu9m0/VKZ0TY2+7uht8KF01ZfAuDW9XpuP6T/f3xnbL6/mKilHpaa308uF0czcLc0em4HVCt5v4sbXSgLXLHI6soFlsYadLw0hTfNupWuJRDEMD3WTxnuSnaqqRRSCIKwlzhDdx2dtyRZ6nDxk2RO0Gy6KhtPXC8njmTt93cdMNeq8LIZ2m13NhfExkL7SSIKAhzxcbG+Ex+2gFbZjMPf0imjSw6alsYqTERIZ+3bbVg654/o6l2UfSocyPTa5kG460qSGgnwuRoqFITR7OQhLQXv8otQKiISKQCSjxHvm1/B9MqcEUXxYP+GtLrhmsuyHkfBhJ9JAiTL35l66xyXUyrRLX4C8GwlkNT7QxCUNd5MLBwUDEiMfLdlyDM14aIgiDoyQbcYceUbNnd2cX2JayvD4WiX0BvkZcTd+Spzhb8333JluD0YxMF8SkIc4WxGNyW+5rNLxDmh6iSqbjSGL6Ezv73sbJ1P7XdbVaOvEBH/yD3cZZXeU1BF+ky8t0XFMk1DSIKwtwRLAYH4RFJYf/XBflk54/Al9BhlTUeY6f7Zvc72zvMh/kEexwt6AJdRr77TscdZZgo8ahBREGYC8IihKIiksJmA7aZR0H5SLNL4EvY4AH2WRrZ5s4QispV0KPfvRf73O3SYZUVLlKjywoX6SzcWe5Rg8mmVKUmPoX5JInPNcqPELYWsGV55KIDR+aPwJdoW+jH3qZxPIcfV+dV3XbuHb3e/oNjXNp08aAUzw7iaBZmhbjO4qiaOZ6vL25dHU8YvPV45zkQqBB8I4Fm/dIEgpCNKDhcHo8s6D8sbjSU/dkrEhEFYWaIE9ARp6qm93/cbo8vOm8dFdZdQQie2y8YIhDZExb5laRDj9MWuR46M1F0xxdh7j+kiZYuzRmbKIhPQagccQI6TH6CIJ6ZutWC170u3nt3u/DII+Pn1tr9WeqyGTNEqzW85+NoX5vOx1DjVR7nh6wrvgEoNLW9y6wcvTb83vsRCImWLi0JIgpC5YgTBhq1sFUwQujq1fjvb++MXEpa52zmsFf/UL42KZom2/wKd/rOaaZHHU2Nnb3DwwFBq0Xn9O9wrfY6CEhK2aPTRBSEyhEnDNS2BDC4yyXefDOcOjWMREp75FbiMHSXypSKNdC/9s2dVmZF8prssM0xAO7iceIKjDcg6HRg7YnvZK93ZORYx6lAdJrJplSlJj6F+WR9fbjSoWfn9xNmI7Ylxga3Ly6GZCxHRL+UwZFoJe86SmnSv/Y2q4GSFtP5DUZuBdd0m1WtQxzFob4qelZHeJmeC8TRPB/MQ3mcsD7NVnvM7yg2bfdK0QTvnfG9uDZSZycoEKXvX0tceiGSZtMY5hnd4ghHTze5OBAEHeIoDh0Q9OsxGQWjBA5mDxGFOaDKA8Ak2Po0x3FH99YRYEQ0kq1G2UAs+oXX/J2GBt3mjmoJcZULNik10eg9qi3w0tj3qomaKXTH6ix5s4wyh6J6iCjMGKZRbZUHgEmIF4o42rwlcePmJJg697Zzr25ycVwcqnaDq/ygNJsTjd7tzc1fcLhsFIU2q3qBl8aOW+Rl3WZ1IADBZ8KYtFayAZqIwgxhmxHYHvwqDACTELdjN/V56+vJjvFmD+22m4k6NipcuLNc/+lxqPKUst3WTbVjFn4OtKKrHS5rh8t98Yjvb/D7Egb/OO22brOqHS6PCIhnPhwRg0ZjxHY5Ihj1S6W7vSIKM4StU7TZy6swAEyCrU8L8yVM08LO3XReLPp2TEaFnU/t9ad0Q10P79D7yWRJBxBNLo5vDExNjbMArun2+lOVElwRhRkizHxSkedxamxO4TCfQhZt1mZhlaDd1u2lu82mPH/T/T46ICDhrTsmAMH3ifQXVERwRRRmiDCTcEWex8yIij5Ku83aLKzstNef0k22w8XAJwreMXUOYn2fim64X4BrmgpEFsVBRGGGqNAMNTNsMwX/tqWlbAUheM/nXZCzxjTqHzMbeS1Qi6i9/lTsFdk8E5I98sjsp6jaAEFEYcaY5w5ofX3chLawkL/pyB/CKkKdPdYZctAPsLhovPFt515rhx6cLWiichRGz1gyQaIAABQGSURBVNNQ112fQoUQURBmgvjVMfMVB6sjuln0HZsdwrLLR264TYlj5jhEzxTc5kU7jUQfVWgUYBMFqX0kVIqNDfdfskzs7bnNROlrIFUIayFErxJpu+2ur2orLLS8zCb30+C69T0aXGeT+wEi9+1Ro0edbY7R4ny+lRCzrF1lUooqNZkpzBdlmyVEjjqbRd+x2SHUpxBcz8B6gsZIRJE/p8Gcrb5qdVJbw1ezJiVbJWI+KpZ59gGkyaSJa0W0ilkTKkF7/alBbaGJzDbttj2hx9LMUUjXzQ7uPEYBKWWkiygUSB5OyHkRnTgrqpWlzep3UDjTPuwTPERj+Qq1k+ORDXmNAlKqXSWiUCBplpoJ/j+sr5udnLM8Sg3eg6I7/7S+WyFHkhTCsjXHKWYkJjOF6otCmB08ybOUdICTVcdUtllJ0cIQ/H5nWZBnjmmmnkVlq4lPofqiENVpKTW+SMwk58njmS1jPH5RJqWFBXPSnAhCxfB/gYcPx38AipwOpvDQ5S4KwEeATwNfAzTw8ZB9PwB8GXgZ2AE+CtTjvE8VRCFOp9UvyBhK0k4ri2e2rFWX07AGJGm2tReEihP3ISp6JJQCNlHIMk/hbuBNwG+H7aSUei/wm8CXgPcBZ/ui8ECG15Y7N98c/rrWcPq0Pdy40wGVYB3yrBYHt8XdFx2P32q5Ierr69m+j1Lud3XlSsnX2Z0l4sbkpxG7H+dBbjYrsNDyFJiUIo0G1Po/DxEyU8CdIXwxsO1jwKvAN0a9T9lnCklNG7YBSJJRcJaj2DLOFIIz6RMntK7Vspkh+D+nmI1yIK69Mi27ZtQ/WtFT4hShKJ9CmCgAb+m/dndg+7H+9ruizl92UZjEpGF67uIkbeVh0iibTyHsek6cSFcQGg3X9+N9p6bvRMxKKRN3FJLWaCVsFDcDJiM/ZRWF7+m/9s8Nr10Hfibq/GUXhUkycE0O4mmWkUybMo2QwxYcUirdSqknTsSf9Yk4pETYTfaT5rrTfgeVl+hW9IOeATZRKLr20ZH+z+cMrz3ne72y2Oq1JD1mc9P1E0SxswOnTrm277RLonh49vteL7zUTB7YTMDdrtsrXLeXrknM5z7nlreJw94erK1lc//nino93nZrYaQJ/gG9B1xruHHD/Vn0g54jsURBKfUepZSO0b6Q8fV617OmlLqglLrw7LPPJj4+y1pSQeJ25h5+B3GnA0ePuh38yZPuT8eJPoc70XIFYtY7pkn+5/Miz/poM0u3G2+76R8tq2iLWcc0fQg2oAG8LUZbNhwbZj56Hzmbj4qwiYeVW7ElRdqWllxYcO3aZUhiKwNlL3tRtdW4SkcSX0GZ7JoVgJL6FJb7r/1QYPtKf3vqjuaiomeSilGYD8G/7GYVO6ZJ/3dtx/m3J6x1lnmbZUHOhTJENsyo2JRSFPqvfwX4/cC2j5JRSGqa/qik+Dtyf8ik97v/eYtyUPvPGTVSLlPHNOn/+DSRiXk0UwjsjAWrFEeRnXIZRCkjchcF4DjwQeD2vij8ev/vDwIN3363AT3gUeC7gB/FzWyONB3pCUSh6Dh7m1ko+LyFzQLq9fFz2kbIcTKl82TS+5/kuPX1fAXB+85mdEA5XwS/xBleUq8IUfhkXwxMbSWw7w8Afw68AuziJq9lUuYiS+GP0ynEMfl4x4btEyRsZlGmzmnSmVqSe5F3gTwJP50Rkkwzy2aTnYDCzEdZt0nyFLIY0cUVm7h5C1rbByn1+vh5ozrCsnRck8wUwgQyOGvSOl9BCPuuhYqRZDQhM4XytrIkr02beGnqxL0BSVgn5Dc1RQlOGTqupDO1uMUEPXGPmmFl2Wagn5hv4o7YyvCPlAIiCikQNsOIaxaJ8ikkaY6T3Klaho4ryUwtyeBtcbHYNZxnwKIw39getqIW08kYEYUpiRrhltkRWuWOq8hO3tZsTv0yCK4wBTMcaWTCJgpFl7moDBsb4yUO/BmrcRMqOx236m5RaO1mRh89Wo1M57JlLNfr8MQTkjw7k7Ra7j9ns+n+k8x6iWwbJqWoUstrphDHPBTHLJJkYaesW63mzozLPCsuY8ayd10zaFEQ5ghkpjAdceptRRWK63Tg2rWsrjA5vZ5buE1rt07SXXcNay0dOpRtUb24+AdvZcC7juB3DfnV0xJmiDwLscXFpBRVamXxKcQhj/j5LBaXKZNZ1Ramm9WiOv62uGieWc2ZKVpIi4IfHCwzBeW+Vl2OHz+uL1y4kMt7dTquD2F3150hbG4mMzfWau43H4W35OMk1Otw003plowGd4TsjYiLxHYPlXLt+ml/7uB793rDvxsNdxazseHOtIKU5Z4JJWVlpdAHRyn1tNb6+Nh2EYX8sD0DfhYW3A7u1VdzuaTYKDXaIRZF2D10HNcclifNpjtIsAlVGe6ZUFLCRjg5PDg2URCfQo7cdpv7fdtwHHjd68onCFCeKKCw9SnyFgQYzhpNlOWezT1ltNtDaR8cEYWc6HTcUMaoidnVq/bXHMdtSoWLS9qUKdyybI5nz4woIaolpdNxV5ra2RlGVJRl5amyPjgmR0OVWlnKXESRtLxFsPkTo9LMio5qZQ63LDqxze8TlBDVklJ0WeQoCnxwkJDUYrGtJRzEFrJ67dpwcLOxkY+JSan44ZZFzNBts+w8ZlH1+mheU5nWrRZ82P7x4v5DZk0ZHxyTUlSpVWWmYJsBTDIyzWsk7A1cglFz3gjdX4SuiMi6sGvLup04ke1nE1Ki7DOFAkFqHxVHmuaevDKivcV5osxejUax65C02+kIbtJmKtktlBBJIrFiEwUxH2WE35xy+nR65p48MqKVgnvucWeyUSG0+/v2qJ+8ZugvvZTP+/jpdvN/T2ECpJ5RYkQUJiDKfh4MeCiqA7HZ1ut1+77NJpw7Bw895H6OaezzeUTWmQoV5sWZM8W8r5CQMtrtS4yIQkLiRLgV2VH50dq8/fWvd0NbPRzHFQKtR/9nNjbs5/DjOMVF1hXpL3z44XKFvQtCGogoJCSshLY3g4gyuRTN3t6oycdkful04n2ORgPOni1uhm6bjXj5HFlTprB3QUgDKXORkLD6RY1GOWYIk+Avt+LNhmyfpV53Z+KT1H9KG9O1ejWJTp7M7zqkzpFQNaTMRUrYRqb1enUFAUbNMGHmr0bDzcwui3k2zI/oN5FlTVnC3gVhWkQUEmKrvVP1aJSlpeHvYR1cGQM3svAjmvwkYUidI2FWEFFIiDcyzXMUmgf+jOmwDs7znZSdTmfyAnlKwe23u9+zKVIrSBnK1QhCWogoTECrBYcPF30V6RO23rRHFRyrnp9hUrR2TWRgXo/Zj+OUc/YkCJMiojAhZbIhHzqUznm8zxRVidSLtioraYQEe58xeC+CEU1FJM4JQpaIKExIWWzIJ07EyyWIg2m9aVtYZ5lE0SPtkOCdHfd8p065fzvO+L0uu0AKQlJEFCYkasGcvPj859Nxctvs4iVdB2SETgeOHnVDUNPMEVFqNEmx6HIegpAHIgoTYFowR6nRCJ68mGaWECfZrKzrgHh4/oMsVl2Le2/LJJCCMC0pWaPnC5PNWuvJZg5eopV33jyzoeMkW/lLXnhLTxadsOan6JIiZRJIQUgDmSlMgM1cEKeC6dLSMMyxVnOF5ORJ+NCH8hUEU0itZ5NXynVeK+X+DeWtJxZluqlFPOELC7C4OLqt0bCHHDuOFNwUZhsRhQmYxlzw0ktDH0CvB9evD3/Pk7NnR//2F/qD4TWWIQQ1rCpt2HexuBh+X5tN+MQn4PHHxzv6s2fNZrOzZ8srkIKQCqZFFqrUilhkx7ZuRxGLvUzSHGf8M0UtplPUQlVRa6SYXvc+Y9j3EefzyLrLwiyDrLyWLqYOo93WemGh+E4/rC0umju3qGUslcr7DrvEWU3R1nmHfSbp4IV5xyYKUiU1ZY4ezSYSJg0cxzV/mEweUdddVBVQW1VapaJNbracBceBK1dSuTxBqCxSJTUnrl4t+grG8aKibKU5Oh144QX78UVG2EyTJ2ELpw36UwRBGCKikDJhndWhQ7C+bi8fkQZKuVnO/rIM3kjb5jTe2ICDA/P5io6wmSZPQpbnFYQJMNmUqtSK8inYaLddu33Qhr20NG7H9tvC6/Xp/QVBZ6jNHl+vj9rfbbb3ovwIQcThKwjpg8WnIDOFDAjawBcW4NFHx0eorZY74l1ejl+qwlbK2YurP3VqGLZpi+Hvdt1r9GYOR46Y9ytLpm7e666HhcAKwqwjopAyJlPMwcHoGs5eZ3PmzGhuQBxspZz39kbr9IR19n68bOAyl7LIE3++hv9eijAI84JEH6VMkjWc/fb+OHgRQJ0O3HdfdJST47jJclFlIJSCc+fKW8oiT2wRS7IGszBrSPRRTiRZwzlMEIJ1lLyRe6fjdt5xwl6vXo23Stzycv4mmqTkZdKxmdykEqowL2QmCkqpjyilPq2U+ppSSiulPm7Z75P914Pt57O6tiyxRcskKW/dbLoj92DUDCQzN3kCFbYQTBXMRHmadKpQKlwQMsXkfU6jAX8F/CnwMKCBj1v2+yRwGXhnoDXjvE9e0UdJImBM+9oigYKRP/4SDkGiSlGYzhN2TFUieeJkNadFVFkNQZgVyLvMBVDr/zwUQxT+YdL3yUMU0ugobOdYX48vNnFKUQQ7+7KHm8Yh788gIbDCPGAThczWU9Ba51z3MztMNfv9a/jGIY11CZaX7aajZnP8fJ2Oa4M3ma6qZA6xfe6sPkOrVT6fiiDkRVkczW9SSl1RSt1QSv2tUuonlFKWiPz8Scv5OI0zt9Mxr9fQaEC7PX4+zw5vEoQq+BH8lH31N0GYJcogCl8Bfgy4HXg/8EXgp4BHi7woP0U7H21LTjqOvWyDbUWyer16pR6kXIUg5IjJphRswHtw/QJR7QuGY0N9Cpb3+7n+Md9seX0NuABcWF5eztr0VrjzcRJH6yz4EtJGfAWCMIQpfQp/BLw9xn5prZZ7HvgR4Djwd8EXtdZbwBa4yWspvaeVotcpnsR8lbcdvux4sy1v9uSFtYLMOATBTyxR0FrvA3+d8bUY37qA9zRSpPNxkg7+ttvgkUdGE+Tm2Q6fRrCAIMwDZfApmGjhCsKXir6QMpDU0drpuDWS/IKgFJw+Pb8doGQqC0I8MgtJVUodB1YYCs8tSqkP9n9/Umu9r5RqAueAXwX+HngN8P3AncCjWuv/ldX1VYmk5ivTqFhrePLJbK+zzIg5TRDikVlBPKXUJ4HTlpePaa23lVJHgMeBbwe+AejhmqkeBx7SMXIdylYQrwxMs4TlrBL0KYA725IoJmFesRXEyzJ57U7cEX/YPleBD2R1DfOKjIrHKTpYQBCqQll9CsIUSLKXmbJXghWEMiCiUDBZlISWZC9BECYlM/OREE2WsfNSv0cQhEmQmUKBhMXOC4IgFIGIQoFI7LwgCGVDRKFAii60JwiCEEREoUAkSkgQhLIholAgEiUkCELZkOijgpEoIUEQyoTMFARBEIQBIgqCIAjCABEFQRAEYYCIgiAIgjBAREEQBEEYkNl6CnmhlHoWMBSKFlLmKHCl6IuYA+Q+54PcZ2hqrd8Y3Fh5URDyQSl1wbQgh5Aucp/zQe6zHTEfCYIgCANEFARBEIQBIgpCXLaKvoA5Qe5zPsh9tiA+BUEQBGGAzBQEQRCEASIKgiAIwgARBSEUpdRHlFKfVkp9TSmllVIfD9n3A0qpLyulXlZK7SilPqqUqud4uZVEKfUWpdRvKKWeV0q9oJT6LaWULLU0BUqpNyulHlRK/bFSar//7K4Y9rtJKfUz/ef7pf7+/zL/Ky4PIgpCFHcDbwJ+O2wnpdR7gd8EvgS8DzgLfBR4IOsLrDJKqQbweeBtwGngFPDNwO8rpZaKvLaK81bgduA54KmQ/X4Z9xn/GPC9wNeA31FKfVvmV1hSxNEshKKUqmmte0qpQ8AB8J+11h837Pdl4AWt9bt92z6GKwzLWuv/m9c1Vwml1H3AzwLforX++/62Y8DfAT+utf7ZIq+vqnjPbf/3HwIeA45prbd9+3wr8BXgw1rrT/S3HQKeAf5Ga/3+3C+8BMhMQQjF+8cKQyn1FuDbgHbgpXPAAu7MQTDzfuBPPEEA0FpfBP4Q+L7CrqrixHluce/9AfBrvuNuAL8KvFcp9ZqMLq/UiCgIaXBr/+df+jf2O7d94Jbcr6g63ErgvvV5BrlvWXMrcFFrvR/Y/gywiGuCmjtEFIQ0ONL/+Zzhted8rwvjHMF8364Cb8j5WuaNsHvvvT53iCjMEUqp9/SjMKLaF4q+VkEQiuFQ0Rcg5MofAW+PsV9wOh2FN9oyjWzfwHDkJYzzHOb7ZhvFCunxHNA0bPdmCHP53IoozBF92+lfZ3DqZ/o/bwX+2NvYjwtvAF/N4D1nhWcY+mT83ILct6x5Bvh+pVQj4Fe4BXgV+HvzYbONmI+EqdFa7wJ/DrQCL53Eje74H7lfVHX478A7lVLf5G3oi+m7+q8J2fFp3Oi4f+Nt6Iek/lvgd7XWrxR1YUUiMwUhFKXUcWCF4QDiFqXUB/u/P+kbYd0PfEYp9ShwHvh23ByFs5KjEMpjwH8APqWU+iiggf8CXAIeLfLCqo7vOX1H/+f7+is1Pqu1/qLW+stKqV8Dfl4ptQBcBNaBY4wPcOYGSV4TQlFKfRI309ZEMBnoB4D/hJud+3Xgl4BNrXU348usNP2SFj8H/GtAAZ8DfsR/b4XkKKVsndsXtdbf1d/nZmATuAN4Pe6M9ye01l/I4xrLiIiCIAiCMEB8CoIgCMIAEQVBEARhgIiCIAiCMEBEQRAEQRggoiAIgiAMEFEQBEEQBogoCIIgCANEFARBEIQB/x9G/TONPk+syAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8tNUBQruihsI"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}