Inertial Wheel Pendulum based on Linear ADRC

## CycleGAN的网络结构

### 1. 整体架构

CycleGAN包含4个网络：
- 两个生成器（Generators）: G_A (A→B) 和 G_B (B→A)
- 两个判别器（Discriminators）: D_A 和 D_B

其中：
- G_A: 将域A的图像转换到域B
- G_B: 将域B的图像转换到域A
- D_A: 判断图像是真实的B域图像还是G_A生成的假B域图像
- D_B: 判断图像是真实的A域图像还是G_B生成的假A域图像



### 2. 生成器结构

CycleGAN使用ResNet架构的生成器：

```python
class ResnetGenerator(nn.Module):
    """Resnet-based generator with 9个残差块"""
    def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect'):
        super(ResnetGenerator, self).__init__()
        # ...
```

生成器结构包括：
1. **初始层**: 由反射填充、卷积、归一化和ReLU激活组成
   ```python
   model = [nn.ReflectionPad2d(3),
            nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),
            norm_layer(ngf),
            nn.ReLU(True)]
   ```

2. **下采样层**: 两个下采样模块，每个将特征图尺寸减小一半，通道数增加一倍
   ```python
   n_downsampling = 2
   for i in range(n_downsampling):
       mult = 2 ** i
       model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),
                 norm_layer(ngf * mult * 2),
                 nn.ReLU(True)]
   ```

3. **残差块**: 多个残差块（默认9个），维持特征图尺寸不变
   ```python
   mult = 2 ** n_downsampling
   for i in range(n_blocks):
       model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]
   ```

4. **上采样层**: 两个上采样模块，每个将特征图尺寸增大一倍，通道数减少一半
   ```python
   for i in range(n_downsampling):
       mult = 2 ** (n_downsampling - i)
       model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
                                    kernel_size=3, stride=2,
                                    padding=1, output_padding=1,
                                    bias=use_bias),
                 norm_layer(int(ngf * mult / 2)),
                 nn.ReLU(True)]
   ```

5. **输出层**: 生成目标域图像
   ```python
   model += [nn.ReflectionPad2d(3)]
   model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]
   model += [nn.Tanh()]
   ```

### 3. 判别器结构

CycleGAN使用PatchGAN判别器，它对输入图像的重叠局部区域进行分类，判断是真实图像还是生成图像：

```python
class NLayerDiscriminator(nn.Module):
    """Defines a PatchGAN discriminator"""
    def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d):
        # ...
```

判别器结构包括：
1. 首层卷积和LeakyReLU激活
2. 多层卷积块，每次下采样并增加通道数
3. 最后输出一个通道的特征图，用于判别

## CycleGAN的损失函数

CycleGAN使用多个损失函数组合：

### 1. 对抗损失(Adversarial Loss)

对生成器和判别器使用对抗损失，默认使用最小二乘对抗损失(LSGAN)：

对于生成器G_A：
$$\mathcal{L}_{GAN}(G_A, D_B, X, Y) = \mathbb{E}_{y \sim p_{data}(y)}[(D_B(y) - 1)^2] + \mathbb{E}_{x \sim p_{data}(x)}[D_B(G_A(x))^2]$$

对于生成器G_B：
$$\mathcal{L}_{GAN}(G_B, D_A, Y, X) = \mathbb{E}_{x \sim p_{data}(x)}[(D_A(x) - 1)^2] + \mathbb{E}_{y \sim p_{data}(y)}[D_A(G_B(y))^2]$$

代码实现：
```python
self.criterionGAN = networks.GANLoss(opt.gan_mode).to(self.device)  # define GAN loss
# ...
# GAN loss D_A(G_A(A))
self.loss_G_A = self.criterionGAN(self.netD_A(self.fake_B), True)
# GAN loss D_B(G_B(B))
self.loss_G_B = self.criterionGAN(self.netD_B(self.fake_A), True)
```

### 2. 循环一致性损失(Cycle Consistency Loss)

确保转换的图像可以被转换回原始域：
$$\mathcal{L}_{cyc}(G_A, G_B) = \mathbb{E}_{x \sim p_{data}(x)}[||G_B(G_A(x)) - x||_1] + \mathbb{E}_{y \sim p_{data}(y)}[||G_A(G_B(y)) - y||_1]$$

