import torch # 导入 PyTorch 库,用于张量操作
import torch.nn.functional as F # 导入 PyTorch 的函数式 API,包含各种神经网络函数
import numpy as np # 导入 NumPy 库,用于数值计算
import matplotlib as mpl # 导入 Matplotlib 库的主模块
import matplotlib.pyplot as plt # 导入 Matplotlib 的绘图模块,用于显示图像
import imageio.v2 as imageio # 导入 imageio 库,用于读取图片文件
mpl.rcParams['figure.figsize'] = (12, 8) # 设置 Matplotlib 图表默认尺寸为 12x8 英寸
img = torch.FloatTensor(imageio.imread('imgs/hills_2.png')/255) # 读取图片,像素值归一化到[0,1],转为 PyTorch 浮点张量
print(type(img))
plt.imshow(img) # 使用 Matplotlib 显示图片
plt.show()
将上述文件保存为1.py,执行后将hills_2.png显示出来。
RGB一共有三个通道
R:Red(红色)
G:Green(绿色)
B:Blue(蓝色)
其取值范围为[0,255]
例如:
黑色:(0,0,0)
白色:(255,255,255)
红色:(255,0,0)
蓝色:(0,0,255)
如果图像尺寸是 𝐻×𝑊
常见 tensor 形状:
PyTorch:(3,𝐻,𝑊)
TensorFlow:(𝐻,𝑊,3)
为了让数据和高斯噪声处在同一个零中心对称空间里,要对像素值进行仿射变换:
原像素值取值范围为[0,255]
归一化(就是除以255),取值范围为[0,1]
现在想它取值范围为[-1,1]
变换形式为$y=ax+b$
当$x=0$时,$y=-1$,当$x=1$时,$y=1$
$y=2x-1$,$x=\frac{1}{2}y+\frac{1}{2}$
仿射变换矩阵为:
$$ \begin{bmatrix} y \\ 1 \end{bmatrix} = \begin{bmatrix} 2 & -1 \\ 0 & 1 \end{bmatrix} \begin{bmatrix} x \\ 1 \end{bmatrix} $$
$$ \begin{bmatrix} x \\ 1 \end{bmatrix} = \begin{bmatrix} \frac{1}{2} & \frac{1}{2} \\ 0 & 1 \end{bmatrix} \begin{bmatrix} y \\ 1 \end{bmatrix} $$
写成代码2.py
import torch # 导入 PyTorch 库,用于张量操作
import torch.nn.functional as F # 导入 PyTorch 的函数式 API,包含各种神经网络函数
import numpy as np # 导入 NumPy 库,用于数值计算
import matplotlib as mpl # 导入 Matplotlib 库的主模块
import matplotlib.pyplot as plt # 导入 Matplotlib 的绘图模块,用于显示图像
import imageio.v2 as imageio # 导入 imageio 库,用于读取图片文件
mpl.rcParams['figure.figsize'] = (12, 8) # 设置 Matplotlib 图表默认尺寸为 12x8 英寸
img = torch.FloatTensor(imageio.imread('imgs/hills_2.png')/255) # 读取图片,像素值归一化到[0,1],转为 PyTorch 浮点张量
print(type(img))
# 使用 Matplotlib 显示图片
def input_T(input):
# [0,1] -> [-1,+1]
return 2*input-1
def output_T(input):
# [-1,+1] -> [0,1]
return (input+1)/2
def show(input):
plt.imshow(output_T(input).clip(0,1))
img_=input_T(img)
plt.imshow(img_)
#show(img_)
plt.show()
这段代码改改玩,如果只进行变换,不进行逆变换
图片长这样
可以看出图片的形状没有变
扩散过程是基于一个方差调度表构建的,这个调度表决定了在扩散过程的每一个时间步中加入噪声的强度。为此,我们定义如下几个量:
1. betas:$\beta_t$
它表示第 $t$ 步加入噪声的强度,也可以理解为该步的“噪声方差比例”。
直观理解:
所以,$\beta_t$ 控制的是:
当前这一步要往图像里掺多少噪声。
它表示第 $t$ 步保留下来的原始信号比例。
直观理解:
因为每一步不是“全换成噪声”,而是:
所以:
可以把它理解为:
这一轮之后,图像内容还能剩下多少。
这个量是在实际加噪公式里直接使用的系数。
单步扩散通常写成:
$$x_t = \sqrt{\alpha_t} \, x_{t-1} + \sqrt{1-\alpha_t} \, \epsilon_t$$
其中:
直观理解:
$\sqrt{\alpha_t}$ 是上一步图像在当前步中的保留权重。
之所以取平方根,是因为扩散模型里控制的是方差,而真正乘在样本上的系数是标准差,所以会出现平方根。
注:变量乘以标准差,才能得到对应的方差。如X⇒3X,方差是原来的9倍。
它表示从第 $0$ 步到第 $t$ 步,所有保留比例连乘之后的结果。
直观理解:
如果每一步都保留一部分信号,那么经过很多步之后,原始图像 $x_0$ 还能剩多少,不是看某一步,而是看所有步骤累积起来的效果。
所以 $\bar{\alpha}_t$ 表示:
原始图像 $x_0$ 到第 $t$ 步时,整体还保留了多少比例的信号能量。
5. alphasprodsqrt:$\sqrt{\bar{\alpha}_t}$
这个量是从原图 $x_0$ 直接生成第 $t$ 步噪声图 $x_t$ 时的关键系数。
扩散模型里一个非常重要的公式是:
$$x_t = \sqrt{\bar{\alpha}_t} \, x_0 + \sqrt{1-\bar{\alpha}_t} \, \epsilon$$
直观理解:
这里:
forward_step()
下面我们定义一个函数 forward_step(),它可以让我们使用单步前向过程 $q(xt|x{t-1})$;同时再定义 forward_jump(),用于表示从 $x0$ 直接到 $xt$ 的过程 $q(xt|x0)$。
<code>
import torch # 导入 PyTorch 库,用于张量操作
import torch.nn.functional as F # 导入 PyTorch 的函数式 API,包含各种神经网络函数
import numpy as np # 导入 NumPy 库,用于数值计算
import matplotlib as mpl # 导入 Matplotlib 库的主模块
import matplotlib.pyplot as plt # 导入 Matplotlib 的绘图模块,用于显示图像
import imageio.v2 as imageio # 导入 imageio 库,用于读取图片文件
mpl.rcParams['figure.figsize'] = (12, 8) # 设置 Matplotlib 图表默认尺寸为 12×8 英寸
# 读取图片,像素值归一化到[0,1],转为 PyTorch 浮点张量
img = torch.FloatTensor(imageio.imread('imgs/hills_2.png')/255)
print(type(img))
# 值域转换函数:将图像从 [0,1] 转换到 [-1,+1]
def inputT(input):
# [0,1] → [-1,+1]
return 2*input-1
====== 反向过程 ======
反向过程 $p$ 的目的是:根据扩散链中的当前样本 $xt$,去近似恢复前一步的样本 $x{t-1}$。在实际情况下,这种近似 $p(x{t-1}|xt)$ 必须在不知道 $x_0$ 的前提下完成。
通常会使用一个带参数 $\theta$ 的可参数化预测模型,来估计 $p\theta(x{t-1}|x_t)$。
如果扩散的每一步足够小,那么反向过程也可以近似看作高斯分布:
$$p\theta(x{t-1}|xt) := \mathcal{N}(x{t-1};\mu\theta(xt),\Sigma\theta(xt))\tag{3}$$
在很多工作中,通常假设这个分布的方差不应强烈依赖于 $x0$ 或 $xt$,而应主要依赖于扩散过程所处的阶段 $t$。这一点可以从真实分布 $q(x{t-1}|xt, x0)$ 中观察到,因为该分布的方差等于 $\tilde{\beta}t$。
对 $\mu_\theta$ 的参数化
对于反向单步分布 $p\theta(x{t-1}|xt)$ 的均值 $\mu\theta$,至少有 3 种参数化方式:
* 直接预测:由神经网络直接估计 $\mu\theta$
* 通过 $x0$ 参数化:由神经网络先估计 $x_0$
$$\tilde{\mu}\theta = \frac{\sqrt{\bar{\alpha}{t-1}}\betat}{1-\bar{\alpha}t}x0 + \frac{\sqrt{\alphat}(1-\bar{\alpha}{t-1})}{1-\bar{\alpha}t}x_t\tag{4}$$
* 通过从 $x_0$ 中减去噪声 $\epsilon$ 来参数化:由神经网络估计 $\epsilon$
$$x0=\frac{1}{\sqrt{\bar{\alpha}t}}(xt-\sqrt{1-\bar{\alpha}t}\epsilon)\tag{5}$$
其中,最常用的方法是近似预测高斯噪声 $\epsilon$。
下面我们来看一个 $\epsilon$ 的示例可能长什么样:
<code>
import torch # 导入 PyTorch 库,用于张量操作
import torch.nn.functional as F # 导入 PyTorch 的函数式 API
import numpy as np # 导入 NumPy 库,用于数值计算
import matplotlib as mpl # 导入 Matplotlib 库的主模块
import matplotlib.pyplot as plt # 导入 Matplotlib 的绘图模块
import imageio.v2 as imageio # 导入 imageio 库,用于读取图片文件
mpl.rcParams['figure.figsize'] = (12, 8) # 设置 Matplotlib 图表默认尺寸
# 读取图片,像素值归一化到[0,1],转为 PyTorch 浮点张量
img = torch.FloatTensor(imageio.imread('imgs/hills_2.png') / 255)
# 值域转换函数:将图像从 [0,1] 转换到 [-1,+1](扩散模型标准输入值域)
def input_T(input):
# [0,1] → [-1,+1]
return 2 * input - 1
# 值域转换函数:将图像从 [-1,+1] 转换到 [0,1](用于显示)
def output_T(input):
# [-1,+1] → [0,1]
return (input + 1) / 2
# 显示图像函数,自动转换值域并裁剪到 [0,1]
def show(input):
plt.imshow(output_T(input).clip(0, 1))
# ========== 扩散模型超参数设置 ==========
T = 100 # 时间步总数
# 定义 beta 调度(线性调度)
betas = torch.linspace(0.0001, 0.02, T) # 从 0.0001 线性增加到 0.02
# 计算 alpha 相关参数
alphas = 1 - betas # alphat = 1 - betat
alphascumprod = torch.cumprod(alphas, dim=0) # 累积乘积:ᾱt = ∏(1-βs)
alphascumprodsqrt = torch.sqrt(alphascumprod) # √ᾱ_t
# 设置前向跳转的时间步
t_step = 50
def forwardjump(t, conditionimg, conditionidx=0, returnnoise=False):
“”“
forward jump: 0 → t
直接跳转加噪:从初始时刻 0 直接加噪到时刻 t
如果噪声 $\epsilon$ 能够被正确预测,那么我们就可以利用公式 $x0=\frac{1}{\sqrt{\bar{\alpha}t}}(xt-\sqrt{1-\bar{\alpha}t}\epsilon)$来预测 $x_0$:
<code python>
import torch # 导入 PyTorch 库,用于张量操作
import torch.nn.functional as F # 导入 PyTorch 的函数式 API
import numpy as np # 导入 NumPy 库,用于数值计算
import matplotlib as mpl # 导入 Matplotlib 库的主模块
import matplotlib.pyplot as plt # 导入 Matplotlib 的绘图模块
import imageio.v2 as imageio # 导入 imageio 库,用于读取图片文件
mpl.rcParams['figure.figsize'] = (12, 8) # 设置 Matplotlib 图表默认尺寸
# 读取图片,像素值归一化到[0,1],转为 PyTorch 浮点张量
img = torch.FloatTensor(imageio.imread('imgs/hills_2.png') / 255)
# 值域转换函数:将图像从 [0,1] 转换到 [-1,+1](扩散模型标准输入值域)
def input_T(input):
# [0,1] → [-1,+1]
return 2 * input - 1
# 值域转换函数:将图像从 [-1,+1] 转换到 [0,1](用于显示)
def output_T(input):
# [-1,+1] → [0,1]
return (input + 1) / 2
# 显示图像函数,自动转换值域并裁剪到 [0,1]
def show(input):
plt.imshow(output_T(input).clip(0, 1))
# ========== 扩散模型超参数设置 ==========
T = 100 # 时间步总数
# 定义 beta 调度(线性调度)
betas = torch.linspace(0.0001, 0.02, T) # 从 0.0001 线性增加到 0.02
# 计算 alpha 相关参数
alphas = 1 - betas # alphat = 1 - betat
alphascumprod = torch.cumprod(alphas, dim=0) # 累积乘积:ᾱt = ∏(1-βs)
alphascumprodsqrt = torch.sqrt(alphascumprod) # √ᾱ_t
# 设置前向跳转的时间步
t_step = 50
def forwardjump(t, conditionimg, returnnoise=False):
“”“
forward jump: 0 → t
直接跳转加噪:从初始时刻 0 直接加噪到时刻 t
这里的含义是:
* 第一幅图显示当前带噪样本 $xt$
* 第二幅图显示根据预测噪声反推出的 $x0$,记作 $x0_pred$
* 第三幅图显示真实的干净样本 $x0$
如果预测的噪声足够准确,那么 $x0_pred$ 就会接近真实的 $x0$。
近似或已知 $x_0$ 后,可以进一步近似 $t-1$ 步的均值
一旦我们得到了对 $x0$ 的近似(或者直接知道真实的 $x0$),就可以利用公式 (4) 来近似第 $t-1$ 步对应分布的均值:
<code python>
# estimate mean
meanpred = x0pred * (alphascumprodsqrt[tstep-1] * betas[tstep]) / (1 - alphascumprod[tstep]) \
+ xt * (alphassqrt[tstep] * (1 - alphascumprod[tstep-1])) / (1 - alphascumprod[tstep])
# let's compare it to ground truth mean of the previous step (requires knowledge of x0)
meangt = alphascumprodsqrt[tstep-1] * img
</code>
其中:
* mean_pred:根据预测得到的 $x0$ 和当前样本 $xt$ 计算出的反向过程均值近似
* mean_gt:真实的前一步均值,它需要知道真实的 $x_0$
这里的 mean_gt 本质上对应的是前向过程中从干净图像得到的“真实均值”。
—-
为什么 mean_pred 的误差通常会更大
由于公式 (4) 中的反向过程均值估计 $\tilde{\mu}\theta$,本质上是对带噪的 $xt$ 和估计出来的 $x_0$ 做一种线性组合,因此它通常会比前向过程直接得到的均值误差更大。
原因是:
* $xt$ 本身仍然含有噪声
* $x0_pred$ 只是估计值,不是真实值
* 因此两者线性组合得到的均值仍然会带来额外误差
而前向过程中的均值通常只是对干净样本乘上一个标量,因此更精确。
下面的代码展示了这种比较:
<code python>
plt.subplot(1,3,1)
show(xt)
plt.title('$xt$ ($\ell1$: {:.3f})'.format(F.l1loss(xt, img)))
plt.subplot(1,3,2)
show(meanpred)
plt.title(r'$\tilde{\mu}{t-1}$' + ' ($\ell1$: {:.3f})'.format(F.l1loss(meanpred, img)))
plt.subplot(1,3,3)
show(meangt)
plt.title(r'$\mu{t-1}$' + ' ($\ell1$: {:.3f})'.format(F.l1loss(meangt, img)))
</code>
这三幅图分别表示:
* 左图:当前带噪图像 $xt$
* 中图:反向过程估计的均值 $\tilde{\mu}{t-1}$
* 右图:真实均值 $\mu_{t-1}$
比较它们的 $\ell_1$ 误差,就可以看出估计值和真实值之间的差别。
—-
得到 mean_pred 之后,就可以定义前一步的分布
当我们获得了 mean_pred,也就是 $\tilde{\mu}_t$ 之后,就可以将前一步的条件分布定义为:
$$\tilde{\beta}t = \betat \tag{6}$$
$$p\theta(x{t-1}|xt) := \mathcal{N}(x{t-1}; \tilde{\mu}\theta(xt,t), \tilde{\beta}_t I) \tag{7}$$
这个定义表示:
* 均值使用网络估计出来的 $\tilde{\mu}\theta(xt,t)$
* 方差使用 $\tilde{\beta}_t$
* 从而构造出反向过程中的高斯分布
重要说明
> 下面的实验应被看作一种模拟。
> 在实际训练和推理中,网络必须预测以下三者之一:
> * $\epsilon$
> * $x0$
> * $\tilde{\mu}\theta$
>
> 而这里的 $\epsilon$ 值只是直接代入使用的,并不是真实模型预测出来的结果。
reverse_step 函数
下面这个函数实现了一次反向扩散步骤:
<code python>
def reversestep(epsilon, xt, tstep, returnnoise=False):
reverse_step() 的逻辑讲解
1. 根据 $\epsilon$ 先恢复 $x_0$
<code python>
x0pred = (xt - (1 - alphascumprod[tstep]).sqrt() * epsilon) / (alphascumprodsqrt[tstep])
</code>
这一行对应公式 (5):
$$x0=\frac{1}{\sqrt{\bar{\alpha}t}}(xt-\sqrt{1-\bar{\alpha}t}\epsilon)$$
作用是:
* 输入当前带噪样本 $xt$
* 输入预测得到的噪声 $\epsilon$
* 反推出干净图像的估计值 $x0$
—-
2. 如果已经到达 $t=0$
<code python>
if tstep == 0:
sample = x0pred
noise = torch.zeroslike(x_0_pred)
</code>
当 t_step == 0 时,说明已经到达反向过程的最后一步,不需要再继续去噪。
因此:
* 直接把 $x_0_pred$ 当作最终结果
* 此时噪声设为全零
—-
3. 如果 $t > 0$,先估计反向均值
<code python>
meanpred = x0pred * (alphascumprodsqrt[tstep-1] * betas[tstep]) / (1 - alphascumprod[tstep]) \
+ xt * (alphassqrt[tstep] * (1 - alphascumprod[tstep-1])) / (1 - alphascumprod[tstep])
</code>
这一行对应公式 (4):
$$\tilde{\mu}\theta = \frac{\sqrt{\bar{\alpha}{t-1}}\betat}{1-\bar{\alpha}t}x0 + \frac{\sqrt{\alphat}(1-\bar{\alpha}{t-1})}{1-\bar{\alpha}t}x_t$$
只不过代码里用的是预测值 x_0_pred 来代替真实的 $x_0$。
意思是:
* 综合当前带噪样本 $xt$
* 再结合恢复出的干净样本估计 $x0_pred$
* 得到前一步分布的均值估计 mean_pred
—-
4. 计算标准差
<code python>
betapred = betas[tstep].sqrt() if t_step != 0 else 0
</code>
这里使用:
* 方差 $\tilde{\beta}t = \betat$
* 所以标准差为 $\sqrt{\beta_t}$
这是为了后面从高斯分布中采样:
$$x{t-1} \sim \mathcal{N}(\tilde{\mu}\theta, \tilde{\beta}_t I)$$
—-
5. 从反向分布中采样
<code python>
sample = meanpred + betapred * torch.randnlike(xt)
</code>
这一步就是从高斯分布中真正采样出 $x_{t-1}$。
也就是:
* 均值为 mean_pred
* 标准差为 beta_pred
* 加上一份标准高斯噪声
对应采样形式可以写成:
$$x{t-1} = \tilde{\mu}\theta + \sqrt{\tilde{\beta}_t}\,z,\quad z\sim\mathcal{N}(0,I)$$
—-
6. 计算 noise 仅用于模拟分析
<code python>
noise = (sample - x0pred * alphascumprodsqrt[tstep-1]) / (1 - alphascumprod[t_step-1]).sqrt()
</code>
这里的 noise 只是为了实验分析而额外算出来的。
因为在真实的反向扩散推理中:
* 我们并不知道真实的 $x0$
* 这里只是因为做实验,才利用 x_0_pred 反推一个噪声值
所以注释里才特别说明:
* 这个噪声只是为了模拟目的而计算
* 并不是实际系统中能直接获得的量
7. 是否返回噪声
<code python>
if returnnoise:
return sample, noise
else:
return sample
</code>
如果 return_noise=True:
* 返回当前反向步骤采样结果 sample
* 同时返回额外计算的 noise
否则:
* 只返回 sample
这个 reverse_step() 函数做的事情是:
* 先根据预测噪声 $\epsilon$ 还原出 $x0$
* 再根据 $xt$ 和 $x0$ 的估计值计算反向分布均值
* 然后从这个高斯分布中采样得到 $x{t-1}$
也就是说,它实现了扩散模型中的一次“去噪反推”。