Score_Wasserstein.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Define dataset:"
      ],
      "metadata": {
        "id": "9X5DauKfKtch"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bgsA3NEjYOy9"
      },
      "outputs": [],
      "source": [
        "#@title Datasets\n",
        "import os\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "import scipy, scipy.io\n",
        "from easydict import EasyDict\n",
        "from collections import OrderedDict\n",
        "from torch.utils.data import Dataset\n",
        "from torchvision import datasets, transforms\n",
        "import torchvision\n",
        "import torch\n",
        "import torch.distributions as tdist\n",
        "\n",
        "class PointsDataset(Dataset):\n",
        "\n",
        "    def __init__(self, num_classes = 4, width = 4, balanced = True):\n",
        "\n",
        "        self.num_classes = num_classes\n",
        "        self.width = width\n",
        "        self.num_centers = int(np.sqrt(self.num_classes))\n",
        "        self.x_centers = torch.linspace(-self.width, self.width, steps = self.num_centers)\n",
        "        self.y_centers = torch.linspace(-self.width, self.width, steps = self.num_centers)\n",
        "        self.centers = []\n",
        "        self.center_label = []\n",
        "        self.data = []\n",
        "        self.label = []\n",
        "        for i in range(self.num_centers):\n",
        "            for j in range(self.num_centers):\n",
        "                if balanced == False and self.x_centers[i]<0 and self.y_centers[j]<0:\n",
        "                    continue\n",
        "                else:\n",
        "                    self.centers.append(torch.tensor([self.x_centers[i], self.y_centers[j]]))\n",
        "                    self.center_label.append(i*self.num_centers + j)\n",
        "        num_samples_per_class = 1000\n",
        "        for i in range(len(self.centers)):\n",
        "            n = tdist.Normal(self.centers[i], 0.1)\n",
        "            self.data.append(n.sample((num_samples_per_class,)).numpy())\n",
        "            self.label.extend([self.center_label[i]] *num_samples_per_class)\n",
        "        if balanced == True:\n",
        "            self.data = torch.tensor(self.data).reshape(num_samples_per_class*self.num_classes,2)/(self.width*2)\n",
        "        else:\n",
        "            self.data = torch.tensor(self.data).reshape(num_samples_per_class * int(self.num_classes*0.75), 2) / (self.width*2)\n",
        "        print(\"max\",self.data.max().item())\n",
        "        print(\"min\",self.data.min().item())\n",
        "        self.label = torch.tensor(self.label)\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "\n",
        "        return self.data[index], self.label[index]\n",
        "\n",
        "    def __len__(self):\n",
        "\n",
        "        return self.data.shape[0]\n",
        "\n",
        "def get_metadata(name):\n",
        "    if name == \"points\":\n",
        "        metadata = EasyDict(\n",
        "            {\n",
        "                \"image_size\": 1,\n",
        "                \"num_classes\": 4,\n",
        "                \"train_images\": 400,\n",
        "                \"val_images\": 400,\n",
        "                \"num_channels\": 1,\n",
        "                \"balanced\": True\n",
        "            }\n",
        "        )\n",
        "    elif name == \"points_imbalanced\":\n",
        "        metadata = EasyDict(\n",
        "            {\n",
        "                \"image_size\": 1,\n",
        "                \"num_classes\": 4,\n",
        "                \"train_images\": 400,\n",
        "                \"val_images\": 400,\n",
        "                \"num_channels\": 1,\n",
        "                \"balanced\": False\n",
        "            }\n",
        "        )\n",
        "    else:\n",
        "        raise ValueError(f\"{name} dataset nor supported!\")\n",
        "    return metadata\n",
        "\n",
        "def get_dataset(name, data_dir, metadata):\n",
        "    \"\"\"\n",
        "    Return a dataset with the current name. We only support two datasets with\n",
        "    their fixed image resolutions. One can easily add additional datasets here.\n",
        "\n",
        "    Note: To avoid learning the distribution of transformed data, don't use heavy\n",
        "        data augmentation with diffusion models.\n",
        "    \"\"\"\n",
        "    if name in [\"points\", \"points_imbalanced\"]:\n",
        "        train_set = PointsDataset(num_classes=metadata.num_classes, balanced=metadata.balanced)\n",
        "\n",
        "    else:\n",
        "        raise ValueError(f\"{name} dataset nor supported!\")\n",
        "    return train_set\n",
        "\n",
        "\n",
        "def remove_module(d):\n",
        "    return OrderedDict({(k[len(\"module.\") :], v) for (k, v) in d.items()})\n",
        "\n",
        "\n",
        "def fix_legacy_dict(d):\n",
        "    keys = list(d.keys())\n",
        "    if \"model\" in keys:\n",
        "        d = d[\"model\"]\n",
        "    if \"state_dict\" in keys:\n",
        "        d = d[\"state_dict\"]\n",
        "    keys = list(d.keys())\n",
        "    # remove multi-gpu module.\n",
        "    if \"module.\" in keys[1]:\n",
        "        d = remove_module(d)\n",
        "    return d\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define NN architecture:"
      ],
      "metadata": {
        "id": "XRjli1dKKrYh"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zoLAjBiPYKyo"
      },
      "outputs": [],
      "source": [
        "#@title NN\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.nn.utils import spectral_norm\n",
        "\n",
        "class ConditionalLinear(nn.Module):\n",
        "    def __init__(self, num_in, num_out, n_steps):\n",
        "        super(ConditionalLinear, self).__init__()\n",
        "        self.num_out = num_out\n",
        "        self.lin = nn.Linear(num_in, num_out)\n",
        "        self.embed = nn.Embedding(n_steps, num_out)\n",
        "        self.embed.weight.data.uniform_()\n",
        "        torch.nn.init.xavier_normal_(self.lin.weight)\n",
        "\n",
        "\n",
        "    def forward(self, x, y):\n",
        "        out = self.lin(x)\n",
        "        gamma = self.embed(y)\n",
        "        out = gamma.view(-1, self.num_out) * out\n",
        "        return out\n",
        "\n",
        "class SpectralConditionalLinear(nn.Module):\n",
        "    def __init__(self, num_in, num_out, n_steps):\n",
        "        super(SpectralConditionalLinear, self).__init__()\n",
        "        self.num_out = num_out\n",
        "        self.lin = spectral_norm(nn.Linear(num_in, num_out))\n",
        "        self.embed = nn.Embedding(n_steps, num_out)\n",
        "        self.embed.weight.data.uniform_()\n",
        "        torch.nn.init.xavier_normal_(self.lin.weight)\n",
        "\n",
        "\n",
        "    def forward(self, x, y):\n",
        "        out = self.lin(x)\n",
        "        gamma = self.embed(y)\n",
        "        out = gamma.view(-1, self.num_out) * out\n",
        "        return out\n",
        "\n",
        "\n",
        "class ConditionalModel(nn.Module):\n",
        "    def __init__(self, n_steps):\n",
        "        super(ConditionalModel, self).__init__()\n",
        "        self.lin1 = ConditionalLinear(2, 64, n_steps)\n",
        "        self.lin2 = ConditionalLinear(64, 64, n_steps)\n",
        "        self.lin3 = ConditionalLinear(64, 64, n_steps)\n",
        "        self.lin4 = nn.Linear(64, 2)\n",
        "\n",
        "    def forward(self, x, y):\n",
        "        x = F.softplus(self.lin1(x, y))\n",
        "        x = F.softplus(self.lin2(x, y))\n",
        "        x = F.softplus(self.lin3(x, y))\n",
        "        return self.lin4(x)\n",
        "\n",
        "class SpectralConditionalModel(nn.Module):\n",
        "    def __init__(self, n_steps):\n",
        "        super(SpectralConditionalModel, self).__init__()\n",
        "        self.lin1 = SpectralConditionalLinear(2, 64, n_steps)\n",
        "        self.lin2 = SpectralConditionalLinear(64,64, n_steps)\n",
        "        self.lin3 = SpectralConditionalLinear(64,64, n_steps)\n",
        "        self.lin4 = spectral_norm(nn.Linear(64, 2))\n",
        "\n",
        "    def forward(self, x, y):\n",
        "        x = F.relu(self.lin1(x, y))\n",
        "        x = F.relu(self.lin2(x, y))\n",
        "        x = F.relu(self.lin3(x, y))\n",
        "        return self.lin4(x)\n",
        "\n",
        "\n",
        "class Classifier(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Classifier, self).__init__()\n",
        "        self.lin1 = nn.Linear(2, 128)\n",
        "        self.lin2 = nn.Linear(128, 128)\n",
        "        self.lin3 = nn.Linear(128, 128)\n",
        "        self.lin4 = nn.Linear(128, 2)\n",
        "        torch.nn.init.xavier_normal_(self.lin1.weight)\n",
        "        torch.nn.init.xavier_normal_(self.lin2.weight)\n",
        "        torch.nn.init.xavier_normal_(self.lin3.weight)\n",
        "        torch.nn.init.xavier_normal_(self.lin4.weight)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.lin1(x))\n",
        "        x = F.relu(self.lin2(x))\n",
        "        x = F.relu(self.lin3(x))\n",
        "        return self.lin4(x)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Install pot in colab:"
      ],
      "metadata": {
        "id": "V_r1snEdK3h1"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7tN4mj-iYvQs",
        "outputId": "e183d2ff-8d4f-494b-edd9-0340129a65da"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: pot in /usr/local/lib/python3.7/dist-packages (0.8.2)\n",
            "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.7/dist-packages (from pot) (1.7.3)\n",
            "Requirement already satisfied: numpy>=1.16 in /usr/local/lib/python3.7/dist-packages (from pot) (1.21.6)\n"
          ]
        }
      ],
      "source": [
        "!pip install pot"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Setup diffusion configurations:"
      ],
      "metadata": {
        "id": "rvdOTRM5K7BS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-dX9DNGoUtx1",
        "outputId": "d9206d9d-8549-4163-fc91-07d27f2bf9b5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "max 0.5508511662483215\n",
            "min -0.5488794445991516\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:40: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at  ../torch/csrc/utils/tensor_new.cpp:201.)\n"
          ]
        }
      ],
      "source": [
        "#@title Diffusion setup\n",
        "import os\n",
        "import cv2\n",
        "import copy\n",
        "import math\n",
        "import argparse\n",
        "import numpy as np\n",
        "from time import time\n",
        "from tqdm import tqdm\n",
        "from easydict import EasyDict\n",
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.distributed as dist\n",
        "from torch.utils.data import DataLoader\n",
        "from torch.utils.data.distributed import DistributedSampler\n",
        "from torch.nn.parallel import DistributedDataParallel as DDP\n",
        "import torch.nn.functional as F\n",
        "# from data import get_metadata, get_dataset, fix_legacy_dict\n",
        "import ot\n",
        "# import unets\n",
        "# os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"6\"\n",
        "\n",
        "import os\n",
        "\n",
        "import torch.multiprocessing as mp\n",
        "\n",
        "# from mlp import ConditionalModel, Classifier, ResConditionalModel\n",
        "from sklearn.datasets import make_swiss_roll, make_moons\n",
        "\n",
        "DEVICE = 'cpu'\n",
        "\n",
        "# def sample_batch(size, noise=0.5):\n",
        "#     x, _= make_swiss_roll(size, noise=noise)\n",
        "#     return x[:, [0, 2]] / 10.0\n",
        "# # Plot it\n",
        "# data = sample_batch(10**4).T\n",
        "\n",
        "\n",
        "name = \"points\"\n",
        "# _imbalanced\n",
        "metadata = get_metadata(name)\n",
        "\n",
        "train_set = get_dataset(name, None, metadata)\n",
        "\n",
        "# # moon\n",
        "# noisy_moons = make_moons(n_samples=5000, noise=0.1, random_state = 0)\n",
        "# train_set, train_set_y = noisy_moons\n",
        "# train_set = torch.tensor(train_set).float()\n",
        "# train_set = train_set/2\n",
        "\n",
        "# train_set = np.random.multivariate_normal([0,0], [[0.1, 0], [0, 0.1]], 5000)\n",
        "# train_set = np.clip(train_set, -1,1)\n",
        "# print(\"done\")\n",
        "\n",
        "def make_beta_schedule(schedule='linear', n_timesteps=1000, start=1e-5, end=1e-2):\n",
        "    if schedule == 'linear':\n",
        "        betas = torch.linspace(start, end, n_timesteps)\n",
        "    elif schedule == \"quad\":\n",
        "        betas = torch.linspace(start ** 0.5, end ** 0.5, n_timesteps) ** 2\n",
        "    elif schedule == \"sigmoid\":\n",
        "        betas = torch.linspace(-6, 6, n_timesteps)\n",
        "        betas = torch.sigmoid(betas) * (end - start) + start\n",
        "    return betas\n",
        "\n",
        "\n",
        "def extract(input, t, x):\n",
        "    shape = x.shape\n",
        "    out = torch.gather(input, 0, t.to(input.device))\n",
        "    reshape = [t.shape[0]] + [1] * (len(shape) - 1)\n",
        "    return out.reshape(*reshape)\n",
        "\n",
        "\n",
        "def noise_estimation_loss(model, x_0):\n",
        "    batch_size = x_0.shape[0]\n",
        "    # Select a random step for each example\n",
        "    t = torch.randint(0, n_steps, size=(batch_size // 2 + 1,))\n",
        "    t = torch.cat([t, n_steps - t - 1], dim=0)[:batch_size].long()\n",
        "    # x0 multiplier\n",
        "    a = extract(alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "    # eps multiplier\n",
        "    am1 = extract(one_minus_alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "    e = torch.randn_like(x_0)\n",
        "    # model input\n",
        "    x = x_0 * a + e * am1\n",
        "    x = x.to(DEVICE)\n",
        "    t = t.to(DEVICE)\n",
        "    output = model(x, t)\n",
        "    return (e - output).square().mean()\n",
        "\n",
        "def noise_estimation_2_loss(model, x_0):\n",
        "    batch_size = x_0.shape[0]\n",
        "    # Select a random step for each example\n",
        "    t = torch.randint(0, n_steps, size=(batch_size // 2 + 1,))\n",
        "    t = torch.cat([t, n_steps - t - 1], dim=0)[:batch_size].long()\n",
        "    # x0 multiplier\n",
        "    a = extract(alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "    # eps multiplier\n",
        "    am1 = extract(one_minus_alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "    e = torch.randn_like(x_0)\n",
        "    # model input\n",
        "    x = x_0 * a + e * am1\n",
        "    x = x.to(DEVICE)\n",
        "    t = t.to(DEVICE)\n",
        "    output = model(x, t)\n",
        "    new_loss = ((e - output).square().mean(dim = 1)* (betas[t])/((1-alphas_prod[t]))).mean()\n",
        "    # grad penalty\n",
        "    # input = x\n",
        "    # input.requires_grad = True\n",
        "    # output = model(input, t)\n",
        "    # grad = 0\n",
        "    # for batch in range(output.shape[0]):\n",
        "    #     grad += torch.autograd.grad(output[batch][0], input, retain_graph=True, create_graph = True)[0]\n",
        "    #     grad += torch.autograd.grad(output[batch][1], input, retain_graph=True, create_graph=True)[0]\n",
        "    # gp = (torch.norm(grad, dim=1)).mean()\n",
        "    return new_loss \n",
        "\n",
        "def noise_integration_loss(model, x_0, t):\n",
        "    batch_size = x_0.shape[0]\n",
        "    # Select a random step for each example\n",
        "    t = torch.zeros([batch_size]) + t\n",
        "    t = t.long()\n",
        "    # t = torch.randint(0, n_steps, size=(batch_size // 2 + 1,))\n",
        "    # t = torch.cat([t, n_steps - t - 1], dim=0)[:batch_size].long()\n",
        "    # x0 multiplier\n",
        "    a = extract(alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "    # eps multiplier\n",
        "    am1 = extract(one_minus_alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "    e = torch.randn_like(x_0)\n",
        "    # model inputs\n",
        "    x = x_0 * a + e * am1\n",
        "    x = x.to(DEVICE)\n",
        "    t = t.to(DEVICE)\n",
        "    output = model(x, t)\n",
        "    new_loss = ((e - output).square().mean(dim=1) * (betas[t])/(1-alphas_prod[t])).mean()\n",
        "    return new_loss\n",
        "\n",
        "def noise_last_step(x_0):\n",
        "    batch_size = x_0.shape[0]\n",
        "    # Select a random step for each example\n",
        "    t = torch.zeros([batch_size]) + n_steps - 1\n",
        "    t = t.long()\n",
        "    # t = torch.randint(0, n_steps, size=(batch_size // 2 + 1,))\n",
        "    # t = torch.cat([t, n_steps - t - 1], dim=0)[:batch_size].long()\n",
        "    # x0 multiplier\n",
        "    a = extract(alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "    # eps multiplier\n",
        "    am1 = extract(one_minus_alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "    e = torch.randn_like(x_0)\n",
        "    # model input\n",
        "    x = x_0 * a + e * am1\n",
        "    return x\n",
        "\n",
        "def noise_all_step(x_0):\n",
        "    x_seq = [x_0]\n",
        "    for step in range(n_steps):\n",
        "        batch_size = x_0.shape[0]\n",
        "        # Select a random step for each example\n",
        "        t = torch.zeros([batch_size]) + step\n",
        "        t = t.long()\n",
        "        # t = torch.randint(0, n_steps, size=(batch_size // 2 + 1,))\n",
        "        # t = torch.cat([t, n_steps - t - 1], dim=0)[:batch_size].long()\n",
        "        # x0 multiplier\n",
        "        a = extract(alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "        # eps multiplier\n",
        "        am1 = extract(one_minus_alphas_bar_sqrt, t, x_0).to(DEVICE)\n",
        "        e = torch.randn_like(x_0)\n",
        "        # model input\n",
        "        x = x_0 * a + e * am1\n",
        "        x_seq.append(x)\n",
        "    return x_seq\n",
        "\n",
        "\n",
        "def p_sample(model, x, t):\n",
        "    t = torch.tensor([t])\n",
        "    # Factor to the model output\n",
        "    eps_factor = ((1 - extract(alphas, t, x)) / extract(one_minus_alphas_bar_sqrt, t, x))\n",
        "    # Model output\n",
        "    eps_theta = model(x.clone().to(DEVICE), t.clone().to(DEVICE))\n",
        "    # eps_theta = eps_theta.cpu()\n",
        "    # Final values\n",
        "    mean = (1 / extract(alphas, t, x).sqrt()) * (x - (eps_factor * eps_theta))\n",
        "    # Generate z\n",
        "    z = torch.randn_like(x)\n",
        "    # Fixed sigma\n",
        "    sigma_t = extract(betas, t, x).sqrt()\n",
        "    sample = mean + sigma_t * z\n",
        "    return (sample)\n",
        "\n",
        "\n",
        "def p_sample_cond(model, x, t, cond):\n",
        "    with torch.no_grad():\n",
        "        t = torch.tensor([t])\n",
        "        # Factor to the model output\n",
        "        eps_factor = ((1 - extract(alphas, t, x)) / extract(one_minus_alphas_bar_sqrt, t, x))\n",
        "        # Model output\n",
        "        eps_theta = model(x, t)\n",
        "        # Final values\n",
        "        mean = (1 / extract(alphas, t, x).sqrt()) * (x - (eps_factor * eps_theta))\n",
        "        # Generate z\n",
        "        z = torch.randn_like(x)\n",
        "        # Fixed sigma\n",
        "        sigma_t = extract(betas, t, x).sqrt()\n",
        "    # sigma *\n",
        "    with torch.enable_grad():\n",
        "        gradient = cond(x)\n",
        "        mean = mean + sigma_t * gradient\n",
        "        sample = mean + sigma_t * z\n",
        "    return (sample)\n",
        "\n",
        "\n",
        "def p_sample_loop(model, shape):\n",
        "    cur_x = torch.randn(shape).to(DEVICE)\n",
        "\n",
        "    x_seq = [cur_x]\n",
        "    for i in reversed(range(n_steps)):\n",
        "        cur_x = p_sample(model, cur_x, i)\n",
        "        x_seq.append(cur_x)\n",
        "    return x_seq\n",
        "\n",
        "\n",
        "def p_sample_loop_from_qnoise(model, cur_x):\n",
        "    # cur_x = torch.randn(shape)\n",
        "\n",
        "    x_seq = [cur_x]\n",
        "    for i in reversed(range(n_steps)):\n",
        "        cur_x = p_sample(model, cur_x, i)\n",
        "        x_seq.append(cur_x)\n",
        "    return x_seq\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "class EMA(object):\n",
        "    def __init__(self, mu=0.999):\n",
        "        self.mu = mu\n",
        "        self.shadow = {}\n",
        "\n",
        "    def register(self, module):\n",
        "        for name, param in module.named_parameters():\n",
        "            if param.requires_grad:\n",
        "                self.shadow[name] = param.data.clone()\n",
        "\n",
        "    def update(self, module):\n",
        "        for name, param in module.named_parameters():\n",
        "            if param.requires_grad:\n",
        "                self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n",
        "\n",
        "    def ema(self, module):\n",
        "        for name, param in module.named_parameters():\n",
        "            if param.requires_grad:\n",
        "                param.data.copy_(self.shadow[name].data)\n",
        "\n",
        "    def ema_copy(self, module):\n",
        "        module_copy = type(module)(module.config).to(module.config.device)\n",
        "        module_copy.load_state_dict(module.state_dict())\n",
        "        self.ema(module_copy)\n",
        "        return module_copy\n",
        "\n",
        "    def state_dict(self):\n",
        "        return self.shadow\n",
        "\n",
        "    def load_state_dict(self, state_dict):\n",
        "        self.shadow = state_dict\n",
        "\n",
        "# def plot()\n",
        "def get_label(x):\n",
        "    y = torch.zeros(x.shape[0], )\n",
        "    for i in range(x.shape[0]):\n",
        "        if x[i][0] * x[i][1] > 0:\n",
        "            y[i] = 1\n",
        "        else:\n",
        "            y[i] = 0\n",
        "    return y.long()\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Setup plots:"
      ],
      "metadata": {
        "id": "W52xpl6zLClZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.rcParams.update({'font.size': 20})\n",
        "fig = plt.figure(figsize = (8,8))\n",
        "\n",
        "#add subplots\n",
        "ax = fig.add_subplot(331)\n",
        "ax1 = fig.add_subplot(334)\n",
        "ax2 = fig.add_subplot(337)\n",
        "ax3 = fig.add_subplot(122)\n",
        "\n",
        "ax.set_xticks([])\n",
        "ax.set_yticks([])\n",
        "ax1.set_xticks([])\n",
        "ax1.set_yticks([])\n",
        "ax2.set_xticks([])\n",
        "ax2.set_yticks([])\n",
        "ax3.set_title('log-log plot')\n",
        "ax.set_title('$q_0$ (start)')\n",
        "ax1.set_title('$q_0$ (convergence)')\n",
        "ax2.set_title('$p_0$')\n",
        "\n",
        "fig.tight_layout()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 558
        },
        "id": "6ehpwKYmfo8P",
        "outputId": "d0d452af-9f0a-4e55-b6c8-203f4ef1e88d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:22: UserWarning: tight_layout not applied: number of columns in subplot specifications must be multiples of one another.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 4 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAH3CAYAAAAmMFzFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZykVX3v8c+PHQYYgRkURR1FFiMalREXXEAi4BaJYq4bCDFyDRrQaG5UTBQjmhsTRVQS0SDuJppEci9GUQMuIHpnDCoKDAKDC4jsy8Cwze/+cU45NUVVd1d3dVf3nM/79arX0/Wc5zn1q6rurm89y3kiM5EkSe3aZNwFSJKk8TIMSJLUOMOAJEmNMwxIktQ4w4AkSY0zDEiS1DjDgCRJjTMMSJLUOMPAPBAR34mIeyLiEeOuZa5ExCYRcXFE3BYR9x93PZLUMsPAmEXE7wP7AZ/PzJ+NoL8jI+IdEfHYmVc3e3Vk5jrgPcAi4C/ntDhpAhFxTkRkRBw57lqmqv6tZUScPu5a5kJ9rhkRy8Zdy8bCMDBGEbEJ8G4ggRNH1O2RwNuBsYaBKdbxGeAK4OiIeNhcFCVJ/UTEoTVU7T/uWsbBMDBeBwOPAr6TmReNu5i5lpn3AJ8ANgdeN+ZyJLXtUMoXmP3HXMdYGAbG64/r9PNjrWK8Plenh0fE5mOtRJIa1WwYiOJldf/gTRFxS0ScV/fhExG/rvuknjpLj78T8HzKLoIvDFhmi4g4rtZ1U0TcHRHXRMQPI+LDEfHkrmWPjIgEnlFnfbxrv1pGxOquZZdExDERcUY9iO/WiFgTET+NiPdFxAMnqHt17W//iHhQRJwSEZdHxJ0RccEwdQBk5irgh8BS4HnDvo6SpJlrMgxExNbAGZR91s+gHMS2KfBk4EsRcThwf8oH9Q9nqYwDKJvHL83Ma/vUuBlwFnBSrWt74DZgJ+AxwDHAcV2r3AFcA9xd799S73du3Y/xZuDDwO8DuwF3AVsCjwTeAFwQEY+ZpP49gAuAP6G8Vp3HHaaOjnPr9KBJHlMau4jYvu5b/mE9G+a2iPhRRJwQEYsnWXe/iDgzIm6oAfyHEfH6enbN6TUwv2MWat4kIl4VEd+sj702Iq6IiFMnO4spInaNiH+KiF/V9S6PiPdHxA6d8B8R5wxZzwbrRcQrI+L8+qXs5oj4RkQcMoPnu1tEfKTWujYiboyIb0XEH0fEpj3L7l+/wLyyznp7zxeYnG4dC0pmNncDPk35oP8V8GJgM0oweirwc+Dm2n7ZLNbw/voYnx3QfkRtXwO8Atiqzt8UeAjwWuAtfdY7p6535ASPfSzwFuDRwGZd/e4DfKWufyEQfdZdXdtvBX4EPKWr7RHD1NG17FGdxxz374Y3bxP97gKP6Pob6Px9rum6fyWw+4B+jwDu7Vr2RkpoTuDfgNPrz++YRs3vqOue3qdtG+CrXY97F3BT1/07gBcM6PcxwPVdy94K3F5//hnwZ/Xnc4as98jOel3/C++tr8m6rsd704D1O+3L+rQ9rz6nzjI31efcuf81YFHX8k8Bft21zm31/m9v4/6dnJPf+3EXMOdPGF5e3/BrgYf1aX9+1y/Nv81iHefWx3jzgPZTavs/DNnvlD+EB6y/JfCT2scz+rR3/hHeCNx/FHUAj6/LrgO2G/fviLe2b4N+d4EtKFsKk/Kl4VlA1NuBlCDQCdJb9qy7F3BnbT+z8yEGbA38KSUU3MjshIF/rG1rgf/ZqY2yde9s1oeaPXrW2xK4pLavAvar8zcBngNc3VXzOUPWe2Rdr/PF62+AxbVtF9Z/YVsHPLXP+n3DAGVL522dmoA9u57L0fU1SOBjffo8fbqv/8Zwa2o3Qd30/s569y8y84o+i3USNMzeLgIov/AA1w1ov6VnuTmRmXdSkjOU8Q8G+WRmXjOih+28BkHZ5SDNR/+D8k35buA5mfm1XO8blA/IuylnCL28Z923UMLEhcAfZOZqgMy8IzM/CBwP3G/UBdfz8F9d7x6XmR+pf+NkOV7nucBllK0Hb+tZ/WWUwLAWOCQzz63rrcvML1OOvp9wt8gUbE/5YH5zZt5c+78aOJwSVIISdKbqrZTdvpdR3qNLap93ZuaplK2iAH802e6R1jQVBoBDgIdTtgp8qt8CmXkXJe1CTxiIiC0j4m/qvrM7IuL7EXHwNGtZUqc3Dmj/zzp9QUT8R0S8sB50OBIRsVdEfKju67wlItZ17R/rHIsw8EBC4LujqoUNX4MlA5eSxuuwOj0jMy/sbczMnwBfrHf/sDM/yngih9a7J9X/Mb0+RPl2Pmp/QPk//2vgY72NmXk78Lf17gt79qe/sE6/mJmX91n3e5Rv3zP17j59J2VQMoBnRsSOk3USEQG8qN59f31uvT5G2T0crH8/RXth4Nl1emZm3t1vgfoLtX2927tl4HTgjZTT4Y6jfAs4MyKewfC2rNN+/xjIzG8CfwXcQ9l18a/AdRFxUUT8XUTsPo3HBCAiXkLZ3/9aynEDiyib6zoH+XX+KS2aoJt+BwJO19qun7ceYb/SKD2+Ts+eYJn/6lkWyheQzv+U7/RbqX5wrZxRdf116vh2Zt47YJlOzYuAPbvmP65O+9bc6XcGtQH8fMAW2s7j3kv54J7KIGoPZ/2Wir7vUZaRT8+pdx/fb5lWtRYGfrdO/3uCZR5JOaDw5u5f0ojYF3gJ8LbMfFPd5HQgZR/6e6dRyw11OnDTYGb+NWUz3Vsouy9uoex7fCPw04g4YtgHjYilwEcpZzL8M7CccnDiDpn5gMx8AOWAHih/hIMM+scyHTt0/Xz9CPuVRmlpnf5qgmV+Wac71S8WsOHWrqsnWPeq3hkR8ZQopzn3uz14xDV3Lw/r6x6q5iENrCsz72D9VsOlg5br0r3MVJ7vVPpsRmthoLM/etCmeSib1aB8c+52GOVgllM7MzJzLfBPwBNi+DGyO/vJd5hoocy8IjP/JjMPAXaknJL4LUpgOSUidh7ycZ8NbAv8FHhZZq7ss5Vkrvfbd78Gg46hkOaLrebwsbag/D32u206wXq95rLm+aC15ztjrYWBjr4fdvUc4c6wuL27CB5HOdWwN0h8v6t9GJfU6ZTH5M/MezPzHMqpM3dTNust71lsXZ0O+la/a53+qG4y20D9NvPMqdY0gcnq6LasTm+m7NuU5qPOrrGHTLBM5+/r+rrfGzYMuBMdEHyftsw8JzNjwG31iGvuXh7W1z1UzUOaaICzrVj/RWEquyW7l5nK8x3lrs4Fr7Uw0Lkq4H0Gt6kH+XwMeECd1RsGdqH/5rLOvIkOtuunM9BO74d5p54tJlj3LtZvpt+yp61zFsKg3Q831+neXZsxu72acnrOTE1WR7cn1Ol5/QKKNE/8oE4PmGCZTpD+Qde8y1n/99B3RNM6ENo+M6quv04dT4yIbQYs06l5Deu/pMD63akTjcL6tBnUBvDQCbaqPpWy9SMpA5xN5nLKmAIw4D2q/+f3r3d/0NM8zBeYjU5rYeA/6vRZEXF8548jIvamnPv7rK5le8PA1pTzhHut7WofRuegnMf1johVfTIiPh4RB0fEdp2Z9Q/nE5TNYHdw3wN4flKnLxwwGtrXKX9cewMnR8T9ar/bR8SfU0YmHMV++8nq6NYJA98aweNKs6VzpsCzI+I+WwIj4lGsP0L9Xzrza8A9o949Lvpfg+MYyu67Ufs3yofcTpTz7DdQ/wf+eWfZnoMM/71OX9TvAzsinsDEwWiq3tKn76CMlArwjcy8oXeZXnVLzL/Vu8cNCD9/DDyI/sPAD/MFZuMz7oEO5vJG2f/2A9YPWHEvZUStpGwS64yEdw+wdc+6FwLf7NPn79R1XjtkLUE5FzaBA/u0f6mrznWU4xy6Rzq7Bzi8z3rdg5vcTTmQZjXlyoidZd7X1U9nAKHOyGhfAd7F4AFMVte2/Sd5fpPWUZfbmvJHuA54+Lh/R7x5Y2qDDl0J/B51lE4mH3TokV1/D/8BPLTO34pyVs9sDjr0D6wfdOhopj7o0FbApbX9YuDJdX5QTtP+FaMbdOjdrB906AHAJ7v+90130KGz2XDQoVezftChj/bp89W17RJgl3H/Hs757/24C5jzJ1wOwvsHyr7ptZRdB++vv4B/WH8Zftpnva8Bq/rMP7Cu8wfTqOX4CX4x96Ik9v+sNa7pqvc04DET9Pv0ut51rP+QX92zzKspwWgt5cN4BeV0yU0n+ceymimEgSHqOKzO/69x/25485Y5OAzUtqkMR7zHgH6PYsOhdm9g/TC5/0LZ4pf0GWZ8CjVP9De7DeU6J53H7Yyl0rm/lsHDET+2Z9nu4YgvYf1wxF8dst4jWT9KYGc44nvqazLT4Yifz4bDEd/IhsMRf52u4Yi71lvC+qGX76XsAl7d+z9rY72NvYD5dANOrL8In+vT9t76C7JDz/y31nXuM7TxFB7vgfWX9Hp6vkm0cqOMn5DAS8ddizdvmROHgdq+GDgB+HFXGPgxZXTTxZP0/VRKQL6prncBZTjiTVi/NfBPplHzwDBQ2zcFXkXZFXcTZSvFasppxn2vpdC17kMoX0CursHhcuDv6+vw+vq4/zxkvb8NA133v0f5YnILZeyDQyZYf2AYqO2PoJz5dUV9rjdRdqm+Gth0gn4fU/8n/ZoSTpK6B2Jjv429gPl0A/5vffPvc70A4Im17S+65m1J2Yy2YgaP+cHa72vG/fzH8Ho/ov7B/QTYZNz1tHCjbIn5YP3HeEv93fv0NPvatX5IXNX14XISPYHZ25Rey6Bc72BKW93my40ykmsy5K6N3jDgbfy3zVC3zqBE97kmQWZ+LyK+ALwrIpZQQsARlFMDn9W7/BD+mvKH8RcR8bHMvGcGfS00b6F8Yzk+PYtgrryN8nt+G2Xwlb2m00lE7AacB+xMOTjuYmBfyq6mQyJiv8x0AKmpewnwYEpA+96Ya5mSiHg464f//dpEy2r+a+1sgoHq2Ned808HXaDoCMr+rZcDJ1MOsHl+Zp493cfNzN/Ufj/Bhuf7btTqKT6XAX+emV8adz0NeQPlwLHtgT+ZQT+nUILAsZl5aJYLzTyT8vexJ2WXm7pExFsj4k8j4sH195+I2CEijqMMXgZwSpaR9+aFiHhBRLw7Ih7VOQuiXqPlBZRN+VsD52e9iJEWrs6RsM2LiAMov9zXZabDVGqjFxH7U464/kxmvmKI9XajHMi6Gtite6tOPQ32aspm750zczYuvrMgRcSnWX81w7soxwzcj/XntX+d8uVibZ/VxyIi/phyXAGUA/tuogTJzlblKylnQ102ZL9HAh+nnKG1/0iK1Yy4ZaDKzLOzjOplEJAm1jm3/Kze3TuZeStlQK1tgCfNdWHz3CmUM5l+TNkdsB3l6PmzKQf3PXs+BYHq65StPN+lHFS3LeVsgh9QDlp87LBBQPOTxwxIGlbnynarBrRfShnlcw/gG3NS0QKQmedRjrNYMLIMefy2Wej3dMpVYDVPLNgwsGTJkly2bNm4y9A8sHLlSnftzK3OiJI3D2jvzB84kltEHE0dEW/RokX77LXXtI5jlJoym//rFmwYWLZsGStWrBh3GZoHIuLKcdeg4WS5BPipAMuXL0//lqXJzeb/Oo8ZkDSszjf/Qdec6My/aUC7pHnGMCBpWJ0r2+0xoH33Oh10TIGkecYwIGlYnXE1DuqcL99RTy3cj3LE+flzXZik6TEMSOorIjaPiL3quAK/VU8lOwtYRrniXrcTgEXApxxjQFo4FuwBhJKGFxGHAofWuw+o0ydHxOn15+sy80315wcBF1EGllnW09UxlNPkTo6IA+tyT6SMQbCKckVOSQuEYUBqy2OBV/bMe3i9QfngfxOTyMzLImI55Up9hwDPoYw8+AHghMy8cWQVS5p1hgGpIZn5DsrIcVNZdjXrh8rt1/4L4KhR1CVpvDxmQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQGpQROwaEadFxFURcWdErI6IkyJihyH7eWpEnFHXXxsRP4+IL0fEIbNVu6TRMwxIjYmI3YCVwFHA94H3A5cDxwHfjYidptjPnwDfBg6s0/cD3wSeAfxnRBw/+uolzYbNxl2ApDl3CrAzcGxmfrAzMyLeB7wBOBF4zUQdRMTmwHuAtcA+mXlJV9u7gf8Gjo+Iv8vMO0f/FCSNklsGpIbUrQIHAauBD/c0vx1YAxweEYsm6WpHYDGwqjsIAGTmRcAqYGtg2xGULWmWGQakthxQp2dl5rruhsy8FTgX2AZ40iT9/Aa4FtgjInbvboiIPYDdgQsy8/qRVC1pVhkGpLbsWaerBrRfWqd7TNRJZibwWsr/kJUR8YmIeE9EfJJyPMJPgBePoF5Jc8BjBqS2LK7Tmwe0d+bfb7KOMvMLEXEV8DngiK6ma4CPUw5K7CsijgaOBnjIQx4y2UNJmmVuGZA0LRHxCuDrlDMJHknZvfBI4BvAh4DPD1o3M0/NzOWZuXzp0qVzUa6kCRgGpLZ0vvkvHtDemX/TRJ3U4wJOo+wOODwzL87MOzLzYuBwyq6CF0fE/jMvWdJsMwxIbekc+T/omIDOwYCDjinoOAjYHPhmnwMR1wHfqnf3mU6RkuaWYUBqy9l1elBEbPD3HxHbAfsBtwPnT9LPlnU6aBt/Z/5d0ylS0twyDEgNyczLgLOAZZSzAbqdACwCPpWZazozI2KviNirZ9lv1+lhEfGY7oaIeCxwGJDAf42uekmzxbMJpPYcA5wHnBwRBwIXAU+kjEGwCugdRviiOo3OjMz8fkR8nDKk8f+LiH8HrqSEjEOBLYCTMvMns/g8JI2IYUBqTGZeFhHLgXcChwDPAa4GPgCckJk3TrGrV1GODTgSOBjYDrgF+A7w0cwceDaBpPnFMCA1KDN/QflWP5VlY8D8BE6vN0kLmMcMSJLUOMOAJEmNMwxIktQ4w4AkSY0zDEiS1DjDgCRJjTMMSJLUOMOAJEmNMwxIktQ4w4AkSY0zDEiS1DjDgCRJjTMMSJLUOMOAJEmNMwxIktQ4w4AkSY0zDEiS1DjDgCRJjTMMSJLUOMOAJEmNMwxIktQ4w4AkSY0zDEiS1DjDgCRJjTMMSJLUOMOAJEmNMwxIktQ4w4AkSY0zDEiS1DjDgCRJjTMMSJLUOMOAJEmN22zcBUzXypUrr4uIrYBtgQuBO8dcksbnoeN40IjYBPgpsCuwW2ZeM446JGmmFmwYAF4FnAF8JjNfMe5i1J7MXBcR7wFOB/4SeN14K5Kk6VmQuwnqN7J3AwmcOOZy1LbPAFcAR0fEw8ZdjCRNx4IMA8DBwKOA72TmReMuRu3KzHuATwCb45YBSQvUQg0Df1ynnx9rFVLxuTo9PCI2H2slkjQNQ4eBKF4WEedExE0RcUtEnBcRv1/bfx0RGRFPHX25EBE7Ac+n7CL4wiTLPjIi/jEiVkXE7bXeH0fEyRGxz4B1XhgRX4mIayPizoj4ZUR8JiIeP8HjrK7Pef+I2DEi3hcRV9T1fxURH42IXXrW2TUi1tX19p6g761q3RkRL+jTvndEnFYfb21d9tyIeM2gD6aeeh8UEadExOW13gt6lt00Il4fET+KiDvq6/J/I2K/2p71tmzAY820vim9nn36mM57P3StAJm5CvghsBR43kR1SdK8lJlTvgFbA/9B+SBO4G5gTf15HXB418/bDdP3EDUcVh/jkkmW+1Pgnq5abwNu7Lp/Ts/ym1A293ba7+lZ/l7gTwY81uq6zCu6fl4DrO1a/wpgh571vlnb3j3B83hhXeYGYIuettfVujqPcWvPcz4b2GaCeo8Gru2q9zbggq7lNge+3PN+39j184u62pb1eZyZ1jfU6znd934mtXat/+G63D/Mxu/9xnzbZ599UtLkgBU5S3+Hw24Z+CjlW/lVwB9SwsF2wNOAXwIfqstdkZm3Dtn3VO1XpysHLRARLwZOBjYFvgj8TmZum5k7ADtRPmR61/9fwBGUf+h/Sfmg2YFy2tgXKGHhQxHx9Alq+yDlQ+cpmbmIctrjC4CbgGXAW3qW/2ydvmSCPl9ap/+amXd1PcdD6+OtqbUvzcztgG2AQ4BLgf2B90/Q998DVwP7ZeaizNyWErY63gY8m/Ih+Xpg+/qaLAO+AnxsUMcjqm/Y13Na7/2Ial1Rp0+bYBlJmp+mmhqAl1M+KK8FHtanvbPpPoF/m630ApxbH+PNA9o3pwSTBD47xT63BW6u67ynT/umwLdr+7f6tK+ubb8GdurT/sbafnnP/B2Bu2rbk/ustx1we20/oKeezmMePOA57Ub5cLsb2GVAvTcC9x+w/naUb9QJvHXA63xB13u+bBbqG/b1nM57P6Nau5Z5PLO8VWxjvbllQJoaxr1lICI2A95Z7/5FZl7RZ7Gv1n+GUPafzpbOvuLrBrQfCDyI8m32z6fY57OA7SkfzH/b25iZ9wJ/Xe8+LSIeMKCfUzPz+j7zv1SnD4uIRV393kB53WD9FoBuh1K2vvyKskuhY3/KQDsXZuZX+6xHZl4GnE8ZS2L/AfV+MgcPlHMQsIiyaf7kPv3fDbxvwLqjqm+o15PpvfejqrXz+xjA/af42JI0L0x10KFDgIdTtgp8qt8CmXlXRNxI+ba7QRiIiC2BEyjHFOwI/Bj4y0H/fCexpE5vHND+pDr9YWb+aop9dg4O/GFmDur3W5QPmU3r8l/us8z/G7Budx33o3zL7Pgs5aCzP4yIN9Tg0fGyOv3nzFzXNf8pdbp7RPx6wGMCLK7TBw9o/+4E6z6uTi/IzNsGLPPtAfNHVd+wr+d03vtR1dr9e7ME+NkUH1+Sxm6qYeDZdXpm/UZ4HxERlG/XcN8tA6dT9kV/AFgFvBI4MyIOzMxvMpwt6/SuAe2db2U/H6LPpXU68AMkM9dGxHW1/6UDFut7nERdt3O396j0MygfZvcHngl8DSAilgC/V5f5bM86na0jWzK1b6HbDJh/7QTrdELX1RMsc9WA+aOqb9jXczrv/ahqXdv189ZDPL4kjd1Uw8Dv1ul/T7DMI2t/N3fvRoiIfSkHyL05M/93nfdJyvUE3gvsO2TNNwAPoHwjHLWtZqHPCWXm7RFxBmUrwMuoYQB4MeX1vCQzew927OzeOSMzD53Bw987+SLTMqr65sKoat2h6+d+uzYkad6a6tkEnW9MgzahA/xBnf6oZ/5hlIOqTu3MyMy1wD8BTxh0fvoEOvtmdxjQ3tkHPszFazrfkB8yaIEoF0XaqWf5Uel88/+DuksF1h9D8Lk+y3ee48B6R6DzOk90Pv+gtrmob6LHHea9H1Wt3b+Pg45nkaR5adhTC/tuRo2IxawfirV3F8HjgMv67Iv/flf7MC6p00HjwJ9fp4+JiAdNsc8f1OnuE6zzdNZvSfnBgGWm6yzKt8nFwHMj4sFAZ9Cm3l0EsH5f/zDPcVidrUCPjYhtBywz6DS6uaivn+m896OqdVmd3kw5C0KSFoyphoHOwVAH9TZEuWjQxyib7uG+YWAX+u937sx74BRr6Di3TpcPaP8GZd//ppTdEFNxFnALZf/zfY5Cj4hNKWMPAHw7M0f6z74eh9EZTfGllN0qQTmN5NI+q3wD+AVTeI4RMWgLymTOohzLsBXw2j79bga8YcC6c1HfoMcd9r0fVa1PqNPzeg72lKR5b6ph4D/q9FkRcXxEbANl+FbgTMqpeR29YWBr4M4+fa7tah/Gd+r0cfVDegP1g/WN9e5LI+JfImKvTnsd3vbVEXFy1zprKFdBBDi2Psdt6/IPomyqfypld8fbhqx3qjpbAJ4HHNUzbwP1Ob6OcirnSyPiSxHx2E57RGweEcsj4m8pI/UNLcugUZ1Bdt4VEX8aEVvX/h9CGdCn79aZuahvgscd9r0fVa2dMPCtUT0fSZozUxmMANiCsmm8e2jeW+vP11E+vDpD+G7ds+6FwDf79Pk7dZ3XDjMwAuUb82V13QMnWO7PuO/wshMNR7wp9x2O+AZKAOg852MGPNbqusz+E9QzcNjerud1Zc9r3HeAm651jqIErc46t1N2N3QPo5vTqbfrff9qV1/dwxHfRTlOpNN2n1pns76JXs9h3/uZ1FrX3ZqyZWkd8PBhfp+9OeiQNFWMe9ChLMPg/h7wj5QDru6u05OAvVl/nveqzLyjZ/Wr6X+gWWfeoNPTBtWSwGn17sBhfDPzfZTjET5O+XDZnPIP/UeUUxzf0LP8vZn5SsoBj2dRhrzdttb/OWDfzDxlmFqHUZ9X91UYz8nMiU7rIzM/DuxJeR9+QvkA3J7yIXYO8PbaPt2a7gKeS/m2fWHt/x7g/1COoTi7a/Gb5rq+Ceoe6r0fQa3PpYzYeE5mXj66ZyJJcyPKZ9AMO4k4EXgr8PnMfGlP23sp39SWZNdBhBHxVuBEyjepoTYVR8QDKf/kbwUemJn9dkNolkXEgcDXgSszc9mYyxmbiPhXygWlXpaZ/c7+0ASWL1+eK1asmHxBqXERsTIzBx0vNyNDX8J4gM44BP2GIf5ifZyjOzPq6XNHASuHDQIAmXkV8BHKaIZHTbK4Zk/nYMuvTbjURiwiHkG5eNJPgX8eczmSNC2zHgYy83uUI+XfFRHvjYijKUdwP4ypjx/fz19TLqTzF/XIdo1YRGwaEV+MiEPq6aOd+cK9xx0AABUeSURBVI+KiC8CB1N2Gd3n2gUNeQvleJPj07MIJC1QM/4QjYgdKZf5hcEXKDqCcqGjV1C+zV8IPD8zzx6w/KQy8zcRcQQliOxK2W2g0QrgRfVGRNxC+Z3pDMm7DnhdZv54POWNVz2t9jLgzzPzS5MtL0nz1YyPGYiIA4D/Aq7LzEFj9msBqtebeA1lC8CjgZ0pB+P9mnIK3UmZOeoBmNQYjxmQpmY2jxmY8ZaB+u0+Jl1QC049w+Ef6k2StJFasPvalyxZksuWLRt3GZoHVq5c6VYpSZqBBRsGli1bhpsWBRARV467BklayEZ1NoEkSVqgDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDANSgyJi14g4LSKuiog7I2J1RJwUETtMo6/HR8RnI+KXta9rIuKbEXHEbNQuafQW7CWMJU1PROwGnAfsDJwBXAzsCxwHHBIR+2Xm9VPs63XAB4AbgTOBXwE7AnsDzwE+OfInIGnkDANSe06hBIFjM/ODnZkR8T7gDcCJwGsm6yQiDgJOBr4GHJaZt/a0bz7KoiXNHncTSA2pWwUOAlYDH+5pfjuwBjg8IhZNobv3AncAL+sNAgCZeffMqpU0V9wyILXlgDo9KzPXdTdk5q0RcS4lLDwJ+MagTiJib+AxwJeAGyLiAGAfIIELgLN7+5c0fxkGpLbsWaerBrRfSgkDezBBGACeUKe/Ac4Bnt7T/uOIeGFm/myadUqaQ+4mkNqyuE5vHtDemX+/SfrZuU5fBSwDnlv73gP4NPBo4MyI2KLfyhFxdESsiIgV11577RRLlzRbDAOSpqPzv2NT4CWZ+eXMvCUzLwWOAFZQgsGL+q2cmadm5vLMXL506dK5qVjSQIYBqS2db/6LB7R35t80ST+d9l9n5ne7GzIzKacsQjllUdI8ZxiQ2nJJne4xoH33Oh10TEFvP4NCw411uvUU65I0RoYBqS1n1+lBEbHB339EbAfsB9wOnD9JP+dTTkNcNuA0xL3r9IoZ1CppjhgGpIZk5mXAWZSD/l7b03wCsAj4VGau6cyMiL0iYq+efm4H/gnYCnhXRETX8o8GjgTuAb44+mchadQ8tVBqzzGU4YhPjogDgYuAJ1LGIFgFHN+z/EV1Gj3z/5JySuHrgSfXMQruD7yQEhJeX8OHpHnOLQNSY+oH9HLgdEoIeCOwG+UaA0+a6nUJMvMW4GnAuynXI3gd8DzgO8DBmfmBkRcvaVa4ZUBqUGb+Ajhqisv2bhHobruNsiWhd2uCpAXELQOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDAOSJDXOMCBJUuMMA5IkNc4wIElS4wwDkiQ1zjAgSVLjDANSgyJi14g4LSKuiog7I2J1RJwUETvMoM+nR8S9EZER8a5R1itpdm027gIkza2I2A04D9gZOAO4GNgXOA44JCL2y8zrh+xzO+ATwO3AtqOtWNJsc8uA1J5TKEHg2Mw8NDPfnJnPBN4P7AmcOI0+PwAsBt4zujIlzRXDgNSQulXgIGA18OGe5rcDa4DDI2LREH2+ADgKOBa4ajSVSppLhgGpLQfU6VmZua67ITNvBc4FtgGeNJXOImJn4KPAlzLz06MsVNLcMQxIbdmzTlcNaL+0TveYYn8fpfwfec1MipI0XoYBqS2L6/TmAe2d+febrKOI+CPg94FjMvOaYYqIiKMjYkVErLj22muHWVXSLDAMSBpaRCwDTgK+kJn/Muz6mXlqZi7PzOVLly4ddXmShmQYkNrS+ea/eEB7Z/5Nk/RzGnAHcMwoipI0XoYBqS2X1OmgYwJ2r9NBxxR0PJ5yeuK1dZChjIgEPl7bj6/zvjSzciXNBQcdktpydp0eFBGbdJ9RUAcO2o8ycND5k/TzScpZB712B54OXACsBP57xhVLmnWGAakhmXlZRJxFGWvgtcAHu5pPABYBH8nMNZ2ZEbFXXffirn6O7dd/RBxJCQNnZubbRv4EJM0Kw4DUnmMowxGfHBEHAhcBT6SMQbAKOL5n+YvqNOasQklzymMGpMZk5mXAcuB0Sgh4I7AbZUjhJw17XQJJC59bBqQGZeYvKEMIT2XZKW8RyMzTKSFD0gLilgFJkhpnGJAkqXGGAUmSGmcYkCSpcYYBSZIaZxiQJKlxhgFJkhpnGJAkqXGGAUmSGmcYkCSpcYYBSZIat2CvTbBy5crrIuLKcdeheeGh4y5AkhayBRsGMnPpuGuQJGlj4G4CSZIaZxiQJKlxhgFJkhpnGJinIuLTEZER8a6IeHhEfCQifhYRd0TETRHxfyJi73HXKUla+BbsAYQNeGyd7gT8BNgKWEsJcIuB5wFPj4h9M/OS8ZQoSdoYuGVgHoqILYE9693XAFcCBwPbANsCLwPWANsDJ46jRknSxsMtA/PT3qx/by4C9svMG+v9u4HPRcRewF8Bz46ITTPz3jHUKUnaCLhlYH763a6fX9UVBLp9uU63Ae4/+yVJkjZWhoH5qXO8wLmZ+d0By1zd9XN2foiILSPibyLiV/Vgw+9HxMGzVqkkacEzDMxPnTDw7xMss2OdJnBt1/zTgTcCnwOOo+xWODMinjHiGiVJGwmPGZifHlOnP5hgmeV1+pPMvAcgIvYFXgK8OTP/d533SeBC4L3AvrNTriRpIXPLwDwTEQ+jnDoIcP0Ei76oTr/cNe8wYB1wamdGZq4F/gl4QkQsG1mhkqSNhmFg/uk+eHBJvwUi4tHAQcA9wEe6mh4HXNbngMPvd7VLkrQBw8D889iunw/qbYyIrSnf9DcBTsvMy7uad2HDAws7OvMeOKoiJUkbD8PA/NPZMnAzcGxEvCIiNgeIiCcD5wBPoIw/8Gc9624N3Nmnz7Vd7ZIkbcAwMP90tgwcRxll8FPAmoi4HTiPchDgxcCzM3NNz7p3AFv26XOrrnZJkjZgGJhHImIxsKze/QqwH/CvlK0EAfwYeCvw+My8sk8XV1N2FfTqzLtqlPVKkjYOnlo4v3R2EVyTmdcA11DOEJiqC4BnRsQOPQcRPrGrXZKkDbhlYH7p7CL40TTX/yLlPT26M6Ne9OgoYGVmXjGz8iRJGyO3DMwvnS0DP5zOypn5vYj4AvCuiFgCXAocATwMeNZoSpQkbWwMA/PLTLcMQPnwfyfwCsqQxRcCz8/Ms2dYmyRpI2UYmCciYjPgUfXutMNAHXHwf9WbJEmTMgzME/X6AltNuqAkSSPmAYSSJDVuwW4ZWLJkSS5btmzcZWgeWLly5XWZuXTcdUjSQrVgw8CyZctYsWLFuMvQPBAR/QZgkiRNkbsJJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUBqUETsGhGnRcRVEXFnRKyOiJMiYocprr8oIl4eEZ+NiIsjYk1E3BoRKyLijRGxxWw/B0mjs9m4C5A0tyJiN+A8YGfgDOBiYF/gOOCQiNgvM6+fpJunAZ8GbgDOBr4E7AD8PvB3wAsj4sDMXDs7z0LSKBkGpPacQgkCx2bmBzszI+J9wBuAE4HXTNLHr4FXAF/IzLu6+ngTcA7wFOC1wN+PtHJJs8LdBFJD6laBg4DVwId7mt8OrAEOj4hFE/WTmRdk5me6g0CdfyvrA8D+o6hZ0uwzDEhtOaBOz8rMdd0N9YP8XGAb4EkzeIy76/SeGfQhaQ4ZBqS27Fmnqwa0X1qne8zgMf6oTr8ygz4kzSHDgNSWxXV684D2zvz7TafziHgdcAhwAXDaBMsdXc88WHHttddO56EkjZBhQNJIRMQLgZMoBxe+KDPvHrRsZp6amcszc/nSpUvnrEZJ/RkGpLZ0vvkvHtDemX/TMJ1GxKHA54HfAPtn5uXTK0/SOBgGpLZcUqeDjgnYvU4HHVNwHxHxYuALwDXAMzLzkklWkTTPGAaktpxdpwdFxAZ//xGxHbAfcDtw/lQ6i4iXA58DrqIEgUsnWUXSPGQYkBqSmZcBZwHLKIMCdTsBWAR8KjPXdGZGxF4RsVdvXxHxSuCTwM+Bp7trQFq4HIFQas8xlOGIT46IA4GLgCdSxiBYBRzfs/xFdRqdGRFxAOVsgU0oWxuOioie1bgpM08aefWSRs4wIDUmMy+LiOXAOymnAT4HuBr4AHBCZt44hW4eyvoti380YJkrKWcXSJrnDANSgzLzF8BRU1z2Pl/5M/N04PTRViVpXDxmQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQGpMROwaEadFxFURcWdErI6IkyJihyH72bGut7r2c1Xtd9fZql3S7Nhs3AVImjsRsRtwHrAzcAZwMbAvcBxwSETsl5nXT6GfnWo/ewD/BXwe2As4CnhuRDw5My+fnWchadTcMiC15RRKEDg2Mw/NzDdn5jOB9wN7AidOsZ93U4LA+zLzwNrPoZRQsXN9HEkLhGFAakTdKnAQsBr4cE/z24E1wOERsWiSfrYFDq/Lv6On+UPAlcDBEfHwmVctaS4YBqR2HFCnZ2Xmuu6GzLwVOBfYBnjSJP08CdgaOLeu193POuCrPY8naZ4zDEjt2LNOVw1ov7RO95ijfiTNEwv2AMKVK1deFxFXjrsOzQsPHXcBC8TiOr15QHtn/v1mu5+IOBo4ut69MyIunOQxNbeWANeNuwjdx56TLzI9CzYMZObScdcgaXoy81TgVICIWJGZy8dckrr4nsxPEbFitvp2N4HUjs439sUD2jvzb5qjfiTNE4YBqR2X1Omgffm71+mgYwFG3Y+kecIwILXj7Do9KCI2+NuPiO2A/YDbgfMn6ed84A5gv7pedz+bUE5f7H68yZw6xeU0d3xP5qdZe18MA1IjMvMy4CxgGfDanuYTgEXApzJzTWdmROwVEXv19HMb8Km6/Dt6+nld7f+rUx2BsB4/oHnE92R+ms33JTJztvqWNM/0GY74IuCJlDEBVgFP6R6OOCISIDOjp5/e4Yi/DzwSeAHwm9rPZbP9fCSNhmFAakxEPBh4J3AIsBNwNfDvwAmZeWPPsn3DQG3bkTJy4aHALsD1wH8Cf5WZv5zN5yBptNxNIDUmM3+RmUdl5i6ZuUVmPjQzX98bBOqy0S8I1LYbMvO4uv4WmbkL8FfAO70i4vwyiitVRsQ5EZET3LaazeewMYmIwyLigxHx7Yi4pb5+n55mXyO5CumCHWdA0vziFRHnp1G9L11OGDD/nhkV2pa3Ab8L3Ab8kvL7PbSRvreZ6c2bN28zvlGuSZDAn/bMf1+d/49T7Ocjdfm/75l/bJ3/lXE/14V0G+H7ck75yBj/c1roN8oxOrsDAexf34dPj+u9zUyPGZA0c/Ubys8oV0TcLbsuhFRPP7ya8o9v5+w6W6FPP9tSDkBcB+ySXRdCqqctXk4Zfnq3dOvApEb1vtTlzwGekQN2G2l6ImJ/ymm4n8nMVwyx3sjeW/CYAUmj4RUR56dRvS+/FRH/IyLeHBF/FhHPjogtR1euhjDS99YwIGkUvCLi/DQbr+fngfcAfw98Gfh5RBw2vfI0AyN9bw0DkkZh3lwRURsY5et5BvB8YFfK1pu9KKHgfsA/R8QhM6hTwxvp34pnE0iSJpWZ7++ZdQnw1oi4CvggJRh8Zc4L00i4ZUDSKHhFxPlpLl7Pj1FOK3xs77UqNKtG+t4aBiSNgldEnJ9m/fXMzLVA52DPRdPtR0Mb6XtrGJA0CvP1ioitG9X7MlBE7AnsQAkE1023Hw1tpO+tYUDSjOU8vSJi60b1vkTEw+q1KOiZvxT4eL37+cx0FMIRi4jN63uyW/f86by3Ez6Ogw5JGgWviDg/jeJ9iYgjgX8EvkMZ+OkG4CHAcyj7plcAz8pMj+WYgog4lHKBL4AHAAdTXtdv13nXZeab6rLLgCuAKzNzWU8/Q723E9ZkGJA0Kl4RcX6a6fsSEY8G3gjsAzwQ2J6yW+AnwL8AH8nMu2b/mWwcIuIdlN/vQX77wT9RGKjtU35vJ6zJMCBJUts8ZkCSpMYZBiRJapxhQJKkxhkGJElqnGFAkqTGGQYkSWqcYUCSpMYZBiRJapxhQJKkxhkGJElq3P8Ha5tPXmnIqBcAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Hyperparamters for training:"
      ],
      "metadata": {
        "id": "0DpjTROoLEvJ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B3-ceCnKYsWx"
      },
      "outputs": [],
      "source": [
        "#@title Hyperparameters\n",
        "n_steps = 10\n",
        "betas = make_beta_schedule(schedule='sigmoid', n_timesteps=n_steps, start=1e-5, end=1e-2)\n",
        "alphas = 1 - betas\n",
        "alphas_prod = torch.cumprod(alphas, 0)\n",
        "alphas_prod_p = torch.cat([torch.tensor([1]).float(), alphas_prod[:-1]], 0)\n",
        "alphas_bar_sqrt = torch.sqrt(alphas_prod)\n",
        "one_minus_alphas_bar_log = torch.log(1 - alphas_prod)\n",
        "one_minus_alphas_bar_sqrt = torch.sqrt(1 - alphas_prod)\n",
        "\n",
        "model = ConditionalModel(n_steps)\n",
        "model = model.to(DEVICE)\n",
        "optimizer = optim.AdamW(model.parameters(), lr=1e-3)\n",
        "dataset = train_set.data.clone().detach().float()\n",
        "\n",
        "# dataset = torch.tensor(train_set).float()\n",
        "dataset = dataset.to(DEVICE)\n",
        "# Create EMA model\n",
        "betas = betas.to(DEVICE)\n",
        "alphas_prod = alphas_prod.to(DEVICE)\n",
        "alphas = alphas.to(DEVICE)\n",
        "one_minus_alphas_bar_sqrt = one_minus_alphas_bar_sqrt.to(DEVICE)\n",
        "ema = EMA(0.9)\n",
        "ema.register(model)\n",
        "\n",
        "batch_size = 128\n",
        "train_gen = True\n",
        "epoch_start = 10\n",
        "simple_losses = []\n",
        "w_distances = []\n",
        "w_final_distances = []"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Start training:"
      ],
      "metadata": {
        "id": "61ch5PTNLIFv"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VaL2NwMA2cgJ",
        "outputId": "2d35bbf2-6efc-4b48-cc39-3c9b0d34778d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 tensor(-7.4793, grad_fn=<NegBackward0>)\n",
            "10 tensor(18472252., grad_fn=<MeanBackward0>)\n",
            "20 tensor(0.8080, grad_fn=<MeanBackward0>)\n",
            "30 tensor(0.4504, grad_fn=<MeanBackward0>)\n",
            "40 tensor(0.5184, grad_fn=<MeanBackward0>)\n",
            "50 tensor(0.5447, grad_fn=<MeanBackward0>)\n",
            "60 tensor(0.3905, grad_fn=<MeanBackward0>)\n",
            "70 tensor(0.7420, grad_fn=<MeanBackward0>)\n",
            "80 tensor(0.4908, grad_fn=<MeanBackward0>)\n",
            "90 tensor(0.4890, grad_fn=<MeanBackward0>)\n",
            "100 tensor(0.4539, grad_fn=<MeanBackward0>)\n",
            "110 tensor(0.4203, grad_fn=<MeanBackward0>)\n",
            "120 tensor(0.5710, grad_fn=<MeanBackward0>)\n",
            "130 tensor(0.5723, grad_fn=<MeanBackward0>)\n",
            "140 tensor(0.4686, grad_fn=<MeanBackward0>)\n",
            "150 tensor(0.6922, grad_fn=<MeanBackward0>)\n",
            "160 tensor(0.3938, grad_fn=<MeanBackward0>)\n",
            "170 tensor(0.6380, grad_fn=<MeanBackward0>)\n",
            "180 tensor(0.4921, grad_fn=<MeanBackward0>)\n",
            "190 tensor(0.4539, grad_fn=<MeanBackward0>)\n",
            "200 tensor(0.4347, grad_fn=<MeanBackward0>)\n",
            "210 tensor(0.4945, grad_fn=<MeanBackward0>)\n",
            "220 tensor(0.4701, grad_fn=<MeanBackward0>)\n",
            "230 tensor(0.3611, grad_fn=<MeanBackward0>)\n",
            "240 tensor(0.3377, grad_fn=<MeanBackward0>)\n",
            "250 tensor(0.3158, grad_fn=<MeanBackward0>)\n",
            "260 tensor(0.2672, grad_fn=<MeanBackward0>)\n",
            "270 tensor(0.2388, grad_fn=<MeanBackward0>)\n",
            "280 tensor(0.3601, grad_fn=<MeanBackward0>)\n",
            "290 tensor(0.3731, grad_fn=<MeanBackward0>)\n",
            "300 tensor(0.3239, grad_fn=<MeanBackward0>)\n",
            "310 tensor(0.2254, grad_fn=<MeanBackward0>)\n",
            "320 tensor(0.2490, grad_fn=<MeanBackward0>)\n",
            "330 tensor(0.2292, grad_fn=<MeanBackward0>)\n",
            "340 tensor(0.1917, grad_fn=<MeanBackward0>)\n",
            "350 tensor(0.2405, grad_fn=<MeanBackward0>)\n",
            "360 tensor(0.1845, grad_fn=<MeanBackward0>)\n",
            "370 tensor(0.3087, grad_fn=<MeanBackward0>)\n",
            "380 tensor(0.2386, grad_fn=<MeanBackward0>)\n",
            "390 tensor(0.2361, grad_fn=<MeanBackward0>)\n",
            "400 tensor(0.2322, grad_fn=<MeanBackward0>)\n",
            "410 tensor(0.2831, grad_fn=<MeanBackward0>)\n",
            "420 tensor(0.0973, grad_fn=<MeanBackward0>)\n",
            "430 tensor(0.1247, grad_fn=<MeanBackward0>)\n",
            "440 tensor(0.1748, grad_fn=<MeanBackward0>)\n",
            "450 tensor(0.1777, grad_fn=<MeanBackward0>)\n",
            "460 tensor(0.1331, grad_fn=<MeanBackward0>)\n",
            "470 tensor(0.0999, grad_fn=<MeanBackward0>)\n",
            "480 tensor(0.0848, grad_fn=<MeanBackward0>)\n",
            "490 tensor(0.1220, grad_fn=<MeanBackward0>)\n",
            "500 tensor(0.2182, grad_fn=<MeanBackward0>)\n",
            "510 tensor(0.2739, grad_fn=<MeanBackward0>)\n",
            "520 tensor(0.0576, grad_fn=<MeanBackward0>)\n",
            "530 tensor(0.1533, grad_fn=<MeanBackward0>)\n",
            "540 tensor(0.2388, grad_fn=<MeanBackward0>)\n",
            "550 tensor(0.1319, grad_fn=<MeanBackward0>)\n",
            "560 tensor(0.0972, grad_fn=<MeanBackward0>)\n",
            "570 tensor(0.2242, grad_fn=<MeanBackward0>)\n",
            "580 tensor(0.0776, grad_fn=<MeanBackward0>)\n",
            "590 tensor(0.0573, grad_fn=<MeanBackward0>)\n",
            "600 tensor(0.1221, grad_fn=<MeanBackward0>)\n",
            "610 tensor(0.1786, grad_fn=<MeanBackward0>)\n",
            "620 tensor(0.2379, grad_fn=<MeanBackward0>)\n",
            "630 tensor(0.0984, grad_fn=<MeanBackward0>)\n",
            "640 tensor(0.2934, grad_fn=<MeanBackward0>)\n",
            "650 tensor(0.1006, grad_fn=<MeanBackward0>)\n",
            "660 tensor(0.3245, grad_fn=<MeanBackward0>)\n",
            "670 tensor(0.1690, grad_fn=<MeanBackward0>)\n",
            "680 tensor(0.2684, grad_fn=<MeanBackward0>)\n",
            "690 tensor(0.2741, grad_fn=<MeanBackward0>)\n",
            "700 tensor(0.1746, grad_fn=<MeanBackward0>)\n",
            "710 tensor(0.2385, grad_fn=<MeanBackward0>)\n",
            "720 tensor(0.1125, grad_fn=<MeanBackward0>)\n",
            "730 tensor(0.1946, grad_fn=<MeanBackward0>)\n",
            "740 tensor(0.2445, grad_fn=<MeanBackward0>)\n",
            "750 tensor(0.1733, grad_fn=<MeanBackward0>)\n",
            "760 tensor(0.0674, grad_fn=<MeanBackward0>)\n",
            "770 tensor(0.2801, grad_fn=<MeanBackward0>)\n",
            "780 tensor(0.4792, grad_fn=<MeanBackward0>)\n",
            "790 tensor(0.1483, grad_fn=<MeanBackward0>)\n",
            "800 tensor(0.2086, grad_fn=<MeanBackward0>)\n",
            "810 tensor(0.1302, grad_fn=<MeanBackward0>)\n",
            "820 tensor(0.1868, grad_fn=<MeanBackward0>)\n",
            "830 tensor(0.0479, grad_fn=<MeanBackward0>)\n",
            "840 tensor(0.1039, grad_fn=<MeanBackward0>)\n",
            "850 tensor(0.1058, grad_fn=<MeanBackward0>)\n",
            "860 tensor(0.1913, grad_fn=<MeanBackward0>)\n",
            "870 tensor(0.1698, grad_fn=<MeanBackward0>)\n",
            "880 tensor(0.0820, grad_fn=<MeanBackward0>)\n",
            "890 tensor(0.1781, grad_fn=<MeanBackward0>)\n",
            "900 tensor(0.2076, grad_fn=<MeanBackward0>)\n",
            "910 tensor(0.1280, grad_fn=<MeanBackward0>)\n",
            "920 tensor(0.2731, grad_fn=<MeanBackward0>)\n",
            "930 tensor(0.2333, grad_fn=<MeanBackward0>)\n",
            "940 tensor(0.1449, grad_fn=<MeanBackward0>)\n",
            "950 tensor(0.2431, grad_fn=<MeanBackward0>)\n",
            "960 tensor(0.2585, grad_fn=<MeanBackward0>)\n",
            "970 tensor(0.1273, grad_fn=<MeanBackward0>)\n",
            "980 tensor(0.0947, grad_fn=<MeanBackward0>)\n",
            "990 tensor(0.1373, grad_fn=<MeanBackward0>)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at  ../aten/src/ATen/native/TensorShape.cpp:2894.)\n",
            "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
          ]
        }
      ],
      "source": [
        "#@title Training\n",
        "num_epoch = 1000\n",
        "if train_gen:\n",
        "    for t in range(num_epoch):\n",
        "        # X is a torch Variable\n",
        "        permutation = torch.randperm(dataset.size()[0])\n",
        "        for i in range(0, dataset.size()[0], batch_size):\n",
        "            # Retrieve current batch\n",
        "            indices = permutation[i:(i + batch_size)]\n",
        "            batch_x = dataset[indices].to(DEVICE)\n",
        "            # plt.scatter(batch_x[:, 0], batch_x[:, 1], s=10)\n",
        "            # axs[i - 1].scatter(cur_x[:, 0], cur_x[:, 1], s=10);\n",
        "            # Compute the loss.\n",
        "            if t<epoch_start:\n",
        "                loss = -noise_estimation_2_loss(model, batch_x)\n",
        "            else:\n",
        "                loss = noise_estimation_2_loss(model, batch_x)\n",
        "            # Before the backward pass, zero all of the network gradients\n",
        "            optimizer.zero_grad()\n",
        "            # Backward pass: compute gradient of the loss with respect to parameters\n",
        "            loss.backward()\n",
        "            # Perform gradient clipping\n",
        "            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.)\n",
        "            # Calling the step function to update the parameters\n",
        "            optimizer.step()\n",
        "            # Update the exponential moving average\n",
        "            # for p in model.parameters():\n",
        "            #     p.data.clamp_(-0.1, 0.1)\n",
        "\n",
        "            ema.update(model)\n",
        "              # print(batch_x.shape)\n",
        "            # print(i)\n",
        "            flag = False\n",
        "            if t < 35: \n",
        "                flag = True\n",
        "            if (i)%(batch_size*10)==0:\n",
        "                flag = True\n",
        "                # print(loss)\n",
        "            if flag == True:\n",
        "\n",
        "                simple_loss = 0\n",
        "                for i in range(n_steps):\n",
        "                    simple_loss += noise_integration_loss(model, batch_x, i).detach()\n",
        "                #   compute J_SM done\n",
        "                q_noise = noise_last_step(batch_x)\n",
        "                # get q_T\n",
        "                x_seq = p_sample_loop_from_qnoise(model, q_noise)\n",
        "                # x_seq = p_sample_loop(model, batch_x.shape)\n",
        "                w_distance = ot.sliced_wasserstein_distance(batch_x.detach().cpu(), x_seq[-1].detach().cpu())\n",
        "\n",
        "                # q_seq = noise_all_step(batch_x)\n",
        "                #\n",
        "                # # fig, axs = plt.subplots(1, 10, figsize=(28, 3))\n",
        "                # # p_noise = torch.randn(batch_x.shape)\n",
        "                # w_seq = []\n",
        "                # for step in range(n_steps+1):\n",
        "                #     # print(step, n_steps -step)\n",
        "                #     w_seq.append(ot.sliced_wasserstein_distance(q_seq[step], x_seq[n_steps - step].detach()))\n",
        "                #\n",
        "                # plt.plot(w_seq)\n",
        "                # plt.show()\n",
        "                # w_final_distance = ot.sliced_wasserstein_distance(p_noise, q_noise.detach())\n",
        "                simple_losses.append(simple_loss)\n",
        "                w_distances.append(w_distance)\n",
        "                # # w_final_distances.append(w_final_distance)\n",
        "                # # plt.scatter(x_seq[-1][:, 0].detach(), x_seq[-1][:, 1].detach(), s=5);\n",
        "                # # for i in range(1, 11):\n",
        "                # #     cur_x = x_seq[i * 10].detach()\n",
        "                # #     axs[i - 1].scatter(cur_x[:, 0], cur_x[:, 1], s=5);\n",
        "                # #     # axs[i-1].set_axis_off();\n",
        "                # #     axs[i - 1].set_title('$q(\\mathbf{x}_{' + str(i * 10) + '})$')\n",
        "                # # plt.show()\n",
        "                # # Print loss\n",
        "        if t % 10 == 0:\n",
        "            print(t, loss)\n",
        "            # torch.save(x_seq[-1],\"random.pt\")\n",
        "        if t == epoch_start-1:\n",
        "            indices = permutation[0:(0 + 256)]\n",
        "            batch_x = dataset[indices].to(DEVICE)\n",
        "            q_noise = noise_last_step(batch_x).detach()\n",
        "            # get q_T\n",
        "            x_seq = p_sample_loop_from_qnoise(model, q_noise)\n",
        "            # plt.figure(figsize=(2, 2))\n",
        "            ax.scatter(x_seq[-1][:, 0].detach().cpu(), x_seq[-1][:, 1].detach().cpu(), s=1, c = \"green\")\n",
        "            # ax2.set_xlabel(\"$q_0$ after maximization\")\n",
        "            # ax.set_xlim(-1, 1)\n",
        "            # ax.set_ylim(-1, 1)\n",
        "        if t == num_epoch-1:\n",
        "            indices = permutation[0:(0 + 128)]\n",
        "            batch_x = dataset[indices].to(DEVICE)\n",
        "            q_noise = noise_last_step(batch_x).detach()\n",
        "            # get q_T\n",
        "            x_seq = p_sample_loop_from_qnoise(model, q_noise)\n",
        "            # plt.figure(figsize=(2, 2))\n",
        "            ax1.scatter(x_seq[-1][:, 0].detach().cpu(), x_seq[-1][:, 1].detach().cpu(), s=1, c = \"green\")\n",
        "            # ax2.set_xlabel(\"$q_0$ after maximization\")\n",
        "            ax1.set_xlim(-1, 1)\n",
        "            ax1.set_ylim(-1, 1)\n",
        "        if t == num_epoch-1:\n",
        "            num = 10\n",
        "            xs = torch.linspace(0, 0.9, steps=num)\n",
        "            ys = torch.linspace(0, 0.9, steps=num)\n",
        "            x_0, x_1 = torch.meshgrid(xs, ys)\n",
        "            x_0 = x_0.reshape(num * num, 1)\n",
        "            x_1 = x_1.reshape(num * num, 1)\n",
        "            input = torch.cat([x_0, x_1], 1).to(DEVICE)\n",
        "            # input = batch_x\n",
        "            output = torch.zeros([n_steps,input.shape[0],2]).to(DEVICE)\n",
        "            for i in range(n_steps):\n",
        "                # print((model(input, torch.tensor(i))/torch.sqrt((1-alphas_prod[i]))).squeeze().shape)\n",
        "                output[i] = (-model(input, torch.tensor(i).to(DEVICE))/torch.sqrt((1-alphas_prod[i]))).squeeze()\n",
        "            # input.requires_grad = True\n",
        "            # compute maximum gradient norm:\n",
        "            grad = torch.zeros([n_steps]).to(DEVICE)\n",
        "            for i in range(n_steps):\n",
        "                new_grad = -float('inf')\n",
        "                for j in range(input.shape[0]):\n",
        "                    for k in range(input.shape[0]):\n",
        "                        if j != k:\n",
        "                            xs = input[j]\n",
        "                            ys = input[k]\n",
        "                            sx = output[i,j]\n",
        "                            sy = output[i,k]\n",
        "                            # print(sx.shape)\n",
        "                            # sy = (model(ys, torch.tensor(i))/torch.sqrt((1-alphas_prod[i]))).squeeze()\n",
        "                            new_grad_new = ((sx-sy).dot(xs-ys))/((xs-ys).dot(xs-ys))\n",
        "                            new_grad = max(new_grad_new, new_grad)\n",
        "                grad[i] = new_grad\n",
        "\n",
        "\n",
        "                # compute grad\n",
        "                # new_grad = 0\n",
        "                # output = torch.norm(model(input, torch.tensor(i))/torch.sqrt((1-alphas_prod[i])),dim=1)\n",
        "                # for batch in range(output.shape[0]):\n",
        "                #     new_grad_new = torch.norm(torch.autograd.grad(output[batch], input, retain_graph=True)[0])\n",
        "                #     new_grad = max(new_grad_new, new_grad)\n",
        "                # grad[i] = new_grad\n",
        "            # print(\"max norm as upper bound L:\", grad.sum(), \"time\", t)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "djskVyQP2_wA"
      },
      "outputs": [],
      "source": [
        "#@title Estimating L_s\n",
        "logits = torch.zeros(n_steps).to(DEVICE)\n",
        "for i in range(n_steps):\n",
        "    logits[i] = (grad[0:i+1]*betas[0:i+1]).sum() + 0.5*betas[0:i+1].sum()\n",
        "its2 = torch.exp((logits))**2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TzF4ajoB4OLi",
        "outputId": "6c14eab1-c90f-4006-a8b9-07f775d7f39b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(5.1929, grad_fn=<MulBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "#@title Estimating intercept\n",
        "intercept = 0.5*torch.log(2*(its2*betas).sum())\n",
        "intercept"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7u_xlT6Y31ff",
        "outputId": "715788e7-b329-48bb-f7a6-74cfd1a64385"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(246.04092057987964, 0.5, '$\\\\log(W(p_0, q_0))$')"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "#@title Generating plots\n",
        "# plt.figure(figsize=(4, 8), dpi=500)\n",
        "import matplotlib\n",
        "cmap = matplotlib.cm.get_cmap('Blues')\n",
        "ax3.set_xlim(0, 6)\n",
        "ax3.set_ylim(-4, 8)\n",
        "num = len(simple_losses)-100\n",
        "cc = np.linspace(0.3, 1, num)\n",
        "\n",
        "\n",
        "ax3.scatter(torch.log(0.5*torch.tensor(simple_losses)[100:]), torch.log(torch.tensor(w_distances)[100:]), c=cmap(cc), s = 5, label = 'Empirical')\n",
        "\n",
        "# print(\"done\")\n",
        "# plt.scatter(torch.tensor(simple_losses), torch.tensor(w_distances), c='y')\n",
        "# plt.show()\n",
        "# fs = 10\n",
        "# plt.rcParams.update({'font.size': 10})\n",
        "xs = torch.linspace(0., 6., steps=100)\n",
        "ys = 0.5*xs + intercept.detach().cpu()\n",
        "ax3.plot(xs.detach().numpy(), ys.detach().numpy(), c = 'black', label = 'Upper bound')\n",
        "ax3.legend(loc = 'upper right', fontsize = 19)\n",
        "# plt.title()\n",
        "ax3.set_xlabel('$\\log(J_{DSM})$')\n",
        "ax3.set_ylabel('$\\log(W(p_0, q_0))$')\n",
        "# plt.savefig('4clusters.png')\n",
        "# plt.show()\n",
        "# print(grad)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "indices = permutation[0:(0 + 128)]\n",
        "batch_x = dataset[indices].to(DEVICE)\n",
        "q_noise = noise_last_step(batch_x).detach()\n",
        "# get q_T\n",
        "x_seq = p_sample_loop_from_qnoise(model, q_noise)\n",
        "# plt.figure(figsize=(2, 2))\n",
        "ax1.scatter(x_seq[-1][:, 0].detach().cpu(), x_seq[-1][:, 1].detach().cpu(), s=1, c = \"green\")\n",
        "# ax2.set_xlabel(\"$q_0$ after maximization\")\n",
        "ax1.set_xlim(-1, 1)\n",
        "ax1.set_ylim(-1, 1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JGkRHryM_h9L",
        "outputId": "d1f34ba6-a6e3-45bb-adeb-2945b8091759"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-1.0, 1.0)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "indices = permutation[0:(0 +256)]\n",
        "batch_x = dataset[indices].to(DEVICE)\n",
        "# q_noise = noise_last_step(batch_x).detach()\n",
        "# get q_T\n",
        "# x_seq = p_sample_loop_from_qnoise(model, q_noise)\n",
        "# plt.figure(figsize=(2, 2))\n",
        "ax2.scatter(batch_x[:, 0].detach().cpu(), batch_x[:, 1].detach().cpu(), s=1, c = \"green\")\n",
        "# ax2.set_xlabel(\"$q_0$ after maximization\")\n",
        "ax2.set_xlim(-1, 1)\n",
        "ax2.set_ylim(-1, 1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jNH2_kDViZPp",
        "outputId": "600a2a92-49cd-4986-facb-610336eaa6c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-1.0, 1.0)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fig"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 547
        },
        "id": "t3O805WWomcU",
        "outputId": "2eec823c-d35a-4749-92f6-afa0e19e8b33"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 576x576 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib\n",
        "cmap = matplotlib.cm.get_cmap('Blues')\n",
        "nfig, ax = plt.subplots(figsize = (4,8), dpi = 100)\n",
        "plt.xlim(0, 6)\n",
        "plt.ylim(-4, 8)\n",
        "num = len(simple_losses)-100\n",
        "cc = np.linspace(0.3, 1, num)\n",
        "\n",
        "\n",
        "plt.scatter(torch.log(0.5*torch.tensor(simple_losses)[100:]), torch.log(torch.tensor(w_distances)[100:]), c=cmap(cc), s = 5, label = 'Empirical')\n",
        "\n",
        "# print(\"done\")\n",
        "# plt.scatter(torch.tensor(simple_losses), torch.tensor(w_distances), c='y')\n",
        "# plt.show()\n",
        "# fs = 10\n",
        "# plt.rcParams.update({'font.size': 10})\n",
        "xs = torch.linspace(0., 6., steps=100)\n",
        "ys = 0.5*xs + intercept.detach().cpu()\n",
        "plt.plot(xs.detach().numpy(), ys.detach().numpy(), c = 'black', label = 'Upper bound')\n",
        "plt.legend(loc = 'upper right', fontsize =19)\n",
        "# plt.title()\n",
        "plt.xlabel('$\\log(J_{DSM})$')\n",
        "plt.ylabel('$\\log(W(p_0, q_0))$')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 745
        },
        "id": "IT3R0n5o0Hmg",
        "outputId": "81c67bab-0285-494c-b35c-1feba59eceb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, '$\\\\log(W(p_0, q_0))$')"
            ]
          },
          "metadata": {},
          "execution_count": 14
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 400x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}