代码实现：
```python
self.criterionCycle = torch.nn.L1Loss()
# ...
# Forward cycle loss || G_B(G_A(A)) - A||
self.loss_cycle_A = self.criterionCycle(self.rec_A, self.real_A) * lambda_A
# Backward cycle loss || G_A(G_B(B)) - B||
self.loss_cycle_B = self.criterionCycle(self.rec_B, self.real_B) * lambda_B
```

### 3. 身份映射损失(Identity Loss)

可选的损失，帮助保持颜色一致性：
$$\mathcal{L}_{identity}(G_A, G_B) = \mathbb{E}_{y \sim p_{data}(y)}[||G_A(y) - y||_1] + \mathbb{E}_{x \sim p_{data}(x)}[||G_B(x) - x||_1]$$

代码实现：
```python
self.criterionIdt = torch.nn.L1Loss()
# ...
if lambda_idt > 0:
    # G_A should be identity if real_B is fed: ||G_A(B) - B||
    self.idt_A = self.netG_A(self.real_B)
    self.loss_idt_A = self.criterionIdt(self.idt_A, self.real_B) * lambda_B * lambda_idt
    # G_B should be identity if real_A is fed: ||G_B(A) - A||
    self.idt_B = self.netG_B(self.real_A)
    self.loss_idt_B = self.criterionIdt(self.idt_B, self.real_A) * lambda_A * lambda_idt
```

### 4. 总损失函数

生成器总损失：
$$\mathcal{L}_G = \mathcal{L}_{GAN}(G_A, D_B) + \mathcal{L}_{GAN}(G_B, D_A) + \lambda_A \mathcal{L}_{cyc}(G_A, G_B) + \lambda_B \mathcal{L}_{cyc}(G_B, G_A) + \lambda_{identity}(\mathcal{L}_{identity}(G_A, G_B))$$

代码实现：
```python
self.loss_G = self.loss_G_A + self.loss_G_B + self.loss_cycle_A + self.loss_cycle_B + self.loss_idt_A + self.loss_idt_B
```

判别器损失：
$$\mathcal{L}_D = \frac{1}{2}[(D(y) - 1)^2 + D(G(x))^2]$$

代码实现：
```python
loss_D = (loss_D_real + loss_D_fake) * 0.5
```

## CycleGAN的训练方法

### 1. 训练流程

CycleGAN的训练过程交替更新生成器和判别器：

1. 首先前向传播，生成假图像
   ```python
   self.forward()  # 生成fake_A、fake_B、rec_A、rec_B
   ```

2. 更新生成器G_A和G_B
   ```python
   # 固定判别器参数
   self.set_requires_grad([self.netD_A, self.netD_B], False)
   self.optimizer_G.zero_grad()  # 将生成器梯度清零
   self.backward_G()  # 计算生成器梯度
   self.optimizer_G.step()  # 更新生成器权重
   ```

3. 更新判别器D_A和D_B
   ```python
   # 解除判别器参数固定
   self.set_requires_grad([self.netD_A, self.netD_B], True)
   self.optimizer_D.zero_grad()  # 将判别器梯度清零
   self.backward_D_A()  # 计算D_A梯度
   self.backward_D_B()  # 计算D_B梯度
   self.optimizer_D.step()  # 更新判别器权重
   ```

### 2. 重要的训练技巧

1. **图像缓冲池**: 使用图像缓冲池存储之前生成的图像，减少模型震荡
   ```python
   self.fake_A_pool = ImagePool(opt.pool_size)
   self.fake_B_pool = ImagePool(opt.pool_size)
   ```

2. **学习率调度**: 在训练过程中逐渐减小学习率
   ```python
   model.update_learning_rate()  # 每个epoch开始时更新学习率
   ```

3. **权重初始化**: 使用特定初始化方法（例如正态分布初始化）

4. **BatchNorm或InstanceNorm归一化**: 帮助稳定训练

5. **训练参数设置**:
   - lambda_A=lambda_B=10.0（循环一致性损失权重）
   - lambda_identity=0.5（身份损失权重）
   - 使用LSGAN损失函数

### 3. 优化器配置

使用Adam优化器，参数如下：
```python
self.optimizer_G = torch.optim.Adam(itertools.chain(self.netG_A.parameters(), self.netG_B.parameters()), 
                                   lr=opt.lr, betas=(opt.beta1, 0.999))
self.optimizer_D = torch.optim.Adam(itertools.chain(self.netD_A.parameters(), self.netD_B.parameters()), 
                                   lr=opt.lr, betas=(opt.beta1, 0.999))
```

