diffusion-models.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b495393e",
   "metadata": {
    "_cell_guid": "23592fb4-51f6-41bb-9130-40c25fe8319e",
    "_uuid": "d547bb4a-b3d3-48b1-81ef-2945a6809c63",
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2022-10-16T14:39:00.752275Z",
     "iopub.status.busy": "2022-10-16T14:39:00.751589Z",
     "iopub.status.idle": "2022-10-16T14:39:02.732938Z",
     "shell.execute_reply": "2022-10-16T14:39:02.732002Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "papermill": {
     "duration": 1.9881,
     "end_time": "2022-10-16T14:39:02.735456",
     "exception": false,
     "start_time": "2022-10-16T14:39:00.747356",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import torchvision\n",
    "from torchvision.transforms import transforms\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "def plotImages(img):\n",
    "    plt.figure(figsize=(32,32))\n",
    "    plt.imshow(torch.cat([\n",
    "        torch.cat([i for i in img.cpu()], dim=-1)\n",
    "    ], dim = -2).permute(1, 2, 0).cpu())\n",
    "    plt.show()\n",
    "\n",
    "def saveImages(img, path, **kwargs):\n",
    "    grid = torchvision.utils.make_grid(img, **kwargs)\n",
    "    ndarr = grid.permute(1, 2, 0).to(\"cpu\").numpy()\n",
    "    im = Image.fromarray(ndarr)\n",
    "    im.save(path)\n",
    "\n",
    "def getData(args):\n",
    "    img_transforms = transforms.Compose([\n",
    "        transforms.Resize(80),\n",
    "        transforms.RandomResizedCrop(args.img_size, scale=(0.8, 1.0)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "    ])\n",
    "    dataset = torchvision.datasets.ImageFolder(args.dataset_path, transform=img_transforms)\n",
    "    dataloader = DataLoader(dataset, batch_size = args.batch_size, shuffle=True)\n",
    "    return dataloader\n",
    "\n",
    "\n",
    "def setupLogging(run_name):\n",
    "    os.makedirs(\"models\", exist_ok=True)\n",
    "    os.makedirs(\"results\", exist_ok=True)\n",
    "    os.makedirs(os.path.join(\"models\", run_name), exist_ok=True)\n",
    "    os.makedirs(os.path.join(\"results\", run_name), exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6050412f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-16T14:39:02.741914Z",
     "iopub.status.busy": "2022-10-16T14:39:02.741508Z",
     "iopub.status.idle": "2022-10-16T14:39:02.782818Z",
     "shell.execute_reply": "2022-10-16T14:39:02.781977Z"
    },
    "papermill": {
     "duration": 0.046781,
     "end_time": "2022-10-16T14:39:02.784823",
     "exception": false,
     "start_time": "2022-10-16T14:39:02.738042",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class EMA:\n",
    "    def __init__(self, beta):\n",
    "        super().__init__()\n",
    "        self.beta = beta\n",
    "        self.step = 0\n",
    "\n",
    "    def update_model_average(self, ma_model, current_model):\n",
    "        for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()):\n",
    "            old_weight, up_weight = ma_params.data, current_params.data\n",
    "            ma_params.data = self.update_average(old_weight, up_weight)\n",
    "\n",
    "    def update_average(self, old, new):\n",
    "        if old is None:\n",
    "            return new\n",
    "        return old * self.beta + (1 - self.beta) * new\n",
    "\n",
    "    def step_ema(self, ema_model, model, step_start_ema=2000):\n",
    "        if self.step < step_start_ema:\n",
    "            self.reset_parameters(ema_model, model)\n",
    "            self.step += 1\n",
    "            return\n",
    "        self.update_model_average(ema_model, model)\n",
    "        self.step += 1\n",
    "\n",
    "    def reset_parameters(self, ema_model, model):\n",
    "        ema_model.load_state_dict(model.state_dict())\n",
    "\n",
    "\n",
    "class SelfAttention(nn.Module):\n",
    "    def __init__(self, channels, size):\n",
    "        super(SelfAttention, self).__init__()\n",
    "        self.channels = channels\n",
    "        self.size = size\n",
    "        self.mha = nn.MultiheadAttention(channels, 4, batch_first=True)\n",
    "        self.ln = nn.LayerNorm([channels])\n",
    "        self.ff_self = nn.Sequential(\n",
    "            nn.LayerNorm([channels]),\n",
    "            nn.Linear(channels, channels),\n",
    "            nn.GELU(),\n",
    "            nn.Linear(channels, channels),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, self.channels, self.size * self.size).swapaxes(1, 2)\n",
    "        x_ln = self.ln(x)\n",
    "        attention_value, _ = self.mha(x_ln, x_ln, x_ln)\n",
    "        attention_value = attention_value + x\n",
    "        attention_value = self.ff_self(attention_value) + attention_value\n",
    "        return attention_value.swapaxes(2, 1).view(-1, self.channels, self.size, self.size)\n",
    "\n",
    "\n",
    "class DoubleConv(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, mid_channels=None, residual=False):\n",
    "        super().__init__()\n",
    "        self.residual = residual\n",
    "        if not mid_channels:\n",
    "            mid_channels = out_channels\n",
    "        self.double_conv = nn.Sequential(\n",
    "            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),\n",
    "            nn.GroupNorm(1, mid_channels),\n",
    "            nn.GELU(),\n",
    "            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),\n",
    "            nn.GroupNorm(1, out_channels),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        if self.residual:\n",
    "            return F.gelu(x + self.double_conv(x))\n",
    "        else:\n",
    "            return self.double_conv(x)\n",
    "\n",
    "\n",
    "class Down(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, emb_dim=256):\n",
    "        super().__init__()\n",
    "        self.maxpool_conv = nn.Sequential(\n",
    "            nn.MaxPool2d(2),\n",
    "            DoubleConv(in_channels, in_channels, residual=True),\n",
    "            DoubleConv(in_channels, out_channels),\n",
    "        )\n",
    "\n",
    "        self.emb_layer = nn.Sequential(\n",
    "            nn.SiLU(),\n",
    "            nn.Linear(\n",
    "                emb_dim,\n",
    "                out_channels\n",
    "            ),\n",
    "        )\n",
    "\n",
    "    def forward(self, x, t):\n",
    "        x = self.maxpool_conv(x)\n",
    "        emb = self.emb_layer(t)[:, :, None, None].repeat(1, 1, x.shape[-2], x.shape[-1])\n",
    "        return x + emb\n",
    "\n",
    "\n",
    "class Up(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, emb_dim=256):\n",
    "        super().__init__()\n",
    "\n",
    "        self.up = nn.Upsample(scale_factor=2, mode=\"bilinear\", align_corners=True)\n",
    "        self.conv = nn.Sequential(\n",
    "            DoubleConv(in_channels, in_channels, residual=True),\n",
    "            DoubleConv(in_channels, out_channels, in_channels // 2),\n",
    "        )\n",
    "\n",
    "        self.emb_layer = nn.Sequential(\n",
    "            nn.SiLU(),\n",
    "            nn.Linear(\n",
    "                emb_dim,\n",
    "                out_channels\n",
    "            ),\n",
    "        )\n",
    "\n",
    "    def forward(self, x, skip_x, t):\n",
    "        x = self.up(x)\n",
    "        x = torch.cat([skip_x, x], dim=1)\n",
    "        x = self.conv(x)\n",
    "        emb = self.emb_layer(t)[:, :, None, None].repeat(1, 1, x.shape[-2], x.shape[-1])\n",
    "        return x + emb\n",
    "\n",
    "\n",
    "class UNet(nn.Module):\n",
    "    def __init__(self, c_in=3, c_out=3, time_dim=256, device=\"cuda\"):\n",
    "        super().__init__()\n",
    "        self.device = device\n",
    "        self.time_dim = time_dim\n",
    "        self.inc = DoubleConv(c_in, 64)\n",
    "        self.down1 = Down(64, 128)\n",
    "        self.sa1 = SelfAttention(128, 32)\n",
    "        self.down2 = Down(128, 256)\n",
    "        self.sa2 = SelfAttention(256, 16)\n",
    "        self.down3 = Down(256, 256)\n",
    "        self.sa3 = SelfAttention(256, 8)\n",
    "\n",
    "        self.bot1 = DoubleConv(256, 512)\n",
    "        self.bot2 = DoubleConv(512, 512)\n",
    "        self.bot3 = DoubleConv(512, 256)\n",
    "\n",
    "        self.up1 = Up(512, 128)\n",
    "        self.sa4 = SelfAttention(128, 16)\n",
    "        self.up2 = Up(256, 64)\n",
    "        self.sa5 = SelfAttention(64, 32)\n",
    "        self.up3 = Up(128, 64)\n",
    "        self.sa6 = SelfAttention(64, 64)\n",
    "        self.outc = nn.Conv2d(64, c_out, kernel_size=1)\n",
    "\n",
    "    def pos_encoding(self, t, channels):\n",
    "        inv_freq = 1.0 / (\n",
    "            10000\n",
    "            ** (torch.arange(0, channels, 2, device=self.device).float() / channels)\n",
    "        )\n",
    "        pos_enc_a = torch.sin(t.repeat(1, channels // 2) * inv_freq)\n",
    "        pos_enc_b = torch.cos(t.repeat(1, channels // 2) * inv_freq)\n",
    "        pos_enc = torch.cat([pos_enc_a, pos_enc_b], dim=-1)\n",
    "        return pos_enc\n",
    "\n",
    "    def forward(self, x, t):\n",
    "        t = t.unsqueeze(-1).type(torch.float)\n",
    "        t = self.pos_encoding(t, self.time_dim)\n",
    "\n",
    "        x1 = self.inc(x)\n",
    "        x2 = self.down1(x1, t)\n",
    "        x2 = self.sa1(x2)\n",
    "        x3 = self.down2(x2, t)\n",
    "        x3 = self.sa2(x3)\n",
    "        x4 = self.down3(x3, t)\n",
    "        x4 = self.sa3(x4)\n",
    "\n",
    "        x4 = self.bot1(x4)\n",
    "        x4 = self.bot2(x4)\n",
    "        x4 = self.bot3(x4)\n",
    "\n",
    "        x = self.up1(x4, x3, t)\n",
    "        x = self.sa4(x)\n",
    "        x = self.up2(x, x2, t)\n",
    "        x = self.sa5(x)\n",
    "        x = self.up3(x, x1, t)\n",
    "        x = self.sa6(x)\n",
    "        output = self.outc(x)\n",
    "        return output\n",
    "\n",
    "\n",
    "class UNet_conditional(nn.Module):\n",
    "    def __init__(self, c_in=3, c_out=3, time_dim=256, num_classes=None, device=\"cuda\"):\n",
    "        super().__init__()\n",
    "        self.device = device\n",
    "        self.time_dim = time_dim\n",
    "        self.inc = DoubleConv(c_in, 64)\n",
    "        self.down1 = Down(64, 128)\n",
    "        self.sa1 = SelfAttention(128, 32)\n",
    "        self.down2 = Down(128, 256)\n",
    "        self.sa2 = SelfAttention(256, 16)\n",
    "        self.down3 = Down(256, 256)\n",
    "        self.sa3 = SelfAttention(256, 8)\n",
    "\n",
    "        self.bot1 = DoubleConv(256, 512)\n",
    "        self.bot2 = DoubleConv(512, 512)\n",
    "        self.bot3 = DoubleConv(512, 256)\n",
    "\n",
    "        self.up1 = Up(512, 128)\n",
    "        self.sa4 = SelfAttention(128, 16)\n",
    "        self.up2 = Up(256, 64)\n",
    "        self.sa5 = SelfAttention(64, 32)\n",
    "        self.up3 = Up(128, 64)\n",
    "        self.sa6 = SelfAttention(64, 64)\n",
    "        self.outc = nn.Conv2d(64, c_out, kernel_size=1)\n",
    "\n",
    "        if num_classes is not None:\n",
    "            self.label_emb = nn.Embedding(num_classes, time_dim)\n",
    "\n",
    "    def pos_encoding(self, t, channels):\n",
    "        inv_freq = 1.0 / (\n",
    "            10000\n",
    "            ** (torch.arange(0, channels, 2, device=self.device).float() / channels)\n",
    "        )\n",
    "        pos_enc_a = torch.sin(t.repeat(1, channels // 2) * inv_freq)\n",
    "        pos_enc_b = torch.cos(t.repeat(1, channels // 2) * inv_freq)\n",
    "        pos_enc = torch.cat([pos_enc_a, pos_enc_b], dim=-1)\n",
    "        return pos_enc\n",
    "\n",
    "    def forward(self, x, t, y):\n",
    "        t = t.unsqueeze(-1).type(torch.float)\n",
    "        t = self.pos_encoding(t, self.time_dim)\n",
    "\n",
    "        if y is not None:\n",
    "            t += self.label_emb(y)\n",
    "\n",
    "        x1 = self.inc(x)\n",
    "        x2 = self.down1(x1, t)\n",
    "        x2 = self.sa1(x2)\n",
    "        x3 = self.down2(x2, t)\n",
    "        x3 = self.sa2(x3)\n",
    "        x4 = self.down3(x3, t)\n",
    "        x4 = self.sa3(x4)\n",
    "\n",
    "        x4 = self.bot1(x4)\n",
    "        x4 = self.bot2(x4)\n",
    "        x4 = self.bot3(x4)\n",
    "\n",
    "        x = self.up1(x4, x3, t)\n",
    "        x = self.sa4(x)\n",
    "        x = self.up2(x, x2, t)\n",
    "        x = self.sa5(x)\n",
    "        x = self.up3(x, x1, t)\n",
    "        x = self.sa6(x)\n",
    "        output = self.outc(x)\n",
    "        return output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d55690a5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-16T14:39:02.789903Z",
     "iopub.status.busy": "2022-10-16T14:39:02.789635Z",
     "iopub.status.idle": "2022-10-16T14:39:03.008262Z",
     "shell.execute_reply": "2022-10-16T14:39:03.007328Z"
    },
    "papermill": {
     "duration": 0.223916,
     "end_time": "2022-10-16T14:39:03.010653",
     "exception": false,
     "start_time": "2022-10-16T14:39:02.786737",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from torch import optim\n",
    "from tqdm import tqdm\n",
    "import logging\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "logging.basicConfig(format=\"%(asctime)s - %(levelname)s: %(message)s\", level=logging.INFO, datefmt=\"%I:%M:%S\")\n",
    "\n",
    "class DiffusionModel:\n",
    "    def __init__(self, noise_steps = 1000, beta_start=1e-4, beta_end=0.02, img_size = 64, device='cuda'):\n",
    "        self.noise_steps = noise_steps\n",
    "        self.beta_start = beta_start\n",
    "        self.beta_end = beta_end\n",
    "        self.img_size = img_size\n",
    "        self.device = device\n",
    "\n",
    "        self.beta = self.prepareNoiseSchedule().to(device)\n",
    "        self.alpha = 1 - self.beta\n",
    "        self.alpha_hat = torch.cumprod(self.alpha, dim=0)\n",
    "    \n",
    "    def prepareNoiseSchedule(self):\n",
    "        return torch.linspace(self.beta_start, self.beta_end, self.noise_steps)\n",
    "    \n",
    "    def noiseImage(self, x, t):\n",
    "        sqrt_alpha_hat = torch.sqrt(self.alpha_hat[t])[:, None, None, None]\n",
    "        sqrt_one_minus_alpha_hat = torch.sqrt(1. - self.alpha_hat[t])[:, None, None, None]\n",
    "        e = torch.randn_like(x)\n",
    "        return sqrt_alpha_hat * x + sqrt_one_minus_alpha_hat* e, e\n",
    "    \n",
    "    def sampleTimesteps(self, n):\n",
    "        return torch.randint(low=1, high=self.noise_steps, size=(n,))\n",
    "    \n",
    "    def sample(self, model, n):\n",
    "        logging.info(f'Sampling {n} new images.....')\n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            x = torch.randn(n, 3, self.img_size, self.img_size).to(self.device)\n",
    "            for i in tqdm(reversed(range(1, self.noise_steps)), position=0):\n",
    "                t = (torch.ones(n) * i).long().to(self.device)\n",
    "                predicted_noise = model(x, t)\n",
    "                alpha = self.alpha[t][:, None, None, None]\n",
    "                alpha_hat = self.alpha_hat[t][:, None, None, None]\n",
    "                beta = self.beta[t][:, None, None, None]\n",
    "                if i > 1:\n",
    "                    noise = torch.randn_like(x)\n",
    "                else:\n",
    "                    noise = torch.zeros_like(x)\n",
    "                x = 1 / torch.sqrt(alpha) * (x - ((1-alpha) / (torch.sqrt(1 - alpha_hat))) * predicted_noise) + torch.sqrt(beta)\n",
    "        model.train()\n",
    "        x = (x.clamp(-1, 1) + 1) / 2\n",
    "        x = (x * 255).type(torch.uint8)\n",
    "        return x\n",
    "         \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def train(args):\n",
    "    setupLogging(args.run_name)\n",
    "    device = args.device\n",
    "    dataloader = getData(args)\n",
    "    model = UNet().to(device)\n",
    "    optimizer = optim.AdamW(model.parameters(), lr=args.lr)\n",
    "    mse = nn.MSELoss()\n",
    "    diffusion = DiffusionModel(img_size=args.img_size, device=device)\n",
    "    logger = SummaryWriter(os.path.join(\"runs\", args.run_name))\n",
    "    l = len(dataloader)\n",
    "\n",
    "    for epoch in range(args.epochs):\n",
    "        logging.info(f\"Starting epoch {epoch}:\")\n",
    "        pbar = tqdm(dataloader)\n",
    "        for i, (images, _) in enumerate(pbar):\n",
    "            images = images.to(device)\n",
    "            t = diffusion.sampleTimesteps(images.shape[0]).to(device)\n",
    "            x_t, noise = diffusion.noiseImage(images, t)\n",
    "            predicted_noise = model(x_t, t)\n",
    "            loss = mse(noise, predicted_noise)\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            pbar.set_postfix(MSE=loss.item())\n",
    "            logger.add_scalar(\"MSE\", loss.item(), global_step=epoch * l + i)\n",
    "\n",
    "        sampled_images = diffusion.sample(model, n=images.shape[0])\n",
    "        saveImages(sampled_images, os.path.join(\"results\", args.run_name, f\"{epoch}.jpg\"))\n",
    "        torch.save(model.state_dict(), os.path.join(\"models\", args.run_name, f\"ckpt.pt\"))\n",
    "\n",
    "\n",
    "def launch():\n",
    "    import argparse\n",
    "    parser = argparse.ArgumentParser()\n",
    "    args, unknown = parser.parse_known_args()\n",
    "    args.run_name = \"DDPM_Uncondtional\"\n",
    "    args.epochs = 50\n",
    "    args.batch_size = 10\n",
    "    args.img_size = 64\n",
    "    args.dataset_path = \"../input/\"\n",
    "    args.device = \"cuda\"\n",
    "    args.lr = 3e-4\n",
    "    train(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1fe1f526",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-16T14:39:03.016039Z",
     "iopub.status.busy": "2022-10-16T14:39:03.015744Z",
     "iopub.status.idle": "2022-10-16T18:41:17.264133Z",
     "shell.execute_reply": "2022-10-16T18:41:17.263085Z"
    },
    "papermill": {
     "duration": 14534.254019,
     "end_time": "2022-10-16T18:41:17.266794",
     "exception": false,
     "start_time": "2022-10-16T14:39:03.012775",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 432/432 [03:52<00:00,  1.86it/s, MSE=0.0489]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:19<00:00,  2.17it/s, MSE=0.0257]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:19<00:00,  2.17it/s, MSE=0.0214]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:19<00:00,  2.17it/s, MSE=0.053]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:19<00:00,  2.17it/s, MSE=0.0296]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:20<00:00,  2.16it/s, MSE=0.0341]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:20<00:00,  2.15it/s, MSE=0.106]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:20<00:00,  2.15it/s, MSE=0.00994]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:20<00:00,  2.16it/s, MSE=0.0332]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:20<00:00,  2.16it/s, MSE=0.00812]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:20<00:00,  2.16it/s, MSE=0.0196]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:20<00:00,  2.15it/s, MSE=0.0108]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:21<00:00,  2.14it/s, MSE=0.0312]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:21<00:00,  2.14it/s, MSE=0.0129]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:23<00:00,  2.12it/s, MSE=0.00854]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:21<00:00,  2.14it/s, MSE=0.0306]\n",
      "999it [01:26, 11.57it/s]\n",
      "100%|██████████| 432/432 [03:22<00:00,  2.13it/s, MSE=0.0164]\n",
      "999it [01:26, 11.56it/s]\n",
      "100%|██████████| 432/432 [03:22<00:00,  2.13it/s, MSE=0.0195]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:22<00:00,  2.14it/s, MSE=0.0213]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:22<00:00,  2.13it/s, MSE=0.0314]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:21<00:00,  2.14it/s, MSE=0.044]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:22<00:00,  2.13it/s, MSE=0.014]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:23<00:00,  2.12it/s, MSE=0.0264]\n",
      "999it [01:26, 11.57it/s]\n",
      "100%|██████████| 432/432 [03:23<00:00,  2.12it/s, MSE=0.0114]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:22<00:00,  2.13it/s, MSE=0.0275]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:22<00:00,  2.13it/s, MSE=0.0206]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:23<00:00,  2.13it/s, MSE=0.0101]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:23<00:00,  2.12it/s, MSE=0.00575]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:23<00:00,  2.12it/s, MSE=0.0463]\n",
      "999it [01:26, 11.59it/s]\n",
      "100%|██████████| 432/432 [03:24<00:00,  2.11it/s, MSE=0.0168]\n",
      "999it [01:26, 11.57it/s]\n",
      "100%|██████████| 432/432 [03:23<00:00,  2.12it/s, MSE=0.00492]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:24<00:00,  2.11it/s, MSE=0.0215]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:23<00:00,  2.12it/s, MSE=0.0134]\n",
      "999it [01:26, 11.57it/s]\n",
      "100%|██████████| 432/432 [03:24<00:00,  2.11it/s, MSE=0.0139]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:24<00:00,  2.11it/s, MSE=0.04]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:25<00:00,  2.10it/s, MSE=0.0381]\n",
      "999it [01:26, 11.57it/s]\n",
      "100%|██████████| 432/432 [03:24<00:00,  2.11it/s, MSE=0.00998]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:25<00:00,  2.10it/s, MSE=0.026]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:25<00:00,  2.10it/s, MSE=0.0118]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:25<00:00,  2.10it/s, MSE=0.036]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:26<00:00,  2.10it/s, MSE=0.00772]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:25<00:00,  2.10it/s, MSE=0.00311]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:25<00:00,  2.10it/s, MSE=0.0084]\n",
      "999it [01:26, 11.57it/s]\n",
      "100%|██████████| 432/432 [03:26<00:00,  2.09it/s, MSE=0.0131]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:26<00:00,  2.09it/s, MSE=0.0148]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:25<00:00,  2.10it/s, MSE=0.00453]\n",
      "999it [01:26, 11.57it/s]\n",
      "100%|██████████| 432/432 [03:25<00:00,  2.10it/s, MSE=0.0093]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:26<00:00,  2.10it/s, MSE=0.0112]\n",
      "999it [01:26, 11.57it/s]\n",
      "100%|██████████| 432/432 [03:27<00:00,  2.09it/s, MSE=0.0131]\n",
      "999it [01:26, 11.58it/s]\n",
      "100%|██████████| 432/432 [03:26<00:00,  2.09it/s, MSE=0.0073]\n",
      "999it [01:26, 11.58it/s]\n"
     ]
    }
   ],
   "source": [
    "launch()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 14551.766605,
   "end_time": "2022-10-16T18:41:24.357508",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2022-10-16T14:38:52.590903",
   "version": "2.3.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}