论文信息

• 标题：Image Super-Resolution via Iterative Refinement
• 会议：arXiv 2021（后续被PAML 2023收录）
• 单位：Google Research, Brain Team
• 代码：github.com/openai/guided-diffusion（官方开源实现）
• 论文：https://arxiv.org/pdf/2104.07636

一、开篇：为什么SR3能成为扩散超分的里程碑？

在SR3诞生前，图像超分辨率领域一直被GAN模型统治。虽然GAN能生成相对清晰的图像，但它有两个致命缺陷：一是训练极不稳定，需要精心设计正则化和优化技巧，一不小心就会出现模式崩溃；二是生成的图像细节往往不自然，容易出现伪影和扭曲。

而此时，扩散模型在无条件图像生成领域已经崭露头角，它训练稳定、生成质量高、模式覆盖全面。Google Research团队就此提出了一个大胆的想法：能不能把扩散模型用到图像超分辨率这个条件生成任务上？

这个想法的产物就是SR3（Super-Resolution via Repeated Refinement），它是第一个将扩散模型成功应用于图像超分辨率的工作，也是后续所有扩散超分模型的鼻祖。SR3不仅在8倍人脸超分任务上实现了接近50%的人类欺骗率（意味着生成的图像和真实照片几乎无法区分），还解锁了级联生成的能力，能从64×64的低分辨率图像一步步生成1024×1024的高清图像，彻底改变了超分辨率的技术范式。

二、SR3核心原理：条件扩散模型的数学本质

SR3的核心是条件去噪扩散概率模型，它把超分辨率任务转化为一个"从噪声中迭代精炼"的过程。简单来说，就是先给一张纯高斯噪声，然后让模型一步步去掉噪声，最终得到一张和输入低分辨率图像一致的高清图像。

1. 前向扩散过程：给高清图像加噪声

前向扩散过程是一个固定的马尔可夫链，它的作用是给高清图像逐步添加高斯噪声，直到图像变成纯噪声。这个过程不需要训练，完全是数学上的确定性操作。

核心公式

$$q\left(y_{1:T}|y_0\right)=\prod _{t=1}^{T}q\left(y_t|y_{t-1}\right)$$

$$q\left(y_t|y_{t-1}\right)=\mathcal{N}\left(y_t|\sqrt{{\alpha }_t}{y}_{t-1},\left(1-{\alpha }_t\right)I\right)$$

公式中每个符号的含义与通俗解释：

• $q$：前向扩散过程的概率分布
• $y_0$：原始高清图像（我们想要生成的目标图像）
• $y_t$：第t步加噪后的图像
• $T$：总扩散步数（SR3中默认T=2000）
• ${\alpha }_t$：第t步的衰减系数，是一个介于0和1之间的超参数
• $\mathcal{N}(\mu ,{\sigma }^{2}I)$：均值为$\mu$、方差为${\sigma }^{2}I$的高斯分布
• $I$：单位矩阵，表示每个像素的噪声是独立的

通俗解释：前向扩散过程就像给一张清晰的照片蒙上一层又一层的磨砂玻璃，每蒙一层，照片就模糊一点。蒙了T层之后，照片就完全变成了雪花屏（纯高斯噪声）。

更重要的是，我们可以直接计算任意第t步的加噪图像，不需要一步步迭代：
$$q\left(y_t|y_0\right)=\mathcal{N}\left(y_t|\sqrt{{\gamma }_t}{y}_0,\left(1-{\gamma }_t\right)I\right)$$
其中${\gamma }_t={\prod }_{i=1}^t{\alpha }_i$，是前t步衰减系数的乘积。这个性质极大地简化了训练过程。

2. 反向去噪过程：从噪声中还原高清图像

反向去噪过程是我们需要训练的部分，它的作用是逆转前向扩散过程，从纯噪声$y_T$一步步还原出高清图像$y_0$。对于超分辨率任务，这个过程还需要额外条件：输入的低分辨率图像$x$。

核心公式

$$p_{\theta }\left(y_{0:T}|x\right)=p\left(y_T\right)\prod _{t=1}^T{p}_{\theta }\left(y_{t-1}|y_t,x\right)$$

$$p\left(y_T\right)=\mathcal{N}\left(y_T|0,I\right)$$

