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

画像生成AIの進化史⑪DDPMの拡散過程

    前回は、DDPMの概念的な理解にフォーカスして解説しました。

    VAEやGANとの比較を通して理解を深めました。特にVAEと似たような考え方から、変分下限(ELBO)による損失の数式を導きました。

    しかし、このままでは、
    「拡散過程の分散スケジュールはどう設定されるのか」
    「損失関数は具体的にはどう実装されるのか」
    「生成モデルはどのような構造になっているのか」
    などがまったく明確ではありません。

    そこで今回から数回に分けて、論文「Denoising Diffusion Probabilistic Models」(ノイズ除去 拡散確率モデル、DDPM)からの情報をもとに上記の質問に一つずつ答えていきます。また、PyTorchによる実装例も示して行きます。

    今回は、DDPMの拡散過程の詳細にフォーカスします。

    分散スケジュールの疑問に答える

    分散スケジュールはどう設定する

    拡散過程は、下図のq(xt∣xt−1)q(\boldsymbol{x}_t \mid \boldsymbol{x}_{t-1})に相当する部分で、右から左へ処理が進みます。

    画像
    論文:図1

    画像データx0\boldsymbol{x}_0に対して、徐々にガウスノイズを付加していき、最終的なxT\boldsymbol{x}_Tは完全なノイズになります。

    なお、拡散過程の処理が進む方向を、順方向としています。よって、ステップ数ttが増えるほど画像内のノイズが増加しています。

    数式では、次のように定義されていました。

    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)

    ここで、βt\beta_tは、分散スケジュールによって定義されるステップttにおけるガウスノイズの分散の値です。

    論文の冒頭では、βt\beta_tの値は「手動でスケジュールを決めることもできる」し「学習で決めることもできる」と述べられています。

    しかし、実験のセクションではこう述べられています。

    順方向プロセスの分散βt\beta_tには、β1=10−4\beta_1 = 10^{-4}からβT=0.02\beta_T = 0.02に線形に(一定の割合で)増加する値を設定しました。

    We set the forward process variances to constants increasing linearly from β1=10−4\beta_1 = 10^{−4} to βT=0.02\beta_T = 0.02.

    https://arxiv.org/abs/2006.11239

    つまり、学習で決めたわけではないということですが、その理由は述べられていません。これだけわかれば「分散スケジュールを実装する」には十分なのですが、もう少し深掘りしてみます。

    付録B「実験の詳細」では、次のように述べられています。

    私たちは、定数スケジュール、線形スケジュール、2次スケジュールの中から、すべてLT≈0L_T \approx 0になるように制約をかけた上で、βt\beta_t のスケジュールを選びました。また、ステップ数T=1000T=1000は、ハイパーパラメータの探索を行わずに設定し、β1=10−4\beta_1 = 10^{−4}からβT=0.02\beta_T=0.02までの線形スケジュールを採用しました。

    We chose the βt\beta_t schedule from a set of constant, linear, and quadratic schedules, all constrained so that LT≈0L_T \approx 0. We set T=1000T = 1000 without a sweep, and we chose a linear schedule from β1=10−4\beta_1 = 10^{-4} to βT=0.02\beta_T = 0.02.

    https://arxiv.org/abs/2006.11239

    これによると、3つの異なるスケジュールによって、いくつかの設定を実験した上で一つを選んだことがわかります。

    • 定数スケジュール:固定値のβt\beta_tをすべてのステップで使う

    • 線形スケジュール:βt\beta_tを直線的に変化させる

    • 2次スケジュール:βt\beta_tを2次的に変化させる
      (おそらく、βt\beta_tがt2t^2に比例するように変化させる)

    具体的にどのような数値を試したのかは書いてありませんが、採用された線形スケジュールは、β1=10−4\beta_1 = 10^{-4}からβT=0.02\beta_T = 0.02へと直線的に増加する値を各ステップに設定しています。

    なお、全ステップ数TTは、「sweep(探索)」をせず、経験的に十分大きな値として1000を選んだようです。

    つまり、T=1000T=1000は、グリッド・サーチなどの厳密な最適化やチューニングをせず、実験的に「十分なノイズ化が行われる」と考えて設定した値です。

    おそらく、分散スケジュールもいくつか試してうまくいったものを選んだということでしょう。この両方の組み合わせで非常に小さなノイズを各ステップで付加するようにしているのがわかります。そのくらいにしておかないと学習も難しいのだと推測されます。

    なお、「LT≈0L_T \approx 0となるように制約をかけた」というのは、損失関数に関連するのですが、これは次回に詳細を紹介します。

    意味としては、t=Tt = Tまで拡散された画像は「各画像要素を標準正規分布からサンプリングしたものに近くなるようにした」ということです。

    PyTorchで分散スケジュールを書く

    このように分散スケジュールをハイパーパラメータとして扱うのは初期の研究としては懸命な選択です。なぜなら、分散スケジュールを学習させるとするといろいろと面倒が生じるからです。

    これは、分散スケジュールがさまざまなことに影響を与えるからです。これについては、徐々に明らかになります。

    ただし、その実装は簡単です。分散スケジュールをPyTorchを使ってコードにすると以下のようになります。

    import torch
    
    beta_1 = 1e-4
    beta_T = 0.02
    T      = 1000
    
    betas = torch.linspace(beta_1, beta_T, T).to(device)

    ここでの device は、環境に合わせて前もって選択したものです。

    if torch.backends.mps.is_available():
        device = "mps"  # Appleシリコン
    elif torch.cuda.is_available():
        device = "cuda" # NVIDIA GPU
    else:
        device = "cpu"  # CPU
    print(f"Using device: {device}")

    このように実装が非常に簡単ですが、理論的な疑問がたくさん浮かんできます。

    まず、「この設定で実際に最終的な拡散画像は標準正規分布に近づくのか」という疑問があります。

    本当に標準正規分布に近づくのか

    前回の記事では、ステップttにおける画像要素の分散を次のよう表現しました。

    Var[xt]=(∏i=1t(1−βi))Var[x0]+∑k=1t(∏j=k+1t(1−βj))βk\text{Var}[x_t] = \left(\prod\limits_{i = 1}^t (1 - \beta_i) \right) \text{Var}[x_0] + \sum\limits_{k=1}^t \left( \prod\limits_{j=k+1}^t (1 - \beta_j) \right) \beta_k

    第1項は、初期画像x0\boldsymbol{x}_0からの分散がステップごとのスケーリングを通じて指数的に減衰し、最終的に無視できるほど小さくなる(0に近づく)ことを意味します。

    上述の線形スケジュールに従って、第1項のt=Tt=Tにおけるカッコ内の値を計算すると約0.00004となります。

    torch.prod(1.0 - betas, dim=0).item()

    このため、初期の分散Var[x0]\text{Var}[x_0]が大きくなければ、第1項は十分に小さくなり、0に近い値になるのがわかります。つまり、初期画像の分散からの影響は無くなります。

    なお、最終的には標準正規分布の近似になる必要があるので、第2項(ノイズの累積分散)は1に近づくことが望まれます。

    PyTorchでは、次のように計算できます。

    # prod_{j=1}^T (1-beta_j)
    cumprod = torch.cumprod(1.0 - betas, dim=0)
    
    # sum (prod_{j=k+1}^t (1 - beta_j)) * beta_k
    (cumprod[T-1] / cumprod * betas).sum().item()

    この値は0.9999595284461975で、約1.0です。つまり最終的な分散が1に非常に近くなっています。

    なお、cumprod は次の積をステップt=1∼Tt = 1 \sim Tに対して計算したものです。

    cumprod[t]=∏j=1t(1−βj)\text{cumprod}[t] = \prod\limits_{j=1}^t (1 - \beta_j)

    Pythonのインデックスは0から始まるので、数式でt=1t=1となっているのはインデックス0で、t=Tt=TとなっているのはインデックスT-1になります。ややこしいので数式の方を重視して説明しています。

    ただし、本来求めたいのは次の項です。

    ∏j=k+1T(1−βj)\prod\limits_{j=k+1}^T (1 - \beta_j)

    これは、全体の積から前半(kk以下)の積を除くことで求められます。

    ∏j=k+1T(1−βj)  =  ∏j=1T(1−βj)∏j=1k(1−βj)\prod\limits_{j=k+1}^T (1 - \beta_j) \ \ = \ \ \frac{\prod\limits_{j=1}^T (1 - \beta_j)}{\prod\limits_{j=1}^k (1 - \beta_j)}

    cumprod[T-1] / cumprod は、上式をすべてのk=1∼Tk = 1 \sim Tで計算しています。

    この各項にβk\beta_kを掛けて(* betas)、全体の和をとることで、累積ノイズの分散成分(式の第2項)が計算できました。

    これで上述の線形スケジュールの具体的なハイパーパラメータ(開始値、終了値、T)が狙い通りであることはわかりました。しかし、どのように計算してこれらのパラメータを選定したのかについては、実験的に決められたこと以外には論文中に詳細な説明がされていません。

    なお、上記の説明で「初期の分散Var[x0]\text{Var}[x_0]が大きくなければ」という条件をつけました。これが妥当な想定なのかについてもう少し考察します。

    画像を[-1, 1]に正規化する重要性

    正規化によって初期の分散を調節

    入力画像の正規化について論文は次のように述べています。

    順方向プロセスの分散βt\beta_tには、β1=10−4\beta_1 = 10^{-4}からβT=0.02\beta_T = 0.02に線形(一定に)に増加する値を設定しました。これらの定数は、[−1,1][−1, 1]にスケーリングされたデータに対して相対的に小さくなるように選ばれています。

    We set the forward process variances to constants increasing linearly from β1=10−4\beta_1 = 10^{−4} to βT=0.02\beta_T = 0.02. These constants were chosen to be small relative to data scaled to [−1, 1], ensuring that reverse and forward processes have approximately the same functional form.

    https://arxiv.org/abs/2006.11239

    まず、入力画像データは[−1,1][−1, 1]に範囲に正規化されていることがわかります。

    PyTorch でこれを実装するには、以下のように ToTensor とラムダ関数を組み合わせることで簡単に実現できます。

    from torchvision import datasets, transforms
    from torch.utils.data import DataLoader
    
    transform = transforms.Compose([
        transforms.ToTensor(),                   # [0, 255] → [0.0, 1.0]
        transforms.Lambda(lambda x: x * 2 - 1),  # [0.0, 1.0] → [-1.0, 1.0]
    ])
    
    dataset = datasets.MNIST(root="./data", train=True, download=True, 
                             transform=transform)
    
    dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
    • 画像データの値の範囲は元は0から255

    • ToTensor によって0から1の値に変換

    • lambda x: x * 2 - 1 によって−1から1の範囲へ

    ここではMNISTを使っていますが、どのデータセットでも処理は同様です。

    では、試しに最初のバッチで画像要素全体の平均と分散を確認してみます。

    # 最初のバッチで平均・分散確認
    images, _ = next(iter(dataloader))  # shape: (32, 1, 28, 28)
    
    print("正規化後の平均:", images.mean().item())
    print("正規化後の分散:", images.var().item())

    以下の結果となりました。

    正規化後の平均: -0.7550729513168335
    正規化後の分散: 0.3563251495361328

    これによって、初期の分散Var[x0]\text{Var}[x_0]が約0.36と小さく抑えられており、前述の想定が成り立つことが確認できます。

    CIFAR10でもやってみます。

    # CIFAR-10 ロード
    transform = transforms.Compose([
        transforms.ToTensor(),                   # [0, 255] → [0.0, 1.0]
        transforms.Lambda(lambda x: x * 2 - 1),  # [0.0, 1.0] → [-1.0, 1.0]
    ])
    dataset = datasets.CIFAR10(root='./data', train=True, download=True,
                               transform=transform)
    dataloader = DataLoader(dataset, batch_size=32, shuffle=False)
    
    # 最初のバッチで平均・分散確認
    images, _ = next(iter(dataloader))  # shape: (32, 3, 32, 32)
    
    print("正規化後の平均:", images.mean().item())
    print("正規化後の分散:", images.var().item())

    以下の結果になりました。

    正規化後の平均: -0.1218399628996849
    正規化後の分散: 0.25408366322517395

    ここでも、初期の分散Var[x0]\text{Var}[x_0]が約0.25と小さく抑えられており、前述の線形の分散スケジュールがうまく機能することがわかります。

    逆に、こういった前処理をすることは重要なのがわかります。さもないと「初期の分散Var[x0]\text{Var}[x_0]が大きくなければ」という前提が崩れてしまいます。

    だったら、もっと分散スケジュールで使う値を小さくすれば良いのでは、という考えも成り立ちそうです。

    しかし、ノイズが小さすぎると、モデルが除去すべき成分がほとんど存在せず、学習に有効なシグナルを得られなくなります。よって、重要なのは、画像データのスケールとノイズのスケールのバランスが取れていることであり、これは拡散モデルにおける分散スケジュールを設計する際に念頭におくべきことです。

    そこで画像データの値の大きさについて考察してみます。

    画像データの値の大きさについて

    まず、一般的な話として、上述のような正規化処理は深層学習全般でも広く用いられています。入力データを一定のスケールにすることで、データの値を連続的にし、勾配の急激な変化を抑え、学習を安定化させる効果があります。

    その上、DDPMの拡散過程では、ノイズは少しずつ付加することが前提となっています。1ステップでのノイズが大きすぎると学習が非常に困難になるためです。よって、DDPMの論文が設定した線形の分散スケジュールでは、βt\beta_tの値を0.0001から0.02まで1000回のステップで少しずつ増加させているわけです。

    順方向の1ステップで、画像にちょっとだけノイズを加えている状態になるので、逆方向も「少しだけ復元」すればよく学習が行いやすくなります。ただし、小さすぎると学習することがなくなってしまします。

    なお、もし画像データの値が元のまま(0〜255)だと、この小さなノイズではほとんど意味を成さず、効果的な拡散が行えません。このため、データを小さなスケールに正規化することはやはり必須です。

    ただし、小さなスケールにするだけであれば、正規化範囲を [0, 1] にするだけでも十分なように思われます。しかし、DDPMでは [-1, 1]の範囲へと変換しています。

    次に、この理由を考えてみます。

    [0, 1]に正規化するのでは不十分か

    再び一般的な話をすると、ニューラルネットの重みの初期化や活性化関数(例:ReLU, tanh,など)は、0を中心とした小さい範囲の入力を前提に設計されることが多いです。よって、入力をこのスケールに正規化することで、勾配が消失せず安定性が高まり、学習の効率も向上します。

    さらに、DDPMにおいては、入力を [−1, 1] の範囲に変換することが、より重要な意味を持ちます。というのも、DDPMでは、順方向と逆方向の両方にガウス分布を用いる構造を持っているためです。

    • 順方向(拡散過程):元データに平均0のガウスノイズを少しずつ付加

    • 逆方向(生成過程):平均0のガウス分布によってノイズを徐々に削除

    なぜ、生成過程がガウス分布によってノイズを削除できるのかは次回に譲りますが、ここで重要なのはどちらの方向から辿り着いても同じステップでのノイズの分布は同様である必要があるということです。

    つまり、ガウス分布は平均0を中心として対称になっており、データも同様に0の周りの限定された範囲に分布しているとすると、順方向と逆方向の過程でノイズのスケールや分布の形状が整合しやすくなります。これにより、生成過程の学習が効率的かつ安定に進みやすくなるという事です。

    生成過程では、t=Tt = Tで正規標準分布N(0,I)\mathcal{N}(\boldsymbol{0}, \mathbf{I})からサンプリングされたノイズを入力として、ネットワークが元の画像の分布へと逆変換するように学習します。

    このとき、画像の分布が正規化されていない(たとえば平均100の)場合、出発点であるノイズの分布は「平均0、分散1」の対称分布だったのに、出力として求められる画像は「平均100」などの大きく偏った分布になっているわけです。よって、ネットワークは、0から100への大きなバイアス(位置のずれ)も学習しなければならないことになります。

    これは、生成過程を複雑にし、学習を不安定にする原因になる可能性があります。

    この整合性については、また後で触れます。

    次に、拡散過程がこのように定義されている利便性を解説します。

    拡散過程は逐次的に使われない

    任意ステップへ拡散できる利便性

    もう一度、拡散過程の式をここに提示します。

    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)

    前回解説しましたが、拡散過程は「マルコフ連鎖」(Markov Chain)と呼ばれる確率過程であり、将来の状態xt+1\boldsymbol{x}_{t+1}は、現在の状態xt\boldsymbol{x}_tだけに依存しており、それよりも過去の状態に依存しません。

    マルコフ連鎖は「計算が効率的」「サンプリングが簡単」「理論的に扱いやすい」など、さまざまな利点があります。

    拡散モデルDDPM:マルコフ連鎖である理由

    さらに、拡散過程がこのように定義されている利点として、任意のステップttにおけるノイズ画像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}\left(\boldsymbol{x}_t; \sqrt{\bar{\alpha}_t} \boldsymbol{x}_0, (1 - \bar{\alpha}_t) \mathbf{I}\right)

    • αt=1−βt\alpha_t = 1 - \beta_t:ノイズを加える際のスケーリング係数

    • αˉt=∏s=1tαt\bar{\alpha}_t = \prod\limits_{s=1}^t \alpha_t:スケーリング係数の累積積

    この式がなぜ成り立つのかは後回しにしますが、ポイントは分散スケジュールβ1,βt,…,βT\beta_1, \beta_t, \ldots, \beta_Tが決まっていれば、αˉt\bar{\alpha}_tも決まるということです。

    なお、αt\alpha_tとαˉt\bar{\alpha}_tは、先ほど実装した betas を使って、次のように実装できます。

    alphas = 1.0 - betas
    alpha_bars = torch.cumprod(alphas, dim=0)  # 累積積

    これによって、例えばαˉ500\bar{\alpha}_{500}(alpha_bars[499])を簡単に得ることができます。

    また、上述の拡散過程の確率分布に従うステップttの画像xt\boldsymbol{x}_tは、次のようにも表現できます。

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

    これは平均がαˉt x0\sqrt{\bar{\alpha}_t} \,\boldsymbol{x}_0で、分散1− αˉt1 - \bar{\alpha}_t(標準偏差1− αˉt \sqrt{1 - \bar{\alpha}_t})のガウス分布からサンプリングしているのと同じです。

    上述の分散スケジュールによるとαˉ500≈0.08\bar{\alpha}_{500} \approx 0.08なので、x500\boldsymbol{x}_{500}は次のようにサンプリングできます。

    x500=0.08  x0+1−0.08 ϵ\boldsymbol{x}_{500} = \sqrt{0.08} \, \boldsymbol{x}_{0} + \sqrt{1 - 0.08} \, \boldsymbol{\epsilon}

    ここで、ϵ∼N(0,I)\boldsymbol{\epsilon} \sim \mathcal{N}(\boldsymbol{0}, \mathbf{I})です。これは、画像の各要素に対して、標準正規分布からサンプリングした値なので全体としてガウスノイズによる画像を意味します。

    つまり、この式は画像x0\boldsymbol{x}_0とノイズ画像ϵ\boldsymbol{\epsilon}の加重平均を重みαˉt\bar{\alpha}_tで計算しているに過ぎません。この例では、0.08≈0.28\sqrt{0.08} \approx 0.28、1−0.08≈0.96\sqrt{1 - 0.08} \approx 0.96なので、x500\boldsymbol{x}_{500}は「2割ほど初期画像 + ほとんどノイズ」という構成になっています。

    なお、次回より詳しく解説しますが、実際の学習では、拡散過程はランダムに選ばれたステップttにおけるノイズ付き画像xt\boldsymbol{x}_tを生成します。生成過程ではこれを入力として元の画像x0\boldsymbol{x}_0を再構築することで訓練が行われます。よって、この計算の効率の良さは非常に重要です。

    直接に拡散できることを証明する

    ここで、拡散過程でαˉt\bar{\alpha}_tを用いた式が成り立つことを帰納法を使って示します。

    帰納法は、ある式が「全ての自然数」で成り立つことを証明する手法です。

    ベースケース:最初のステップで式が成り立つことを確認します。
    帰納ステップ:あるステップt−1t-1で式が成り立つとすると、ステップttでも成り立つことを示します。

    すると、最初のステップt=1t=1から次のステップt=2t=2が成り立ちます。そして、次から次へと順次のステップで式が成り立つことを意味します。よって、ドミノ倒しのように全ての自然数で式が成り立つことになります。

    まず、ステップt=1t=1におけるベースケースは以下のように成り立ちます。

    x1=αˉ1x0+1−αˉ1ϵ1=α1x0+1−α1ϵ1=1−β1x0+βϵ1∼N(x1;1−β1x0,β1I)\begin{aligned} \boldsymbol{x}_1 &= \sqrt{\bar{\alpha}_1}\boldsymbol{x}_0 + \sqrt{1 - \bar{\alpha}_1}\boldsymbol{\epsilon}_1 \\[2ex] &= \sqrt{\alpha}_1\boldsymbol{x}_0 + \sqrt{1 - \alpha}_1\boldsymbol{\epsilon}_1 \\[2ex] &= \sqrt{1 - \beta_1} \boldsymbol{x}_0 + \sqrt{\beta} \boldsymbol{\epsilon}_1 \\[1ex] &\sim \mathcal{N}\biggl(\boldsymbol{x}_1; \sqrt{1 - \beta_1}\boldsymbol{x}_0, \beta_1 \mathbf{I} \biggr) \end{aligned}

    ここで、αˉ1=α1=1−β1\bar{\alpha}_1 = \alpha_1 = 1 - \beta_1であることを利用しました。また、ϵ1\boldsymbol{\epsilon}_1はステップ1での具体的なノイズ画像を意味します。

    次に、帰納法の仮定としてステップt−1t-1で以下が成り立つとします。

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

    拡散過程の式より、ステップttの状態はステップt−1t-1から計算できます。

    xt=1−βtxt−1+βtϵt=αtxt−1+1−αtϵt\begin{aligned} \boldsymbol{x}_{t} &= \sqrt{1 - \beta_t}\boldsymbol{x}_{t-1} + \sqrt{\beta_t} \boldsymbol{\epsilon}_{t} \\[2ex] &= \sqrt{\alpha_t}\boldsymbol{x}_{t-1} + \sqrt{1 - \alpha_t} \boldsymbol{\epsilon}_{t} \end{aligned}

    これに帰納ステップt−1t-1の式を代入します。

    xt=αtxt−1+1−αtϵt= αt(αˉt−1x0+1−αˉt−1ϵt−1)+1−αtϵt= αtαˉt−1x0+αt1−αˉt−1ϵt−1+1−αtϵt=αˉtx0+αt(1−αˉt−1)ϵt−1+1−αtϵt\begin{aligned} \boldsymbol{x}_{t} &=\sqrt{\alpha_t}\boldsymbol{x}_{t-1} + \sqrt{1 - \alpha_t} \boldsymbol{\epsilon}_{t} \\ &= \sqrt{\alpha}_{t}\biggl( \sqrt{\bar{\alpha}_{t-1}}\boldsymbol{x}_0 + \sqrt{1 - \bar{\alpha}_{t-1}} \boldsymbol{\epsilon}_{t-1} \biggr) + \sqrt{1 - \alpha_{t}} \boldsymbol{\epsilon}_{t} \\[2ex] &= \sqrt{\alpha_{t}}\sqrt{\bar{\alpha}_{t-1}}\boldsymbol{x}_0 + \sqrt{\alpha_{t}}\sqrt{1 - \bar{\alpha}_{t-1}} \boldsymbol{\epsilon}_{t-1} + \sqrt{1 - \alpha_{t}} \boldsymbol{\epsilon}_{t}\\[2ex] &= \sqrt{\bar{\alpha}_{t}}\boldsymbol{x}_0 + \sqrt{\alpha_{t}(1 - \bar{\alpha}_{t-1})} \boldsymbol{\epsilon}_{t-1} + \sqrt{1 - \alpha_{t}} \boldsymbol{\epsilon}_{t} \end{aligned}

    よって、第1項はステップttにおいても成立しています。

    また、第2項、第3項は、それぞれ独立な正規分布です。

    αt(1−αˉt−1)ϵt−1∼N(0,αt(1−αˉt−1)I)1−αtϵt−1∼N(0,(1−αt)I)\begin{aligned} \sqrt{\alpha_{t}(1 - \bar{\alpha}_{t-1})} \boldsymbol{\epsilon}_{t-1} &\sim \mathcal{N}\biggl(0, \alpha_t(1 - \bar{\alpha}_{t-1})\mathbf{I}\biggr) \\[3ex] \sqrt{1 - \alpha_{t}} \boldsymbol{\epsilon}_{t-1} &\sim \mathcal{N}\biggl(0, (1 - \alpha_{t})\mathbf{I}\biggr) \end{aligned}

    二つの独立な正規分布の和は、再び正規分布となります。また、この場合、分散は単純な合計として計算されます。

    αt(1−αˉt−1)+ 1−αt=1−αˉt\alpha_t(1 - \bar{\alpha}_{t-1}) + 1 - \alpha_{t} = 1 - \bar{\alpha}_t

    つまり、第1〜3項を合わせると、次の関係がステップttで成り立ちます。

    xt∼N(xt;αˉtx0,(1−αˉt)I)\begin{aligned} \boldsymbol{x}_t &\sim \mathcal{N}\biggl(\boldsymbol{x}_t; \sqrt{\bar{ \alpha}_t}\boldsymbol{x}_0, (1 - \bar{\alpha}_t) \mathbf{I} \biggr) \end{aligned}

    これで、任意のステップttにおけるノイズ画像xt\boldsymbol{x}_tがを元のデータx0\boldsymbol{x}_0から直接的にサンプリングできることが帰納的に証明されました。

    順方向と逆方向で統計的な整合性

    ここでもう一度、順方向と逆方向が統計的に整合性があることの意味を考えます。繰り返しの議論にはなりますが、より統計的に整合性の意味を捉え直します。

    任意のステップttにおける期待値はE[xt]=αˉt E[x0]\mathbb{E}[\boldsymbol{x}_t] = \sqrt{\bar{\alpha}_t}\,\mathbb{E}[\boldsymbol{x}_0]なので、画像データセットの期待値E[x0]\mathbb{E}[\boldsymbol{x}_0]に依存しています。

    このため、初期画像x0\boldsymbol{x}_0を [−1, 1] の範囲に正規化することは、 [0, 1]で正規化するよりも画像データ全体としての期待値をより0に近づけることになります。

    つまり、最終的なノイズ画像の期待値E[xT]\mathbb{E}[\boldsymbol{x}_T]もより0に近くなります。これは、生成過程の入力ノイズの分布がP(xT)=N(xT;0,I)P(\boldsymbol{x}_T) = \mathcal{N}(\boldsymbol{x}_T; \boldsymbol{0}, \mathbf{I})であることと統計的な整合性を持ちます。

    この整合性が崩れると、逆方向である生成過程ではN(0,I)\mathcal{N}(\boldsymbol{0},\boldsymbol{I})からサンプリングしたノイズ画像xT\boldsymbol{x}_Tを、本来のデータ分布(E[x0]≠0\mathbb{E}[\boldsymbol{x}_0] \neq \boldsymbol{0})へ変換する必要があり、モデルは「ノイズ除去」だけでなく「分布の平均の補正」(バイアス補正)も同時に学習しなければならなりません。その結果、学習効率や生成品質が低下するリスクがあります。

    拡散過程によるサンプリング実装

    最後に拡散過程を実装しましょう。

    拡散過程は、画像データxt\boldsymbol{x}_tとランダムに選ばれたステップttを入力としてノイズ付き画像xt\boldsymbol{x}_tを以下の式に従って生成します。

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

    画像がバッチになっていることに留意して、次のように拡散過程を実装します。

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

    この x_0 は一つの画像ではなく、バッチなので、その形状を元にサンプリングされるノイズ epsilon もバッチと同じ形状になり4次元です。

    また、alpha_bar_t(αˉt\bar{\alpha}_tに相当)も4次元に拡張して、epsilon と掛け算ができるようにしておきます。

    拡散過程の実装はこれだけです。

    次回予告

    次回は、DDPMの損失関数に焦点を当てます。

    前回にELBOの式を導き出しましたが、そのままでは実装が難しいのでさらなる変形が行われます。最終的に実装可能な形になるまでを解説します。

    また、今回は疑問のままに残した以下の疑問にも答えます。

    • なぜガウス分布でモデル化された生成過程がノイズを削除できる?

    • ランダムに選ばれたステップttのノイズ付き画像xt\boldsymbol{x}_tで学習する理由

    お楽しみに!

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

    あなたへのおすすめ