## 总结

**CycleGAN的创新点**：
1. 无需配对数据进行图像到图像的转换
2. 通过循环一致性约束维持图像内容不变
3. 使用PatchGAN判别器专注于局部结构

**核心公式总结**：
1. 对抗损失: 使生成图像在目标域中看起来真实
2. 循环一致性损失: $\mathcal{L}_{cyc}(G_A, G_B) = ||G_B(G_A(x)) - x||_1 + ||G_A(G_B(y)) - y||_1$
3. 身份损失: $\mathcal{L}_{identity}(G_A, G_B) = ||G_A(y) - y||_1 + ||G_B(x) - x||_1$

**网络结构**：
- 生成器: 9-残差块的ResNet
- 判别器: 70x70感受野的PatchGAN

**训练技巧**：
- 图像缓冲池存储历史生成样本
- 学习率调度
- LSGAN损失稳定训练

通过这些设计，CycleGAN成功实现了无需配对数据的图像风格转换任务。

CycleGAN 的原理与代码

# 文本提示如何作用于Stable Diffusion的图像生成过程

Stable Diffusion的文本转图像过程是一个复杂的流程，文本提示(prompt)会被转换成嵌入向量，然后通过条件扩散模型引导图像生成。以下是完整的流程：



## 1. 文本编码阶段

当您输入文本提示时，首先会经过以下处理：

### 1.1 文本标记化(Tokenization)

文本首先被分解成标记(tokens)，这是由CLIP文本编码器完成的：

```python
# modules/sd_hijack_clip.py
def tokenize(self, texts):
    # 将文本转换成token标记ID列表
    tokenized = self.wrapped.tokenizer(texts, truncation=False, add_special_tokens=False)["input_ids"]
    return tokenized
```

例如，"a photo of a cat"会被分解成["a", "photo", "of", "a", "cat"]等标记，然后转换为数字ID。

### 1.2 标记编码(Token Encoding)

标记化后的文本会通过CLIP的文本编码器转换为嵌入向量：

```python
# modules/sd_hijack_clip.py
def encode_with_transformers(self, tokens):
    # 对标记进行编码，生成隐藏状态
    outputs = self.wrapped.transformer(input_ids=tokens, output_hidden_states=-opts.CLIP_stop_at_last_layers)
    
    if opts.CLIP_stop_at_last_layers > 1:
        z = outputs.hidden_states[-opts.CLIP_stop_at_last_layers]
        z = self.wrapped.transformer.text_model.final_layer_norm(z)
    else:
        z = outputs.last_hidden_state
        
    return z
```

这将每个标记转换为一个高维向量（SD1.5是768维，SDXL是1024维）。

### 1.3 文本条件生成

处理类`StableDiffusionProcessing`中的`get_conds`方法获取条件向量：

```python
# modules/processing.py
def get_conds(self):
    # 返回文本条件向量(c)和无条件向量(uc)
    return self.c, self.uc
```

这里会返回两个关键的条件向量：
- **c (条件向量)**: 包含您的提示文本编码
- **uc (无条件向量)**: 包含负面提示文本编码，或空白提示的编码

## 2. 采样过程中的文本条件应用

### 2.1 采样器初始化

在采样过程开始时，文本条件被传递给采样器：

```python
# modules/sd_samplers_kdiffusion.py
self.sampler_extra_args = {
    'cond': conditioning,           # 正面提示的条件向量
    'image_cond': image_conditioning,
    'uncond': unconditional_conditioning,  # 负面提示的无条件向量
    'cond_scale': p.cfg_scale,      # CFG缩放比例
    's_min_uncond': self.s_min_uncond
}
```

### 2.2 CFG Denoiser中的条件应用

CFG缩放在`CFGDenoiser.forward`方法中实现，这是文本条件实际影响图像生成的关键部分：

```python
# modules/sd_samplers_cfg_denoiser.py
def forward(self, x, sigma, uncond, cond, cond_scale, s_min_uncond, image_cond):
    # ... [代码省略]
    
    # 对噪声图像应用模型，获取噪声预测
    x_out = self.inner_model(x_in, sigma_in, cond=make_condition_dict(cond_in, image_cond_in))
    
    # ... [代码省略]
    
    # 关键公式：结合条件和无条件预测
    denoised = self.combine_denoised(x_out, conds_list, uncond, cond_scale)
    
    # ... [代码省略]
    
    return denoised
```