$$p_{\theta }\left(y_{t-1}|y_t,x\right)=\mathcal{N}\left(y_{t-1}|{\mu }_{\theta }\left(x,y_t,{\gamma }_t\right),{\sigma }_t^{2}I\right)$$

公式中每个符号的含义与通俗解释：

• $p_{\theta }$：反向去噪过程的概率分布，可学习参数为$\theta$
• $x$：输入的低分辨率图像（超分的条件）
• $y_T$：初始纯噪声图像，服从标准正态分布
• ${\mu }_{\theta }$：模型预测的第t-1步图像的均值
• ${\sigma }_t^2$：第t-1步图像的方差，SR3中直接设置为$1-{\alpha }_t$，不需要学习

通俗解释：反向去噪过程就像一个经验丰富的修复师，拿着一张被磨砂玻璃蒙住的照片（加噪图像）和一张低分辨率的参考图（输入x），一步步擦掉磨砂玻璃，最终还原出一张清晰的高清照片。

3. 训练目标：让模型学会预测噪声

SR3的训练目标非常简单：让模型学会预测加噪图像中添加的噪声。

训练损失函数

$${\mathbb{E}}_{(x,y)}{\mathbb{E}}_{ϵ,\gamma }\Vert f_{\theta }(x,\underset{\tilde{y}}{\underbrace{\sqrt{\gamma }{y}_0+\sqrt{1-\gamma }ϵ}},\gamma )-ϵ{\Vert }_p^p$$

公式中每个符号的含义与通俗解释：

• $\mathbb{E}$：数学期望，通俗理解为对所有随机变量取平均值
• $(x,y)$：训练集中的低分辨率-高分辨率图像对
• $ϵ$：添加的高斯噪声，服从标准正态分布
• $\gamma$：噪声水平，对应前向扩散过程中的${\gamma }_t$
• $\tilde{y}$：加噪后的图像，由高清图像$y_0$和噪声$ϵ$混合而成
• $f_{\theta }$：我们训练的U-Net模型，输入是低分辨率图像x、加噪图像$\tilde{y}$和噪声水平$\gamma$，输出是预测的噪声
• $p$：范数的阶数，SR3中实验证明L1范数（p=1）效果略好于L2范数（p=2）

通俗解释：训练时，我们随机选一张高清图像$y_0$，给它加一个随机水平的噪声$ϵ$，得到加噪图像$\tilde{y}$。然后把$\tilde{y}$、对应的低分辨率图像x和噪声水平$\gamma$输入模型，让模型预测我们添加的噪声$ϵ$。模型预测得越准，损失就越小。

4. 推理过程：迭代精炼生成高清图像

训练完成后，我们就可以用模型来做超分辨率了。推理过程从纯高斯噪声开始，一步步迭代去噪，最终得到高清图像。

推理算法

输入：低分辨率图像x
输出：高清图像y0
1. 初始化yT ~ N(0, I)  # 纯高斯噪声
2. 从t=T到t=1迭代：
   a. 如果t>1，采样z ~ N(0, I)，否则z=0
   b. 计算预测的噪声：epsilon_pred = f_theta(x, yt, gamma_t)
   c. 更新图像：yt-1 = (1/sqrt(alpha_t)) * (yt - ((1-alpha_t)/sqrt(1-gamma_t)) * epsilon_pred) + sqrt(1-alpha_t) * z
3. 返回y0

通俗解释：推理时，我们先拿一张纯雪花屏，然后让模型一步步去掉噪声。每一步，模型都会根据输入的低分辨率图像，预测当前图像中还有多少噪声，然后把这些噪声去掉一点。重复这个过程T次，雪花屏就变成了一张清晰的高清图像。

三、SR3模型架构与关键设计

SR3的模型架构基于DDPM的U-Net，但做了几个关键的改进，使其更适合超分辨率任务。

1. 整体架构

SR3采用经典的编码器-解码器U-Net架构，包含下采样的编码器、上采样的解码器和跳跃连接。编码器逐步降低图像分辨率，提取高级语义特征；解码器逐步恢复图像分辨率，生成高清图像；跳跃连接将编码器的低级特征和解码器的高级特征融合，保留细节信息。

2. 关键改进

