メインコンテンツへスキップ
見出し画像

画像生成AIの進化史⑭DDPMでMNIST

    前回までにDDPMの理論的な説明と実装のガイドラインの解説が終わりました。あとは、ノイズ予測モデルを実装すれば学習・生成の実験が行えるようになります。

    その具体例として、MNISTの手書き文字の生成を行います。

    画像
    MNISTの手書き文字の例

    まずは、前回に解説したノイズ予測モデルの実装から始めます。最終的にはMNISTで学習を行ったモデルで画像を生成してそのクオリティを確認します。

    なお、再現するためのすべてのコードは最後にまとめてあります。

    ノイズ予測モデル

    ノイズ予測モデルは、U-Netをベースにしています。それを構成する各コンポーネントを実装していきます。

    残差ブロック

    残差ブロックは、U-Netの各段階における特徴量抽出のために使われます。その定義は以下になります。

    # ----------------------------------------------------------------------
    # グループ正規化を使用した残差ブロック
    # ----------------------------------------------------------------------
    class ResidualBlock(nn.Module):
        def __init__(self, in_ch, out_ch, t_dim):
            super().__init__()
    
            # グループ正規化を使用した残差ブロック
            self.block1 = nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 3, padding=1),
                nn.GroupNorm(32, out_ch),
                nn.SiLU()
            )
    
            self.block2 = nn.Sequential(
                nn.Conv2d(out_ch, out_ch, 3, padding=1),
                nn.GroupNorm(32, out_ch),
                nn.SiLU()
            )
    
            # 時間ステップの埋め込みを線形変換するMLP
            self.time_mlp = nn.Linear(t_dim, out_ch)
    
            # ショートカット接続
            if in_ch != out_ch:
                # 入力チャンネル数と出力チャンネル数が異なる場合は1x1畳み込みで調整
                self.shortcut = nn.Conv2d(in_ch, out_ch, 1)
            else:
                # 入力と出力のチャンネル数が同じ場合は恒等写像を使用
                self.shortcut = nn.Identity()
    
        def forward(self, x, t_emb):
            h = self.block1(x)
            h = h + self.time_mlp(t_emb)[:, :, None, None]
            h = self.block2(h)
            return h + self.shortcut(x)  # 残差接続を追加

    残差ブロックは、グループ正規化(グループ数32)を使用した畳込み層です。活性化にSwish活性化関数(SiLU)を使います。この畳み込みブロックを2回繰り返します。

    最初の畳み込み層(block1)の後に、時間ステップの埋め込み(後で解説)を追加し、2番目の畳み込み層(block2)を適用します。

    最後に、残差接続を行いますが、入力と出力のチャンネル数が異なる場合は、1x1畳こみで入力のチャンネル数を調節してから接続します。

    この残差ブロックは、エンコーダ、ボトルネック、デコーダで使用されます。

    自己アテンション

    自己アテンションは、画像上の広域な関係によって特徴量を抽出するために使われます。その定義は以下になります。

    # ----------------------------------------------------------------------
    # 自己アテンションブロック
    # ----------------------------------------------------------------------
    class SelfAttention(nn.Module):
        def __init__(self, ch):
            super().__init__()
    
            # 1x1畳込みで、各ピクセル位置からQuery (Q), Key (K), Value (V) を生成
            self.q = nn.Conv2d(ch, ch, 1)
            self.k = nn.Conv2d(ch, ch, 1)
            self.v = nn.Conv2d(ch, ch, 1)
            self.proj = nn.Conv2d(ch, ch, 1)
    
        def forward(self, x):
            B, C, H, W = x.shape
    
            # 画像の空間次元 (H, W) を一つのシーケンス長 (HW) と見なし、アテンションを計算
            # (チャンネル数Cが埋め込み次元)
            q = self.q(x).reshape(B, C, H*W).permute(0,2,1)   # (B, HW, C)
            k = self.k(x).reshape(B, C, H*W)                  # (B, C, HW)
            v = self.v(x).reshape(B, C, H*W).permute(0,2,1)   # (B, HW, C)
    
            attn = torch.bmm(q, k) / (C ** 0.5)               # (B, HW, HW)
            attn = attn.softmax(dim=-1)
    
            out = torch.bmm(attn, v)                          # (B, HW, C)
            out = out.permute(0,2,1).reshape(B, C, H, W)
            out = self.proj(out)
    
            return out + x  # 残差接続

    これは標準的な自己アテンションの実装です。行列同士の積を計算するために、テンソルの形を調節していることに注意すると、やっていることは以下の図にある通りです。

    画像
    Attention Is All You Need

    言語モデルではないので、将来のトークンを隠す目的である Mask (opt.) は、ここでは使用されていません。

    数式的には以下になります。

    画像
    Attention Is All You Need

    scale=dk\text{scale} = \sqrt{d_k}で、dkd_kとは、キー(K)の埋め込みの次元です。ここではクエリ(Q)とキー(K)のベクトル次元数がチャンネル数と同じなのでCをdkd_kとして使っています。

    最後に線形変換と残差接続が行われています。

    エンコーダ

    エンコーダは画像の特徴を抽出してから、ダウンサンプリング(画像を縮小)していきます。これがU-Netの「Uの字」左側に相当します。

    各段階において、次に定義されるエンコーダブロックを使います。

    # ----------------------------------------------------------------------
    # エンコーダブロック(ダウンサンプリング)
    # ----------------------------------------------------------------------
    class Encode(nn.Module):
        def __init__(self, in_ch, out_ch, t_emb_dim, atten=False, down=True):
            super().__init__()
     
            self.block1 = ResidualBlock(in_ch, out_ch, t_emb_dim)
            self.block2 = ResidualBlock(out_ch, out_ch, t_emb_dim)
            self.atten  = SelfAttention(out_ch) if atten else nn.Identity()
            self.down   = nn.Conv2d(out_ch, out_ch, 3, 2, 1) \
                if down else nn.Identity()
    
        def forward(self, x, t_emb):
            x = self.block1(x, t_emb)
            x = self.block2(x, t_emb)
            x = self.atten(x)
            return self.down(x), x  # アップサンプリングに結合用

    ここでは残差ブロックを2回繰り返し、必要に応じて自己アテンションを適用し、ダウンサンプリング(縦横を1/2に縮小)を行います。

    アテンションは、画像が中間の大きさ(例:16x16)で行われます。画像が大きい段階(例:32x32)だと計算量が膨大になり、また画像が小さい段階(例:8x8)では、アテンションを使うほどのことではないからです。

    最後に返すのは、エンコーダブロックの出力と、後でデコーダへスキップ接続するためのものです。これはダウンサンプリングされる以前のものを返してより詳細な情報をデコーダへと伝える役割を果たします。

    ボトルネック

    ボトルネックは、U-Netの「Uの字」の底の部分です。ここでは、基本的にエンコーダと同じように残差ブロックを2回繰り返しますが、アテンションやダウンサンプリングは行いません。よって、Encodeでdown=Falseを指定して使います。

    デコーダ

    デコーダは、画像をアップサンプリング(画像を拡大)していきます。これがU-Netの「Uの字」右側に相当します。

    各段階において、次に定義されるデコーダブロックを使います。

    # ----------------------------------------------------------------------
    # デコーダブロック(アップサンプリング)
    # ----------------------------------------------------------------------
    class Decode(nn.Module):
        def __init__(self, in_ch, out_ch, t_emb_dim, atten=False):
            super().__init__()
    
            self.up = nn.Sequential(
                nn.Upsample(scale_factor=2, mode='nearest'),
                nn.Conv2d(in_ch, out_ch, 3, padding=1)  # アップサンプリング
            )
            self.block1 = ResidualBlock(out_ch*2, out_ch, t_emb_dim)
            self.block2 = ResidualBlock(out_ch, out_ch, t_emb_dim)
            self.atten  = SelfAttention(out_ch) if atten else nn.Identity()
    
        def forward(self, x, t_emb, skip):
            x = self.up(x)
            x = torch.cat([x, skip], dim=1)  # エンコーダからのスキップ接続
            x = self.block1(x, t_emb)
            x = self.block2(x, t_emb)
            x = self.atten(x)
            return x

    アップサンプリング(縦横を2倍に拡大)し、3×3の畳み込みでチャンネル変換と滑らかな補正を行う層です。

    「滑らかな補正」というのは、単純な最近傍補間で生じるブロック状・ギザギザのパターンを、畳み込みでなめらかに整えることを指します。

    つまり、Upsampleで拡大しただけの荒い特徴マップを、畳み込み層がより自然で連続的な表現に変換するイメージです。

    この部分は、転置畳み込み(ConvTranspose2d)を使うことも可能です。

    ConvTranspose2d は便利ですが、格子状アーティファクト(画像を生成・復元する際に、市松模様のような規則的な格子パターンが不自然に出てしまう現象)が出やすいと言われています。

    次に、エンコーダからの特徴マップとデコーダの特徴マップをチャンネル方向(dim=1)に連結(スキップ接続)しています。これを、2つの残差ブロックを通し、最後に必要に応じて自己アテンションを適用します。

    こうして、エンコーダから得た細かい特徴を混ぜて、拡大された画像の特徴と合わせてノイズを予測していきます。

    ステップのエンコーディング

    時間ステップを埋め込みベクトルにすることで、ニューラルネットワークが扱いやすいようにしています。

    まずは、ステップttを以下のように三角関数によってエンコードします。

    # ----------------------------------------------------------------------
    # サイン・コサインによるタイムステップのエンコーディング
    # ----------------------------------------------------------------------
    def sinusoidal_time_encoding(t: torch.Tensor, dim: int) -> torch.Tensor:
        # dimは埋め込み次元(チャンネル数)で、偶数である必要がある
        half_dim = dim // 2
    
        # 埋め込み次元方向のインデックス
        embedding_indices = torch.arange(
            half_dim, dtype=torch.float32, device=t.device)
    
        # インデックスに応じたスケールを計算(対数スケールで広げる)
        scale_factors = 10000 ** (-embedding_indices / (half_dim - 1))
    
        # 時間ステップをスケール
        scaled_t = t[:, None].float() * scale_factors[None, :]
    
        # サイン・コサイン
        return torch.cat([torch.sin(scaled_t), torch.cos(scaled_t)], dim=-1)

    これは、オリジナルのトランスフォーマーが行なっていた位置エンコーディングと同じ計算です。ただし、ここではトークンの位置ではなく、拡散過程のステップをエンコーディングしています。

    画像
    Attention Is All You Need

    DDPMの文脈では以下のように解釈します。

    • pos はもとは「位置」(Position)の意味だが、DDPMでは「時間ステップ」

    • i は、埋め込み次元のインデックス。DDPMでは「チャンネル」

    ただし、実装ではバッチ処理しているので少し分かりにくくなっています。以下に順番に解説します。

    def sinusoidal_time_encoding(t: torch.Tensor, dim: int) -> torch.Tensor:
        ...

    入力 t は、バッチサイズ分の時間ステップを含む整数テンソルです。また、dim は、埋め込み次元(チャンネル数)です。

    バッチの各画像に対して異なるステップを指定できるように書かれています。

    埋め込み次元の2つを一つのペアとして扱うので、dim の半分の次元で1のインデックスを準備します。

        # dimは埋め込み次元(チャンネル数)で、偶数である必要がある
        half_dim = dim // 2

    これを使って埋め込み次元のインデックスを準備します。

        # 埋め込み次元方向のインデックス
        indices = torch.arange(half_dim, dtype=torch.float32, device=t.device)

    これが数式のiiに相当します。

    i∈{0,1,…,half_dim−1}i \in \biggl\{0,1, \ldots, \text{half\_dim} −1\biggr\}

    次に、このインデックスに応じたスケールを計算します。

        # インデックスに応じたスケールを計算
        scales = torch.exp(-math.log(10000.0) * indices / (half_dim - 1))

    ここで対数と指数を使って計算しているのは、10000の指数計算を直接行うと非常に大きな次元や値で数値的に不安定になることがあるからです。よって、以下の変形を行います。

    1100002i/dmodel=exp⁡(log⁡(1100002i/dmodel))=exp⁡(−log⁡(100002i/dmodel))=exp⁡(−log⁡(10000)×2idmodel)=exp⁡(−log⁡(10000)×idmodel/2)\begin{aligned} \frac{1}{10000^{2i/d_\text{model}}} &= \exp\left(\log\left(\frac{1}{10000^{2i/d_\text{model}}}\right)\right) \\[3ex] &= \exp\left(-\log\left(10000^{2i/d_\text{model}}\right)\right) \\[2ex] &= \exp\left(-\log\left(10000\right) \times \frac{2i}{d_\text{model}}\right) \\[2ex] &= \exp\left(-\log\left(10000\right) \times \frac{i}{d_\text{model}/2}\right) \end{aligned}

    また、dmodel/2d_\text{model} /2は、コードではhalf_dim−1\text{half\_dim}-1に相当します。

    2idmodel=idmodel/2⟹ indexhalf_dim−1\frac{2i}{d_\text{model}} = \frac{i}{d_\text{model}/2} \quad \Longrightarrow \quad  \frac{\text{index}}{\text{half\_dim}-1}

    次に、時間ステップtt(posに相当)を、すべての埋め込み次元に対してスケールします。

        # 時間ステップをスケール(角度に相当)
        angles = t[:, None].float() * scales[None, :]

    ここでの形状変換は、以下になります。

    • t: (batch_size,) → (batch_size, 1)

    • scales: (half_dim,) → (1, half_dim)

    二つの積によって、angles の形状が(batch_size, half_dim)になります。つまり、バッチ内の各時間ステップを全ての埋め込み次元に対してスケールしています。

    最後に、埋め込み次元のインデックスに対してsin と cos を交互に計算します。

        # サイン・コサインによる時間ステップのエンコーディング
        enc = torch.zeros(t.shape[0], dim, device=t.device)
        enc[:, 0::2] = torch.sin(angles)
        enc[:, 1::2] = torch.cos(angles)
        return enc

    以上の処理によって、各画像の時間ステップttは、指定した埋め込み次元数(チャンネル数)と同じ次元を持つ連続的な埋め込みベクトルに変換されました。

    ステップの埋め込み

    時間ステップのエンコーディングをもとに、時間ステップの埋め込みを学習できるようにします。

    # ----------------------------------------------------------------------
    # 時間ステップの埋め込みを行うMLP
    # ----------------------------------------------------------------------
    class TimeEmbedding(nn.Module):
        def __init__(self, t_dim):
            super().__init__()
            self.t_dim = t_dim
            self.mlp = nn.Sequential(
                nn.Linear(t_dim, t_dim * 4),
                nn.SiLU(),
                nn.Linear(t_dim * 4, t_dim),
            )
    
        def forward(self, t):
            emb = sinusoidal_time_encoding(t, self.t_dim)
            return self.mlp(emb)

    これは線形変換に活性化のSiLUを挟んだものです。

    U-Netの全体像

    すべてのコンポーネントを使って、U-Netを以下のように定義します。

    # ----------------------------------------------------------------------
    # U-Netアーキテクチャの定義
    # ----------------------------------------------------------------------
    class UNet(nn.Module):
        def __init__(self, image_ch: int, base_ch: int, t_dim: int):
            super().__init__()
    
            # 時間ステップの埋め込み
            self.time_mlp = TimeEmbedding(t_dim)
    
            # エンコーダ
            self.enc1 = Encode(image_ch , base_ch  , t_dim)
            self.enc2 = Encode(base_ch  , base_ch*2, t_dim, atten=True)
            self.enc3 = Encode(base_ch*2, base_ch*2, t_dim)
    
            # ボトルネック
            self.neck = Encode(base_ch*2, base_ch*2, t_dim, down=False)
    
            # デコーダ
            self.dec1 = Decode(base_ch*2, base_ch*2, t_dim)
            self.dec2 = Decode(base_ch*2, base_ch*2, t_dim, atten=True)
            self.dec3 = Decode(base_ch*2, base_ch  , t_dim)
    
            # Output
            self.out_conv = nn.Conv2d(base_ch, image_ch, 1)
    
        def forward(self, x, t):
            # 時間ステップの埋め込み
            t_emb = self.time_mlp(t)
    
            # エンコーダ
            x, skip1 = self.enc1(x, t_emb)
            x, skip2 = self.enc2(x, t_emb)
            x, skip3 = self.enc3(x, t_emb)
    
            # ボトルネック
            x, _ = self.neck(x, t_emb)
    
            # デコーダ
            x = self.dec1(x, t_emb, skip3)
            x = self.dec2(x, t_emb, skip2)
            x = self.dec3(x, t_emb, skip1)
    
            return self.out_conv(x)

    まず、U-Netの foward 処理では、最初に時間ステップを埋め込みに変換します。それがエンコーダ、ボトルネック、デコーダに渡されます。

    エンコーダでは、画像のチャンネル数からベースのチャンネル数(base_ch)へ次元を増やし、さらにその2倍のチャンネル数(base_ch x 2)へと拡張します。

    3つのエンコーダで縮小していくので、例えば、32 x 32 => 16 x 16 => 8 x 8 => 4 x 4 と画像のサイズは小さくなります。また、デコーダへのスキップ接続のために skip1, skip2, skip3 を使います。

    ボトルネックはさらに残差接続による処理を行います。ここでは、アテンションも縮小もありません。

    3つデコーダは、ボトルネックの出力を 4x4 => 8x8 => 16 x 16 => 32 x 32と拡大しながら、エンコーダからのスキップ接続を受け取りノイズの予測をしていきます。

    最後の畳み込みで、画像のチャンネル数に調節されたものがノイズの予測となります。

    拡散モデルの構成

    拡散モデルの実装はすでに解説済みですが、ここにまとめておきます。

    デバイス設定

    まずは、PyTorchが使うデバイスを設定します。

    # ----------------------------------------------------------------------
    # デバイス設定
    # ----------------------------------------------------------------------
    if torch.backends.mps.is_available():
       device = torch.device("mps")
    elif torch.cuda.is_available():
       device = torch.device("cuda")
    else:
       device = torch.device("cpu")
    print(f"Using device: {device}")

    これは、環境に合わせて変更してください。例えば、マルチGPUを持っていて cuda:1 を使う場合はここで設定できます。

    分散スケジュール

    分散スケジュールは、DDPMの論文に書いてある通りの設定にしてあります。

    # ----------------------------------------------------------------------
    # 分散スケジュール
    # ----------------------------------------------------------------------
    T = 1000     # 時間ステップ数
    beta_start = 1e-4
    beta_end = 0.02
    
    betas = torch.linspace(beta_start, beta_end, T).to(device)
    alphas = 1. - betas
    alpha_bars = torch.cumprod(alphas, dim=0)  # 累積積

    拡散過程

    拡散過程では、以下の sample_q を使って、与えられたステップに対するノイズ付き画像を準備します。

    # ----------------------------------------------------------------------
    # 拡散過程 Q(x_t | x_0) からサンプリングする順方向の処理
    # ----------------------------------------------------------------------
    def sample_q(
        x_0: torch.Tensor,  # 画像データ(バッチ、チャンネル、高さ、幅)
        t: torch.Tensor,    # ステップ数(バッチサイズ分のテンソル)
    ):
        # 画像データx_0 と同じ形状(バッチ、チャンネル、高さ、幅)のノイズを生成
        epsilon = torch.randn_like(x_0)
    
        # tに対応するalpha_barを取得(4次元テンソルに変形)
        alpha_bar_t = alpha_bars[t].view(-1, 1, 1, 1)
    
        # ノイズを加えた画像を生成
        x_t = (alpha_bar_t.sqrt() * x_0 + (1 - alpha_bar_t).sqrt() * epsilon)
    
        # ラベルとしてノイズも返す
        return x_t, epsilon

    生成過程

    生成過程では、以下の sample_p を使って、ステップttにおけるノイズ付き画像からステップt−1t-1のノイズ画像をサンプリングします。

    # ----------------------------------------------------------------------
    # 生成過程 P_θ(x_{t-1} | x_t) からサンプリングする逆方向の処理
    # ----------------------------------------------------------------------
    def sample_p(
        x_t: torch.Tensor,  # ノイズ付き画像(バッチ、チャンネル、高さ、幅)
        t: torch.Tensor,    # ステップ数(バッチサイズ分のテンソル)
        noise_pred: torch.Tensor  # モデルによるノイズ予測(バッチ、チャンネル、高さ、幅)
    ):
        # tに対応するalpha_barとbetaを取得(4次元テンソルに変形)
        beta = betas[t].view(-1, 1, 1, 1)
        alpha = alphas[t].view(-1, 1, 1, 1)
        s1_ab = torch.sqrt(1 - alpha_bars[t]).view(-1, 1, 1, 1)
    
        # 平均を計算
        mean = (1 / torch.sqrt(alpha)) * (x_t - beta / s1_ab * noise_pred)
    
        # ステップ 0 ではノイズを加えない(決定的出力)
        mask = (t != 0).float().view(-1, 1, 1, 1)
    
        # サンプリングのノイズを追加
        noise = torch.randn_like(x_t)
        return mean + torch.sqrt(beta) * noise * mask

    ただし、ステップt=0t=0ではサンプリングを行わないので、予測された平均の値をそのまま返します。これは mask によってノイズを加えるかどうかを判断しています。

    サンプリングによる画像生成

    画像生成では、与えられたノイズをステップt=Tt = Tからt=0t=0まで逆過程を通してサンプリングしていきます。

    # ----------------------------------------------------------------------
    # サンプリング関数(画像生成)
    # ----------------------------------------------------------------------
    def sample(model: nn.Module, x: torch.Tensor):
        # xはノイズ画像(バッチ、チャンネル、高さ、幅)
        n_samples = x.shape[0]
    
        # 時間ステップを逆順にサンプリン
        for t_step in reversed(range(T)):
            # 時間ステップをテンソルに変換
            t = torch.full((n_samples,), t_step, device=x.device, dtype=torch.long)
    
            # ノイズ予測を行う
            noise_pred = model(x, t)
    
            # 生成過程によって次のステップの画像をサンプリング
            x = sample_p(x, t, noise_pred)
        return x

    ここでは、ノイズ予測モデル(model)が予測したノイズを sample_p に渡して、一つ前のステップの画像を逐次的に予測していきます。ステップt=0t=0に到達した時点の画像が生成された画像となります。

    画像表示

    以下は、生成された複数の画像をグリッド表示するためのヘルパー関数です。

    # ----------------------------------------------------------------------
    # 生成画像の表示
    # ----------------------------------------------------------------------
    def show_images(samples, n_images_per_row: int=None):
        if n_images_per_row is None:
            n_images_per_row = samples.shape[0]  # デフォルトはサンプル数
    
        # 画像の値を0-1の範囲に正規化
        samples = (samples + 1) / 2  # [-1, 1] -> [0, 1]
        samples = samples.clamp(0, 1)  # 0-1の範囲にクリップ
        samples = samples.cpu()
    
        # グリッド形式で表示するためのテンソルを作成
        grid = utils.make_grid(samples, nrow=n_images_per_row)
    
        # (B, C, H, W) -> (B, H, W, C)に変換して表示
        plt.imshow(grid.permute(1, 2, 0).numpy())
        plt.axis('off')
        plt.tight_layout()
        plt.show()

    まず、画像の値を[-1, 1]の範囲から[0, 1]の範囲に正規化します。

    ただし、DDPMの出力はガウス分布によるため、この範囲に収まるとは限りません。学習によって多くのピクセルは範囲内で予測されるようになりますが、そうでないものは、clamp によって[0, 1]の範囲にクリップします。

    また、GPUなどを使っている場合を考慮して、.cpu() でCPUに画像を移動しています。

    あとは、PyTorch の make_grid を利用して matplotlib でグリッド表示します。

    MNISTでの学習

    ハイパーパラメータ

    以下は、学習・生成のためのハイパーパラメータです。

    # ----------------------------------------------------------------------
    # ハイパーパラメータの設定
    # ----------------------------------------------------------------------
    image_ch       = 1
    image_size     = 32       # 28x28 => 32x32にリサイズされる
    base_ch        = 64
    t_dim          = 128
    epochs         = 200
    batch_size     = 128

    MNISTの画像にはチャンネルが1つしかないので、image_ch = 1となっています。また、画像サイズは、28 x 28ですが、DDPMのCIFAR10(32x32)に対する実装を参考にしているため、MNISTの画像を 32x32 にリサイズします。

    こうしないと、エンコーダによるダウンサンプリングが 28x28 => 14x14 => 7x7 => 4x4 となるため、デコーダによるアップサンプリングが、4x4 => 8x8 => 16x16 => 32x32となりエンコーダからのスキップ接続が成立しません。

    もちろん、U-Net内でパディングなどを使って調節はできますが、入力画像をリサイズすれば、その必要もありません。

    あとは、U-Netにおけるベースのチャネル数、時間ステップの埋め込み次元数、訓練ループのエポック数、バッチサイズなどを指定しています。

    データの前処理

    PyTorchのデータセットとデータローダを使ってMNISTのデータを読み込みます。

    # ----------------------------------------------------------------------
    # データセットの読み込みとデータローダーの設定
    # ----------------------------------------------------------------------
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Resize((image_size, image_size)),  # リサイズ
        transforms.Lambda(lambda x: x * 2 -1)
    ])
    dataset = datasets.MNIST(
        root="./data",
        train=True,
        download=True,
        transform=transform,
    )
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    なお、transforms.ToTensor() は、画像データ(Numpy)をPyTorchのテンソル型に変換します。その際に、0 ~ 255の整数データが0.0 ~ 1.0に標準化されます。

    その次に、画像サイズは 32x32 にリサイズします。最後の Lambda (ラムダ)は、0.0 ~ 1.0 のピクセル値を -1.0 ~ +1.0 に変換しています。これは拡散過程の最終ノイズ画像が標準正規分布に近づくようにするためです。

    モデルとオプティマイザ

    U-Netのオブジェクトを作成して、パラメータ最適化のためのオプティマイザを設定します。

    # ----------------------------------------------------------------------
    # UNetモデルの初期化とオプティマイザの設定
    # ----------------------------------------------------------------------
    model = UNet(image_ch, base_ch, t_dim).to(device)
    
    optimizer = torch.optim.Adam(model.parameters(), lr=2e-4)

    アダム(Adam)を使い、学習率を0.0002にしているのは論文のとおりです。

    EMAモデルの設定

    学習中のモデルパラメータは、オプティマイザの更新によりバッチごとに大きく揺れることがあります。そこで、U-Netの学習では、EMAモデルを使用します。

    # ----------------------------------------------------------------------
    # EMAモデルの設定
    # ----------------------------------------------------------------------
    ema_model = copy.deepcopy(model)
    ema_model.eval()  # 評価モードに設定
    ema_decay = 0.9999

    EMA(Exponential Moving Average、指数移動平均)モデルを学習で使用する理由は、推論時の生成結果をより安定させ、高品質にするためです。

    θema←βθema+(1− β)θ\theta_{\text{ema}} \leftarrow \beta \theta_{\text{ema}} + (1 - \beta) \theta

    • θ\theta:現在の学習中のモデルパラメータ

    • θema\theta_{\text{ema}}​:EMAで平滑化した「平均的な」パラメータ

    • β\beta:減衰率(例:0.9999)

    実際に訓練されるのは、model ですが、学習中の重みはノイズやバッチごとの揺らぎによって頻繁に変動するため、別に用意したEMAモデルでは過去のパラメータを重く保持しつつ、新しいパラメータを少しずつ混ぜるようにしています。

    # EMAモデルの更新(学習ループの中)
    with torch.no_grad():
        for ema_param, param in zip(ema_model.parameters(), model.parameters()):
            ema_param.data.mul_(ema_decay).add_(param.data, alpha=1 - ema_decay)

    下線がついたメソッド(mul_、add_)は、テンソルを直接に変更するという意味です。ema_param.data.mul_(ema_decay)で、EMAモデルのデータに0.9999を掛け、.add_(param.data, alpha=1 - ema_decay)で、modelのパラメータに0.0001を掛けたものを加算しています。

    これによって、過去のパラメータの情報を「重く」保持し、学習中の短期的なノイズを除いた滑らかな重みの平均になります。

    学習ループ

    学習ループは以下のようになっています。

    # ----------------------------------------------------------------------
    # 学習ループ
    # ----------------------------------------------------------------------
    for epoch in range(1,epochs+1):
        for x_0, _ in dataloader:
            # 画像データをデバイスに転送
            x_0 = x_0.to(device)
    
            # ランダムな時間ステップからノイズ付き画像を生成
            t = torch.randint(0, T, (x_0.size(0),), device=device)
            x_t, epsilon = sample_q(x_0, t)  # ノイズをラベルとして返す
    
            # ノイズ予測を行い、損失を計算
            noise_pred = model(x_t, t)
            loss = F.mse_loss(noise_pred, epsilon)
    
            # 勾配の計算とパラメータの更新
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
            # EMAモデルの更新
            with torch.no_grad():
                for ema_param, param in zip(ema_model.parameters(),
                                            model.parameters()):
                    ema_param.data.mul_(ema_decay).add_(
                        param.data, alpha=1 - ema_decay)
    
        print(f"Epoch {epoch}/{epochs}, Loss: {loss.item():.4f}")

    順番に解説します。まず、データローダからバッチを受け取り指定されたデバイスに転送します。

    for epoch in range(1,epochs+1):
        for x_0, _ in dataloader:
            # 画像データをデバイスに転送
            x_0 = x_0.to(device)

    次に、ランダムな時間ステップを選び、ノイズ付き画像を sample_q を使って生成します。その際に、ノイズそのものである epsilon も返しています。

            # ランダムな時間ステップからノイズ付き画像を生成
            t = torch.randint(0, T, (x_0.size(0),), device=device)
            x_t, epsilon = sample_q(x_0, t)  # ノイズをラベルとして返す

    ノイズ予測モデル(U-Net)が予測したノイズと正解のノイズで損失(平均2乗誤差)を計算します。

            # ノイズ予測を行い、損失を計算
            noise_pred = model(x_t, t)
            loss = F.mse_loss(noise_pred, epsilon)

    U-Netモデルのパラメータをオプティマイザ(Adam)で更新します。

            # 勾配の計算とパラメータの更新
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

    次に、EMAモデルのパラメータを更新します。

            # EMAモデルの更新
            with torch.no_grad():
                for ema_param, param in zip(ema_model.parameters(),
                                            model.parameters()):
                    ema_param.data.mul_(ema_decay).add_(
                        param.data, alpha=1 - ema_decay)

    エポックが終了するごとに、損失を報告します。

        print(f"Epoch {epoch}/{epochs}, Loss: {loss.item():.4f}")

    あと、10エポックごとに、生成画像を表示して、学習の進み具体を可視化します。この時にモデルの重みも保存しておきます。

        if epoch % 10 == 0 or epoch == epochs:
            # 学習中のサンプル画像を生成して表示
            with torch.no_grad():
                # ノイズ画像から画像を生成
                noise = torch.randn(10, image_ch, image_size, image_size).to(device)
                samples = sample(ema_model, noise)
            show_images(samples)
    
            # EMAモデルの保存
            model_path = f'DDPM-MNIST-{epoch:03d}.pth'  # モデルの保存パス
            torch.save(ema_model.state_dict(), model_path)

    以上の処理をエポックが終了するまで繰り返します。

    実験結果

    エポック10

    エポック10までの損失値は以下のようになっています。

    Epoch 1/200, Loss: 0.0218
    Epoch 2/200, Loss: 0.0250
    Epoch 3/200, Loss: 0.0152
    Epoch 4/200, Loss: 0.0223
    Epoch 5/200, Loss: 0.0165
    Epoch 6/200, Loss: 0.0212
    Epoch 7/200, Loss: 0.0206
    Epoch 8/200, Loss: 0.0150
    Epoch 9/200, Loss: 0.0169
    Epoch 10/200, Loss: 0.0126

    この損失値は、model によるものです。EMAモデルではありません。

    なお、この時点でのEMAモデルで生成した画像はまだ形になっていません。

    画像

    エポック50

    エポック50になる頃の損失値は以下のようになっています。

    Epoch 41/200, Loss: 0.0114
    Epoch 42/200, Loss: 0.0141
    Epoch 43/200, Loss: 0.0157
    Epoch 44/200, Loss: 0.0135
    Epoch 45/200, Loss: 0.0194
    Epoch 46/200, Loss: 0.0107
    Epoch 47/200, Loss: 0.0137
    Epoch 48/200, Loss: 0.0141
    Epoch 49/200, Loss: 0.0140
    Epoch 50/200, Loss: 0.0153

    EMAモデルで生成した画像は数字として成り立っています。

    画像

    エポック100

    損失に大きな動きはないようです。

    Epoch 91/200, Loss: 0.0144
    Epoch 92/200, Loss: 0.0171
    Epoch 93/200, Loss: 0.0152
    Epoch 94/200, Loss: 0.0106
    Epoch 95/200, Loss: 0.0128
    Epoch 96/200, Loss: 0.0167
    Epoch 97/200, Loss: 0.0120
    Epoch 98/200, Loss: 0.0145
    Epoch 99/200, Loss: 0.0148
    Epoch 100/200, Loss: 0.0185

    EMAモデルによる画像のクオリティもそれほど変化はない感じがします。

    画像

    ここで止めても良さそうですが、200エポックまで訓練を行いました。

    エポック200

    数時間かけてエポック200が終了しました。

    Epoch 191/200, Loss: 0.0155
    Epoch 192/200, Loss: 0.0122
    Epoch 193/200, Loss: 0.0115
    Epoch 194/200, Loss: 0.0116
    Epoch 195/200, Loss: 0.0117
    Epoch 196/200, Loss: 0.0138
    Epoch 197/200, Loss: 0.0133
    Epoch 198/200, Loss: 0.0147
    Epoch 199/200, Loss: 0.0149
    Epoch 200/200, Loss: 0.0119
    画像

    100個の画像を生成

    最後に、保存したEMAモデルで100個の手書き数字を生成してみました。

    # 学習済みモデルの読み込み
    model = UNet(image_ch, base_ch, t_dim).to(device)
    model.load_state_dict(torch.load("DDPM-MNIST-200.pth", map_location=device))
    
    # 学習済みモデルを使用して画像を生成
    model.eval()
    with torch.no_grad():
        # ノイズ画像から画像を生成
        noise = torch.randn(100, image_ch, image_size, image_size).to(device)
        samples = sample(model, noise)
    show_images(samples, 10)
    画像
    生成されたMNIST画像

    これは、本物(下)と見分けつかないほどよくできています。

    画像
    本物のMNIST画像

    CIFAR10でやるとしたら

    論文ではMNISTではなく、CIFAR10で実験しています。そこで、今回の実装をCIFAR10用に変更するガイドラインを紹介します。

    ドロップアウト

    CIFAR10では、残差ブロックにドロップアウト(p=0.1)を適用したとのことなので、ResidualBlockに変更が必要です。

    たとえば、こんな感じになります。

    # ----------------------------------------------------------------------
    # グループ正規化を使用した残差ブロック
    # ----------------------------------------------------------------------
    class ResidualBlock(nn.Module):
        def __init__(self, in_ch, out_ch, t_dim):
            super().__init__()
    
            # グループ正規化を使用した残差ブロック
            self.block1 = nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 3, padding=1),
                nn.GroupNorm(32, out_ch),
                nn.SiLU()
            )
    
            self.block2 = nn.Sequential(
                nn.Conv2d(out_ch, out_ch, 3, padding=1),
                nn.GroupNorm(32, out_ch),
                nn.SiLU(),
                nn.Dropout(0.1)  # ドロップアウトを追加
            )
    
            ....

    ただし、ドロップアウトを挿入する位置は実装によって異なるものが見られます。

    ハイパーパラメータ

    また、ハイパーパラメータも以下のような設定になるでしょう。

    image_ch       = 3
    image_size     = 32       # CIFAR10は32x32なのでリサイズなし
    base_ch        = 128
    t_dim          = 512
    epochs         = 2000
    batch_size     = 128

    DDPMがCIFAR-10に対して学習されたとき、論文によると「80万ステップ」学習させたと書いてあります。

    CIFAR-10の訓練セットは50,000枚なので、80万(800,000)ステップは約2,051エポックに相当します。

    ランダム水平フリップ

    さらに、画像をランダムに水平フリップ(左右反転)するということなので、transform に次のような変更も必要です。

    # ----------------------------------------------------------------------
    # データセットの読み込みとデータローダーの設定
    # ----------------------------------------------------------------------
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.RandomHorizontalFlip(),  # 水平方向のランダムフリップ
        transforms.Lambda(lambda x: x * 2 -1)
    ])
    dataset = datasets.CIFAR10(
        root="./data",
        train=True,
        download=True,
        transform=transform,
    )
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    このような水平フリップはMNISTでは行いませんでした。数字を左右反転させると、0、1、8など以外では数字としての意味が失われるからです。

    なお、もともと32x32のサイズなので、リサイズは必要ありません。

    重み保存ファイル名

    あとは、モデルの保存ファイル名もMNISTではなく、CIFAR10にしたほうが良いでしょう。

            model_path = f'DDPM-CIFAR10-{epoch:03d}.pth'  # CIFAR10モデルの保存パス

    しかし数日はかかる

    このような変更で、実際に学習ループが稼働することは確認しています。しかし、CIFAR10でDDPMの訓練を完了するには、個人が使えるレベルのGPUでは、おそらく数日かかります。

    論文は以下のように述べています。

    すべての実験でTPU v3-8(8つのV100 GPUに相当)を使用しました。CIFARモデルは、バッチサイズ128で1秒あたり21ステップの速度で学習し、80万ステップで完了するまでに約10.6時間かかります。

    We used TPU v3-8 (similar to 8 V100 GPUs) for all experiments. Our CIFAR model trains at 21 steps per second at batch size 128 (10.6 hours to train to completion at 800k steps), …

    https://arxiv.org/abs/2006.11239

    8つのNVIDIAのV100GPUに相当するTPUで、約10.6時間かかったとのことです。強力なTPUあるいはGPUを自由に使える方は挑戦してみてください。


    3日ほどクーラーを効かせた部屋で2000エポックで訓練したところ、最終モデルで以下のような画像が生成できました。

    画像
    DDPMによる生成画像

    なお、下の画像は本物のCIFAR10からのものです。

    画像
    本物のCIFAR10の画像

    どちらも粗い画像(32x32)なのでぼやけた感じがありますが、DDPMが生成した画像と本物とを見分けるのはかなり難しいでしょう。

    次回予告

    実際に、MNISTで学習したモデルで100画像生成すると、数十秒かかるのがわかります。このままでは実用的に問題があります。

    そこで次回は、DDPMのサンプリング速度を大幅に高速化したDDIM(Denoising Diffusion Implicit Models)を紹介します。

    お楽しみに!

    全体のソースコード

    import copy
    import math
    import matplotlib.pyplot as plt
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    from torchvision import datasets, transforms, utils
    from torch.utils.data import DataLoader
    
    
    # ----------------------------------------------------------------------
    # グループ正規化を使用した残差ブロック
    # ----------------------------------------------------------------------
    class ResidualBlock(nn.Module):
        def __init__(self, in_ch, out_ch, t_dim):
            super().__init__()
    
            # グループ正規化を使用した残差ブロック
            self.block1 = nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 3, padding=1),
                nn.GroupNorm(32, out_ch),
                nn.SiLU()
            )
    
            self.block2 = nn.Sequential(
                nn.Conv2d(out_ch, out_ch, 3, padding=1),
                nn.GroupNorm(32, out_ch),
                nn.SiLU()
            )
    
            # 時間ステップの埋め込みを線形変換するMLP
            self.time_mlp = nn.Linear(t_dim, out_ch)
    
            # ショートカット接続
            if in_ch != out_ch:
                # 入力チャンネル数と出力チャンネル数が異なる場合は1x1畳み込みで調整
                self.shortcut = nn.Conv2d(in_ch, out_ch, 1)
            else:
                # 入力と出力のチャンネル数が同じ場合は恒等写像を使用
                self.shortcut = nn.Identity()
    
        def forward(self, x, t_emb):
            h = self.block1(x)
            h = h + self.time_mlp(t_emb)[:, :, None, None]
            h = self.block2(h)
            return h + self.shortcut(x)  # 残差接続を追加
    
    
    # ----------------------------------------------------------------------
    # 自己アテンションブロック
    # ----------------------------------------------------------------------
    class SelfAttention(nn.Module):
        def __init__(self, ch):
            super().__init__()
    
            # 1x1畳込みで、各ピクセル位置からQuery (Q), Key (K), Value (V) を生成
            self.q = nn.Conv2d(ch, ch, 1)
            self.k = nn.Conv2d(ch, ch, 1)
            self.v = nn.Conv2d(ch, ch, 1)
            self.proj = nn.Conv2d(ch, ch, 1)
    
        def forward(self, x):
            B, C, H, W = x.shape
    
            # 画像の空間次元 (H, W) を一つのシーケンス長 (HW) と見なし、アテンションを計算
            # (チャンネル数Cが埋め込み次元)
            q = self.q(x).reshape(B, C, H*W).permute(0,2,1)   # (B, HW, C)
            k = self.k(x).reshape(B, C, H*W)                  # (B, C, HW)
            v = self.v(x).reshape(B, C, H*W).permute(0,2,1)   # (B, HW, C)
    
            attn = torch.bmm(q, k) / (C ** 0.5)               # (B, HW, HW)
            attn = attn.softmax(dim=-1)
    
            out = torch.bmm(attn, v)                          # (B, HW, C)
            out = out.permute(0,2,1).reshape(B, C, H, W)
            out = self.proj(out)
    
            return out + x  # 残差接続
    
    
    # ----------------------------------------------------------------------
    # エンコーダブロック(ダウンサンプリング)
    # ----------------------------------------------------------------------
    class Encode(nn.Module):
        def __init__(self, in_ch, out_ch, t_emb_dim, atten=False, down=True):
            super().__init__()
     
            self.block1 = ResidualBlock(in_ch, out_ch, t_emb_dim)
            self.block2 = ResidualBlock(out_ch, out_ch, t_emb_dim)
            self.atten  = SelfAttention(out_ch) if atten else nn.Identity()
            self.down   = nn.Conv2d(out_ch, out_ch, 3, 2, 1) \
                if down else nn.Identity()
    
        def forward(self, x, t_emb):
            x = self.block1(x, t_emb)
            x = self.block2(x, t_emb)
            x = self.atten(x)
            return self.down(x), x  # アップサンプリングに結合用
    
    
    # ----------------------------------------------------------------------
    # デコーダブロック(アップサンプリング)
    # ----------------------------------------------------------------------
    class Decode(nn.Module):
        def __init__(self, in_ch, out_ch, t_emb_dim, atten=False):
            super().__init__()
    
            self.up = nn.Sequential(
                nn.Upsample(scale_factor=2, mode='nearest'),
                nn.Conv2d(in_ch, out_ch, 3, padding=1)  # アップサンプリング
            )
            self.block1 = ResidualBlock(out_ch*2, out_ch, t_emb_dim)
            self.block2 = ResidualBlock(out_ch, out_ch, t_emb_dim)
            self.atten  = SelfAttention(out_ch) if atten else nn.Identity()
    
        def forward(self, x, t_emb, skip):
            x = self.up(x)
            x = torch.cat([x, skip], dim=1)  # エンコーダからのスキップ接続
            x = self.block1(x, t_emb)
            x = self.block2(x, t_emb)
            x = self.atten(x)
            return x
    
    
    # ----------------------------------------------------------------------
    # サイン・コサインによるタイムステップのエンコーディング
    # ----------------------------------------------------------------------
    def sinusoidal_time_encoding(t: torch.Tensor, dim: int) -> torch.Tensor:
        # dimは埋め込み次元(チャンネル数)で、偶数である必要がある
        half_dim = dim // 2
    
        # 埋め込み次元方向のインデックス
        indices = torch.arange(half_dim, dtype=torch.float32, device=t.device)
    
        # インデックスに応じたスケールを計算
        scales = torch.exp(-math.log(10000.0) * indices / (half_dim - 1))
    
        # 時間ステップをスケール(角度に相当)
        angles = t[:, None].float() * scales[None, :]
    
        # サイン・コサインによる時間ステップのエンコーディング
        enc = torch.zeros(t.shape[0], dim, device=t.device)
        enc[:, 0::2] = torch.sin(angles)
        enc[:, 1::2] = torch.cos(angles)
        return enc
    
    
    
    # ----------------------------------------------------------------------
    # 時間ステップの埋め込みを行うMLP
    # ----------------------------------------------------------------------
    class TimeEmbedding(nn.Module):
        def __init__(self, t_dim):
            super().__init__()
            self.t_dim = t_dim
            self.mlp = nn.Sequential(
                nn.Linear(t_dim, t_dim * 4),
                nn.SiLU(),
                nn.Linear(t_dim * 4, t_dim),
            )
    
        def forward(self, t):
            emb = sinusoidal_time_encoding(t, self.t_dim)
            return self.mlp(emb)
    
    
    # ----------------------------------------------------------------------
    # U-Netアーキテクチャの定義
    # ----------------------------------------------------------------------
    class UNet(nn.Module):
        def __init__(self, image_ch: int, base_ch: int, t_dim: int):
            super().__init__()
    
            # 時間ステップの埋め込み
            self.time_mlp = TimeEmbedding(t_dim)
    
            # エンコーダ
            self.enc1 = Encode(image_ch , base_ch  , t_dim)
            self.enc2 = Encode(base_ch  , base_ch*2, t_dim, atten=True)
            self.enc3 = Encode(base_ch*2, base_ch*2, t_dim)
    
            # ボトルネック
            self.neck = Encode(base_ch*2, base_ch*2, t_dim, down=False)
    
            # デコーダ
            self.dec1 = Decode(base_ch*2, base_ch*2, t_dim)
            self.dec2 = Decode(base_ch*2, base_ch*2, t_dim, atten=True)
            self.dec3 = Decode(base_ch*2, base_ch  , t_dim)
    
            # Output
            self.out_conv = nn.Conv2d(base_ch, image_ch, 1)
    
        def forward(self, x, t):
            # 時間ステップの埋め込み
            t_emb = self.time_mlp(t)
    
            # エンコーダ
            x, skip1 = self.enc1(x, t_emb)
            x, skip2 = self.enc2(x, t_emb)
            x, skip3 = self.enc3(x, t_emb)
    
            # ボトルネック
            x, _ = self.neck(x, t_emb)
    
            # デコーダ
            x = self.dec1(x, t_emb, skip3)
            x = self.dec2(x, t_emb, skip2)
            x = self.dec3(x, t_emb, skip1)
    
            return self.out_conv(x)
    
    
    # ----------------------------------------------------------------------
    # デバイス設定
    # ----------------------------------------------------------------------
    if torch.backends.mps.is_available():
       device = torch.device("mps")
    elif torch.cuda.is_available():
       device = torch.device("cuda")
    else:
       device = torch.device("cpu")
    print(f"Using device: {device}")
    
    
    # ----------------------------------------------------------------------
    # 分散スケジュール
    # ----------------------------------------------------------------------
    T = 1000     # 時間ステップ数
    beta_start = 1e-4
    beta_end = 0.02
    
    betas = torch.linspace(beta_start, beta_end, T).to(device)
    alphas = 1. - betas
    alpha_bars = torch.cumprod(alphas, dim=0)  # 累積積
    
    
    # ----------------------------------------------------------------------
    # 拡散過程 Q(x_t | x_0) からサンプリングする順方向の処理
    # ----------------------------------------------------------------------
    def sample_q(
        x_0: torch.Tensor,  # 画像データ(バッチ、チャンネル、高さ、幅)
        t: torch.Tensor,    # ステップ数(バッチサイズ分のテンソル)
    ):
        # 画像データx_0 と同じ形状(バッチ、チャンネル、高さ、幅)のノイズを生成
        epsilon = torch.randn_like(x_0)
    
        # tに対応するalpha_barを取得(4次元テンソルに変形)
        alpha_bar_t = alpha_bars[t].view(-1, 1, 1, 1)
    
        # ノイズを加えた画像を生成
        x_t = (alpha_bar_t.sqrt() * x_0 + (1 - alpha_bar_t).sqrt() * epsilon)
    
        # ラベルとしてノイズも返す
        return x_t, epsilon
    
    
    # ----------------------------------------------------------------------
    # 生成過程 P_θ(x_{t-1} | x_t) からサンプリングする逆方向の処理
    # ----------------------------------------------------------------------
    def sample_p(
        x_t: torch.Tensor,  # ノイズ付き画像(バッチ、チャンネル、高さ、幅)
        t: torch.Tensor,    # ステップ数(バッチサイズ分のテンソル)
        noise_pred: torch.Tensor  # モデルによるノイズ予測(バッチ、チャンネル、高さ、幅)
    ):
        # tに対応するalpha_barとbetaを取得(4次元テンソルに変形)
        beta = betas[t].view(-1, 1, 1, 1)
        alpha = alphas[t].view(-1, 1, 1, 1)
        s1_ab = torch.sqrt(1 - alpha_bars[t]).view(-1, 1, 1, 1)
    
        # 平均を計算
        mean = (1 / torch.sqrt(alpha)) * (x_t - beta / s1_ab * noise_pred)
    
        # ステップ 0 ではノイズを加えない(決定的出力)
        mask = (t != 0).float().view(-1, 1, 1, 1)
    
        # サンプリングのノイズを追加
        noise = torch.randn_like(x_t)
        return mean + torch.sqrt(beta) * noise * mask
    
    
    # ----------------------------------------------------------------------
    # サンプリング関数(画像生成)
    # ----------------------------------------------------------------------
    def sample(model: nn.Module, x: torch.Tensor):
        # xはノイズ画像(バッチ、チャンネル、高さ、幅)
        n_samples = x.shape[0]
    
        # 時間ステップを逆順にサンプリン
        for t_step in reversed(range(T)):
            # 時間ステップをテンソルに変換
            t = torch.full((n_samples,), t_step, device=x.device, dtype=torch.long)
    
            # ノイズ予測を行う
            noise_pred = model(x, t)
    
            # 生成過程によって次のステップの画像をサンプリング
            x = sample_p(x, t, noise_pred)
        return x
    
    
    # ----------------------------------------------------------------------
    # 生成画像の表示
    # ----------------------------------------------------------------------
    def show_images(samples, n_images_per_row: int=None):
        if n_images_per_row is None:
            n_images_per_row = samples.shape[0]  # デフォルトはサンプル数
    
        # 画像の値を0-1の範囲に正規化
        samples = (samples + 1) / 2  # [-1, 1] -> [0, 1]
        samples = samples.clamp(0, 1)  # 0-1の範囲にクリップ
        samples = samples.cpu()
    
        # グリッド形式で表示するためのテンソルを作成
        grid = utils.make_grid(samples, nrow=n_images_per_row)
    
        # (B, C, H, W) -> (B, H, W, C)に変換して表示
        plt.imshow(grid.permute(1, 2, 0).numpy())
        plt.axis('off')
        plt.tight_layout()
        plt.show()
    
    
    # ----------------------------------------------------------------------
    # ハイパーパラメータの設定
    # ----------------------------------------------------------------------
    image_ch       = 1
    image_size     = 32       # 28x28 => 32x32にリサイズされる
    base_ch        = 64
    t_dim          = 128
    epochs         = 200
    batch_size     = 128
    
    
    # ----------------------------------------------------------------------
    # データセットの読み込みとデータローダーの設定
    # ----------------------------------------------------------------------
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Resize((image_size, image_size)),  # リサイズ
        transforms.Lambda(lambda x: x * 2 -1)
    ])
    dataset = datasets.MNIST(
        root="./data",
        train=True,
        download=True,
        transform=transform,
    )
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
    
    
    # ----------------------------------------------------------------------
    # UNetモデルの初期化とオプティマイザの設定
    # ----------------------------------------------------------------------
    model = UNet(image_ch, base_ch, t_dim).to(device)
    
    optimizer = torch.optim.Adam(model.parameters(), lr=2e-4)
    
    # ----------------------------------------------------------------------
    # EMAモデルの設定
    # ----------------------------------------------------------------------
    ema_model = copy.deepcopy(model)
    ema_model.eval()  # 評価モードに設定
    ema_decay = 0.9999
    
    # ----------------------------------------------------------------------
    # 学習ループ
    # ----------------------------------------------------------------------
    for epoch in range(1,epochs+1):
        for x_0, _ in dataloader:
            # 画像データをデバイスに転送
            x_0 = x_0.to(device)
    
            # ランダムな時間ステップからノイズ付き画像を生成
            t = torch.randint(0, T, (x_0.size(0),), device=device)
            x_t, epsilon = sample_q(x_0, t)  # ノイズをラベルとして返す
    
            # ノイズ予測を行い、損失を計算
            noise_pred = model(x_t, t)
            loss = F.mse_loss(noise_pred, epsilon)
    
            # 勾配の計算とパラメータの更新
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
            # EMAモデルの更新
            with torch.no_grad():
                for ema_param, param in zip(ema_model.parameters(),
                                            model.parameters()):
                    ema_param.data.mul_(ema_decay).add_(param.data, alpha=1 - ema_decay)
    
        print(f"Epoch {epoch}/{epochs}, Loss: {loss.item():.4f}")
    
        if epoch % 10 == 0 or epoch == epochs:
            # 学習中のサンプル画像を生成して表示
            with torch.no_grad():
                # ノイズ画像から画像を生成
                noise = torch.randn(10, image_ch, image_size, image_size).to(device)
                samples = sample(ema_model, noise)
            show_images(samples)
    
            # EMAモデルの保存
            model_path = f'DDPM-MNIST-{epoch:03d}.pth'  # モデルの保存パス
            torch.save(ema_model.state_dict(), model_path)

    学習済みのモデルは以下のように読み込み画像生成することができます。

    # 学習済みモデルの読み込み
    model = UNet(image_ch, base_ch, t_dim).to(device)
    model.load_state_dict(torch.load("DDPM-MNIST-200.pth", map_location=device))
    
    # 学習済みモデルを使用して画像を生成
    model.eval()
    with torch.no_grad():
        # ノイズ画像から画像を生成
        noise = torch.randn(100, image_ch, image_size, image_size).to(device)
        samples = sample(model, noise)
    show_images(samples, 10)

    ただし、ハイパーパラメータは学習時と同じものを使うように注意してください。

     
     
    「わかりやすく、具体的に」AIとサイエンスの情報を発信中

    あなたへのおすすめ