### 2.3 CFG的关键公式

文本提示通过以下公式直接影响每一步的去噪过程：

```python
# modules/sd_samplers_cfg_denoiser.py
def combine_denoised(self, x_out, conds_list, uncond, cond_scale):
    denoised_uncond = x_out[-uncond.shape[0]:]  # 无条件预测结果
    denoised = torch.clone(denoised_uncond)     # 从无条件结果开始

    # 应用条件预测的影响，加权以cond_scale（也就是CFG Scale）
    for i, conds in enumerate(conds_list):
        for cond_index, weight in conds:
            denoised[i] += (x_out[cond_index] - denoised_uncond[i]) * (weight * cond_scale)

    return denoised
```

这个公式的简化版本是：

**最终预测 = 无条件预测 + CFG_Scale × (条件预测 - 无条件预测)**

以数学形式表示：

$$x_{denoised} = x_{uncond} + \text{CFG\_Scale} \cdot (x_{cond} - x_{uncond})$$

其中：
- $x_{uncond}$ 是基于负面提示（或空提示）的预测
- $x_{cond}$ 是基于您的文本提示的预测
- $\text{CFG\_Scale}$ 是控制文本条件强度的参数

## 3. 具体工作原理

当您提供一个文本提示如"一只漂亮的黑猫"时：

1. 提示被标记化并通过CLIP文本编码器转换成嵌入向量
2. 同样，负面提示也被编码成嵌入向量
3. 采样过程开始，执行多步去噪
4. 在每个去噪步骤：
   - 模型基于正面提示预测噪声（条件预测）
   - 模型基于负面提示预测噪声（无条件预测）
   - 根据上述CFG公式，两个预测结合在一起，CFG Scale决定了正面提示的影响力
   - 这个结合后的预测用于从当前噪声中去除一部分，生成更清晰的图像

5. 经过多次迭代后，最终的潜在表示被解码成像素图像

## 4. CFG Scale参数的影响

CFG Scale参数直接控制了文本提示的影响程度：

- **CFG Scale = 1.0**: 文本提示几乎不起作用，生成类似于无条件生成
- **CFG Scale = 7.0-8.0**: 默认范围，文本提示有明显影响但不过度
- **CFG Scale > 15.0**: 文本提示影响非常强烈，可能导致过度强调某些元素

## 5. 示例：如何体现在图像上

当您使用提示"一只漂亮的黑猫"时：

- 低CFG Scale：可能生成一个猫，但不一定是黑猫，或者可能是其他动物
- 中等CFG Scale：更可能生成一只黑猫，特征更清晰
- 高CFG Scale：一定会生成黑猫，但可能过度强调"黑色"和"猫"的特征，显得不自然

## 总结

文本提示通过CLIP文本编码器转换为条件向量，然后在每个采样步骤中通过CFG机制引导去噪过程。CFG Scale参数控制文本提示对生成过程的影响程度，使Stable Diffusion能够根据用户的文本描述生成相应的图像。整个过程是一个精妙的平衡，既保持了生成的多样性，又确保了与文本提示的相关性。

Stable Diffusion：文本提示如何作用于Stable Diffusion的图像生成过程

## CFG Scale（Classifier-Free Guidance Scale）是如何控制文生图的

CFG Scale（Classifier-Free Guidance Scale，无分类器指导缩放）是Stable Diffusion中的一个关键参数，它控制生成图像在遵循文本提示的严格程度。



### 工作原理

CFG Scale控制了两种预测之间的平衡：
1. **条件预测(cond)** - 基于文本提示（即你想要的内容）进行的预测
2. **无条件预测(uncond)** - 基于空提示或负面提示进行的预测

### 核心公式

根据代码分析，CFG Scale的核心公式实现在`modules/sd_samplers_cfg_denoiser.py`文件中：

```python
def combine_denoised(self, x_out, conds_list, uncond, cond_scale):
    denoised_uncond = x_out[-uncond.shape[0]:]
    denoised = torch.clone(denoised_uncond)

    for i, conds in enumerate(conds_list):
        for cond_index, weight in conds:
            denoised[i] += (x_out[cond_index] - denoised_uncond[i]) * (weight * cond_scale)

    return denoised
```