1. BigGAN残差块：将DDPM中原始的残差块替换为BigGAN的残差块，提升了模型的表达能力和训练稳定性。
2. 跳跃连接缩放：将跳跃连接的输出乘以$1/\sqrt{2}$，防止训练过程中梯度爆炸。
3. 条件注入方式：将低分辨率图像x用双线性插值上采样到目标分辨率，然后和加噪图像$y_t$在通道维度上拼接，作为模型的输入。论文实验证明，这种简单的拼接方式和更复杂的FiLM条件注入方式效果相当。
4. 噪声水平条件：将噪声水平$\gamma$通过正弦位置编码后，注入到每个残差块中，让模型知道当前处于去噪的哪个阶段。

3. 噪声调度与高效推理

SR3训练时使用2000步扩散，但推理时可以通过调整噪声调度，将步数减少到100步，而生成质量几乎没有下降。这是因为SR3直接对噪声水平$\gamma$建模，而不是对时间步t建模，这给了推理时选择步数和噪声调度的灵活性。

四、实验结果与核心结论

论文通过大量严谨的实验，全面验证了SR3的性能优势，核心实验如下。

1. 定性结果：生成效果对比

图1 SR3代表性生成结果（出处：原论文图1）

效果分析：

• 上半部分是8倍人脸超分（16×16→128×128），SR3生成的人脸细节丰富，皮肤纹理、头发丝都清晰可见，和真实人脸几乎无法区分。
• 下半部分是4倍自然图像超分（64×64→256×256），SR3生成的自然图像纹理自然，没有明显的伪影，细节远超传统方法。

图2 不同方法的人脸超分效果对比（出处：原论文图5）

效果分析：

• Bicubic（双三次插值）：生成的图像非常模糊，几乎没有细节。
• FSRGAN：生成的图像有明显的伪影，人脸区域扭曲，眼镜和头发细节处理得很差。
• PULSE：生成的图像和输入低分辨率图像差异很大，经常出现人脸形状、性别甚至背景的错误。
• Regression（回归基线）：生成的图像和输入一致，但非常模糊，缺乏高频细节。
• SR3（本文）：生成的图像既和输入一致，又有丰富的细节，纹理自然，没有明显的伪影。

2. 定量结果：人类评估与自动指标

论文指出，传统的自动指标（如PSNR、SSIM）不能很好地反映人类的视觉偏好，因为它们会惩罚那些和参考图像不完全对齐的合成高频细节（比如头发丝、豹纹斑点）。因此，论文采用了2-alternative forced-choice (2AFC) 人类评估范式，让人类受试者在模型输出和真实图像之间做选择，计算"欺骗率"（fool rate），即人类选择模型输出的比例。欺骗率越高，说明生成的图像越逼真。

表1 自动指标对比（出处：原论文表1）

Model	FID	IS	PSNR	SSIM
Reference	1.9	240.8	-	-
Regression	15.2	180.1	27.9	0.801
SR3	5.2	121.1	26.4	0.762

表格分析：

• FID（Fréchet Inception Distance）：衡量生成图像分布和真实图像分布的相似度，数值越低越好。SR3的FID远低于回归基线，说明生成的图像更接近真实图像。
• IS（Inception Score）：衡量生成图像的质量和多样性，数值越高越好。SR3的IS也低于回归基线，这是因为回归基线生成的图像更保守，多样性更低。
• PSNR和SSIM：传统的图像质量指标，数值越高越好。回归基线的PSNR和SSIM更高，这验证了论文的观点：传统指标偏好保守的、模糊的生成结果，而不是逼真的、有丰富细节的结果。

图3 人脸超分人类欺骗率对比（出处：原论文图6）

效果分析：

• 上半部分是有输入低分辨率图像的任务（Task-1），受试者需要选择哪个高清图像是低分辨率图像更好的版本。SR3的欺骗率达到了54.1%，接近50%的理论上限，说明生成的图像和真实图像几乎无法区分。
• 下半部分是没有输入低分辨率图像的任务（Task-2），受试者只需要选择哪个图像更像真实照片。SR3的欺骗率达到了47.4%，同样远高于其他方法。
• 对比来看，FSRGAN和PULSE的欺骗率都不超过34%，远低于SR3。回归基线在Task-1中的欺骗率为29.3%，在Task-2中只有15.3%，说明模糊的图像很容易被人类识别出来。

