Full Code of LinXueyuanStdio/PyTorch-DDPM for AI

Repository: LinXueyuanStdio/PyTorch-DDPM
Branch: main
Commit: e87727a7add3
Files: 6
Total size: 7.2 MB

Directory structure:
gitextract_b4ltif3p/

├── ClassifierFreeDDPM.ipynb
├── DDPM.ipynb
├── MeanFlow.py
├── README.md
├── classifier_free_ddpm.py
└── ddpm.py

================================================
FILE CONTENTS
================================================

================================================
FILE: ClassifierFreeDDPM.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d051e615",
   "metadata": {},
   "source": [
    "## 模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c93dd70e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-09-22T17:49:10.507284Z",
     "start_time": "2022-09-22T17:49:09.662911Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/cpfs/29583eqvgtdvw5cvegg/data/shared/AIME-COMMON/miniconda3/envs/lxy39/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import math\n",
    "from abc import abstractmethod\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5af9e239",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-09-22T17:49:15.016449Z",
     "start_time": "2022-09-22T17:49:10.509309Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARNING: Ignoring invalid distribution -orch (/cpfs/29583eqvgtdvw5cvegg/data/shared/AIME-COMMON/miniconda3/envs/lxy39/lib/python3.9/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution -orch (/cpfs/29583eqvgtdvw5cvegg/data/shared/AIME-COMMON/miniconda3/envs/lxy39/lib/python3.9/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution -orch (/cpfs/29583eqvgtdvw5cvegg/data/shared/AIME-COMMON/miniconda3/envs/lxy39/lib/python3.9/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0mLooking in indexes: http://mirrors.cloud.aliyuncs.com/pypi/simple/\n",
      "Requirement already satisfied: einops-exts in /cpfs/29583eqvgtdvw5cvegg/data/shared/AIME-COMMON/miniconda3/envs/lxy39/lib/python3.9/site-packages (0.0.4)\n",
      "Requirement already satisfied: einops>=0.4 in /cpfs/29583eqvgtdvw5cvegg/data/shared/AIME-COMMON/miniconda3/envs/lxy39/lib/python3.9/site-packages (from einops-exts) (0.7.0)\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -orch (/cpfs/29583eqvgtdvw5cvegg/data/shared/AIME-COMMON/miniconda3/envs/lxy39/lib/python3.9/site-packages)\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pip install einops>=0.4\n",
    "!pip install einops-exts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e3841a64",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-09-22T17:49:15.031107Z",
     "start_time": "2022-09-22T17:49:15.019867Z"
    }
   },
   "outputs": [],
   "source": [
    "from einops import rearrange\n",
    "from einops.layers.torch import Rearrange\n",
    "from einops_exts import rearrange_many, repeat_many"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3b86a5b0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-09-22T17:58:02.118576Z",
     "start_time": "2022-09-22T17:58:01.931790Z"
    },
    "code_folding": [
     0,
     22,
     35,
     49,
     53,
     219,
     249,
     263,
     407,
     417
    ]
   },
   "outputs": [],
   "source": [
    "def timestep_embedding(timesteps, dim, max_period=10000):\n",
    "    \"\"\"Create sinusoidal timestep embeddings.\n",
    "\n",
    "    Args:\n",
    "        timesteps (Tensor): a 1-D Tensor of N indices, one per batch element. These may be fractional.\n",
    "        dim (int): the dimension of the output.\n",
    "        max_period (int, optional): controls the minimum frequency of the embeddings. Defaults to 10000.\n",
    "\n",
    "    Returns:\n",
    "        Tensor: an [N x dim] Tensor of positional embeddings.\n",
    "    \"\"\"\n",
    "    half = dim // 2\n",
    "    freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half).to(device=timesteps.device)\n",
    "    args = timesteps[:, None].float() * freqs[None]\n",
    "    embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)\n",
    "    if dim % 2:\n",
    "        embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)\n",
    "    return embedding\n",
    "\n",
    "\n",
    "def norm_layer(channels):\n",
    "    return nn.GroupNorm(32, channels)\n",
    "\n",
    "\n",
    "class AttentionBlock(nn.Module):\n",
    "    def __init__(self, channels, num_heads=1):\n",
    "        \"\"\"\n",
    "        Attention block with shortcut\n",
    "\n",
    "        Args:\n",
    "            channels (int): channels\n",
    "            num_heads (int, optional): attention heads. Defaults to 1.\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "        self.num_heads = num_heads\n",
    "        assert channels % num_heads == 0\n",
    "\n",
    "        self.norm = norm_layer(channels)\n",
    "        self.qkv = nn.Conv2d(channels, channels * 3, kernel_size=1, bias=False)\n",
    "        self.proj = nn.Conv2d(channels, channels, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        B, C, H, W = x.shape\n",
    "        qkv = self.qkv(self.norm(x))\n",
    "        q, k, v = qkv.reshape(B * self.num_heads, -1, H * W).chunk(3, dim=1)\n",
    "        scale = 1.0 / math.sqrt(math.sqrt(C // self.num_heads))\n",
    "        attn = torch.einsum(\"bct,bcs->bts\", q * scale, k * scale)\n",
    "        attn = attn.softmax(dim=-1)\n",
    "        h = torch.einsum(\"bts,bcs->bct\", attn, v)\n",
    "        h = h.reshape(B, -1, H, W)\n",
    "        h = self.proj(h)\n",
    "        return h + x\n",
    "\n",
    "\n",
    "class Upsample(nn.Module):\n",
    "    def __init__(self, channels, use_conv):\n",
    "        super().__init__()\n",
    "        self.use_conv = use_conv\n",
    "        if use_conv:\n",
    "            self.conv = nn.Conv2d(channels, channels, kernel_size=3, padding=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.interpolate(x, scale_factor=2, mode=\"nearest\")\n",
    "        if self.use_conv:\n",
    "            x = self.conv(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class Downsample(nn.Module):\n",
    "    def __init__(self, channels, use_conv):\n",
    "        super().__init__()\n",
    "        self.use_conv = use_conv\n",
    "        if use_conv:\n",
    "            self.op = nn.Conv2d(channels, channels, kernel_size=3, stride=2, padding=1)\n",
    "        else:\n",
    "            self.op = nn.AvgPool2d(stride=2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.op(x)\n",
    "\n",
    "\n",
    "class TimestepBlock(nn.Module):\n",
    "    \"\"\"\n",
    "    Any module where forward() takes timestep embeddings as a second argument.\n",
    "    \"\"\"\n",
    "\n",
    "    @abstractmethod\n",
    "    def forward(self, x, t, y):\n",
    "        \"\"\"\n",
    "        Apply the module to `x` given `t` timestep embeddings, `y` conditional embedding same shape as t.\n",
    "        \"\"\"\n",
    "        pass\n",
    "\n",
    "\n",
    "class TimestepEmbedSequential(nn.Sequential, TimestepBlock):\n",
    "    \"\"\"\n",
    "    A sequential module that passes timestep embeddings to the children that support it as an extra input.\n",
    "    \"\"\"\n",
    "\n",
    "    def forward(self, x, t, y):\n",
    "        for layer in self:\n",
    "            if isinstance(layer, TimestepBlock):\n",
    "                x = layer(x, t, y)\n",
    "            else:\n",
    "                x = layer(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class Identity(nn.Module):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super().__init__()\n",
    "\n",
    "    def forward(self, x, *args, **kwargs):\n",
    "        return x\n",
    "\n",
    "\n",
    "class Always:\n",
    "    def __init__(self, val):\n",
    "        self.val = val\n",
    "\n",
    "    def __call__(self, *args, **kwargs):\n",
    "        return self.val\n",
    "\n",
    "\n",
    "class LayerNorm(nn.Module):\n",
    "    def __init__(self, feats, stable=True, dim=-1):\n",
    "        super().__init__()\n",
    "        self.stable = stable\n",
    "        self.dim = dim\n",
    "\n",
    "        self.g = nn.Parameter(torch.ones(feats, *((1,) * (-dim - 1))))\n",
    "\n",
    "    def forward(self, x):\n",
    "        dtype, dim = x.dtype, self.dim\n",
    "        if self.stable:\n",
    "            x = x / x.amax(dim=dim, keepdim=True).detach()\n",
    "        eps = 1e-5 if x.dtype == torch.float32 else 1e-3\n",
    "        var = torch.var(x, dim=dim, unbiased=False, keepdim=True)\n",
    "        mean = torch.mean(x, dim=dim, keepdim=True)\n",
    "        return (x - mean) * (var + eps).rsqrt().type(dtype) * self.g.type(dtype)\n",
    "\n",
    "\n",
    "class Block(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        dim,\n",
    "        dim_out,\n",
    "        groups=8,\n",
    "        norm=True,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.groupnorm = nn.GroupNorm(groups, dim) if norm else Identity()\n",
    "        self.activation = nn.SiLU()\n",
    "        self.project = nn.Conv2d(dim, dim_out, kernel_size=3, padding=1)\n",
    "\n",
    "    def forward(self, x, scale_shift=None):\n",
    "        x = self.groupnorm(x)\n",
    "\n",
    "        if scale_shift is not None:\n",
    "            scale, shift = scale_shift\n",
    "            x = x * (scale + 1) + shift\n",
    "\n",
    "        x = self.activation(x)\n",
    "        return self.project(x)\n",
    "\n",
    "\n",
    "class CrossAttention(nn.Module):\n",
    "    def __init__(self, dim, *, context_dim=None, dim_head=64, heads=8, norm_context=False, cosine_sim_attn=False):\n",
    "        super().__init__()\n",
    "        self.scale = dim_head**-0.5 if not cosine_sim_attn else 1.0\n",
    "        self.cosine_sim_attn = cosine_sim_attn\n",
    "        self.cosine_sim_scale = 16 if cosine_sim_attn else 1\n",
    "\n",
    "        self.heads = heads\n",
    "        inner_dim = dim_head * heads\n",
    "\n",
    "        context_dim = dim if context_dim is None else context_dim\n",
    "\n",
    "        self.norm = LayerNorm(dim)\n",
    "        self.norm_context = LayerNorm(context_dim) if norm_context else Identity()\n",
    "\n",
    "        self.null_kv = nn.Parameter(torch.randn(2, dim_head))\n",
    "        self.to_q = nn.Linear(dim, inner_dim, bias=False)\n",
    "        self.to_kv = nn.Linear(context_dim, inner_dim * 2, bias=False)\n",
    "\n",
    "        self.to_out = nn.Sequential(nn.Linear(inner_dim, dim, bias=False), LayerNorm(dim))\n",
    "\n",
    "    def forward(self, x, context):\n",
    "        b, n, device = *x.shape[:2], x.device\n",
    "        x = self.norm(x)\n",
    "        context = self.norm_context(context)\n",
    "        q, k, v = (self.to_q(x), *self.to_kv(context).chunk(2, dim=-1))\n",
    "        q, k, v = rearrange_many((q, k, v), \"b n (h d) -> b h n d\", h=self.heads)\n",
    "        # add null key / value for classifier free guidance in prior net\n",
    "        nk, nv = repeat_many(self.null_kv.unbind(dim=-2), \"d -> b h 1 d\", h=self.heads, b=b)\n",
    "        k = torch.cat((nk, k), dim=-2)\n",
    "        v = torch.cat((nv, v), dim=-2)\n",
    "        q = q * self.scale\n",
    "        # similarities\n",
    "        sim = torch.einsum(\"b h i d, b h j d -> b h i j\", q, k) * self.cosine_sim_scale\n",
    "        # masking\n",
    "        max_neg_value = -torch.finfo(sim.dtype).max\n",
    "        attn = sim.softmax(dim=-1, dtype=torch.float32)\n",
    "        attn = attn.to(sim.dtype)\n",
    "        out = torch.einsum(\"b h i j, b h j d -> b h i d\", attn, v)\n",
    "        out = rearrange(out, \"b h n d -> b n (h d)\")\n",
    "        return self.to_out(out)\n",
    "\n",
    "\n",
    "class GlobalContext(nn.Module):\n",
    "    \"\"\"basically a superior form of squeeze-excitation that is attention-esque\"\"\"\n",
    "\n",
    "    def __init__(self, *, dim_in, dim_out):\n",
    "        super().__init__()\n",
    "        self.to_k = nn.Conv2d(dim_in, 1, 1)\n",
    "        hidden_dim = max(3, dim_out // 2)\n",
    "\n",
    "        self.net = nn.Sequential(nn.Conv2d(dim_in, hidden_dim, 1), nn.SiLU(), nn.Conv2d(hidden_dim, dim_out, 1), nn.Sigmoid())\n",
    "\n",
    "    def forward(self, x):\n",
    "        context = self.to_k(x)\n",
    "        x, context = rearrange_many((x, context), \"b n ... -> b n (...)\")\n",
    "        out = torch.einsum(\"b i n, b c n -> b c i\", context.softmax(dim=-1), x)\n",
    "        out = rearrange(out, \"... -> ... 1\")\n",
    "        return self.net(out)\n",
    "\n",
    "\n",
    "class ResidualBlock(TimestepBlock):\n",
    "    def __init__(self, in_channels, out_channels, time_channels, dropout, use_global_context=False, groups=8):\n",
    "        super().__init__()\n",
    "        self.block1 = Block(in_channels, out_channels, groups=groups)\n",
    "\n",
    "        # pojection for time step embedding\n",
    "        self.time_emb = nn.Sequential(nn.SiLU(), nn.Linear(time_channels, out_channels * 2))\n",
    "\n",
    "        self.block2 = Block(out_channels, out_channels, groups=groups)\n",
    "\n",
    "        if in_channels != out_channels:\n",
    "            self.shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=1)\n",
    "        else:\n",
    "            self.shortcut = nn.Identity()\n",
    "        cond_dim = time_channels\n",
    "        self.gca = GlobalContext(dim_in=out_channels, dim_out=out_channels) if use_global_context else Always(1)\n",
    "        self.cross_attn = CrossAttention(\n",
    "            dim=out_channels,\n",
    "            context_dim=cond_dim,\n",
    "        )\n",
    "\n",
    "    def forward(self, x, t, y):\n",
    "        \"\"\"\n",
    "        `x` has shape `[batch_size, in_dim, height, width]`\n",
    "        `t` has shape `[batch_size, time_dim]`\n",
    "        `y` has shape `[batch_size, num_time_tokens, cond_dim]`\n",
    "        \"\"\"\n",
    "        h = self.block1(x)\n",
    "\n",
    "        # Apply condition on hidden state via cross attention\n",
    "        context = y\n",
    "        size = h.size(-2)\n",
    "        hidden = rearrange(h, \"b c h w -> b (h w) c\")\n",
    "        attn = self.cross_attn(hidden, context)\n",
    "        attn = rearrange(attn, \"b (h w) c -> b c h w\", h=size)\n",
    "        h += attn\n",
    "\n",
    "        # Add time step embeddings\n",
    "        t = self.time_emb(t)\n",
    "        t = rearrange(t, \"b c -> b c 1 1\")\n",
    "        scale_shift = t.chunk(2, dim=1)\n",
    "        h = self.block2(h, scale_shift=scale_shift)\n",
    "\n",
    "        h *= self.gca(h)\n",
    "        return h + self.shortcut(x)\n",
    "\n",
    "\n",
    "class UNetModel(nn.Module):\n",
    "    \"\"\"\n",
    "    The full UNet model with attention and timestep embedding\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        in_channels=3,\n",
    "        model_channels=128,\n",
    "        out_channels=3,\n",
    "        num_res_blocks=2,\n",
    "        attention_resolutions=(8, 16),\n",
    "        dropout=0,\n",
    "        channel_mult=(1, 2, 2, 2),\n",
    "        conv_resample=True,\n",
    "        num_heads=4,\n",
    "        label_num=10,\n",
    "        num_time_tokens=2,\n",
    "    ):\n",
    "        super().__init__()\n",
    "\n",
    "        self.in_channels = in_channels\n",
    "        self.model_channels = model_channels\n",
    "        self.out_channels = out_channels\n",
    "        self.num_res_blocks = num_res_blocks\n",
    "        self.attention_resolutions = attention_resolutions\n",
    "        self.dropout = dropout\n",
    "        self.channel_mult = channel_mult\n",
    "        self.conv_resample = conv_resample\n",
    "        self.num_heads = num_heads\n",
    "\n",
    "        # time embedding\n",
    "        time_embed_dim = model_channels * 4\n",
    "        self.time_embed = nn.Sequential(\n",
    "            nn.Linear(model_channels, time_embed_dim),\n",
    "            nn.SiLU(),\n",
    "            nn.Linear(time_embed_dim, time_embed_dim),\n",
    "        )\n",
    "\n",
    "        # condition embedding\n",
    "        cond_dim = time_embed_dim\n",
    "        self.label_embedding = nn.Embedding(label_num, time_embed_dim)\n",
    "        self.to_time_tokens = nn.Sequential(nn.Linear(time_embed_dim, num_time_tokens * cond_dim), Rearrange(\"b (r d) -> b r d\", r=num_time_tokens))\n",
    "\n",
    "        # down blocks\n",
    "        self.down_blocks = nn.ModuleList([TimestepEmbedSequential(nn.Conv2d(in_channels, model_channels, kernel_size=3, padding=1))])\n",
    "        down_block_chans = [model_channels]\n",
    "        ch = model_channels\n",
    "        ds = 1\n",
    "        for level, mult in enumerate(channel_mult):\n",
    "            for _ in range(num_res_blocks):\n",
    "                layers = [ResidualBlock(ch, mult * model_channels, time_embed_dim, dropout)]\n",
    "                ch = mult * model_channels\n",
    "                if ds in attention_resolutions:\n",
    "                    layers.append(AttentionBlock(ch, num_heads=num_heads))\n",
    "                self.down_blocks.append(TimestepEmbedSequential(*layers))\n",
    "                down_block_chans.append(ch)\n",
    "            if level != len(channel_mult) - 1:  # don't use downsample for the last stage\n",
    "                self.down_blocks.append(TimestepEmbedSequential(Downsample(ch, conv_resample)))\n",
    "                down_block_chans.append(ch)\n",
    "                ds *= 2\n",
    "\n",
    "        # middle block\n",
    "        self.middle_block = TimestepEmbedSequential(ResidualBlock(ch, ch, time_embed_dim, dropout), AttentionBlock(ch, num_heads=num_heads), ResidualBlock(ch, ch, time_embed_dim, dropout))\n",
    "\n",
    "        # up blocks\n",
    "        self.up_blocks = nn.ModuleList([])\n",
    "        for level, mult in list(enumerate(channel_mult))[::-1]:\n",
    "            for i in range(num_res_blocks + 1):\n",
    "                layers = [ResidualBlock(ch + down_block_chans.pop(), model_channels * mult, time_embed_dim, dropout)]\n",
    "                ch = model_channels * mult\n",
    "                if ds in attention_resolutions:\n",
    "                    layers.append(AttentionBlock(ch, num_heads=num_heads))\n",
    "                if level and i == num_res_blocks:\n",
    "                    layers.append(Upsample(ch, conv_resample))\n",
    "                    ds //= 2\n",
    "                self.up_blocks.append(TimestepEmbedSequential(*layers))\n",
    "\n",
    "        self.out = nn.Sequential(\n",
    "            norm_layer(ch),\n",
    "            nn.SiLU(),\n",
    "            nn.Conv2d(model_channels, out_channels, kernel_size=3, padding=1),\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.FloatTensor, t: torch.LongTensor, y: torch.LongTensor):\n",
    "        \"\"\"Apply the model to an input batch.\n",
    "\n",
    "        Args:\n",
    "            x (Tensor): [N x C x H x W]\n",
    "            t (Tensor): [N,] a 1-D batch of timesteps.\n",
    "            y (Tensor): [N,] LongTensor conditional labels.\n",
    "\n",
    "        Returns:\n",
    "            Tensor: [N x C x ...]\n",
    "        \"\"\"\n",
    "        # time step embedding\n",
    "        t = self.time_embed(timestep_embedding(t, self.model_channels))\n",
    "        y = self.label_embedding(y)\n",
    "        y = self.to_time_tokens(y)\n",
    "\n",
    "        hs = []\n",
    "        # down stage\n",
    "        h = x\n",
    "        for module in self.down_blocks:\n",
    "            h = module(h, t, y)\n",
    "            hs.append(h)\n",
    "        # middle stage\n",
    "        h = self.middle_block(h, t, y)\n",
    "        # up stage\n",
    "        for module in self.up_blocks:\n",
    "            cat_in = torch.cat([h, hs.pop()], dim=1)\n",
    "            h = module(cat_in, t, y)\n",
    "        return self.out(h)\n",
    "\n",
    "\n",
    "def linear_beta_schedule(timesteps):\n",
    "    \"\"\"\n",
    "    beta schedule\n",
    "    \"\"\"\n",
    "    scale = 1000 / timesteps\n",
    "    beta_start = scale * 0.0001\n",
    "    beta_end = scale * 0.02\n",
    "    return torch.linspace(beta_start, beta_end, timesteps, dtype=torch.float64)\n",
    "\n",
    "\n",
    "def cosine_beta_schedule(timesteps, s=0.008):\n",
    "    \"\"\"\n",
    "    cosine schedule\n",
    "    as proposed in https://arxiv.org/abs/2102.09672\n",
    "    \"\"\"\n",
    "    steps = timesteps + 1\n",
    "    x = torch.linspace(0, timesteps, steps, dtype=torch.float64)\n",
    "    alphas_cumprod = torch.cos(((x / timesteps) + s) / (1 + s) * math.pi * 0.5) ** 2\n",
    "    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]\n",
    "    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])\n",
    "    return torch.clip(betas, 0, 0.999)\n",
    "\n",
    "\n",
    "class GaussianDiffusion:\n",
    "    def __init__(self, timesteps=1000, beta_schedule=\"linear\"):\n",
    "        self.timesteps = timesteps\n",
    "\n",
    "        if beta_schedule == \"linear\":\n",
    "            betas = linear_beta_schedule(timesteps)\n",
    "        elif beta_schedule == \"cosine\":\n",
    "            betas = cosine_beta_schedule(timesteps)\n",
    "        else:\n",
    "            raise ValueError(f\"unknown beta schedule {beta_schedule}\")\n",
    "        self.betas = betas\n",
    "\n",
    "        self.alphas = 1.0 - self.betas\n",
    "        self.alphas_cumprod = torch.cumprod(self.alphas, axis=0)\n",
    "        self.alphas_cumprod_prev = F.pad(self.alphas_cumprod[:-1], (1, 0), value=1.0)\n",
    "\n",
    "        # calculations for diffusion q(x_t | x_{t-1}) and others\n",
    "        self.sqrt_alphas_cumprod = torch.sqrt(self.alphas_cumprod)\n",
    "        self.sqrt_one_minus_alphas_cumprod = torch.sqrt(1.0 - self.alphas_cumprod)\n",
    "        self.log_one_minus_alphas_cumprod = torch.log(1.0 - self.alphas_cumprod)\n",
    "        self.sqrt_recip_alphas_cumprod = torch.sqrt(1.0 / self.alphas_cumprod)\n",
    "        self.sqrt_recipm1_alphas_cumprod = torch.sqrt(1.0 / self.alphas_cumprod - 1)\n",
    "\n",
    "        # calculations for posterior q(x_{t-1} | x_t, x_0)\n",
    "        self.posterior_variance = self.betas * (1.0 - self.alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)\n",
    "        # below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain\n",
    "        self.posterior_log_variance_clipped = torch.log(self.posterior_variance.clamp(min=1e-20))\n",
    "        self.posterior_mean_coef1 = self.betas * torch.sqrt(self.alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)\n",
    "        self.posterior_mean_coef2 = (1.0 - self.alphas_cumprod_prev) * torch.sqrt(self.alphas) / (1.0 - self.alphas_cumprod)\n",
    "\n",
    "    def _extract(self, a: torch.FloatTensor, t: torch.LongTensor, x_shape):\n",
    "        # get the param of given timestep t\n",
    "        batch_size = t.shape[0]\n",
    "        out = a.to(t.device).gather(0, t).float()\n",
    "        out = out.reshape(batch_size, *((1,) * (len(x_shape) - 1)))\n",
    "        return out\n",
    "\n",
    "    def q_sample(self, x_start: torch.FloatTensor, t: torch.LongTensor, noise=None):\n",
    "        # forward diffusion (using the nice property): q(x_t | x_0)\n",
    "        if noise is None:\n",
    "            noise = torch.randn_like(x_start)\n",
    "\n",
    "        sqrt_alphas_cumprod_t = self._extract(self.sqrt_alphas_cumprod, t, x_start.shape)\n",
    "        sqrt_one_minus_alphas_cumprod_t = self._extract(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape)\n",
    "\n",
    "        return sqrt_alphas_cumprod_t * x_start + sqrt_one_minus_alphas_cumprod_t * noise\n",
    "\n",
    "    def q_mean_variance(self, x_start: torch.FloatTensor, t: torch.LongTensor):\n",
    "        # Get the mean and variance of q(x_t | x_0).\n",
    "        mean = self._extract(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start\n",
    "        variance = self._extract(1.0 - self.alphas_cumprod, t, x_start.shape)\n",
    "        log_variance = self._extract(self.log_one_minus_alphas_cumprod, t, x_start.shape)\n",
    "        return mean, variance, log_variance\n",
    "\n",
    "    def q_posterior_mean_variance(self, x_start: torch.FloatTensor, x_t: torch.FloatTensor, t: torch.LongTensor):\n",
    "        # Compute the mean and variance of the diffusion posterior: q(x_{t-1} | x_t, x_0)\n",
    "        posterior_mean = self._extract(self.posterior_mean_coef1, t, x_t.shape) * x_start + self._extract(self.posterior_mean_coef2, t, x_t.shape) * x_t\n",
    "        posterior_variance = self._extract(self.posterior_variance, t, x_t.shape)\n",
    "        posterior_log_variance_clipped = self._extract(self.posterior_log_variance_clipped, t, x_t.shape)\n",
    "        return posterior_mean, posterior_variance, posterior_log_variance_clipped\n",
    "\n",
    "    def predict_start_from_noise(self, x_t: torch.FloatTensor, t: torch.LongTensor, noise: torch.FloatTensor):\n",
    "        # compute x_0 from x_t and pred noise: the reverse of `q_sample`\n",
    "        return self._extract(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - self._extract(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise\n",
    "\n",
    "    def p_mean_variance(self, model, x_t: torch.FloatTensor, t: torch.LongTensor, y: torch.LongTensor, clip_denoised=True):\n",
    "        # compute predicted mean and variance of p(x_{t-1} | x_t)\n",
    "        # predict noise using model\n",
    "        pred_noise = model(x_t, t, y)\n",
    "        # get the predicted x_0: different from the algorithm2 in the paper\n",
    "        x_recon = self.predict_start_from_noise(x_t, t, pred_noise)\n",
    "        if clip_denoised:\n",
    "            x_recon = torch.clamp(x_recon, min=-1.0, max=1.0)\n",
    "        model_mean, posterior_variance, posterior_log_variance = self.q_posterior_mean_variance(x_recon, x_t, t)\n",
    "        return model_mean, posterior_variance, posterior_log_variance\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def p_sample(self, model, x_t: torch.FloatTensor, t: torch.LongTensor, y: torch.LongTensor, clip_denoised=True):\n",
    "        # denoise_step: sample x_{t-1} from x_t and pred_noise\n",
    "        # predict mean and variance\n",
    "        model_mean, _, model_log_variance = self.p_mean_variance(model, x_t, t, y, clip_denoised=clip_denoised)\n",
    "        noise = torch.randn_like(x_t)\n",
    "        # no noise when t == 0\n",
    "        nonzero_mask = (t != 0).float().view(-1, *([1] * (len(x_t.shape) - 1)))\n",
    "        # compute x_{t-1}\n",
    "        pred_img = model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise\n",
    "        return pred_img\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def sample(self, model: nn.Module, y: torch.LongTensor, image_size, batch_size=8, channels=3):\n",
    "        # sample new images\n",
    "        # denoise: reverse diffusion\n",
    "        shape = (batch_size, channels, image_size, image_size)\n",
    "        device = next(model.parameters()).device\n",
    "        # start from pure noise (for each example in the batch)\n",
    "        img = torch.randn(shape, device=device)  # x_T ~ N(0, 1)\n",
    "        imgs = []\n",
    "        for i in tqdm(reversed(range(0, self.timesteps)), desc=\"sampling loop time step\", total=self.timesteps):\n",
    "            t = torch.full((batch_size,), i, device=device, dtype=torch.long)\n",
    "            img = self.p_sample(model, img, t, y)\n",
    "            imgs.append(img.cpu().numpy())\n",
    "        return imgs\n",
    "\n",
    "    def train_losses(self, model, x_start: torch.FloatTensor, t: torch.LongTensor, y: torch.LongTensor):\n",
    "        # compute train losses\n",
    "        noise = torch.randn_like(x_start)  # random noise ~ N(0, 1)\n",
    "        x_noisy = self.q_sample(x_start, t, noise=noise)  # x_t ~ q(x_t | x_0)\n",
    "        predicted_noise = model(x_noisy, t, y)  # predict noise from noisy image and condition\n",
    "        loss = F.mse_loss(noise, predicted_noise)\n",
    "        return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81387cdf",
   "metadata": {},
   "source": [
    "看看效果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cccd64a2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-09-22T17:49:17.254252Z",
     "start_time": "2022-09-22T17:49:16.223580Z"
    }
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import requests\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import datasets, transforms\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eea4f90a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-09-22T17:49:19.136721Z",
     "start_time": "2022-09-22T17:49:17.256333Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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