Generating_Human_Faces_with_Simple_Diffusion_Model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "mount_file_id": "1VHLSI1y1tc8FrQ60Nio4aAEuOJKNQbyu",
      "authorship_tag": "ABX9TyMBU0njvSouCTR4p+8SzXAH",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/lifeisbeautifu1/deep-learning/blob/main/Generating_Human_Faces_with_Simple_Diffusion_Model.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "SoeQ_Xq8ey94"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "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())"
      ],
      "metadata": {
        "id": "5q-okOcrg-Ui"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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)"
      ],
      "metadata": {
        "id": "lwQACDsGhD_d"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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)"
      ],
      "metadata": {
        "id": "WRNW8w_MhF_g"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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"
      ],
      "metadata": {
        "id": "h8yabSTwhHzb"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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"
      ],
      "metadata": {
        "id": "nJDv5SHihJ-J"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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"
      ],
      "metadata": {
        "id": "EZyXpbwxhLxI"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import torch\n",
        "import torchvision\n",
        "from PIL import Image\n",
        "from matplotlib import pyplot as plt\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "\n",
        "def plot_images(images):\n",
        "    plt.figure(figsize=(64, 64))\n",
        "    plt.imshow(torch.cat([\n",
        "        torch.cat([i for i in images.cpu()], dim=-1),\n",
        "    ], dim=-2).permute(1, 2, 0).cpu())\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "def save_images(images, path, **kwargs):\n",
        "    grid = torchvision.utils.make_grid(images, **kwargs)\n",
        "    ndarr = grid.permute(1, 2, 0).to('cpu').numpy()\n",
        "    im = Image.fromarray(ndarr)\n",
        "    im.save(path)\n",
        "\n",
        "\n",
        "def get_data(args):\n",
        "    transforms = torchvision.transforms.Compose([\n",
        "        torchvision.transforms.Resize(80),  # args.image_size + 1/4 *args.image_size\n",
        "        torchvision.transforms.RandomResizedCrop(args.image_size, scale=(0.8, 1.0)),\n",
        "        torchvision.transforms.ToTensor(),\n",
        "        torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
        "    ])\n",
        "    dataset = torchvision.datasets.ImageFolder(args.dataset_path, transform=transforms)\n",
        "    dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)\n",
        "    return dataloader\n",
        "\n",
        "\n",
        "def setup_logging(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)"
      ],
      "metadata": {
        "id": "3FqkJJhnhUcK"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import DataLoader\n",
        "import torchvision\n",
        "from matplotlib import pyplot as plt\n",
        "from PIL import Image\n",
        "from tqdm import tqdm\n",
        "from torch import optim\n",
        "import logging\n",
        "\n",
        "\n",
        "logging.basicConfig(format=\"%(asctime)s - %(levelname)s: %(message)s\", level=logging.INFO, datefmt=\"%I:%M:%S\")"
      ],
      "metadata": {
        "id": "EmOwItFEhv6i"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import DataLoader\n",
        "import torchvision\n",
        "from matplotlib import pyplot as plt\n",
        "from PIL import Image\n",
        "from tqdm import tqdm\n",
        "from torch import optim\n",
        "import logging\n",
        "\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "logging.basicConfig(format=\"%(asctime)s - %(levelname)s: %(message)s\", level=logging.INFO, datefmt=\"%I:%M:%S\")\n",
        "\n",
        "class Diffusion:\n",
        "    def __init__(self, noise_steps=1000, beta_start=1e-4, beta_end=0.02, img_size=64, device=device):\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.prepare_noise_schedule().to(device)\n",
        "        self.alpha = 1. - self.beta\n",
        "        self.alpha_hat = torch.cumprod(self.alpha, dim=0)\n",
        "\n",
        "    def prepare_noise_schedule(self):\n",
        "        return torch.linspace(self.beta_start, self.beta_end, self.noise_steps)\n",
        "\n",
        "    def noise_images(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",
        "        Ɛ = torch.randn_like(x)\n",
        "        return sqrt_alpha_hat * x + sqrt_one_minus_alpha_hat * Ɛ, Ɛ\n",
        "\n",
        "    def sample_timesteps(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) * noise\n",
        "        model.train()\n",
        "        x = (x.clamp(-1, 1) + 1) / 2\n",
        "        x = (x * 255).type(torch.uint8)\n",
        "        return x"
      ],
      "metadata": {
        "id": "QJIYhXioiPrx"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train(args):\n",
        "    setup_logging(args.run_name)\n",
        "    device = args.device\n",
        "    dataloader = get_data(args)\n",
        "    model = UNet().to(device)\n",
        "    #ckpt = torch.load(\"drive/MyDrive/params/ckpt.pt\", map_location=torch.device('cpu'))\n",
        "    #model.load_state_dict(ckpt)\n",
        "    optimizer = optim.AdamW(model.parameters(), lr=args.lr)\n",
        "    mse = nn.MSELoss()\n",
        "    diffusion = Diffusion(img_size=args.image_size, device=device)\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.sample_timesteps(images.shape[0]).to(device)\n",
        "            x_t, noise = diffusion.noise_images(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",
        "\n",
        "        sampled_images = diffusion.sample(model, n=images.shape[0])\n",
        "        save_images(sampled_images, os.path.join(\"results\", args.run_name, f\"{epoch}.jpg\"))\n",
        "        torch.save(model.state_dict(), os.path.join(\"drive/MyDrive/params\", f\"ckpt.pt\"))"
      ],
      "metadata": {
        "id": "PS5fZiCwiUNT"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def launch():\n",
        "    import argparse\n",
        "    parser = argparse.ArgumentParser()\n",
        "    args = parser.parse_args(args=[])\n",
        "    args.run_name = \"DDPM_Uncondtional\"\n",
        "    args.epochs = 50\n",
        "    args.batch_size = 5\n",
        "    args.image_size = 64\n",
        "    args.dataset_path = r\"drive/MyDrive/training\"\n",
        "    args.device = device\n",
        "    args.lr = 3e-4\n",
        "    train(args)"
      ],
      "metadata": {
        "id": "Ikta_90biyck"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"cuda\" if torch.cuda.is_available() else 'cpu'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ltCovIxEjl4w",
        "outputId": "86c52c3b-c2fc-4a0c-c70e-cbfaac1f8652"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cuda'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "device = \"cuda\" if torch.cuda.is_available() else 'cpu'\n",
        "model = UNet().to(device)\n",
        "#ckpt = torch.load(\"drive/MyDrive/params/ckpt.pt\", map_location=torch.device('cpu'))\n",
        "#model.load_state_dict(ckpt)\n",
        "diffusion = Diffusion(img_size=64, device=device)\n",
        "x = diffusion.sample(model, 8)\n",
        "print(x.shape)\n",
        "plt.figure(figsize=(64, 64))\n",
        "plt.imshow(torch.cat([\n",
        "    torch.cat([i for i in x.cpu()], dim=-1),\n",
        "], dim=-2).permute(1, 2, 0).cpu())\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "id": "p3HSj9YCjnv5",
        "outputId": "ffc89a98-7006-4910-98e7-dbe2574d06ed"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "999it [01:45,  9.45it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([8, 3, 64, 64])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 6400x6400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "launch()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ZbDTflwjs-T",
        "outputId": "84520ead-cdaf-4411-88b9-cdbe5a05b400"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            " 17%|█▋        | 241/1444 [03:50<06:10,  3.24it/s, MSE=0.0443]/usr/local/lib/python3.10/dist-packages/PIL/Image.py:996: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n",
            "  warnings.warn(\n",
            "100%|██████████| 1444/1444 [10:34<00:00,  2.27it/s, MSE=0.0435]\n",
            "999it [00:54, 18.38it/s]\n",
            "100%|██████████| 1444/1444 [08:00<00:00,  3.01it/s, MSE=0.0283]\n",
            "999it [00:54, 18.36it/s]\n",
            "100%|██████████| 1444/1444 [08:02<00:00,  2.99it/s, MSE=0.027]\n",
            "999it [00:54, 18.36it/s]\n",
            "100%|██████████| 1444/1444 [08:02<00:00,  2.99it/s, MSE=0.0619]\n",
            "999it [00:54, 18.34it/s]\n",
            "100%|██████████| 1444/1444 [08:02<00:00,  2.99it/s, MSE=0.00633]\n",
            "999it [00:54, 18.36it/s]\n",
            "100%|██████████| 1444/1444 [08:01<00:00,  3.00it/s, MSE=0.052]\n",
            "999it [00:54, 18.32it/s]\n",
            "100%|██████████| 1444/1444 [08:03<00:00,  2.99it/s, MSE=0.0296]\n",
            "999it [00:54, 18.35it/s]\n",
            "100%|██████████| 1444/1444 [08:02<00:00,  2.99it/s, MSE=0.0124]\n",
            "999it [00:54, 18.33it/s]\n",
            "100%|██████████| 1444/1444 [08:11<00:00,  2.94it/s, MSE=0.00872]\n",
            "999it [00:56, 17.70it/s]\n",
            "100%|██████████| 1444/1444 [08:12<00:00,  2.93it/s, MSE=0.0116]\n",
            "999it [00:56, 17.69it/s]\n",
            "100%|██████████| 1444/1444 [08:09<00:00,  2.95it/s, MSE=0.0115]\n",
            "999it [00:56, 17.69it/s]\n",
            "100%|██████████| 1444/1444 [08:12<00:00,  2.93it/s, MSE=0.0203]\n",
            "999it [00:56, 17.66it/s]\n",
            "100%|██████████| 1444/1444 [08:06<00:00,  2.97it/s, MSE=0.00603]\n",
            "999it [00:54, 18.28it/s]\n",
            "100%|██████████| 1444/1444 [08:07<00:00,  2.96it/s, MSE=0.0116]\n",
            "999it [00:56, 17.67it/s]\n",
            "100%|██████████| 1444/1444 [08:09<00:00,  2.95it/s, MSE=0.0235]\n",
            "999it [00:56, 17.73it/s]\n",
            "100%|██████████| 1444/1444 [08:10<00:00,  2.94it/s, MSE=0.000912]\n",
            "999it [00:56, 17.64it/s]\n",
            "100%|██████████| 1444/1444 [08:10<00:00,  2.95it/s, MSE=0.00712]\n",
            "999it [00:56, 17.67it/s]\n",
            "100%|██████████| 1444/1444 [08:08<00:00,  2.96it/s, MSE=0.0488]\n",
            "999it [00:56, 17.71it/s]\n",
            "100%|██████████| 1444/1444 [08:10<00:00,  2.95it/s, MSE=0.00846]\n",
            "999it [00:56, 17.70it/s]\n",
            "100%|██████████| 1444/1444 [08:11<00:00,  2.94it/s, MSE=0.00348]\n",
            "999it [00:56, 17.67it/s]\n",
            "100%|██████████| 1444/1444 [08:14<00:00,  2.92it/s, MSE=0.00211]\n",
            "999it [00:56, 17.61it/s]\n",
            " 83%|████████▎ | 1196/1444 [06:49<01:43,  2.39it/s, MSE=0.00501]"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-ot0M7iqlBwK"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}