图4 自然图像超分人类欺骗率对比（出处：原论文图7）

效果分析：

• 在自然图像超分任务上，SR3同样取得了接近40%的欺骗率，远高于回归基线。
• 这说明SR3不仅在人脸这个特定领域表现出色，在通用自然图像上也有很好的效果。

3. 级联生成：从64×64到1024×1024

SR3的一个重要应用是级联生成：将多个SR3模型串联起来，逐步提升图像分辨率。论文中实现了从64×64到256×256再到1024×1024的三级级联生成，能生成高质量的1024×1024人脸图像。

图5 级联生成1024×1024人脸图像（出处：原论文图8）

效果分析：

• 第一级：从64×64生成256×256图像
• 第二级：从256×256生成1024×1024图像
• 生成的1024×1024人脸图像细节极其丰富，皮肤纹理、头发丝、胡须都清晰可见，和真实照片几乎没有区别。

论文还实现了类条件ImageNet图像的级联生成，从64×64生成256×256图像，取得了11.3的FID分数，达到了当时的SOTA水平。

4. 消融实验

论文还做了详细的消融实验，验证了不同设计选择的影响：

1. 数据增强：在训练时给低分辨率输入添加高斯模糊和噪声，能将FID提升约2个点。
2. 损失函数：L1范数损失的效果略好于L2范数损失。

五、核心代码实现

以下是SR3核心模块的PyTorch实现，贴合论文的原生设计，包含U-Net模型、训练过程和推理过程。

1. 正弦位置编码（噪声水平嵌入）

import torch
import torch.nn as nn
import math

def get_timestep_embedding(timesteps, dim: int):
    """
    生成正弦位置编码，用于嵌入噪声水平γ
    :param timesteps: 噪声水平γ，形状为[batch_size]
    :param dim: 嵌入维度
    :return: 位置编码，形状为[batch_size, dim]
    """
    half_dim = dim // 2
    emb = math.log(10000) / (half_dim - 1)
    emb = torch.exp(torch.arange(half_dim, device=timesteps.device) * -emb)
    emb = timesteps[:, None] * emb[None, :]
    emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=-1)
    if dim % 2 == 1:
        emb = torch.cat([emb, torch.zeros_like(emb[:, :1])], dim=-1)
    return emb

2. BigGAN残差块

class BigGANResBlock(nn.Module):
    def __init__(self, in_channels, out_channels, time_emb_dim, dropout=0.0):
        super().__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        
        self.norm1 = nn.GroupNorm(32, in_channels)
        self.act1 = nn.SiLU()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)
        
        self.time_emb_proj = nn.Linear(time_emb_dim, out_channels)
        
        self.norm2 = nn.GroupNorm(32, out_channels)
        self.act2 = nn.SiLU()
        self.dropout = nn.Dropout(dropout)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
        
        if in_channels != out_channels:
            self.shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=1)
        else:
            self.shortcut = nn.Identity()
    
    def forward(self, x, time_emb):
        """
        前向传播
        :param x: 输入特征图，形状为[batch_size, in_channels, H, W]
        :param time_emb: 时间嵌入，形状为[batch_size, time_emb_dim]
        :return: 输出特征图，形状为[batch_size, out_channels, H, W]
        """
        h = self.norm1(x)
        h = self.act1(h)
        h = self.conv1(h)
        
        # 添加时间嵌入
        time_emb = self.time_emb_proj(time_emb)[:, :, None, None]
        h = h + time_emb
        
        h = self.norm2(h)
        h = self.act2(h)
        h = self.dropout(h)
        h = self.conv2(h)
        
        # 跳跃连接
        return h + self.shortcut(x)

3. SR3 U-Net模型

