toy_example_bin_mnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Toy Example for Dirichlet Diffusion Score Model "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook demo, we provide a quick demo on binarized MNIST dataset. Let's load required libraries first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "\n",
    "import torch\n",
    "import functools\n",
    "from torch.optim import Adam\n",
    "from torch.utils.data import DataLoader\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.datasets import MNIST\n",
    "from torchvision.utils import make_grid\n",
    "import tqdm\n",
    "\n",
    "\n",
    "import pandas as pd\n",
    "import functools\n",
    "import numpy as np\n",
    "\n",
    "# Main file which contrains all DDSM logic\n",
    "from ddsm import * "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading Presampled Noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While Jacobi diffusion evaluation is more expensive than the commonly used diffusion process with Gaussian stationary distribution, all Jacobi diffusion-related computations can be precomputed prior to training and do not add to training time. This is feasible because we only need to generate samples from two starting points, 0 and 1, for any categorical data. Training time sampling is done by choosing randomly from the pre-sampled samples and scores. \n",
    "\n",
    "For presampling weights, you need to presample everything by running ''presample_noise.py'' script provided in the repo. For example,  \n",
    "```\n",
    "python presample_noise.py -n 10000 -c 2 -t 400 --out_path . --mode path\n",
    "```\n",
    "generates file with 2 categories, 10000 samples, and 400 timepoints. This noise will be used later for training, sampling, and computing negative log likelihood. \n",
    "\n",
    "Let's load generated file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_one, v_zero, v_one_loggrad, v_zero_loggrad, timepoints = torch.load(\"steps400.cat2.time4.0.samples10000.pth\")\n",
    "\n",
    "# We have two categories, so the beta parameters are \n",
    "alpha = torch.DoubleTensor([1.0])\n",
    "beta = torch.DoubleTensor([1.0])\n",
    "\n",
    "# Example of 4 categories to be used with diffusion_factory\n",
    "# alpha = torch.DoubleTensor([1.0, 1.0, 1.0])\n",
    "# beta = torch.DoubleTensor([3.0, 2.0, 1.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the Model\n",
    "\n",
    "Now, let's define the score-based model for binarized MNIST data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model architecture borrowed from https://github.com/yang-song/score_sde\n",
    "# Note the manuscript experiment on binarized MNIST use a different, larger model\n",
    "\n",
    "class Dense(nn.Module):\n",
    "    \"\"\"\n",
    "    A fully connected layer that reshapes outputs to feature maps.\n",
    "    \"\"\"\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super().__init__()\n",
    "        self.dense = nn.Linear(input_dim, output_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.dense(x)[..., None, None]\n",
    "\n",
    "\n",
    "class ScoreNet(nn.Module):\n",
    "    \"\"\"A time-dependent score-based model built upon U-Net architecture.\"\"\"\n",
    "    def __init__(self, channels=[32, 64, 128, 256], embed_dim=256):\n",
    "        \"\"\"Initialize a time-dependent score-based network.\n",
    "\n",
    "        Args:\n",
    "          marginal_prob_std: A function that takes time t and gives the standard\n",
    "            deviation of the perturbation kernel p_{0t}(x(t) | x(0)).\n",
    "          channels: The number of channels for feature maps of each resolution.\n",
    "          embed_dim: The dimensionality of Gaussian random feature embeddings.\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "        # Gaussian random feature embedding layer for time\n",
    "        self.embed = nn.Sequential(\n",
    "            GaussianFourierProjection(embed_dim=embed_dim),\n",
    "            nn.Linear(embed_dim, embed_dim),\n",
    "        )\n",
    "        \n",
    "        # Encoding layers where the resolution decreases\n",
    "        self.conv1 = nn.Conv2d(2, channels[0], 3, stride=1, bias=False)\n",
    "        self.dense1 = Dense(embed_dim, channels[0])\n",
    "        self.gnorm1 = nn.GroupNorm(4, num_channels=channels[0])\n",
    "        self.conv2 = nn.Conv2d(channels[0], channels[1], 3, stride=2, bias=False)\n",
    "        self.dense2 = Dense(embed_dim, channels[1])\n",
    "        self.gnorm2 = nn.GroupNorm(32, num_channels=channels[1])\n",
    "        self.conv3 = nn.Conv2d(channels[1], channels[2], 3, stride=2, bias=False)\n",
    "        self.dense3 = Dense(embed_dim, channels[2])\n",
    "        self.gnorm3 = nn.GroupNorm(32, num_channels=channels[2])\n",
    "        self.conv4 = nn.Conv2d(channels[2], channels[3], 3, stride=2, bias=False)\n",
    "        self.dense4 = Dense(embed_dim, channels[3])\n",
    "        self.gnorm4 = nn.GroupNorm(32, num_channels=channels[3])\n",
    "\n",
    "        # Decoding layers where the resolution increases\n",
    "        self.tconv4 = nn.ConvTranspose2d(\n",
    "            channels[3], channels[2], 3, stride=2, bias=False\n",
    "        )\n",
    "        \n",
    "        self.dense5 = Dense(embed_dim, channels[2])\n",
    "        self.tgnorm4 = nn.GroupNorm(32, num_channels=channels[2])\n",
    "        self.tconv3 = nn.ConvTranspose2d(\n",
    "            channels[2] + channels[2],\n",
    "            channels[1],\n",
    "            3,\n",
    "            stride=2,\n",
    "            bias=False,\n",
    "            output_padding=1,\n",
    "        )\n",
    "        \n",
    "        self.dense6 = Dense(embed_dim, channels[1])\n",
    "        self.tgnorm3 = nn.GroupNorm(32, num_channels=channels[1])\n",
    "        self.tconv2 = nn.ConvTranspose2d(\n",
    "            channels[1] + channels[1],\n",
    "            channels[0],\n",
    "            3,\n",
    "            stride=2,\n",
    "            bias=False,\n",
    "            output_padding=1,\n",
    "        )\n",
    "        self.dense7 = Dense(embed_dim, channels[0])\n",
    "        self.tgnorm2 = nn.GroupNorm(32, num_channels=channels[0])\n",
    "        self.tconv1 = nn.ConvTranspose2d(channels[0] + channels[0], 2, 3, stride=1)\n",
    "\n",
    "        # The swish activation function\n",
    "        self.act = lambda x: x * torch.sigmoid(x)\n",
    "\n",
    "    def forward(self, x, t):\n",
    "        # Obtain the Gaussian random feature embedding for t\n",
    "        embed = self.act(self.embed(t / 4.0))\n",
    "        # Encoding path\n",
    "        h1 = self.conv1(x.permute(0, 3, 1, 2))\n",
    "        ## Incorporate information from t\n",
    "        h1 += self.dense1(embed)\n",
    "        h1 = self.gnorm1(h1)\n",
    "        h1 = self.act(h1)\n",
    "        h2 = self.conv2(h1)\n",
    "        h2 += self.dense2(embed)\n",
    "        h2 = self.gnorm2(h2)\n",
    "        h2 = self.act(h2)\n",
    "        h3 = self.conv3(h2)\n",
    "        h3 += self.dense3(embed)\n",
    "        h3 = self.gnorm3(h3)\n",
    "        h3 = self.act(h3)\n",
    "        h4 = self.conv4(h3)\n",
    "        h4 += self.dense4(embed)\n",
    "        h4 = self.gnorm4(h4)\n",
    "        h4 = self.act(h4)\n",
    "\n",
    "        # Decoding path\n",
    "        h = self.tconv4(h4)\n",
    "        ## Skip connection from the encoding path\n",
    "        h += self.dense5(embed)\n",
    "        h = self.tgnorm4(h)\n",
    "        h = self.act(h)\n",
    "        h = self.tconv3(torch.cat([h, h3], dim=1))\n",
    "        h += self.dense6(embed)\n",
    "        h = self.tgnorm3(h)\n",
    "        h = self.act(h)\n",
    "        h = self.tconv2(torch.cat([h, h2], dim=1))\n",
    "        h += self.dense7(embed)\n",
    "        h = self.tgnorm2(h)\n",
    "        h = self.act(h)\n",
    "        h = self.tconv1(torch.cat([h, h1], dim=1))\n",
    "\n",
    "        # some scaling here by time or x may be helpful but no scaling works fine here\n",
    "        h = h.permute(0, 2, 3, 1)\n",
    "        h = h - h.mean(axis=-1, keepdims=True)\n",
    "        return h\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading Binarized Mnist Data \n",
    "\n",
    "The following code load MNIST data and create binarized version of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mkdir: cannot create directory ‘mnist’: File exists\r\n"
     ]
    }
   ],
   "source": [
    "mkdir mnist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "import os\n",
    "import joblib\n",
    "import numpy as np\n",
    "from urllib.request import urlretrieve\n",
    "\n",
    "\n",
    "def load_mnist_binarized(root):\n",
    "    datapath = os.path.join(root, \"bin-mnist\")\n",
    "    if not os.path.exists(datapath):\n",
    "        os.makedirs(datapath)\n",
    "    dataset = os.path.join(datapath, \"mnist.pkl.gz\")\n",
    "\n",
    "    if not os.path.isfile(dataset):\n",
    "\n",
    "        datafiles = {\n",
    "            \"train\": \"http://www.cs.toronto.edu/~larocheh/public/\"\n",
    "            \"datasets/binarized_mnist/binarized_mnist_train.amat\",\n",
    "            \"valid\": \"http://www.cs.toronto.edu/~larocheh/public/datasets/\"\n",
    "            \"binarized_mnist/binarized_mnist_valid.amat\",\n",
    "            \"test\": \"http://www.cs.toronto.edu/~larocheh/public/datasets/\"\n",
    "            \"binarized_mnist/binarized_mnist_test.amat\",\n",
    "        }\n",
    "        datasplits = {}\n",
    "        for split in datafiles.keys():\n",
    "            print(\"Downloading %s data...\" % (split))\n",
    "            datasplits[split] = np.loadtxt(urlretrieve(datafiles[split])[0])\n",
    "\n",
    "        joblib.dump(\n",
    "            [datasplits[\"train\"], datasplits[\"valid\"], datasplits[\"test\"]],\n",
    "            open(dataset, \"wb\"),\n",
    "        )\n",
    "\n",
    "    x_train, x_valid, x_test = joblib.load(open(dataset, \"rb\"))\n",
    "    return x_train, x_valid, x_test\n",
    "\n",
    "\n",
    "class BinMNIST(Dataset):\n",
    "    \"\"\"Binary MNIST dataset\"\"\"\n",
    "\n",
    "    def __init__(self, data, device=\"cpu\", transform=None):\n",
    "        h, w, c = 28, 28, 1\n",
    "        self.device = device\n",
    "        self.data = torch.tensor(data, dtype=torch.float).view(-1, c, h, w)\n",
    "        self.transform = transform\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        sample = self.data[idx]\n",
    "        if self.transform:\n",
    "            sample = self.transform(sample)\n",
    "        return sample.to(self.device)\n",
    "\n",
    "\n",
    "def get_binmnist_datasets(root, device=\"cpu\"):\n",
    "    x_train, x_valid, x_test = load_mnist_binarized(root)\n",
    "    # x_train = np.append(x_train, x_valid, axis=0)  # https://github.com/casperkaae/LVAE/blob/master/run_models.py (line 401)\n",
    "    return (\n",
    "        BinMNIST(x_train, device=device),\n",
    "        BinMNIST(x_valid, device=device),\n",
    "        BinMNIST(x_test, device=device),\n",
    "    )\n",
    "\n",
    "\n",
    "def binary_to_onehot(x):\n",
    "    xonehot = []\n",
    "    xonehot.append((x == 1)[..., None])\n",
    "    xonehot.append((x == 0)[..., None])\n",
    "    return torch.cat(xonehot, -1)\n",
    "\n",
    "train_set, valid_set, test_set = get_binmnist_datasets(\"./mnist\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's load training/validation/test datasets and dataset for importance sampling weights estimation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights_est_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_data_loader = DataLoader(valid_set, batch_size=batch_size, shuffle=False, num_workers=0)\n",
    "valid_datasets = []\n",
    "for x in valid_data_loader:\n",
    "    valid_datasets.append(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dl = DataLoader(test_set, batch_size=batch_size, shuffle=True, num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Global Parameters \n",
    "\n",
    "We define a few global parameters for our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of categories are 2 for binarized MNIST data\n",
    "C = 2  \n",
    "\n",
    "# device, where code will be run\n",
    "device = \"cuda\" # alternative option is \"cpu\"\n",
    "\n",
    "# setting speed_balanced does not have an effect for C=2\n",
    "# For >2 categories, setting speed_balanced flag affects the convergence speed of the forward diffusion. \n",
    "# (see Appendix A.2)\n",
    "# speed_balanced = True leads to similar convergence speed across individual univariate Jacobi diffusion processes\n",
    "# speed balanced = False leads to similar convergence speed across different categories after stick breaking transform\n",
    "\n",
    "speed_balanced = False  \n",
    "\n",
    "if speed_balanced:\n",
    "    s = 2 / (\n",
    "        torch.ones(C - 1, device=device)\n",
    "        + torch.arange(C - 1, 0, -1, device=device).float()\n",
    "    )\n",
    "else:\n",
    "    s = torch.ones(C - 1, device=device)\n",
    "        \n",
    "# Number of epochs for training\n",
    "num_epochs = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jacobi diffusion process converges to Beta stationary distribution, a univariate special case of Dirichlet distribution. Using the connection between Beta distribution and Dirichlet distribution, we construct a\n",
    "multivariate diffusion process on probability simplex that converges to Dirichlet distribution with k − 1 independent univariate Jacobi diffusion processes by a classical stick- breaking construction (see Paragraph 3.2 for more details) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "sb = UnitStickBreakingTransform()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing Importance Sampling Weights \n",
    "\n",
    "Importance sampling is often needed to stabilize the training of diffusion model with likelihood weighting, since the scores for the forward diffusion transition density functions are usually large when time is small. Importance sampling is thus used as a variance reduction technique that samples time non-uniformly during training. By sampling time points where the scale of the score is higher more often and down-weight the sample loss accordingly, the variance of the gradient can be reduced. We determine the importance sampling weight based on the scale of the scores at each time point observed empirically. The choice of using importance sampling or not or the form of importance sampling weights depends on your applications."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_time_steps = timepoints.shape[0]\n",
    "\n",
    "time_dependent_cums = torch.zeros(n_time_steps).to(device)\n",
    "time_dependent_counts = torch.zeros(n_time_steps).to(device)\n",
    "\n",
    "for i, x in enumerate(weights_est_dl):\n",
    "    x = binary_to_onehot(x.squeeze())\n",
    "    random_t = torch.randint(0, n_time_steps, (x.shape[0],))\n",
    "    order = np.random.permutation(np.arange(C))\n",
    "    \n",
    "    # There are two options for using presampled noise: \n",
    "    # First one is regular approach and second one is fast sampling (see Appendix A.4 for more info)\n",
    "    perturbed_x, perturbed_x_grad = diffusion_factory(\n",
    "        x, random_t, v_one, v_zero, v_one_loggrad, v_zero_loggrad, alpha, beta\n",
    "    )\n",
    "    # perturbed_x, perturbed_x_grad = diffusion_fast_flatdirichlet(x, random_t, v_one, v_one_loggrad)\n",
    "    \n",
    "    perturbed_x = perturbed_x.to(device)\n",
    "    perturbed_x_grad = perturbed_x_grad.to(device)\n",
    "    random_t = random_t.to(device)\n",
    "    \n",
    "    # Transform data from x space to v space, where diffusion happens\n",
    "    order = np.random.permutation(np.arange(C))\n",
    "    perturbed_v = sb._inverse(perturbed_x, prevent_nan=True).detach()\n",
    "\n",
    "    # Computing score. gx_to_gv transforms gradient in x space to gradient in v space\n",
    "    time_dependent_cums[random_t] += (\n",
    "            (perturbed_v * (1 - perturbed_v)\n",
    "                * s[(None,) * (x.ndim - 1)]\n",
    "                * gx_to_gv(perturbed_x_grad, perturbed_x, compute_gradlogdet=False)** 2\n",
    "            ).view(x.shape[0], -1).mean(dim=1).detach()\n",
    "        )\n",
    "        \n",
    "    time_dependent_counts[random_t] += 1\n",
    "    \n",
    "time_dependent_weights = time_dependent_cums / time_dependent_counts\n",
    "time_dependent_weights = time_dependent_weights / time_dependent_weights.mean()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following plot verifies that our importance sampling weights are nice. It should be monotonic decreasing curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2aabd2b98df0>]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGdCAYAAACyzRGfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAApOklEQVR4nO3df3RV5Z3v8c8+yckhiUkAgZxEAgSNP+NPsBS0QmtJ69iOLm47VpwuvF3XkUEcGJwyUqY1umpiaYfFjFSszlyKt5fiuqNOnaW2pCPE8dJekR+KYNGWiFGI8QckgfzOee4fJ2cnh4QfJyTnSc7zfq111k723uec52G3zaff/TzP9owxRgAAAEkSsN0AAADgFsIHAABIKsIHAABIKsIHAABIKsIHAABIKsIHAABIKsIHAABIKsIHAABIqnTbDThRJBLRoUOHlJOTI8/zbDcHAACcAWOMmpqaVFhYqEDg1LWNYRc+Dh06pKKiItvNAAAAA1BbW6uJEyee8pxhFz5ycnIkRRufm5truTUAAOBMNDY2qqioyP87firDLnzEbrXk5uYSPgAAGGHOZMgEA04BAEBSET4AAEBSET4AAEBSET4AAEBSET4AAEBSET4AAEBSET4AAEBSET4AAEBSET4AAEBSET4AAEBSET4AAEBSET4AAEBSDbsHyw2Vjq6IHn7hbUnS/TddrFHBNMstAgDATc5UPiLG6Ofb3tPPt72njq6I7eYAAOAsZ8JHoNcjfiPGYkMAAHCck+HDGNIHAAC2OBM+vF4/U/kAAMAed8JHr/RB5QMAAHsSCh+dnZ36h3/4BxUXFyszM1NTp07VQw89pEikZwCnMUbl5eUqLCxUZmam5syZo7179w56wxPleZ4fQKh8AABgT0Lh40c/+pEef/xxrV27Vm+//bZWrVqlH//4x3r00Uf9c1atWqXVq1dr7dq12r59u8LhsObOnaumpqZBb3yiYuM+qHwAAGBPQuHjd7/7nW655RbdfPPNmjJlir7xjW+orKxMr7/+uqToH/U1a9Zo5cqVmjdvnkpLS7VhwwY1Nzdr48aNQ9KBRMTuvFD5AADAnoTCx/XXX6///M//1DvvvCNJeuONN/Tqq6/qz/7szyRJNTU1qqurU1lZmf+eUCik2bNna9u2bf1+ZltbmxobG+NeQ8WvfIj0AQCALQmtcPr3f//3amho0MUXX6y0tDR1dXXp4Ycf1u233y5JqqurkyTl5+fHvS8/P18HDx7s9zMrKyv14IMPDqTtCWPMBwAA9iVU+Xj66af1i1/8Qhs3btTOnTu1YcMG/eQnP9GGDRvizvN6Ty1R9HbMiftiVqxYoYaGBv9VW1ubYBfOXKzyESF9AABgTUKVj+9+97u6//779a1vfUuSdPnll+vgwYOqrKzUggULFA6HJUUrIAUFBf776uvr+1RDYkKhkEKh0EDbn5BY/mG8KQAA9iRU+WhublYgEP+WtLQ0f6ptcXGxwuGwqqqq/OPt7e2qrq7WrFmzBqG5Z4cxHwAA2JdQ5ePrX/+6Hn74YU2aNEmXXXaZdu3apdWrV+s73/mOpOjtlqVLl6qiokIlJSUqKSlRRUWFsrKyNH/+/CHpQCIY8wEAgH0JhY9HH31U3//+97Vo0SLV19ersLBQd999t37wgx/45yxfvlwtLS1atGiRjhw5ohkzZmjz5s3KyckZ9MYnqmeqLekDAABbPDPMVtxqbGxUXl6eGhoalJubO6iffdVDm3W0uUO/XTZbF0w4Z1A/GwAAlyXy99uZZ7tIrHAKAMBw4Fj4iG4Z8wEAgD1OhY/YqA/GfAAAYI9T4SPAOh8AAFjnWPig8gEAgG2OhY/oluwBAIA9ToUPj8oHAADWORY+oluiBwAA9jgVPhjzAQCAfU6Fj56n2hI+AACwxanw0VP5sNwQAAAc5lT48JjtAgCAdU6FD8Z8AABgn1Pho7vwQfgAAMAip8JHgLm2AABY51T48HiqLQAA1jkVPhjzAQCAfU6Fj57KB+EDAABbnAofscoH0QMAAHscCx/RLSucAgBgj1Phw3+qbcRyQwAAcJhj4SO6ZcwHAAD2OBU+GPMBAIB9joWP6JYxHwAA2ONU+PDEU20BALDNrfDBmA8AAKxzKnz4Yz7IHgAAWONW+OjuLZUPAADscSp8xMZ8kD0AALDHrfARm+3CZFsAAKxxKnwEWOEUAADrHAsf0S1jPgAAsMep8OEx2wUAAOucCh8BxnwAAGCdU+HDf6ot2QMAAGucCh+M+QAAwD6nwgfPdgEAwD6nwkdshVNGnAIAYI9T4YMxHwAA2OdW+OjeMuYDAAB7nAofPNUWAAD7HAsf0S2VDwAA7HEsfFD5AADANqfCh6h8AABgnVPhw698WG4HAAAucyx8RLdUPgAAsMex8MGYDwAAbHMqfHixygerjAEAYI1j4YMxHwAA2OZU+GDMBwAA9jkWPni2CwAAtjkVPmLPdjFUPgAAsMat8MFsFwAArHMqfPTcdiF9AABgi1Phw59qS/YAAMAap8JHbLaLYbItAADWOBY+GPMBAIBtToWP2IBTVjgFAMAex8JHdEv2AADAHqfCB2M+AACwz7HwwZgPAABscyp8eKzzAQCAdW6Fj+4t4QMAAHucCh/cdgEAwD7Hwkd0y2wXAADscSp8xKba8lRbAADscSx8MOAUAADbnAofjPkAAMA+x8JHdMuYDwAA7HEqfDDmAwAA+5wKH/5tF8vtAADAZQmHjw8//FB/+Zd/qXPPPVdZWVm66qqrtGPHDv+4MUbl5eUqLCxUZmam5syZo7179w5qoweKAacAANiXUPg4cuSIrrvuOgWDQb300kvat2+f/vEf/1GjR4/2z1m1apVWr16ttWvXavv27QqHw5o7d66ampoGu+0JY8wHAAD2pSdy8o9+9CMVFRVp/fr1/r4pU6b4PxtjtGbNGq1cuVLz5s2TJG3YsEH5+fnauHGj7r777sFp9QCxvDoAAPYlVPl4/vnnNX36dH3zm9/UhAkTdPXVV+vJJ5/0j9fU1Kiurk5lZWX+vlAopNmzZ2vbtm39fmZbW5saGxvjXkMlECt9kD0AALAmofBx4MABrVu3TiUlJfrNb36jhQsX6m/+5m/01FNPSZLq6uokSfn5+XHvy8/P94+dqLKyUnl5ef6rqKhoIP04I4z5AADAvoTCRyQS0TXXXKOKigpdffXVuvvuu3XXXXdp3bp1cefF/sjHGGP67ItZsWKFGhoa/FdtbW2CXThzPWM+CB8AANiSUPgoKCjQpZdeGrfvkksu0fvvvy9JCofDktSnylFfX9+nGhITCoWUm5sb9xoqnmKVjyH7CgAAcBoJhY/rrrtO+/fvj9v3zjvvaPLkyZKk4uJihcNhVVVV+cfb29tVXV2tWbNmDUJzz44/5IPwAQCANQnNdvnbv/1bzZo1SxUVFfqLv/gLvfbaa3riiSf0xBNPSIreblm6dKkqKipUUlKikpISVVRUKCsrS/Pnzx+SDiSi59kupA8AAGxJKHxce+21eu6557RixQo99NBDKi4u1po1a3THHXf45yxfvlwtLS1atGiRjhw5ohkzZmjz5s3KyckZ9MYnjDEfAABY55lhVgZobGxUXl6eGhoaBn38x7/t+EB/93/e0JyLxuvn//1zg/rZAAC4LJG/34492yW6ZcApAAD2OBY+GPMBAIBtToUPjzEfAABY51j4iFU+LDcEAACHORU+WOEUAAD7HAsfrHAKAIBtToWP2NNlGHAKAIA9boUPxnwAAGCdU+GDMR8AANjnWPhgzAcAALY5FT48/6m2pA8AAGxxKnz4K5xabgcAAC5zKnywwikAAPY5Fj66x3xELDcEAACHORU+YrNdqHsAAGCPY+GDp9oCAGCbU+GDMR8AANjnVvgQ63wAAGCbU+EjwDofAABY51b4CPBsFwAAbHMrfDDmAwAA65wKH2LMBwAA1jkVPnrW+SB9AABgi2PhgxVOAQCwzanwwVNtAQCwz6nw4Vc+yB4AAFjjVPjwGPMBAIB1ToUPKh8AANjnVPhgzAcAAPY5FT56nmpruSEAADjMsfAR3bLCKQAA9jgVPjzGfAAAYJ1b4aN7S+UDAAB7nAofgZ65tgAAwBInwweVDwAA7HEqfHj+gFO77QAAwGWOhg/SBwAAtjgVPvx1Piy3AwAAl7kZPqh8AABgjVPhgzEfAADY52j4IH0AAGCLU+GDZ7sAAGCfk+FDYtwHAAC2OBU+vF4/M+4DAAA7nAofVD4AALDPqfDh9eotlQ8AAOxwKnz0rnww4wUAADucCh+9x3yQPQAAsMOp8BE35oNF1gEAsMKp8NErezDmAwAAS5wKH4z5AADAPqfCR+/Kh4nYawcAAC5zKnww5gMAAPscCx89PzPmAwAAO5wKHx5jPgAAsM6p8CH1jPsgewAAYIdz4SM27oNnuwAAYIeD4SO6ZcwHAAB2OBc+vO5F1hnzAQCAHe6Fj9iYD7vNAADAWc6Fj9iYjwj3XQAAsMLB8BHdctcFAAA7nAsfsbU+GPMBAIAdDoaP6JboAQCAHc6FjwCVDwAArHIufPSscEr4AADABufCR0/lw3JDAABwlIPhI7ql8AEAgB3OhQ9muwAAYJdz4SNW+ejivgsAAFY4Fz7SA9EuEz4AALDjrMJHZWWlPM/T0qVL/X3GGJWXl6uwsFCZmZmaM2eO9u7de7btHDTpadHSR2ckYrklAAC4acDhY/v27XriiSd0xRVXxO1ftWqVVq9erbVr12r79u0Kh8OaO3eumpqazrqxgyG9+75LRxeVDwAAbBhQ+Dh27JjuuOMOPfnkkxozZoy/3xijNWvWaOXKlZo3b55KS0u1YcMGNTc3a+PGjYPW6LMRTIt2uZPwAQCAFQMKH/fcc49uvvlmffnLX47bX1NTo7q6OpWVlfn7QqGQZs+erW3btvX7WW1tbWpsbIx7DaXYbZcObrsAAGBFeqJv2LRpk3bu3Knt27f3OVZXVydJys/Pj9ufn5+vgwcP9vt5lZWVevDBBxNtxoDFBpxS+QAAwI6EKh+1tbVasmSJfvGLX2jUqFEnPS+2lkaMMabPvpgVK1aooaHBf9XW1ibSpIQFYwNOu6h8AABgQ0KVjx07dqi+vl7Tpk3z93V1demVV17R2rVrtX//fknRCkhBQYF/Tn19fZ9qSEwoFFIoFBpI2wckVvnoYKotAABWJFT5uPHGG7Vnzx7t3r3bf02fPl133HGHdu/eralTpyocDquqqsp/T3t7u6qrqzVr1qxBb/xApFP5AADAqoQqHzk5OSotLY3bl52drXPPPdffv3TpUlVUVKikpEQlJSWqqKhQVlaW5s+fP3itPgvMdgEAwK6EB5yezvLly9XS0qJFixbpyJEjmjFjhjZv3qycnJzB/qoB8df5YLYLAABWnHX42Lp1a9zvnuepvLxc5eXlZ/vRQ4LKBwAAdrn3bJfYOh+M+QAAwAr3wkdsnQ9muwAAYIVz4YN1PgAAsMu58NFz24XKBwAANrgXPvzbLlQ+AACwwbnw0XPbhcoHAAA2OBc+0run2nLbBQAAO5wLH8HuRca47QIAgB3OhQ8qHwAA2OVg+GCqLQAANjkXPoIsMgYAgFXOhQ+WVwcAwC4HwwcPlgMAwCbnwgezXQAAsMu58MFsFwAA7HIufPgrnFL5AADACufCR+zZLlQ+AACww73wwTofAABY5Vz46LntQuUDAAAbnAsf3HYBAMAu98IHt10AALDKufARTGN5dQAAbHIufKQHWF4dAACbnAsfQZZXBwDAKufCRzqLjAEAYJV74YPZLgAAWOVc+Agy2wUAAKucCx/+g+WY7QIAgBXOhY9ggMoHAAA2ORc+YpWPiJEiVD8AAEg6B8OH5//cwYwXAACSzrnwEQz0dJm1PgAASD7nwkfvygfhAwCA5HMvfAS47QIAgE3OhQ/P8/wAQuUDAIDkcy58SD23Xni4HAAAyedk+IgNOu1kqi0AAEnnZPhIZ4l1AACscTR88HA5AABscTJ8+EusM9sFAICkczJ8UPkAAMAeR8MHYz4AALDFyfDBbBcAAOxxMnywzgcAAPY4Gj66Kx+M+QAAIOmcDB8ZVD4AALDGyfAxKpgmSWrt7LLcEgAA3ONk+MjsDh8t7VQ+AABINjfDR0Z3+Oig8gEAQLI5GT5GpXffdiF8AACQdE6GD7/y0U74AAAg2ZwMH7EBp9x2AQAg+ZwMH5mEDwAArHEzfGREu93KbRcAAJLOzfBB5QMAAGucDB+M+QAAwB4nwwezXQAAsMfN8BFknQ8AAGxxPHywvDoAAMnmZPgIMeYDAABrnAwfzHYBAMAeN8NH94BT1vkAACD53AwfVD4AALDG6fDRGTHq6GLQKQAAyeRk+BiV0dNtqh8AACSXk+EjIy2ggBf9mXEfAAAkl5Phw/M8xn0AAGCJk+FD6rXEOuEDAICkcjZ8+A+X47YLAABJ5Xz4YIl1AACSK6HwUVlZqWuvvVY5OTmaMGGCbr31Vu3fvz/uHGOMysvLVVhYqMzMTM2ZM0d79+4d1EYPBh4uBwCAHQmFj+rqat1zzz36/e9/r6qqKnV2dqqsrEzHjx/3z1m1apVWr16ttWvXavv27QqHw5o7d66ampoGvfFngwGnAADYkZ7Iyb/+9a/jfl+/fr0mTJigHTt26IYbbpAxRmvWrNHKlSs1b948SdKGDRuUn5+vjRs36u677x68lp+lURmM+QAAwIazGvPR0NAgSRo7dqwkqaamRnV1dSorK/PPCYVCmj17trZt23Y2XzXoMoPRrlP5AAAguRKqfPRmjNGyZct0/fXXq7S0VJJUV1cnScrPz487Nz8/XwcPHuz3c9ra2tTW1ub/3tjYONAmJSST2S4AAFgx4MrH4sWL9eabb+qXv/xln2Oe58X9bozpsy+msrJSeXl5/quoqGigTUpIbmZQktTY2pGU7wMAAFEDCh/33nuvnn/+eW3ZskUTJ07094fDYUk9FZCY+vr6PtWQmBUrVqihocF/1dbWDqRJCcvrDh9HmwkfAAAkU0LhwxijxYsX69lnn9XLL7+s4uLiuOPFxcUKh8Oqqqry97W3t6u6ulqzZs3q9zNDoZByc3PjXskQCx8NLYQPAACSKaExH/fcc482btyoX/3qV8rJyfErHHl5ecrMzJTneVq6dKkqKipUUlKikpISVVRUKCsrS/Pnzx+SDgyUX/kgfAAAkFQJhY9169ZJkubMmRO3f/369brzzjslScuXL1dLS4sWLVqkI0eOaMaMGdq8ebNycnIGpcGDZXRWhiQqHwAAJFtC4cMYc9pzPM9TeXm5ysvLB9qmpIhVPhoJHwAAJJWzz3bpGXDabrklAAC4xdnwMTqrZ8BpJHL6ig4AABgczoaPWOUjYqRj7Z2WWwMAgDucDR+jgmkKpUe738BaHwAAJI2z4UNirQ8AAGwgfIjwAQBAMjkdPnoPOgUAAMnhdPjg+S4AACSf4+GDVU4BAEg2x8NH7PkuLDQGAECyOB0+xnSP+fjsGOEDAIBkcTp85OeOkiTVN7VZbgkAAO5wOnxMyA1Jkj5qbLXcEgAA3OF0+IhVPj6m8gEAQNI4HT4m5EQrH58eb1d7Z8RyawAAcIPT4WNMVoaCaZ4k6eNjVD8AAEgGp8NHIOBpQk701gvjPgAASA6nw4fUM+i0nvABAEBSED66x30w3RYAgORwPnzEZrxw2wUAgOQgfPjhg8oHAADJQPjoDh+HjrZYbgkAAG5wPnwUj8uSJNV8ctxySwAAcIPz4WPquHMkSYcbWnW8rdNyawAASH3Oh48x2Rkam50hieoHAADJ4Hz4kKTzx2dLkv708THLLQEAIPURPtRz6+VPH1P5AABgqBE+JJ0/IVr5OEDlAwCAIUf4EJUPAACSifAh6cL8HEnSn+qPqbMrYrk1AACkNsKHpIljMpWdkab2rggzXgAAGGKED0mBgKeLwtHqx9t1TZZbAwBAaiN8dLu4IFeS9IfDjZZbAgBAaiN8dLuku/LxByofAAAMKcJHt1jl420qHwAADCnCR7eLwzkKeNFnvHzU2Gq7OQAApCzCR7ecUUFdFI5WP15/74jl1gAAkLoIH71cO2WMJOn1g59ZbgkAAKmL8NHL9CljJVH5AABgKBE+eolVPvYdbtSxtk7LrQEAIDURPnopyMvU5HOz1BUx2vbHT2w3BwCAlET4OMGcC8dLkra+87HllgAAkJoIHyeYc9EESdLWP9TLGGO5NQAApB7Cxwk+P/VchdIDOtTQqrcPs9opAACDjfBxgsyMNH2xu/rx9Pb3LbcGAIDUQ/jox/wZkyRJz+78UM3tzHoBAGAwET76cf0F4zT53Cw1tXXqP944ZLs5AACkFMJHPwIBT/M/F61+/O//x60XAAAGE+HjJL4xbaIy0gJ684MGvfnBUdvNAQAgZRA+TuLcc0K66fKwJOl/vlpjuTUAAKQOwscp3PWFqZKk/3jzsGo/a7bcGgAAUgPh4xRKz8vTF0rGqStitLrqHdvNAQAgJRA+TuO+sosU8KTndn2o3+77yHZzAAAY8Qgfp3FV0Wj9j+7bL3/3b2/o/U+5/QIAwNkgfJyBZXMv1JUT83S0uUN/9b9e1/E2Fh4DAGCgCB9nYFQwTY9/e5rGnRPSH+qa9N1/e4OHzgEAMECEjzNUkJepn337GgXTPL24p04/3fJH200CAGBEInwkYNrksXrollJJ0k82v6Onfvee3QYBADACET4SdPvnJumvbogOQP3Br/bqyVcOWG4RAAAjC+FjAFbcdLEWzTlfkvTwi2/rr556XYeOtlhuFQAAIwPhYwA8z9Pyr16s5V+9SGkBT5v3faSvrHlFv9r9oe2mAQAw7BE+zsKiORfopSVf0FVFo9XU2qklm3brzvWvacfBz2w3DQCAYcszw2zOaGNjo/Ly8tTQ0KDc3FzbzTkjnV0Rrd3yRz368h/VFYn+c84oHqtFX7xAN5SMk+d5llsIAMDQSuTvN+FjEB34+Jh+Vn1Az+76QB1d0X/W0vNytWjOBfrKZWGlBQghAIDURPiw7HBDi558pUa/fO19tXR0SZKmjs/Wf7tmor5yWb4umJBjuYUAAAwuwscw8dnxdv38/9bo59veU2Nrz5LsU8dn64aS8fr81LGac9EEjQqmWWwlAABnj/AxzDS1dug/3jis3+yt07Y/feLfkpGk7Iw0XTN5jK6dMlbTp4zR1UVjlJlBGAEAjCyEj2GsqbVD1e98rO01n2nzvo90uKE17nh6wFPpeXm6dsoYXVU0RheFz9GUc7OVnsbEJADA8EX4GCEiEaP9HzVp+3ufaft7R7S95jPVNbb2OS8jLaDzJ5yjC/PP0fnjz1HxuGz/lR1Kt9ByAADiET5GKGOMPjjSotcPRsPI3kONevejJjW3d530Pfm5IU0em62C0aMUzhulwrxMhfNGqSAv+vu47JACzLIBAAwxwkcKiUSMPjzaoj/UNemdj5pU88lx//XZ8fbTvj+Y5mlCTjSMFIzOVH5OSGOyMzQ6K6jRmd3brKBGZ2VodGZQWRlprEsCAEjYsAgfjz32mH784x/r8OHDuuyyy7RmzRp94QtfOO37CB9n7mhzu2o+Oa7aIy2qa2jR4YZW1TW06lBDq+oaWlTf1KZEr24wzVNeLJRkRoNJXmaGxnSHlLzukJKXGdQ5o9J1Tihd2aF0ZWekKTuUriBjUwDASYn8/R6SAQNPP/20li5dqscee0zXXXedfvazn+mmm27Svn37NGnSpKH4SieNzsrQ1ZMydPWkMf0e7+iK6OOmNh1uaNXhhhbVNbTqo8ZWHWnu0NHmDjW0tOtoc4eOtnToaHO7OrqMOrqMPjnWpk+OtQ2oTRnpge5AkqbsjGg4yQqlKyuYplHBgEYF03q9un9PD/Td1/0KpnkKpQcUTAsoo3sbTAv4+1i4DQBGniGpfMyYMUPXXHON1q1b5++75JJLdOutt6qysvKU76XyYYcxRi0dXdEw0hwNI9FQ0qGjLe1qaO75ORpcOnSsrVPH2zp1vK1L7V0RK+1OC3gKpnnK6A4nGWkBBWNhpfvnUFpAwfToOcHe53XvTw8ElB7wlJbmRbex3wNe/Datv/2BXsdP3B99CGHA8xTwpIDnyeve+vsCpz7u9ToWPbfneM+5Pe/llhkAW6xWPtrb27Vjxw7df//9cfvLysq0bdu2Pue3tbWpra3n/2U3NjYOdpNwBjzPU1ZGurIy0lU4OjPh97d3RqJBpD0aRnqCSaeOtXWqtaNLrR2R6Laz18/+9sT90Z87uiJq74qoozOiji7TJ+R0RYy6IkatHXbCz3BzYiDpE2wCJwk2nqdAoFewkSRP8hQ9z+v1+Z6inyX1hB0vduzE491v8o+r531er89Tr/P7fsdpvrOfNqr7fM//vecz/O+M+4c75a9x33uyc07MfX2Pn/r9/X3pie08/Xck+P5+s+rgfudgGYpcPVRRfST8n4BgmqeVN19q7fsHPXx88skn6urqUn5+ftz+/Px81dXV9Tm/srJSDz744GA3A0mWkR5QRnqGxmRnDOn3GGP8ENLRGQ0m7Z29Q4pRe1eX2jvjz+noPi9+n1F7Z0RdEaPOiFFXJNK97f696yT7e5/fdfL9EWMUMVLEGJnubVckus+Y/o/7+yI9Pyf27yN1GaPo/KhhNZYcwDCSkR5IrfARc2LyM8b0mwZXrFihZcuW+b83NjaqqKhoqJqFEc7zPGWke8pID0gh261JDtMrpJw8yPQ9fmKIiR7rdW6kJ/h0+e/teZ9RNMyYWIgx6rPP+PtMT9TpPm5Mz3H1Oid6o/fE9/f/mfLPP/Vnqt/397zH/8be7fQ/o++/d59rcLr39Dl+6uDX9/39fOdpv+PUn3G6G+r99nOIv3OghuRjh6ixQ/GpQ9FU20swDHr4GDdunNLS0vpUOerr6/tUQyQpFAopFHLkrwgwAJ7nKc2T0oasSAwAyTXo8yIzMjI0bdo0VVVVxe2vqqrSrFmzBvvrAADACDMkt12WLVumb3/725o+fbpmzpypJ554Qu+//74WLlw4FF8HAABGkCEJH7fddps+/fRTPfTQQzp8+LBKS0v14osvavLkyUPxdQAAYARheXUAAHDWEvn7zVrYAAAgqQgfAAAgqQgfAAAgqQgfAAAgqQgfAAAgqQgfAAAgqQgfAAAgqQgfAAAgqQgfAAAgqYZkefWzEVtwtbGx0XJLAADAmYr93T6ThdOHXfhoamqSJBUVFVluCQAASFRTU5Py8vJOec6we7ZLJBLRoUOHlJOTI8/zBu1zGxsbVVRUpNra2pR8Zkyq909K/T6mev+k1O9jqvdPSv0+pnr/pKHrozFGTU1NKiwsVCBw6lEdw67yEQgENHHixCH7/Nzc3JT9D5SU+v2TUr+Pqd4/KfX7mOr9k1K/j6neP2lo+ni6ikcMA04BAEBSET4AAEBSORM+QqGQHnjgAYVCIdtNGRKp3j8p9fuY6v2TUr+Pqd4/KfX7mOr9k4ZHH4fdgFMAAJDanKl8AACA4YHwAQAAkorwAQAAkorwAQAAksqJ8PHYY4+puLhYo0aN0rRp0/Rf//Vftps0YOXl5fI8L+4VDof948YYlZeXq7CwUJmZmZozZ4727t1rscWn9sorr+jrX/+6CgsL5Xme/v3f/z3u+Jn0p62tTffee6/GjRun7Oxs/fmf/7k++OCDJPbi1E7XxzvvvLPPNf385z8fd85w7mNlZaWuvfZa5eTkaMKECbr11lu1f//+uHNG8nU8k/6N9Gu4bt06XXHFFf6iUzNnztRLL73kHx/J1086ff9G+vU7UWVlpTzP09KlS/19w+4amhS3adMmEwwGzZNPPmn27dtnlixZYrKzs83BgwdtN21AHnjgAXPZZZeZw4cP+6/6+nr/+COPPGJycnLMM888Y/bs2WNuu+02U1BQYBobGy22+uRefPFFs3LlSvPMM88YSea5556LO34m/Vm4cKE577zzTFVVldm5c6f54he/aK688krT2dmZ5N7073R9XLBggfnqV78ad00//fTTuHOGcx+/8pWvmPXr15u33nrL7N6929x8881m0qRJ5tixY/45I/k6nkn/Rvo1fP75580LL7xg9u/fb/bv32++973vmWAwaN566y1jzMi+fsacvn8j/fr19tprr5kpU6aYK664wixZssTfP9yuYcqHj8997nNm4cKFcfsuvvhic//991tq0dl54IEHzJVXXtnvsUgkYsLhsHnkkUf8fa2trSYvL888/vjjSWrhwJ34h/lM+nP06FETDAbNpk2b/HM+/PBDEwgEzK9//euktf1MnSx83HLLLSd9z0jrY319vZFkqqurjTGpdx1P7J8xqXcNjTFmzJgx5l/+5V9S7vrFxPpnTOpcv6amJlNSUmKqqqrM7Nmz/fAxHK9hSt92aW9v144dO1RWVha3v6ysTNu2bbPUqrP37rvvqrCwUMXFxfrWt76lAwcOSJJqampUV1cX199QKKTZs2ePyP6eSX927Nihjo6OuHMKCwtVWlo6ovq8detWTZgwQRdeeKHuuusu1dfX+8dGWh8bGhokSWPHjpWUetfxxP7FpMo17Orq0qZNm3T8+HHNnDkz5a7fif2LSYXrd8899+jmm2/Wl7/85bj9w/EaDrsHyw2mTz75RF1dXcrPz4/bn5+fr7q6OkutOjszZszQU089pQsvvFAfffSRfvjDH2rWrFnau3ev36f++nvw4EEbzT0rZ9Kfuro6ZWRkaMyYMX3OGSnX+KabbtI3v/lNTZ48WTU1Nfr+97+vL33pS9qxY4dCodCI6qMxRsuWLdP111+v0tJSSal1Hfvrn5Qa13DPnj2aOXOmWltbdc455+i5557TpZde6v/hGenX72T9k1Lj+m3atEk7d+7U9u3b+xwbjv8dTOnwEeN5Xtzvxpg++0aKm266yf/58ssv18yZM3X++edrw4YN/gCpVOqvNLD+jKQ+33bbbf7PpaWlmj59uiZPnqwXXnhB8+bNO+n7hmMfFy9erDfffFOvvvpqn2OpcB1P1r9UuIYXXXSRdu/eraNHj+qZZ57RggULVF1d7R8f6dfvZP279NJLR/z1q62t1ZIlS7R582aNGjXqpOcNp2uY0rddxo0bp7S0tD6prb6+vk8CHKmys7N1+eWX69133/VnvaRKf8+kP+FwWO3t7Tpy5MhJzxlpCgoKNHnyZL377ruSRk4f7733Xj3//PPasmWLJk6c6O9Plet4sv71ZyRew4yMDF1wwQWaPn26KisrdeWVV+qf/umfUub6nax//Rlp12/Hjh2qr6/XtGnTlJ6ervT0dFVXV+uf//mflZ6e7rdxOF3DlA4fGRkZmjZtmqqqquL2V1VVadasWZZaNbja2tr09ttvq6CgQMXFxQqHw3H9bW9vV3V19Yjs75n0Z9q0aQoGg3HnHD58WG+99daI7LMkffrpp6qtrVVBQYGk4d9HY4wWL16sZ599Vi+//LKKi4vjjo/063i6/vVnpF3D/hhj1NbWNuKv38nE+tefkXb9brzxRu3Zs0e7d+/2X9OnT9cdd9yh3bt3a+rUqcPvGg76ENZhJjbV9l//9V/Nvn37zNKlS012drZ57733bDdtQO677z6zdetWc+DAAfP73//efO1rXzM5OTl+fx555BGTl5dnnn32WbNnzx5z++23D+uptk1NTWbXrl1m165dRpJZvXq12bVrlz8V+kz6s3DhQjNx4kTz29/+1uzcudN86UtfGlZT4E7Vx6amJnPfffeZbdu2mZqaGrNlyxYzc+ZMc955542YPv71X/+1ycvLM1u3bo2bqtjc3OyfM5Kv4+n6lwrXcMWKFeaVV14xNTU15s033zTf+973TCAQMJs3bzbGjOzrZ8yp+5cK168/vWe7GDP8rmHKhw9jjPnpT39qJk+ebDIyMsw111wTN0VupInNzQ4Gg6awsNDMmzfP7N271z8eiUTMAw88YMLhsAmFQuaGG24we/bssdjiU9uyZYuR1Oe1YMECY8yZ9aelpcUsXrzYjB071mRmZpqvfe1r5v3337fQm/6dqo/Nzc2mrKzMjB8/3gSDQTNp0iSzYMGCPu0fzn3sr2+SzPr16/1zRvJ1PF3/UuEafuc73/H/N3L8+PHmxhtv9IOHMSP7+hlz6v6lwvXrz4nhY7hdQ88YYwa/ngIAANC/lB7zAQAAhh/CBwAASCrCBwAASCrCBwAASCrCBwAASCrCBwAASCrCBwAASCrCBwAASCrCBwAASCrCBwAASCrCBwAASCrCBwAASKr/D9wQfqorgpsNAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.plot(np.arange(1, n_time_steps + 1), time_dependent_weights.cpu())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code trains the model and do validation check every 10 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "#the score loss is computed in the v-space\n",
    "def loss_fn(score, perturbed_x_grad, perturbed_x, important_sampling_weights=None):\n",
    "    perturbed_v = sb._inverse(perturbed_x, prevent_nan=True).detach()\n",
    "    if important_sampling_weights is not None:\n",
    "        important_sampling_weights = 1/important_sampling_weights[\n",
    "                    (...,) + (None,) * (x.ndim - 1)]\n",
    "    else:\n",
    "        important_sampling_weights = 1\n",
    "    loss = torch.mean(\n",
    "            torch.mean(\n",
    "                important_sampling_weights\n",
    "                * s[(None,) * (x.ndim - 1)]\n",
    "                * perturbed_v * (1 - perturbed_v)\n",
    "                * (gx_to_gv(\n",
    "                        score, perturbed_x, create_graph=True, compute_gradlogdet=False\n",
    "                    ) - gx_to_gv(perturbed_x_grad, perturbed_x, compute_gradlogdet=False)\n",
    "                  ) ** 2,\n",
    "                dim=(1))\n",
    "        )\n",
    "    return loss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "48c309a642f242db938615bbe9a9a43c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Loss: 0.419345\n",
      "Average Loss: 0.130004\n",
      "Average Loss: 0.123888\n",
      "Average Loss: 0.119601\n",
      "Average Loss: 0.119123\n"
     ]
    }
   ],
   "source": [
    "torch.set_default_dtype(torch.float32)\n",
    "\n",
    "# Defining a model\n",
    "score_model = ScoreNet(channels=[64, 128, 256, 512], embed_dim=512)\n",
    "score_model = score_model.to(device)\n",
    "score_model.train()\n",
    "\n",
    "# Defining optimizer\n",
    "lr = 5e-4\n",
    "optimizer = Adam(score_model.parameters(), lr=lr, weight_decay=1e-10)\n",
    "\n",
    "timepoints = timepoints.cuda()\n",
    "\n",
    "tqdm_epoch = tqdm.notebook.trange(num_epochs)\n",
    "for epoch in tqdm_epoch:\n",
    "    avg_loss = 0.0\n",
    "    num_items = 0\n",
    "\n",
    "    for x in training_dl:\n",
    "        x = binary_to_onehot(x.squeeze())\n",
    "        random_t = torch.LongTensor(\n",
    "            np.random.choice(\n",
    "                np.arange(n_time_steps),\n",
    "                size=x.shape[0],\n",
    "                p=(\n",
    "                    torch.sqrt(time_dependent_weights)\n",
    "                    / torch.sqrt(time_dependent_weights).sum()\n",
    "                )\n",
    "                .cpu()\n",
    "                .detach()\n",
    "                .numpy(),\n",
    "            )\n",
    "        ).to(device)\n",
    "        \n",
    "        # Similarly to computing importance sampling weights, there are two options \n",
    "        perturbed_x, perturbed_x_grad = diffusion_factory(\n",
    "            x, random_t, v_one, v_zero, v_one_loggrad, v_zero_loggrad, alpha, beta\n",
    "        )\n",
    "        # perturbed_x, perturbed_x_grad = diffusion_fast_flatdirichlet(x, random_t, v_one, v_one_loggrad)\n",
    "        \n",
    "        perturbed_x = perturbed_x.to(device)\n",
    "        perturbed_x_grad = perturbed_x_grad.to(device)\n",
    "        random_t = random_t.to(device)\n",
    "        random_timepoints = timepoints[random_t]\n",
    "        \n",
    "        # Doing score estimation via neural network\n",
    "        score = score_model(perturbed_x, random_timepoints)\n",
    "        \n",
    "        # Computing loss function\n",
    "        loss = loss_fn(score, perturbed_x_grad, perturbed_x, \n",
    "                       important_sampling_weights=(torch.sqrt(time_dependent_weights))[random_t])\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        avg_loss += loss.item() * x.shape[0]\n",
    "        num_items += x.shape[0]\n",
    "\n",
    "    # Print the averaged training loss so far.\n",
    "    tqdm_epoch.set_description(\"Average Loss: {:5f}\".format(avg_loss / num_items))\n",
    "\n",
    "    # Doing validation check every 10 epochs.\n",
    "    if epoch % 10 == 0:\n",
    "        valid_avg_loss = 0.0\n",
    "        valid_num_items = 0\n",
    "        \n",
    "        for x in valid_datasets:\n",
    "            \n",
    "            x = binary_to_onehot(x.squeeze())\n",
    "            random_t = torch.LongTensor(\n",
    "                np.random.choice(\n",
    "                    np.arange(n_time_steps),\n",
    "                    size=x.shape[0],\n",
    "                    p=(\n",
    "                        torch.sqrt(time_dependent_weights)\n",
    "                        / torch.sqrt(time_dependent_weights).sum()\n",
    "                    ).cpu().detach().numpy(),\n",
    "                )\n",
    "            ).to(device)\n",
    "            \n",
    "            perturbed_x, perturbed_x_grad = diffusion_factory(\n",
    "                x, random_t, v_one, v_zero, v_one_loggrad, v_zero_loggrad, alpha, beta\n",
    "            )\n",
    "            # perturbed_x, perturbed_x_grad = diffusion_fast_flatdirichlet(x, random_t, v_one, v_one_loggrad)\n",
    "            \n",
    "            perturbed_x = perturbed_x.to(device)\n",
    "            perturbed_x_grad = perturbed_x_grad.to(device)\n",
    "            random_t = random_t.to(device)\n",
    "            random_timepoints = timepoints[random_t]\n",
    "\n",
    "            score = score_model(perturbed_x, random_timepoints)            \n",
    "            loss = loss_fn(score, perturbed_x_grad, perturbed_x, \n",
    "                       important_sampling_weights=(torch.sqrt(time_dependent_weights))[random_t])\n",
    "\n",
    "            valid_avg_loss += loss.item() * x.shape[0]\n",
    "            valid_num_items += x.shape[0]\n",
    "\n",
    "        print(\"Average Loss: {:5f}\".format(valid_avg_loss / valid_num_items))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sampling Examples from Dataset. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's sample a few examples from the model by using simple Euler-Maruyama sampler. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100/100 [00:00<00:00, 273.55it/s]\n"
     ]
    }
   ],
   "source": [
    "# generate samples from trained model\n",
    "torch.set_default_dtype(torch.float32)\n",
    "score_model.eval()\n",
    "\n",
    "device = 'cuda' \n",
    "\n",
    "sample_batch_size = 64 \n",
    "sampler = Euler_Maruyama_sampler ## Generate samples using the specified sampler.\n",
    "\n",
    "samples = sampler(score_model, (28, 28, 2),\n",
    "                        batch_size=sample_batch_size,\n",
    "                        max_time= 4,\n",
    "                        min_time=0.01, \n",
    "                        num_steps=100, \n",
    "                        eps=1e-5,\n",
    "                        device=device)\n",
    "\n",
    "samples = samples.clamp(0.0, 1.0)\n",
    "sample_grid = make_grid(samples[:,None, :,:,0].detach().cpu(), nrow=int(np.sqrt(sample_batch_size)))\n",
    "\n",
    "plt.figure(figsize=(6,6))\n",
    "plt.axis('off')\n",
    "plt.imshow(sample_grid.permute(1, 2, 0).cpu(), vmin=0., vmax=1.)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also propose technique called **time dialation** to improve sample quality (see Appendix A.5 and B.9). \n",
    "\n",
    "Comparing to unbiasedly sample from the learned model distribution, it is often desirable to sample near the high probability density regions, which often corresponds to higher quality samples in suitable application. Time dilation is applicable to reverse diffusion sampling without modifying the score model, when a flat distribution such as the flat Dirichlet distribution is the stationary distribution. Our sampler implementation support time dilation technique out-of-box.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 275/275 [00:00<00:00, 308.14it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#generate samples with time dilation\n",
    "\n",
    "samples = sampler(score_model,\n",
    "                        (28,28,2),\n",
    "                        batch_size=sample_batch_size,\n",
    "                        max_time= 4,\n",
    "                        min_time=0.01,\n",
    "                        num_steps=100,\n",
    "                        time_dilation=8,\n",
    "                        time_dilation_start_time=1,\n",
    "                        eps=1e-5,\n",
    "                        device=device)\n",
    "\n",
    "## Sample visualization.\n",
    "samples = samples.clamp(0.0, 1.0)\n",
    "sample_grid = make_grid(samples[:,None, :,:,0].detach().cpu(), nrow=int(np.sqrt(sample_batch_size)))\n",
    "\n",
    "plt.figure(figsize=(6,6))\n",
    "plt.axis('off')\n",
    "plt.imshow(sample_grid.permute(1, 2, 0).cpu(), vmin=0., vmax=1.)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing Negative Log Likelihood (ELBO) in Discrete Space\n",
    "\n",
    "We can estimate likelihood using probability flow ODE. Our formulation allows both computing the likelihood from\n",
    "the continuous distribution over the simplex, and computing a variation lower-bound of the likelihood of discrete data. The ELBO formulation is chosen so that the diffusion model training will also minimize the variational gap of this ELBO, which reduces to the KL divergence between the forward diffusion density and the reverse diffusion density up to a constant when minimum time is close to zero. The following code estimates ELBO based on test data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "# compute NLL (ELBO) in discrete space\n",
    "diffusion_factory_fn = lambda x, time_inds : diffusion_factory(x, time_inds, v_one, v_zero,\n",
    "                                        v_one_loggrad, v_zero_loggrad, alpha, beta)\n",
    "\n",
    "def ELBO(x, score_model, diffusion_factory_fn, min_time, max_time, device=\"cuda\", elbo_only=True):\n",
    "    perturbed_x, _ = diffusion_factory_fn(x.cpu(), torch.zeros(x.shape[0]).long())\n",
    "    perturbed_x = perturbed_x.to(device)\n",
    "    x = x.to(device)\n",
    "    v = sb._inverse(x, prevent_nan=False)\n",
    "    perturbed_v = sb._inverse(perturbed_x, prevent_nan=False)\n",
    "\n",
    "    z, loglik = ode_likelihood(\n",
    "        perturbed_v, score_model,\n",
    "        eps=1e-5, min_time=min_time, max_time=max_time, device=device,\n",
    "        alpha=None, beta=None, speed_balanced=speed_balanced)\n",
    "    N = np.prod(x.shape[1:-1])\n",
    "    loglik = loglik / N\n",
    "\n",
    "    loglikx = (torch.log(perturbed_x) * (x == 1)).sum(-1).mean()\n",
    "\n",
    "    torch.set_default_dtype(torch.float64)\n",
    "\n",
    "    qlog = jacobi_diffusion_density(\n",
    "        v.double(), perturbed_v.double(), min_time,\n",
    "        alpha.to(device), beta.to(device),\n",
    "        order=1000,\n",
    "        speed_balanced=speed_balanced,\n",
    "    ).log()\n",
    "    \n",
    "    for i, (a, b) in enumerate(zip(alpha.to(device), beta.to(device))):\n",
    "        B = Beta(a, b)\n",
    "        nanmask = torch.isnan(qlog[..., i])\n",
    "        qlog[..., i][nanmask] = B.log_prob(perturbed_v[..., i][nanmask].double())\n",
    "        \n",
    "    qlog = (qlog.sum(-1) + sb.log_abs_det_jacobian(perturbed_v)).mean().float()\n",
    "    torch.set_default_dtype(torch.float32)\n",
    "\n",
    "    elbo = loglik + loglikx - qlog\n",
    "    if elbo_only:\n",
    "        return elbo\n",
    "    else:\n",
    "        return elbo, loglik, loglikx, qlog\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "score_model.cuda()\n",
    "score_model.eval()\n",
    "\n",
    "all_bpds = 0.0\n",
    "all_items = 0\n",
    "min_time = timepoints[0].item()\n",
    "max_time = timepoints[-1].item()\n",
    "\n",
    "\n",
    "\n",
    "# note that as the NLL estimate used the stochastic Huchinson's trace estimator\n",
    "# it generally requires multiple passes to obtain a stable estimate\n",
    "for x in test_dl:\n",
    "    x = binary_to_onehot(x).squeeze()\n",
    "    \n",
    "    elbo = ELBO(x, score_model, diffusion_factory_fn, min_time, max_time)\n",
    "    bpd = -(elbo.cpu().detach().numpy()) / np.log(2)\n",
    "    all_bpds += bpd.sum()\n",
    "    all_items += bpd.shape[0]\n",
    "    print(\"Average bits: {:5f}\".format(all_bpds / all_items))\n",
    "    print(\"Average nats: {:5f}\".format(all_bpds / all_items * np.log(2)))\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch_ml",
   "language": "python",
   "name": "pytorch_ml"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.15"
  },
  "nteract": {
   "version": "0.28.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}