这就是CFG的核心实现，可简化为以下公式：

**最终去噪结果 = 无条件预测 + CFG_Scale * (条件预测 - 无条件预测)**

或者写成数学形式：

$$x_{\text{denoised}} = x_{\text{uncond}} + \text{CFG\_Scale} \cdot (x_{\text{cond}} - x_{\text{uncond}})$$

### K-Diffusion实现

在`repositories/k-diffusion/k_diffusion/sampling.py`中，classifier-free guidance的实现类似：

```python
elif guidance_type == "classifier-free":
    if guidance_scale == 1. or unconditional_condition is None:
        return noise_pred_fn(x, t_continuous, cond=condition)
    else:
        x_in = torch.cat([x] * 2)
        t_in = torch.cat([t_continuous] * 2)
        c_in = torch.cat([unconditional_condition, condition])
        noise_uncond, noise = noise_pred_fn(x_in, t_in, cond=c_in).chunk(2)
        return noise_uncond + guidance_scale * (noise - noise_uncond)
```

### CFG Scale的影响

1. **CFG Scale = 1.0**: 生成的图像基本上忽略了提示，类似于无条件生成
2. **CFG Scale = 7.0-8.0**: 通常的默认值，提供良好的平衡
3. **CFG Scale > 15.0**: 非常严格地遵循提示，但可能导致图像质量下降

### 在Stable Diffusion中的实现流程

1. 在`modules/processing.py`中，CFG Scale作为参数传入到处理类中：

```python
class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
    # ...
    def init(self, all_prompts, all_seeds, all_subseeds):
        # ...
        self.sampler = sd_samplers.create_sampler(self.sampler_name, self.sd_model)
```

2. 在采样过程中，CFG Scale被传递给采样器：

```python
# modules/sd_samplers_kdiffusion.py
self.sampler_extra_args = {
    'cond': conditioning,
    'image_cond': image_conditioning,
    'uncond': unconditional_conditioning,
    'cond_scale': p.cfg_scale,
    's_min_uncond': self.s_min_uncond
}
```

3. 最终在`CFGDenoiser.forward`方法中应用公式，将条件和无条件预测组合起来

### 结论

CFG Scale本质上是控制生成图像在多大程度上遵循文本提示。它是一个平衡因子：
- 低CFG Scale值导致图像更"自由"但可能偏离提示
- 高CFG Scale值使图像更严格遵循提示，但可能过度强调某些元素，降低整体美感

在实际使用中：
- 简单场景或需要更有创意的输出：使用较低的CFG Scale (1-7)
- 需要精确遵循提示的复杂场景：使用较高的CFG Scale (7-15)
- 超过20的CFG Scale通常会产生不自然的结果

CFG Scale是文生图中最重要的参数之一，它直接影响生成图像与文本提示的一致性。

Stable Diffusion：CFG Scale 是如何控制文生图的

# Stable Diffusion WebUI 噪声采样的调度器的原理

噪声调度器(Noise Schedulers)是扩散模型生成过程中的关键组件，它们决定了扩散过程中噪声水平如何随时间变化。合适的噪声调度可以显著提高生成质量和效率。我将详细解析 SD WebUI 中的各种调度器，包括其数学原理和具体实现。



## 1. 噪声调度器基础概念

在扩散模型中，噪声调度器定义了 σ (sigma) 值如何从高噪声水平逐渐降低到低噪声水平。这些 σ 值构成了采样过程中的离散步骤。

首先让我们查看 SD WebUI 中的调度器代码实现：

Read file: modules/sd_schedulers.py


Read file: repositories/k-diffusion/k_diffusion/sampling.py

## 2. Automatic (自动)

`Automatic` 调度器不是一个实际的调度器，而是让系统基于当前选择的采样器自动选择最合适的调度器。

```python
Scheduler('automatic', 'Automatic', None)
```

例如，当你使用DPM++ 2M采样器时，它默认会使用Karras调度器，因为这是该采样器的推荐调度器。

## 3. Uniform (均匀)

Uniform调度器使用模型内置的均匀间隔噪声调度，通常是线性间隔的噪声水平。

```python
def uniform(n, sigma_min, sigma_max, inner_model, device):
    return inner_model.get_sigmas(n)
```

它直接从内部模型获取均匀分布的噪声水平，不考虑给定的 `sigma_min` 和 `sigma_max`。