class SR3UNet(nn.Module):
    def __init__(
        self,
        in_channels=6,  # 3通道加噪图像 + 3通道上采样后的低分辨率图像
        out_channels=3,
        model_channels=128,
        num_res_blocks=2,
        channel_mult=(1, 2, 4, 8),
        dropout=0.0
    ):
        super().__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.model_channels = model_channels
        
        # 时间嵌入层
        time_emb_dim = model_channels * 4
        self.time_mlp = nn.Sequential(
            nn.Linear(model_channels, time_emb_dim),
            nn.SiLU(),
            nn.Linear(time_emb_dim, time_emb_dim)
        )
        
        # 输入卷积
        self.init_conv = nn.Conv2d(in_channels, model_channels, kernel_size=3, padding=1)
        
        # 编码器
        self.down_blocks = nn.ModuleList()
        ch = model_channels
        for i, mult in enumerate(channel_mult):
            for _ in range(num_res_blocks):
                self.down_blocks.append(BigGANResBlock(ch, model_channels * mult, time_emb_dim, dropout))
                ch = model_channels * mult
            if i != len(channel_mult) - 1:
                self.down_blocks.append(nn.Conv2d(ch, ch, kernel_size=3, stride=2, padding=1))
        
        # 中间块
        self.mid_blocks = nn.ModuleList([
            BigGANResBlock(ch, ch, time_emb_dim, dropout),
            BigGANResBlock(ch, ch, time_emb_dim, dropout)
        ])
        
        # 解码器
        self.up_blocks = nn.ModuleList()
        for i, mult in reversed(list(enumerate(channel_mult))):
            for _ in range(num_res_blocks + 1):
                self.up_blocks.append(BigGANResBlock(ch + model_channels * mult, model_channels * mult, time_emb_dim, dropout))
                ch = model_channels * mult
            if i != 0:
                self.up_blocks.append(nn.ConvTranspose2d(ch, ch, kernel_size=3, stride=2, padding=1, output_padding=1))
        
        # 输出卷积
        self.final_norm = nn.GroupNorm(32, ch)
        self.final_act = nn.SiLU()
        self.final_conv = nn.Conv2d(ch, out_channels, kernel_size=3, padding=1)
    
    def forward(self, x, gamma):
        """
        前向传播
        :param x: 输入，形状为[batch_size, 6, H, W]，前3通道是加噪图像，后3通道是上采样后的低分辨率图像
        :param gamma: 噪声水平，形状为[batch_size]
        :return: 预测的噪声，形状为[batch_size, 3, H, W]
        """
        batch_size = x.shape[0]
        
        # 时间嵌入
        t_emb = get_timestep_embedding(gamma, self.model_channels)
        t_emb = self.time_mlp(t_emb)
        
        # 输入卷积
        h = self.init_conv(x)
        
        # 编码器
        skips = []
        for block in self.down_blocks:
            if isinstance(block, BigGANResBlock):
                h = block(h, t_emb)
            else:
                h = block(h)
            skips.append(h)
        
        # 中间块
        for block in self.mid_blocks:
            h = block(h, t_emb)
        
        # 解码器
        for block in self.up_blocks:
            if isinstance(block, BigGANResBlock):
                skip = skips.pop()
                h = torch.cat([h, skip], dim=1)
                h = block(h, t_emb)
            else:
                h = block(h)
        
        # 输出卷积
        h = self.final_norm(h)
        h = self.final_act(h)
        h = self.final_conv(h)
        
        return h

4. 训练过程

def train_step(model, x_lr, y_hr, optimizer, noise_scheduler, device):
    """
    单步训练
    :param model: SR3模型
    :param x_lr: 低分辨率图像，形状为[batch_size, 3, H_lr, W_lr]
    :param y_hr: 高分辨率图像，形状为[batch_size, 3, H_hr, W_hr]
    :param optimizer: 优化器
    :param noise_scheduler: 噪声调度器
    :param device: 设备
    :return: 损失值
    """
    model.train()
    optimizer.zero_grad()
    
    batch_size = x_lr.shape[0]
    
    # 将低分辨率图像上采样到高分辨率
    x_lr_up = nn.functional.interpolate(x_lr, size=y_hr.shape[2:], mode='bilinear', align_corners=False)
    
    # 随机采样噪声水平γ
    gamma = torch.rand(batch_size, device=device)
    
    # 生成随机噪声
    noise = torch.randn_like(y_hr)
    
    # 生成加噪图像
    y_noisy = torch.sqrt(gamma)[:, None, None, None] * y_hr + torch.sqrt(1 - gamma)[:, None, None, None] * noise
    
    # 拼接加噪图像和上采样后的低分辨率图像
    model_input = torch.cat([y_noisy, x_lr_up], dim=1)
    
    # 模型预测噪声
    noise_pred = model(model_input, gamma)
    
    # 计算L1损失
    loss = nn.functional.l1_loss(noise_pred, noise)
    
    # 反向传播
    loss.backward()
    optimizer.step()
    
    return loss.item()

