
画像生成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のおさらい
まず、拡散モデルには、拡散過程(フォワードプロセス)と生成過程(リバースプロセス)があります。
拡散過程のマルコフ連鎖
拡散過程は、入力画像を段階的にノイズにするマルコフ連鎖です。ノイズは分散スケジュールに従って計算されます。
マルコフ連鎖とは、未来の状態が現在の状態だけに依存し、過去の状態には依存しない確率過程のことです。拡散過程は、ステップにおけるノイズ画像が一つ前のステップの画像にだけ依存するためマルコフ連鎖になっています。
拡散過程の定義は、以下のようにガウス分布で表現されます。
DDPMの拡散過程はマルコフ連鎖ですが、ガウス分布を使っているため以下のような関係がとの間に導かれます。
つまり、拡散過程は逐次的に(ステップを一つずつ)計算する必要はなく、指定されたステップにおけるノイズを一気に計算できます。
このため学習中は、ランダムに選ばれたステップにおけるノイズを以下のように一気に計算します。
ここで、は、標準正規分布からのノイズです。この式は、平均で標準偏差となっており、上述のガウス分布と同等です。
拡散過程の逆過程(理想)
次に、拡散過程においてとを条件としての確率を考えます。
これは拡散過程によるからへの逆過程の式です。拡散過程では常にが条件に入ってきます。この式の平均と分散は以下のように計算されます。
この平均の式の導出そのものよりも、の平均がとの加重平均になっていること、また、その重みが分散スケジュールからの値によって計算されていること理解することが重要です。
この拡散過程の逆過程を生成過程は近似しているわけですが、上式には生成過程が知ることができないが含まれています。
生成過程の逆過程(近似)
生成過程(逆過程)は拡散過程の逆過程を近似するために、拡散過程のマルコフ連鎖の式をの式に書き直します。
これをノイズ予測モデル(U-Net)を使って予測したノイズを使い近似します。
はニューラルネットワークのパラメータの集合を意味します。この式によるを拡散過程の逆過程(理想)に代入すると以下の式が得られます。
この平均と拡散過程の逆過程の分散を使えば、を必要とせずに生成過程のサンプリングが行えます。
生成過程のマルコフ連鎖
生成過程のマルコフ連鎖は、次のように定義されます。
これを更新式の形で書くと以下になります。
は、標準正規分布からサンプリングされた値です。
ただし、論文によると、実験ではをで近似しても同様の結果が得られたため、生成過程の実装もこれに従っています。
# ----------------------------------------------------------------------
# 生成過程 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画像から画像の平均値 mean = を計算
新しいガウスノイズを * noise で加える
なお、からは、サンプリングは行わず予測された平均値をそのまま使います。これはには拡散過程によるノイズが含まれないからです。
こうして生成過程は逐次的にノイズ画像からサンプリングを行い最終的に得たが生成画像となるという仕組みです。
以下は、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と同じです。
また、の予測の部分も同じです。
は、ノイズ予測モデル(U-Net)によるものであり、訓練を変える必要はありません。
新しい「逆過程」の形
DDIMでは生成過程(拡散過程の逆過程近似)を以下のように設計しています。
この式での場合、DDPMの平均の形と同じになります。
ただし、ノイズ予測はニューラルネットワークによって決定論的に計算されるので、の場合はサンプリングの効果がありません。よって、同じノイズからは常に同じ画像が生成されるよう(決定論的なマッピング)になります。
サンプリングの効果を得るためには、である必要があります。自体は以下のように定義されています。
このはハイパーパラメータであり0から1の値を指定することができます。だととなるので決定論的に画像が生成されます。
なお、DDIMの論文ではDDPMの論文と表記の仕方が少し違っていてなどをと書いたり、なるべくを出さないスタイルになっています。しかし、であり、さらにも使うと簡略化できます。
なお、とを使うと、です。
よって、をもう少し簡略化できます。
つまり、はは以下になります。
だとなので、DDPMの拡散過程のノイズの分散と同じ計算です。その場合のDDIMの生成過程の更新式は以下になります。
第1項にの予測の式を代入して整理します。
第2項は次のように変形できます。
以上より、の時の更新式は以下になります。
これは、DDPMの生成過程の更新式と同じです。
つまり、係数によってサンプリングの際に与えるノイズの量をコントロールすることが可能になっています。
:完全決定論的サンプリング(毎回同じノイズなら同じ画像)
:ノイズを加えて多様性を出す
:DDPMのノイズレベルを模倣
:これも指定はできますが、画質が著しく悪化します
少ないステップで生成
DDPMの生成過程はマルコフ連鎖であり、以下のように表現できます。
このように、各ステップは1つ前のだけに条件づけられて進みます。つまり、であり、これはマルコフ連鎖です。こちらでも解説しています。
DDPMでもの推定を行なっていますが、これはあくまでサンプリングのための平均値を計算するためであり、生成過程そのものはマルコフ性があります。
そのため、DDPMではTステップすべてを逐次的なサンプリングによって画像生成を行います。
また、DDPMではステップからの画像を直接生成するように定式化されています。よって、以外のステップにジャンプして進むことはできません。
一方、DDIMでは全ての1ステップ刻みを使う必要はなく、たとえば1000ステップから50ステップへ間引きスケジュールを設定しても高品質な生成が可能です。
DDIMの更新式は以下になっています。
かつ1ステップ刻みの場合はDDPMの生成過程と一致します。このように、DDIMはDDPMの生成過程を柔軟化・一般化した手法です。
なぜスキップができるのかというと、DDIMではステップから一旦を予測して、そこからに戻るという処理を行います。その際に、限らず任意に間引いたステップに戻ることもできるため、スキップが可能となっています。
これは学習時に全てのに対してノイズ予測モデルを利用することでを推定できるように学習されていることをうまく利用しています。このため、任意のからを予測し、そこから任意のへマッピング可能になっています。
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 * maskDDPMの sample_p と似た処理ですが、以下のDDIMの計算式を使っています。
なお、スキップできるので、更新先は必ずしもとは限りません。つまり、コードの中の 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 xDDPMと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
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
かなり速くなりました。
推論時のノイズ効果
以下のコードを使ってノイズ係数を変化させてその影響を確認します。
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 をもとに異なる各の値に対して複数回画像を生成しています。
結果はこうなりました。