这种调度的特点是简单直接，但对于许多采样器来说并不是最优的选择，尤其是在较少步数的情况下。

## 4. Karras

Karras调度器来自Karras等人在2022年的论文，是目前最广泛使用的调度器之一，尤其适合DPM系列采样器。

```python
def get_sigmas_karras(n, sigma_min, sigma_max, rho=7., device='cpu'):
    """Constructs the noise schedule of Karras et al. (2022)."""
    ramp = torch.linspace(0, 1, n)
    min_inv_rho = sigma_min ** (1 / rho)
    max_inv_rho = sigma_max ** (1 / rho)
    sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
    return append_zero(sigmas).to(device)
```

### 数学公式

$$\sigma(t) = \left( \sigma_{\max}^{1/\rho} + t \cdot (\sigma_{\min}^{1/\rho} - \sigma_{\max}^{1/\rho}) \right)^{\rho}$$

其中：
- $t$ 是从0到1的归一化时间
- $\rho$ 是控制曲线形状的参数，默认值为7
- $\sigma_{\min}$ 和 $\sigma_{\max}$ 是噪声范围

Karras调度器的特点是在高噪声区域分配更多步骤，在低噪声区域分配较少步骤，这与生成过程中最需要精确控制的区域相匹配。它显著提高了低步数采样的质量。

## 5. Exponential (指数)

指数调度器在对数空间中线性安排噪声水平，使噪声按指数衰减。

```python
def get_sigmas_exponential(n, sigma_min, sigma_max, device='cpu'):
    """Constructs an exponential noise schedule."""
    sigmas = torch.linspace(math.log(sigma_max), math.log(sigma_min), n, device=device).exp()
    return append_zero(sigmas)
```

### 数学公式

$$\sigma(t) = \exp\left( \log(\sigma_{\max}) + t \cdot (\log(\sigma_{\min}) - \log(\sigma_{\max})) \right)$$

其中 $t$ 从0到1线性变化。

指数调度器在高噪声区域提供稍快的初始去噪，然后在细节形成阶段逐渐减慢，它是一个比均匀调度更好，但比Karras调度更简单的选择。

## 6. Polyexponential (多项式指数)

多项式指数调度器结合了指数衰减和多项式控制，提供更灵活的噪声分布。

```python
def get_sigmas_polyexponential(n, sigma_min, sigma_max, rho=1., device='cpu'):
    """Constructs an polynomial in log sigma noise schedule."""
    ramp = torch.linspace(1, 0, n, device=device) ** rho
    sigmas = torch.exp(ramp * (math.log(sigma_max) - math.log(sigma_min)) + math.log(sigma_min))
    return append_zero(sigmas)
```

### 数学公式

$$\sigma(t) = \exp\left( (1-t)^{\rho} \cdot (\log(\sigma_{\max}) - \log(\sigma_{\min})) + \log(\sigma_{\min}) \right)$$

其中：
- $t$ 从0到1线性变化
- $\rho$ 控制多项式的幂，默认值为1

当 $\rho = 1$ 时，它与指数调度器非常相似。但当 $\rho > 1$ 时，它会在初始阶段分配更多步骤，使去噪过程更平滑。当 $\rho < 1$ 时，初始去噪更快，后期细节生成更慢。

## 7. SGM Uniform (SGM均匀)

SGM均匀调度器是专为SGM (Score-based Generative Models) 设计的调度器，它在t空间（而非sigma空间）均匀采样。

```python
def sgm_uniform(n, sigma_min, sigma_max, inner_model, device):
    start = inner_model.sigma_to_t(torch.tensor(sigma_max))
    end = inner_model.sigma_to_t(torch.tensor(sigma_min))
    sigs = [
        inner_model.t_to_sigma(ts)
        for ts in torch.linspace(start, end, n + 1)[:-1]
    ]
    sigs += [0.0]
    return torch.FloatTensor(sigs).to(device)
```

这个调度器首先将 sigma 值转换为 t 空间，在 t 空间中均匀采样点，然后再将这些点转换回sigma值。

这种方法特别适合某些扩散模型变体，比如来自Stability AI的SGM模型。

## 8. 调度器的选择与影响

### 调度器选择建议

1. **默认选择**：对大多数情况，使用 `Automatic` 让系统自动选择最合适的调度器。

