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

画像生成AIの進化史⑮DDPMの高速化

    前回までの記事では、DDPM(Denoising Diffusion Probabilistic Models)の理論と実装を解説し、MNISTを使って実際に画像生成を行いました。

    ただし、実験を通して分かったように、DDPMの素直な実装には課題があります。それは 「推論が非常に遅い」という点です。

    この問題は理論段階から予想されていたもので、DDPMの生成過程がマルコフ連鎖としてサンプリングを行うためです。

    • 生成時には、ガウス分布からノイズを逐次的にサンプリングして、「ノイズを少しずつ取り除く」ステップを繰り返す。

    • この「逐次的サンプリング」が計算を非常に遅くする要因となる。

    実際、前回の実装では論文通りT=1000ステップでサンプリングするため、単純なMNISTのモデルでも100枚生成するのに数十秒かかりました。

    もちろん実際の速度はCPUやGPU性能にも依存しますが、この遅さは拡散モデルが本質的に持つ「逐次生成構造の制約」から来ています。

    しかし、単純にステップ数を減らすと画質が大きく劣化してしまうという問題があり、ステップ数を減らすことは難しそうです。

    そこで今回の記事では、この 「DDPMの推論を高速化する」 という課題を解決するために提案された手法であるDDIM(Denoising Diffusion Implicit Models)を紹介します。

    DDIMは、学習済みのDDPMモデルのノイズ予測モデル(U-Net)をそのまま使いながら、生成過程(サンプリング経路)を再設計することで少ステップでも高品質な生成を可能にする手法です。再訓練は必要ありません。

    たとえば、DDIMでは1000ステップ必要だった推論を、DDIMでは50ステップ程度に短縮しつつも画質を保つことを可能にしています。

    DDPMのおさらい

    まず、拡散モデルには、拡散過程(フォワードプロセス)と生成過程(リバースプロセス)があります。

    拡散過程のマルコフ連鎖

    拡散過程は、入力画像x0\boldsymbol{x}_0を段階的にノイズにするマルコフ連鎖です。ノイズは分散スケジュールに従って計算されます。

    β1,β2,…,βT\beta_1, \beta_2, \ldots, \beta_T

    マルコフ連鎖とは、未来の状態が現在の状態だけに依存し、過去の状態には依存しない確率過程のことです。拡散過程は、ステップttにおけるノイズ画像が一つ前のステップt−1t-1の画像にだけ依存するためマルコフ連鎖になっています。

    拡散過程の定義は、以下のようにガウス分布で表現されます。

    Q(xt∣xt−1)=N(xt;1−βtxt−1,βtI)Q(\boldsymbol{x}_t \mid \boldsymbol{x}_{t-1}) = \mathcal{N}\biggl( \boldsymbol{x}_t; \sqrt{1 - \beta_t} \boldsymbol{x}_{t-1}, \beta_t \mathbf{I} \biggr)

    DDPMの拡散過程はマルコフ連鎖ですが、ガウス分布を使っているため以下のような関係がxt\boldsymbol{x}_tとx0\boldsymbol{x}_{0}の間に導かれます。

    Q(xt∣x0)= N(xt;αˉtx0,(1−αˉt)I)Q(\boldsymbol{x}_t \mid \boldsymbol{x}_{0}) =  \mathcal{N}\biggl( \boldsymbol{x}_t; \sqrt{\bar{\alpha}_t} \boldsymbol{x}_{0}, (1 - \bar{\alpha}_t) \mathbf{I} \biggr)

    • αt=1−βt\alpha_t = 1 - \beta_t

    • αˉt=∏s=1tαt\bar{\alpha}_t = \prod\limits_{s=1}^t \alpha_t

    つまり、拡散過程は逐次的に(ステップを一つずつ)計算する必要はなく、指定されたステップttにおけるノイズを一気に計算できます。

    このため学習中は、ランダムに選ばれたステップttにおけるノイズを以下のように一気に計算します。

    xt=αˉtx0+1−αˉtϵ\boldsymbol{x}_t = \sqrt{\bar{\alpha}_t} \boldsymbol{x}_0 + \sqrt{1 - \bar{\alpha}_t} \boldsymbol{\epsilon}

    ここで、ϵ\boldsymbol{\epsilon}は、標準正規分布からのノイズです。この式は、平均αˉtx0\sqrt{\bar{\alpha}_t} \boldsymbol{x}_0で標準偏差1−αˉt\sqrt{1 - \bar{\alpha}_t}となっており、上述のガウス分布と同等です。

    拡散過程の逆過程(理想)

    次に、拡散過程においてx0\boldsymbol{x}_0とxt\boldsymbol{x}_tを条件としてxt−1\boldsymbol{x}_{t-1}の確率を考えます。

    Q(xt−1∣xt,x0)=N(μ~(xt,x0),β~tI)Q(\boldsymbol{x}_{t-1} \mid \boldsymbol{x}_t, \boldsymbol{x}_0) = \mathcal{N}(\tilde{\boldsymbol{\mu}}(\boldsymbol{x}_t, \boldsymbol{x}_0), \tilde{\beta}_t \mathbf{I})

    これは拡散過程によるxt\boldsymbol{x}_tからxt−1\boldsymbol{x}_{t-1}への逆過程の式です。拡散過程では常にx0\boldsymbol{x}_0が条件に入ってきます。この式の平均と分散は以下のように計算されます。

    μ~t(xt,x0)=αt(1−αˉt−1)1−αˉtxt+αˉt−1βt1−αˉtx0β~t=1−αˉt−11−αˉtβt\begin{aligned} \tilde{\boldsymbol{\mu}}_t(\boldsymbol{x}_t, \boldsymbol{x}_0) &= \frac{\sqrt{\alpha_t}(1 - \bar{\alpha}_{t-1})}{1 - \bar{\alpha}_t} \boldsymbol{x}_t + \frac{\sqrt{\bar{\alpha}_{t-1}}\beta_t}{1 - \bar{\alpha}_t} \boldsymbol{x}_0 \\ \tilde{\beta}_t &= \frac{1 - \bar{\alpha}_{t-1}}{1 - \bar{\alpha}_t} \beta_t \end{aligned}

    この平均の式の導出そのものよりも、xt−1\boldsymbol{x}_{t-1}の平均がxt\boldsymbol{x}_{t}とx0\boldsymbol{x}_{0}の加重平均になっていること、また、その重みが分散スケジュールからの値によって計算されていること理解することが重要です。

    この拡散過程の逆過程を生成過程は近似しているわけですが、上式には生成過程が知ることができないx0\boldsymbol{x}_{0}が含まれています。

    生成過程の逆過程(近似)

    生成過程(逆過程)は拡散過程の逆過程を近似するために、拡散過程のマルコフ連鎖の式をx0\boldsymbol{x}_0の式に書き直します。

    x0=1αˉt(xt−1−αˉtϵ)\boldsymbol{x}_0 = \frac{1}{\sqrt{\bar{\alpha}_t}} \bigl( \boldsymbol{x}_t - \sqrt{1 - \bar{\alpha}_t} \boldsymbol{\epsilon} \bigr)

    これをノイズ予測モデル(U-Net)を使って予測したノイズϵ^θ(xt,t)\hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t)を使い近似します。

    x^0=1αˉt(xt−1−αˉt  ϵ^θ(xt,t))\hat{\boldsymbol{x}}_0 = \frac{1}{\sqrt{\bar{\alpha}_t}} \bigl( \boldsymbol{x}_t - \sqrt{1 - \bar{\alpha}_t} \;\hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \bigr)

    θ_\thetaはニューラルネットワークのパラメータの集合を意味します。この式によるx^0\hat{\boldsymbol{x}}_0を拡散過程の逆過程(理想)に代入すると以下の式が得られます。

    μ~θ(xt,t)=1αt(xt−βt1−αˉtϵ^θ(xt,t))\tilde{\boldsymbol{\mu}}_\theta(\boldsymbol{x}_t, t) = \frac{1}{\sqrt{\alpha_t}}\biggl( \boldsymbol{x}_t - \frac{\beta_t}{\sqrt{1 - \bar{\alpha}_t}} \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \biggr)

    この平均と拡散過程の逆過程の分散β~t\tilde{\beta}_tを使えば、x0\boldsymbol{x}_0を必要とせずに生成過程のサンプリングが行えます。

    生成過程のマルコフ連鎖

    生成過程のマルコフ連鎖は、次のように定義されます。

    Pθ(xt−1∣xt)=N(xt−1;μ~θ(xt,t),β~tI)P_\theta(\boldsymbol{x}_{t-1} \mid \boldsymbol{x}_t) = \mathcal{N}\bigl(\boldsymbol{x}_{t-1}; \tilde{\boldsymbol{\mu}}_\theta(\boldsymbol{x}_t, t), \tilde{\beta}_t \mathbf{I} \bigr)

    これを更新式の形で書くと以下になります。

    xt−1=1αt(xt−βt1−αˉtϵ^θ(xt,t))+β~tϵ\boldsymbol{x}_{t-1} = \frac{1}{\sqrt{\alpha_t}}\biggl( \boldsymbol{x}_t - \frac{\beta_t}{\sqrt{1 - \bar{\alpha}_t}} \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \biggr) + \sqrt{\tilde{\beta}_t} \boldsymbol{\epsilon}

    ϵ\boldsymbol{\epsilon}は、標準正規分布からサンプリングされた値です。

    ただし、論文によると、実験ではβ~t\tilde{\beta}_tをβt\beta_tで近似しても同様の結果が得られたため、生成過程の実装もこれに従っています。

    # ----------------------------------------------------------------------
    # 生成過程 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
    • 画像xt\boldsymbol{x}_tから画像xt−1\boldsymbol{x}_{t-1}の平均値 mean = μ~θ(xt,t)\tilde{\boldsymbol{\mu}}_\theta(\boldsymbol{x}_t, t)を計算

    • 新しいガウスノイズをβt\sqrt{\beta_t} * noise で加える

    なお、x1\boldsymbol{x}_1からx0\boldsymbol{x}_0は、サンプリングは行わず予測された平均値をそのまま使います。これはx0\boldsymbol{x}_0には拡散過程によるノイズが含まれないからです。

    こうして生成過程は逐次的にノイズ画像xT\boldsymbol{x}_Tからサンプリングを行い最終的に得たx0\boldsymbol{x}_0が生成画像となるという仕組みです。

    以下は、DDPMのサンプリングループを簡略的に示したコードです。

    for t in reversed(range(T)):
        noise_pred = model(x_t, t)
        x_t = sample_p(x_t, t, noise_pred)

    これは生成過程の理論通りにマルコフ連鎖として、逐次的なサンプリングで実装されていますが、多いステップ数(例:T=1000)では、時間がかかります。

    DDIMで何が変わるのか

    DDIMは、DDPMで学習されたノイズ予測モデル(U-Netなど)をそのまま利用します。しかし、サンプリング(生成)過程の定義を変えることで、サンプリングを高速化しています。

    DDPMと同じところ

    拡散過程の定式化はDDPMと同じです。

    xt=αˉtx0+1−αˉtϵ\boldsymbol{x}_t = \sqrt{\bar{\alpha}_t} \boldsymbol{x}_0 + \sqrt{1 - \bar{\alpha}_t} \boldsymbol{\epsilon}

    また、x0\boldsymbol{x}_0の予測の部分も同じです。

    x^0=1αˉt(xt−1−αˉt  ϵ^θ(xt,t))\hat{\boldsymbol{x}}_0 = \frac{1}{\sqrt{\bar{\alpha}_t}} \bigl( \boldsymbol{x}_t - \sqrt{1 - \bar{\alpha}_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \bigr)

    ϵ^θ(xt,t)\hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t)は、ノイズ予測モデル(U-Net)によるものであり、訓練を変える必要はありません。

    新しい「逆過程」の形

    DDIMでは生成過程(拡散過程の逆過程近似)を以下のように設計しています。

    xt−1=αˉt−1  x^0+1−αˉt−1−σt2  ϵ^θ(xt,t)+σtϵ\boldsymbol{x}_{t-1} = \sqrt{\bar{\alpha}_{t-1}} \; \hat{\boldsymbol{x}}_0 + \sqrt{1 - \bar{\alpha}_{t-1} - \sigma^2_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) + \sigma_t \epsilon

    この式でσt=0\sigma_t = 0の場合、DDPMの平均の形と同じになります。

    xt−1=αˉt−1  x^0+1−αˉt−1  ϵ^θ(xt,t)\boldsymbol{x}_{t-1} = \sqrt{\bar{\alpha}_{t-1}} \; \hat{\boldsymbol{x}}_0 + \sqrt{1 - \bar{\alpha}_{t-1}} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t)

    ただし、ノイズ予測はニューラルネットワークによって決定論的に計算されるので、σt=0\sigma_t = 0の場合はサンプリングの効果がありません。よって、同じノイズからは常に同じ画像が生成されるよう(決定論的なマッピング)になります。

    サンプリングの効果を得るためには、σt>0\sigma_t > 0である必要があります。σt\sigma_t自体は以下のように定義されています。

    σt=η1−αˉt−11−αˉt  1−αˉtαˉt−1\sigma_t = \eta \sqrt{\frac{1 - \bar{\alpha}_{t-1}}{1 - \bar{\alpha}_t}} \; \sqrt{1 - \frac{\bar{\alpha}_t}{\bar{\alpha}_{t-1}}}

    このη\etaはハイパーパラメータであり0から1の値を指定することができます。η=0\eta = 0だとσt=0\sigma_t = 0となるので決定論的に画像が生成されます。

    なお、DDIMの論文ではDDPMの論文と表記の仕方が少し違っていてαˉt\bar{\alpha}_tなどをαt\alpha_tと書いたり、なるべくβt\beta_tを出さないスタイルになっています。しかし、αˉt=αtαˉt−1\bar{\alpha}_t = \alpha_t \bar{\alpha}_{t-1}であり、さらにβt\beta_tも使うと簡略化できます。

    なお、αˉt=αtαˉt−1\bar{\alpha}_t = \alpha_t \bar{\alpha}_{t-1}と1−αt=βt1 - \alpha_t = \beta_tを使うと、1−αˉtαˉt−1=1−αt=βt1 - \frac{\bar{\alpha}_t}{\bar{\alpha}_{t-1}} = 1 - \alpha_t = \beta_tです。

    よって、σt\sigma_tをもう少し簡略化できます。

    σt=η1−αˉt−11−αˉt  βt=ηβ~t\sigma_t = \eta \sqrt{\frac{1 - \bar{\alpha}_{t-1}}{1 - \bar{\alpha}_t} \;\beta_t} = \eta \sqrt{\tilde{\beta}_t}

    つまり、σt2\sigma_t^2はは以下になります。

    σt2=η2β~t\sigma^2_t = \eta^2 \tilde{\beta}_t

    η=1\eta = 1だとσt2=β~t\sigma^2_t = \tilde{\beta}_tなので、DDPMの拡散過程のノイズの分散と同じ計算です。その場合のDDIMの生成過程の更新式は以下になります。

    xt−1=αˉt−1  x^0+1−αˉt−1−β~t  ϵ^θ(xt,t)+β~tϵ\boldsymbol{x}_{t-1} = \sqrt{\bar{\alpha}_{t-1}} \; \hat{\boldsymbol{x}}_0 + \sqrt{1 - \bar{\alpha}_{t-1} - \tilde{\beta}_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) + \sqrt{\tilde{\beta}_t} \epsilon

    第1項にx0\boldsymbol{x}_0の予測の式を代入して整理します。

    αˉt−1  x^0=αˉt−1(1αˉt(xt−1−αˉt  ϵ^θ(xt,t)))=1αt (xt−1−αˉt  ϵ^θ(xt,t))\begin{aligned} \sqrt{\bar{\alpha}_{t-1}} \; \hat{\boldsymbol{x}}_0 &= \sqrt{\bar{\alpha}_{t-1}} \biggl( \frac{1}{\sqrt{\bar{\alpha}_t}} \bigl( \boldsymbol{x}_t - \sqrt{1 - \bar{\alpha}_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \bigr) \biggr) \\[2ex] &= \frac{1}{\sqrt{\alpha_t}} \biggl( \boldsymbol{x}_t - \sqrt{1 - \bar{\alpha}_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \biggr) \end{aligned}

    第2項は次のように変形できます。

    1−αˉt−1−β~t  ϵ^θ(xt,t)= 1−αˉt−1−1−αˉt−11−αˉt  βt  ϵ^θ(xt,t)= 1−αˉt−1−1−αˉt−11−αˉt  (1−αt)  ϵ^θ(xt,t)= αt(1−αˉt−1)21−αˉt  ϵ^θ(xt,t)= αt1−αˉt  (1−αˉt−1)  ϵ^θ(xt,t)\begin{aligned} \sqrt{1 - \bar{\alpha}_{t-1} - \tilde{\beta}_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) &= \sqrt{1 - \bar{\alpha}_{t-1} - \frac{1 - \bar{\alpha}_{t-1}}{1 - \bar{\alpha}_t} \;\beta_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \\[2ex] &= \sqrt{1 - \bar{\alpha}_{t-1} - \frac{1 - \bar{\alpha}_{t-1}}{1 - \bar{\alpha}_t} \;(1 - \alpha_t)} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \\[2ex] &= \sqrt{\frac{\alpha_t(1 - \bar{\alpha}_{t-1})^2}{1 - \bar{\alpha}_t}} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \\[2ex] &= \sqrt{\frac{\alpha_t}{1 - \bar{\alpha}_t}}\;(1 - \bar{\alpha}_{t-1}) \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \\ \end{aligned}

    以上より、η=1\eta = 1の時の更新式は以下になります。

    xt−1=αˉt−1  x^0+1−αˉt−1−β~t  ϵ^θ(xt,t)+β~tϵ=1αt(xt−βt1−αˉtϵ^θ(xt,t)) +β~tϵ\begin{aligned} \boldsymbol{x}_{t-1} &= \sqrt{\bar{\alpha}_{t-1}} \; \hat{\boldsymbol{x}}_0 + \sqrt{1 - \bar{\alpha}_{t-1} - \tilde{\beta}_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) + \sqrt{\tilde{\beta}_t} \epsilon \\[2ex] &= \frac{1}{\sqrt{\alpha_t}} \biggl( \boldsymbol{x}_t - \frac{\beta_t}{\sqrt{1 - \bar{\alpha}_t}} \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) \biggr) + \sqrt{\tilde{\beta}_t} \epsilon \end{aligned}

    これは、DDPMの生成過程の更新式と同じです。

    つまり、係数η\etaによってサンプリングの際に与えるノイズの量をコントロールすることが可能になっています。

    • η=0\eta =0:完全決定論的サンプリング(毎回同じノイズなら同じ画像)

    • 0<η<10 < \eta < 1:ノイズを加えて多様性を出す

    • η=1\eta =1:DDPMのノイズレベルを模倣

    • η>1\eta > 1:これも指定はできますが、画質が著しく悪化します

    少ないステップで生成

    DDPMの生成過程はマルコフ連鎖であり、以下のように表現できます。

    Pθ(x0:T)=P(xT)∏t=1TPθ(xt−1∣xt)P_\theta(\boldsymbol{x}_{0:T}) = P(\boldsymbol{x}_T) \prod\limits_{t=1}^T P_\theta(\boldsymbol{x}_{t-1} \mid \boldsymbol{x}_t)

    このように、各ステップは1つ前のxt\boldsymbol{x}_tだけに条件づけられて進みます。つまり、Pθ(xt−1∣xt:T)=Pθ(xt−1∣xt)P_\theta(\boldsymbol{x}_{t-1} | \boldsymbol{x}_{t:T}) = P_\theta(\boldsymbol{x}_{t-1} | \boldsymbol{x}_t)であり、これはマルコフ連鎖です。こちらでも解説しています。

    DDPMでもx^0\hat{\boldsymbol{x}}_0の推定を行なっていますが、これはあくまでサンプリングのための平均値を計算するためであり、生成過程そのものはマルコフ性があります。

    そのため、DDPMではTステップすべてを逐次的なサンプリングによって画像生成を行います。

    また、DDPMではステップttからt−1t-1の画像を直接生成するように定式化されています。よって、t−1t-1以外のステップにジャンプして進むことはできません。

    一方、DDIMでは全ての1ステップ刻みを使う必要はなく、たとえば1000ステップから50ステップへ間引きスケジュールを設定しても高品質な生成が可能です。

    DDIMの更新式は以下になっています。

    xt−1=αˉt−1  x^0+1−αˉt−1−σt2  ϵ^θ(xt,t)+σtϵ\boldsymbol{x}_{t-1} = \sqrt{\bar{\alpha}_{t-1}} \; \hat{\boldsymbol{x}}_0 + \sqrt{1 - \bar{\alpha}_{t-1} - \sigma^2_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) + \sigma_t \epsilon

    η=1\eta = 1かつ1ステップ刻みの場合はDDPMの生成過程と一致します。このように、DDIMはDDPMの生成過程を柔軟化・一般化した手法です。

    なぜスキップができるのかというと、DDIMではステップttから一旦x0\boldsymbol{x}_0を予測して、そこからt−1t-1に戻るという処理を行います。その際に、t−1t-1限らず任意に間引いたステップに戻ることもできるため、スキップが可能となっています。

    これは学習時に全てのttに対してノイズ予測モデルを利用することでx0\boldsymbol{x}_0を推定できるように学習されていることをうまく利用しています。このため、任意のttからx0\boldsymbol{x}_0を予測し、そこから任意のt′t'へマッピング可能になっています。

    DDIMの実装

    DDIMの生成過程の実装

    DDIMによる生成過程の式を実装すると以下のようになります。

    # ----------------------------------------------------------------------
    # DDIMによる生成過程 P_θ(x_t' | x_t) からサンプリングする逆方向の処理
    # ----------------------------------------------------------------------
    def ddim_sample_p(
        x_t: torch.Tensor,     # ノイズ付き画像(バッチ、チャンネル、高さ、幅)
        t: torch.Tensor,       # ステップ数(バッチサイズ分のテンソル)
        t_prev: torch.Tensor,  # 前ステップ数(バッチサイズ分のテンソル)
        noise_pred: torch.Tensor,  # モデルによるノイズ予測(バッチ、チャンネル、高さ、幅)
        eta: float = 0.0       # DDIMパラメータ、0で決定論的サンプリング
    ):
        # tに対応するalpha_barなどを取得(4次元テンソルに変形)
        alpha_bar_t = alpha_bars[t].view(-1, 1, 1, 1)
        alpha_bar_t_prev = alpha_bars[t_prev].view(-1, 1, 1, 1)
        s1_ab_t = torch.sqrt(1 - alpha_bars[t]).view(-1, 1, 1, 1)
    
        # x0の予測を計算
        x0_pred = 1.0 / torch.sqrt(alpha_bar_t) * (x_t - s1_ab_t * noise_pred)
    
        # ノイズのスケールを計算
        sigma = eta * torch.sqrt((1 - alpha_bar_t_prev) / (1 - alpha_bar_t)) \
                     * torch.sqrt(1 - alpha_bar_t / alpha_bar_t_prev)
    
        # 次のステップ(t_prev)の平均を計算
        mean = torch.sqrt(alpha_bar_t_prev) * x0_pred + \
                torch.sqrt(1 - alpha_bar_t_prev - sigma**2) * noise_pred
    
        # ステップ 0 ではノイズを加えない(決定的出力)
        mask = (t != 0).float().view(-1, 1, 1, 1)
    
        # サンプリングのノイズを追加
        noise = torch.randn_like(x_t)
        return mean + sigma * noise * mask

    DDPMの sample_p と似た処理ですが、以下のDDIMの計算式を使っています。

    xt−1=αˉt−1  x^0+1−αˉt−1−σt2  ϵ^θ(xt,t)+σtϵ\boldsymbol{x}_{t-1} = \sqrt{\bar{\alpha}_{t-1}} \; \hat{\boldsymbol{x}}_0 + \sqrt{1 - \bar{\alpha}_{t-1} - \sigma^2_t} \; \hat{\boldsymbol{\epsilon}}_\theta(\boldsymbol{x}_t, t) + \sigma_t \epsilon

    なお、スキップできるので、更新先は必ずしもt−1t-1とは限りません。つまり、コードの中の t_prev は t より小さい0以上の任意のステップです。

    DDIMのサンプリングの実装

    DDIMによる画像生成(サンプリング)もDDPMと同様の流れですが、ddim_sample_p を使うようになっています。

    # ----------------------------------------------------------------------
    # DDIMによるサンプリング関数(画像生成)
    # ----------------------------------------------------------------------
    def ddim_sample(model: nn.Module, x: torch.Tensor, n_steps: int, eta: float):
        # xはノイズ画像(バッチ、チャンネル、高さ、幅)
        # n_steps: DDIMのステップ数(例: 50)
        # eta: ストキャスティック性のためのノイズスケーリング。eta=0で決定論的DDIM。
        n_samples = x.shape[0]
    
        # 時間ステップを逆順にサンプリング(等間隔の時間ステップ)
        t_steps = torch.linspace(0, T - 1, n_steps,
                                 device=device, dtype=torch.long).tolist()
        for i in reversed(range(1, len(t_steps))):
            # 時間ステップをテンソルに変換
            t = torch.full((n_samples,), t_steps[i],
                           device=device, dtype=torch.long)
            t_prev = torch.full((n_samples,), t_steps[i - 1],
                                device=device, dtype=torch.long)
    
            # ノイズ予測を行う
            noise_pred = model(x, t)
    
            # 生成過程によって次のステップの画像をサンプリング
            x = ddim_sample_p(x, t, t_prev, noise_pred, eta)
        return x

    DDPMとDDIMの比較

    DDPMの実行速度

    前回のコードの続きとして以下のコードを追加します。

    import time
    
    torch.manual_seed(42)  # 再現性のためのシード設定
    
    # 学習済みモデルの読み込み
    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)
        start_time = time.time()
        samples = sample(model, noise)
        end_time = time.time()
        print(f"DDPM sampling took {end_time - start_time:.2f} seconds")
    show_images(samples, 10)

    実行速度と生成画像は以下となりました。

    DDPM sampling: 44.49 seconds
    画像
    DDPMによる生成画像

    DDIMの実行速度

    さらに続けて次のコードを追加します。

    # ----------------------------------------------------------------------
    # DDIMによる生成過程 P_θ(x_t' | x_t) からサンプリングする逆方向の処理
    # ----------------------------------------------------------------------
    def ddim_sample_p(
        x_t: torch.Tensor,     # ノイズ付き画像(バッチ、チャンネル、高さ、幅)
        t: torch.Tensor,       # ステップ数(バッチサイズ分のテンソル)
        t_prev: torch.Tensor,  # 前ステップ数(バッチサイズ分のテンソル)
        noise_pred: torch.Tensor, # モデルによるノイズ予測(バッチ、チャンネル、高さ、幅)
        eta: float = 0.0       # DDIMパラメータ、0で決定論的サンプリング
    ):
        # tに対応するalpha_barなどを取得(4次元テンソルに変形)
        alpha_bar_t = alpha_bars[t].view(-1, 1, 1, 1)
        alpha_bar_t_prev = alpha_bars[t_prev].view(-1, 1, 1, 1)
        s1_ab_t = torch.sqrt(1 - alpha_bars[t]).view(-1, 1, 1, 1)
    
        # x0の予測を計算
        x0_pred = 1.0 / torch.sqrt(alpha_bar_t) * (x_t - s1_ab_t * noise_pred)
    
        # ノイズのスケールを計算
        sigma = eta * torch.sqrt((1 - alpha_bar_t_prev) / (1 - alpha_bar_t)) \
                     * torch.sqrt(1 - alpha_bar_t / alpha_bar_t_prev)
    
        # 次のステップ(t_prev)の平均を計算
        mean = torch.sqrt(alpha_bar_t_prev) * x0_pred + \
                torch.sqrt(1 - alpha_bar_t_prev - sigma**2) * noise_pred
    
        # ステップ 0 ではノイズを加えない(決定的出力)
        mask = (t != 0).float().view(-1, 1, 1, 1)
    
        # サンプリングのノイズを追加
        noise = torch.randn_like(x_t)
        return mean + sigma * noise * mask
    
    
    # ----------------------------------------------------------------------
    # DDIMによるサンプリング関数(画像生成)
    # ----------------------------------------------------------------------
    def ddim_sample(model: nn.Module, x: torch.Tensor, n_steps: int, eta: float):
        # xはノイズ画像(バッチ、チャンネル、高さ、幅)
        # n_steps: DDIMのステップ数(例: 50)
        # eta: ストキャスティック性のためのノイズスケーリング。eta=0で決定論的DDIM。
        n_samples = x.shape[0]
    
        # 時間ステップを逆順にサンプリング(等間隔の時間ステップ)
        t_steps = torch.linspace(0, T - 1, n_steps,
                                 device=device, dtype=torch.long).tolist()
        for i in reversed(range(1, len(t_steps))):
            # 時間ステップをテンソルに変換
            t = torch.full((n_samples,), t_steps[i],
                           device=device, dtype=torch.long)
            t_prev = torch.full((n_samples,), t_steps[i - 1],
                                device=device, dtype=torch.long)
    
            # ノイズ予測を行う
            noise_pred = model(x, t)
    
            # 生成過程によって次のステップの画像をサンプリング
            x = ddim_sample_p(x, t, t_prev, noise_pred, eta)
        return x

    そして先ほどロードした学習済みモデルで実行速度を図ります。

    # 学習済みモデルを使用してDDIMサンプリング
    model.eval()
    with torch.no_grad():
        noise = torch.randn(100, image_ch, image_size, image_size).to(device)
    
        start_time = time.time()
        samples = ddim_sample(model, noise, n_steps=50, eta=1.0)
        end_time = time.time()
        print(f"DDIM sampling: {end_time - start_time:.2f} seconds")
    
    show_images(samples, 10)

    50ステップによる結果は以下になりました。

    DDIM sampling: 2.17 seconds
    画像
    DDIMの生成画像

    かなり速くなりました。

    推論時のノイズ効果

    以下のコードを使ってノイズ係数η\etaを変化させてその影響を確認します。

    etas = [0.0, 0.2, 1.0]  # DDIMのηパラメータ
    n_samples = 36
    n_steps = 50
    
    # ノイズ画像を生成(この画像を繰り返し使う)
    torch.manual_seed(42)  # 再現性のためのシード設定
    noise = torch.randn(n_samples, image_ch, image_size, image_size).to(device)
    
    fig, axs = plt.subplots(3, 3, figsize=(10, 10))
    
    for row, eta in enumerate(etas):
        print(f"Sampling with eta = {eta}")
        for col in range(3):  # 3列のグリッド
    
            # DDIMサンプリングを実行
            with torch.no_grad():
                samples = ddim_sample(model, noise, n_steps=n_steps, eta=eta)
                samples = (samples + 1) / 2
                samples = samples.clamp(0, 1).cpu()
    
            # グリッド形式で表示するためのテンソルを作成
            grid = utils.make_grid(samples, nrow=6)
            idx = row, col
            axs[idx].imshow(grid.permute(1, 2, 0).numpy())
            axs[idx].axis('off')
            axs[idx].set_title(f"η = {eta}")
    
    plt.tight_layout()
    plt.show()

    このコードでは、同じノイズ画像 noise をもとに異なる各etaetaの値に対して複数回画像を生成しています。

    結果はこうなりました。

    画像

    再現性のために乱数シードを固定してあり、さらに最上行はη=0\eta = 0なので、何度生成しても同じ画像が決定論的に生成されます。η>0\eta > 0だと多様性が増します(同じノイズからでも異なる画像が出る)が、品質が大きく劣化することは通常ありません。

    η=0.2\eta = 0.2は、若干η=0\eta = 0と同じ数字が同じ位置にあるようには感じます。それと比べると、η=1.0\eta = 1.0はη=0\eta = 0と異なる数字が出ているように見受けられます。

    CIFAR10で比較すると

    DDPMの実行速度

    CIFAR10でも同様な速度測定を行いました。

    import time
    
    model_path = f'DDPM-CIFAR10-2000.pth'  # モデルの保存パス
    
    # 学習済みモデルの読み込み
    model = UNet(image_ch, base_ch, t_dim).to(device)
    model.load_state_dict(torch.load(model_path, map_location=device))
    
    # 学習済みモデルを使用して画像を生成
    model.eval()
    with torch.no_grad():
        # ノイズ画像から画像を生成
        noise = torch.randn(100, image_ch, image_size, image_size).to(device)
        start_time = time.time()
        samples = sample(model, noise)
        end_time = time.time()
        print(f"DDPM sampling: {end_time - start_time:.2f} seconds")
    
    #plt.figure(figsize=(10, 10))
    show_images(samples, 10)
    DDPM sampling: 84.32 seconds
    画像
    DDPMによるCIFAR10の生成画像

    DDIMの実行速度

    生成過程やサンプリングのコードはMNISTのものと全く同じです。以下の結果が出ました。

    DDIM sampling: 4.04 seconds
    画像
    DDIMによるCIFAR10の静瀬画像

    推論時のノイズ効果

    これもMNISTの時と同じコードを使いました。結果は以下になります。

    画像

    最上行はη=0\eta = 0なので、何度生成しても同じ画像が決定論的に生成されます。これはMNISTの時と同じです。車や鳥が出てくる場所を比べるとη=0.2\eta = 0.2はη=0\eta = 0に似ている傾向があります。同様に同じ位置で比べると、η=1.0\eta = 1.0はη=0\eta = 0と異なったクラスの画像がより多くの位置で生成されています。

    次回予告

    これまで、DDPMとDDIMで拡散モデルの基本とその高速化手法を解説してきました。ただし、これらはピクセル空間での拡散を前提としており、高解像度画像では計算コストが非常に大きくなります。

    次回は、こうした課題を解決するために提案された Latent Diffusion Models (LDM) を紹介します。LDMはピクセル空間ではなく潜在空間で拡散を行うことで、高解像度画像を効率的に生成します。また、LDMは Stable Diffusion v1 の原型となったモデルです。

    お楽しみに!

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

    あなたへのおすすめ