5. 推理过程

def infer(model, x_lr, noise_scheduler, num_inference_steps=100, device='cuda'):
    """
    超分辨率推理
    :param model: SR3模型
    :param x_lr: 低分辨率图像，形状为[1, 3, H_lr, W_lr]
    :param noise_scheduler: 噪声调度器
    :param num_inference_steps: 推理步数
    :param device: 设备
    :return: 生成的高分辨率图像，形状为[1, 3, H_hr, W_hr]
    """
    model.eval()
    
    # 将低分辨率图像上采样到高分辨率
    H_hr, W_hr = x_lr.shape[2] * 4, x_lr.shape[3] * 4  # 4倍超分
    x_lr_up = nn.functional.interpolate(x_lr, size=(H_hr, W_hr), mode='bilinear', align_corners=False)
    
    # 初始化纯噪声
    y = torch.randn((1, 3, H_hr, W_hr), device=device)
    
    # 推理迭代
    for i in reversed(range(num_inference_steps)):
        # 获取当前噪声水平γ
        gamma = noise_scheduler.get_gamma(i, num_inference_steps)
        gamma = torch.tensor([gamma], device=device)
        
        # 拼接输入
        model_input = torch.cat([y, x_lr_up], dim=1)
        
        # 预测噪声
        with torch.no_grad():
            noise_pred = model(model_input, gamma)
        
        # 更新图像
        alpha_t = noise_scheduler.get_alpha(gamma)
        y = (1 / torch.sqrt(alpha_t)) * (y - ((1 - alpha_t) / torch.sqrt(1 - gamma)) * noise_pred)
        
        # 最后一步不添加噪声
        if i > 0:
            noise = torch.randn_like(y)
            y = y + torch.sqrt(1 - alpha_t) * noise
    
    # 将图像归一化到[0, 1]
    y = (y + 1) / 2
    y = torch.clamp(y, 0, 1)
    
    return y

六、模型局限性与未来方向

1. 局限性

1. 推理速度慢：虽然SR3可以将推理步数减少到100步，但仍然比GAN模型慢很多，不适合实时应用。
2. 计算资源需求大：训练SR3需要大量的计算资源，论文中的64×64→256×256模型有6.25亿参数，需要在多个GPU上训练数周。
3. 细节还原能力有限：对于一些非常精细的纹理和结构，SR3仍然无法完美还原，有时会生成不自然的细节。

2. 未来方向

1. 加速推理：通过知识蒸馏、采样器优化等方法，进一步减少推理步数，提升推理速度。
2. 模型轻量化：设计更高效的模型架构，减少参数数量，降低计算资源需求。
3. 通用超分：将SR3扩展到更广泛的超分任务，如真实世界超分、视频超分等。
4. 可控生成：增加对生成内容的控制能力，让用户可以调整生成图像的风格、细节等属性。

七、总结与核心贡献

SR3的诞生，标志着扩散模型正式进入图像超分辨率领域，其核心贡献可以总结为4点：

1. 首次将扩散模型成功应用于图像超分辨率，提出了条件去噪扩散模型的超分框架，证明了扩散模型在超分任务上的巨大潜力。
2. 在8倍人脸超分任务上取得了接近50%的人类欺骗率，生成的图像和真实照片几乎无法区分，远超同期的GAN模型。
3. 提出了级联生成的方法，通过串联多个SR3模型，实现了从64×64到1024×1024的高清图像生成，为高分辨率图像生成提供了新的思路。
4. 验证了传统自动指标的局限性，强调了人类评估在图像生成任务中的重要性，为后续的图像生成研究提供了更合理的评估标准。

SR3的设计思想深刻影响了后续所有的扩散超分模型，如Stable Diffusion的超分模块、Real-ESRGAN的扩散版本等，是扩散模型在低级别视觉任务中应用的里程碑式工作。