2. **高质量结果**：
   - 与DPM++系列采样器结合使用 `Karras` 调度器
   - 此组合在低步数下也有优异表现

3. **特定模型**：
   - 对于SGM模型使用 `SGM Uniform` 调度器
   - 对于最新的SD XL模型，`Karras` 通常也是最佳选择

4. **实验和微调**：
   - 当标准调度器结果不够理想时，尝试 `Polyexponential` 并调整 rho 参数
   - 较小的 rho 值（如0.5）会在生成早期进行更快去噪，适合保留大致结构
   - 较大的 rho 值（如2.0）会进行更均匀的去噪，可能产生更一致的细节

### 调度器对最终图像的影响

不同调度器对生成结果有显著影响：

1. **细节和清晰度**：
   - `Karras` 调度器通常产生最清晰、最精细的细节
   - `Uniform` 调度器在同样步数下通常细节较少

2. **噪点和纹理**：
   - 不同调度器对最终图像的纹理和噪点有不同影响
   - `Exponential` 和 `Polyexponential` 可能在某些纹理上表现更好

3. **速度和步数权衡**：
   - 对于低步数生成（<30步），`Karras` 通常有最佳性能
   - 对于高步数生成（>50步），调度器之间的差异减小

## 9. 调度器原理与噪声水平的重要性

### 为什么噪声调度很重要

扩散模型的去噪过程是从高噪声状态到低噪声状态的转换。这个过程不是均匀的：

1. **高噪声区域**（早期步骤）：主要确定图像的整体结构和构图
2. **中等噪声区域**：形成主要特征和大型细节
3. **低噪声区域**（后期步骤）：精细细节和纹理的生成

因此，理想的噪声调度应该根据每个阶段的重要性分配步骤。这就是为什么Karras调度器在实践中表现优异 - 它在关键的噪声水平分配了更多步骤。

### 时间步长与数值精度

噪声调度器实质上控制着数值积分过程中的"时间步长"。较小的时间步长（在关键区域）提供更高的精度，但需要更多计算步骤。最优的调度器找到了这一权衡的良好平衡点。

## 10. 自定义调度器参数的影响

### sigma_min 和 sigma_max

这些参数定义了噪声范围：

- **sigma_max**：初始噪声的大小，较大值会产生更多样的结果，但可能降低与提示的相关性
- **sigma_min**：最终噪声的大小，过小可能导致过度平滑，过大可能保留噪点

### rho 参数（Karras 和 Polyexponential）

控制噪声分布的"形状"：

- **较小的 rho**：更快的初始去噪，更多的步骤用于后期细节生成
- **较大的 rho**：更均匀的去噪过程，对整体质量可能更好

## 11. 调度器代码实现的技术细节

### 零点附加

所有调度器都使用 `append_zero` 函数在噪声序列末尾添加一个零：

```python
def append_zero(x):
    return torch.cat([x, x.new_zeros([1])])
```

这确保了最终状态完全无噪声，这对于生成干净的最终图像很重要。

### 内部模型依赖

某些调度器（Uniform 和 SGM Uniform）需要 `inner_model` 参数：

```python
need_inner_model: bool = False
```

这是因为它们需要访问模型特定的函数来执行噪声转换。

## 总结

噪声调度器是扩散模型生成过程中的关键组件，正确选择调度器可以显著提高生成质量和效率：

1. **Automatic**：默认选择，根据采样器自动选择最佳调度器
2. **Uniform**：简单的均匀调度，不是最优选择
3. **Karras**：高性能调度器，特别适合低步数采样
4. **Exponential**：在对数空间均匀分布步骤
5. **Polyexponential**：结合多项式和指数调度，提供灵活控制
6. **SGM Uniform**：专为SGM模型设计的均匀t空间调度

在实际使用中，除非你有特定需求，否则使用 Automatic 让系统自动选择是最简单有效的方法。如果你想要更精细的控制，Karras调度器在大多数情况下是最佳选择，尤其是与DPM++系列采样器结合使用时。

Stable Diffusion：噪声采样的调度器的原理

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。

1. 论文细节

1.1 摘要

CycleGAN的网络结构

1. 整体架构

文本提示如何作用于Stable Diffusion的图像生成过程

CFG Scale（Classifier-Free Guidance Scale）是如何控制文生图的

Stable Diffusion WebUI 噪声采样的调度器的原理