再現性のために乱数シードを固定してあり、さらに最上行はなので、何度生成しても同じ画像が決定論的に生成されます。だと多様性が増します(同じノイズからでも異なる画像が出る)が、品質が大きく劣化することは通常ありません。
は、若干と同じ数字が同じ位置にあるようには感じます。それと比べると、はと異なる数字が出ているように見受けられます。
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
DDIMの実行速度
生成過程やサンプリングのコードはMNISTのものと全く同じです。以下の結果が出ました。
DDIM sampling: 4.04 seconds
推論時のノイズ効果
これもMNISTの時と同じコードを使いました。結果は以下になります。

最上行はなので、何度生成しても同じ画像が決定論的に生成されます。これはMNISTの時と同じです。車や鳥が出てくる場所を比べるとはに似ている傾向があります。同様に同じ位置で比べると、はと異なったクラスの画像がより多くの位置で生成されています。
次回予告
これまで、DDPMとDDIMで拡散モデルの基本とその高速化手法を解説してきました。ただし、これらはピクセル空間での拡散を前提としており、高解像度画像では計算コストが非常に大きくなります。
次回は、こうした課題を解決するために提案された Latent Diffusion Models (LDM) を紹介します。LDMはピクセル空間ではなく潜在空間で拡散を行うことで、高解像度画像を効率的に生成します。また、LDMは Stable Diffusion v1 の原型となったモデルです。
お楽しみに!