diff --git "a/DiffusionModel_CN_book_Chapter5&6/README_chapter5&6.md" "b/DiffusionModel_CN_book_Chapter5&6/README_chapter5&6.md"
new file mode 100644--- /dev/null
+++ "b/DiffusionModel_CN_book_Chapter5&6/README_chapter5&6.md"
@@ -0,0 +1,2120 @@
+# 《从零开始学扩散模型》
+
+## 术语表
+
+| 词汇 | 翻译 |
+| :---------------------- | :--- |
+| Corruption Process | 退化过程 |
+| Pipeline | 管线 |
+| Timestep | 时间步 |
+| Scheduler | 调度器 |
+| Gradient Accumulation | 梯度累加 |
+| Fine-Tuning | 微调 |
+| Guidance | 引导 |
+# 目录
+
+## 第一部分 基础知识
+
+### 第一章 扩散模型的原理、发展和应用
+
+#### 1.1 扩散模型的原理
+#### 1.2 扩散模型的发展
+#### 1.3 扩散模型的应用
+
+### 第二章 HuggingFace介绍与环境准备
+
+#### 2.1 HuggingFace Space
+#### 2.2 Transformer 与 diffusers 库
+#### 2.3 环境准备
+
+## 第二部分 扩散模型实战
+
+### 第三章 从零开始做扩散模型
+
+#### 3.1 章节概述
+#### 3.2 环境准备
+#### 3.2.1 环境的创建与导入
+#### 3.2.2 数据集测试
+#### 3.3 扩散模型-退化过程
+#### 3.4 扩散模型训练
+#### 3.4.1 Unet模型
+#### 3.4.2 开始训练模型
+#### 3.5 扩散模型-采样（取样）过程
+#### 3.5.1 采样（取样）过程
+#### 3.5.2 与DDPM的区别
+#### 3.5.3 UNet2DModel模型
+#### 3.6 扩散模型-退化过程示例
+#### 3.6.1 退化过程
+#### 3.6.2 最终的训练目标
+#### 3.7 拓展知识
+#### 3.7.1 迭代周期（Timestep）的调节
+#### 3.7.2 采样（取样）的关键问题
+#### 3.8 本章小结
+
+### 第四章 Diffusers实战
+#### 4.1 章节概述
+#### 4.2 环境准备
+#### 4.2.1 安装Diffusers库
+#### 4.2.2 Dreambooth-全新的扩散模型
+#### 4.2.3 Diffusers核心API
+#### 4.3 实战：生成美丽的蝴蝶图片
+#### 4.3.1 下载蝴蝶图像集
+#### 4.3.2 扩散模型-调度器
+#### 4.3.3 定义扩散模型
+#### 4.3.4 创建扩散模型训练循环
+#### 4.3.5 图像的生成
+#### 4.4 拓展知识
+#### 4.4.1 将模型上传到Hub上
+#### 4.4.2 扩大训练模型的规模
+#### 4.5 本章小结
+
+### 第五章 微调和引导
+#### 5.1 章节概述
+
+欢迎来到 Hugging Face 扩散模型课程的第二单元！在这一单元，你将会学到新的方法去使用和适配预训练过的扩散模型。你也会看到我们如何创建带有额外输入作为**生成条件**的扩散模型，以此控制生成过程。
+
+我们将讲解两种主要的基于现有模型实现改造的方法：
+
+* 通过**微调（fine-tuning）**，我们将在新的数据集上重新训练已有的模型，来改变它原有的输出类型
+* 通过**引导（guidance）**，我们将在推理阶段引导现有模型的生成过程，以此来获取额外的控制
+
+#### 5.1.1 微调（Fine-Tuning）
+
+正如你在第一单元看见的，从头训练一个扩散模型耗费的时间相当长！尤其是当你使用高分辨率图片时，从头训练模型所需的时间和数据量可能多得不切实际。幸运的是，我们还有个解决方法：从一个已经被训练过的模型去开始训练！这样，我们从一个已经学过如何去噪的模型开始，希望能相比于随机初始化的模型能有一个更好的起始点。
+
+
+
+一般而言，当你的新数据和原有模型的原始训练数据多多少少有点相似的时候，微调效果会最好（比如你想生成卡通人脸，那你用于微调的模型最好是个在人脸数据上训练过的模型）。但让人吃惊的是，这些益处在图片分布变化显著时也会存在。上面的图片是通过微调一个[在 LSUN 卧室图片数据集上训练的模型](https://huggingface.co/google/ddpm-bedroom-256)而生成的，这个模型在 [WikiArt 数据集](https://huggingface.co/datasets/huggan/wikiart)被微调了500步。相关的[训练脚本](https://github.com/huggingface/diffusion-models-class/blob/main/unit2/finetune_model.py)也放在了本单元中供大家参考。
+
+#### 5.1.2 引导（Guidance）
+
+无条件模型一般没有对生成能内容的掌控。我们可以训练一个条件模型（更过内容将会在下节讲述），接收额外输入，以此来操控生成过程。但我们如何使用一个已有的无条件模型去做这件事呢？我们可以用引导这一方法：生成过程中每一步的模型预测都将会被一些引导函数所评估，并加以修改，以此让最终的生成结果符合我们所想。
+
+
+
+这个引导函数可以是任何函数，这让我们有了很大的设计空间。在笔记本中，我们从一个简单的例子（控制颜色，如上图所示）开始，到使用一个叫CLIP的预训练模型，让生成的结果基于文字描述。
+
+#### 5.1.3 条件生成（conditioning）
+
+引导能让我们从一个无条件扩散模型中多少得到些额外的收益，但如果我们在训练过程中就有一些额外的信息（比如���像类别或文字描述）可以输入到模型里，我们可以把这些信息输入模型，让模型使用这些信息去做预测。由此我们就创建了一个条件模型，我们可以在推理阶段通过输入什么信息作为条件来控制模型生成什么。相关的笔记本中就展示了一个例子：一个类别条件的模型，可以根据类别标签生成对应的图像。
+
+
+
+有很多种方法可以把条件信息输入到模型种，比如：
+
+* 把条件信息作为额外的通道输入给 UNet。这种情况下一般条件信息都和图片有着相同的形状，比如条件信息是图像分割的掩模（mask）、深度图或模糊版的图像（针对图像修复、超分辨率任务的模型）。这种方法在一些其它条件下也可以用，比如在相应的笔记本的例子中，类别标签就被映射成了一个嵌入（embedding），并被展开成和输入图片一样的宽度和高度，以此来作为额外的通道输入到模型里。
+* 把条件信息做成一个嵌入（embedding），然后把它映射到和模型其中一个或多个中间层输出的通道数一样，再把这个嵌入加到中间层输出上。这一般是以时间步（timestep）为条件时的做法。比如，你可以把时间步的嵌入映射到特定通道数，然后加到模型的每一个残差网络模块的输出上。这种方法在你有一个向量形式的条件时很有用，比如 CLIP 的图像嵌入。一个值得注意的例子是一个[能修改输入图片的Stable Diffusion模型](https://huggingface.co/spaces/lambdalabs/stable-diffusion-image-variations)。
+* 添加有交叉注意力机制的网络层（cross-attention）。这在当条件是某种形式的文字时最有效 —— 比如文字被一个 transformer 模型映射成了一串 embedding，那么UNet中有交叉注意力机制的网络层就会被用来把这些信息合并到去噪路径中。我们将在第三单元研究 Stable Diffusion 如何处理文字信息条件时看到这种情况。
+
+#### 5.2 环境准备
+
+为了将你的微调过的模型保存到 Hugging Face Hub 上，你需要使用一个**具有写权限的访问令牌**来登录。下列代码将会引导你登陆并连接上你的账号的相关令牌页。如果在模型训练过程中，你想使用训练脚本将样本记录到日志，你也需要一个 Weights and Biases 账号 —— 同样地，这些代码也会在需要的时候引导你登录。
+
+此外，你唯一需要配置的就是安装几个依赖，并在程序中引入我们需要的东西然后制定好我们将使用的计算设备。
+
+
+
+```python
+!pip install -qq diffusers datasets accelerate wandb open-clip-torch
+```
+
+
+```python
+# Code to log in to the Hugging Face Hub, needed for sharing models
+# Make sure you use a token with WRITE access
+from huggingface_hub import notebook_login
+
+notebook_login()
+```
+
+ Token is valid.
+ Your token has been saved in your configured git credential helpers (store).
+ Your token has been saved to /root/.huggingface/token
+ Login successful
+
+
+
+```python
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torchvision
+from datasets import load_dataset
+from diffusers import DDIMScheduler, DDPMPipeline
+from matplotlib import pyplot as plt
+from PIL import Image
+from torchvision import transforms
+from tqdm.auto import tqdm
+```
+
+
+```python
+device = (
+ "mps"
+ if torch.backends.mps.is_available()
+ else "cuda"
+ if torch.cuda.is_available()
+ else "cpu"
+)
+```
+
+#### 5.3 载入一个预训练过的管线
+
+在本节笔记本的开始，我们先载入一个现有的管线，来看看我们能用它做些什么：
+
+
+
+```python
+image_pipe = DDPMPipeline.from_pretrained("google/ddpm-celebahq-256")
+image_pipe.to(device);
+```
+
+
+ Fetching 4 files: 0%| | 0/4 [00:00]
+
+
+
+
+
+
+
+
+
+**考虑因素2：** 我们的损失值曲线简直像噪声一样混乱！这是因为每一次迭代我们都只用了四个训练样本，而且加到它们上面的噪声水平还都是随机挑选的。这对于训练来讲并不理想。一种弥补的措施是，我们使用一个非常小的学习率，限制每次更新的幅度。但我们还有一个更好的方法，既能得到和使用更大的 batch size 一样的收益，又不需要让我们的内存爆掉。
+
+点击这里看看：[gradient accumulation](https://kozodoi.me/python/deep%20learning/pytorch/tutorial/2021/02/19/gradient-accumulation.html#:~:text=Simply%20speaking%2C%20gradient%20accumulation%20means,might%20find%20this%20tutorial%20useful.)。如果我们多运行几次`loss.backward()`后再调用`optimizer.step()`和`optimizer.zero_grad()`，PyTorch 就会把梯度累积（加和）起来，这样多个批次的数据产生的更新信号就会被高效地融合在一起，产出一个单独的（更好的）梯度估计用于参数更新。这样做会减少参数更新的总次数，就正如我们使用更大的 batch size 时希望看到的一样。梯度累积是一个很多框架都会替你做的事情（比如这里：[🤗 Accelerate makes this easy](https://huggingface.co/docs/accelerate/usage_guides/gradient_accumulation)），但这里我们从头实现一遍也挺好的，因为这对你在 GPU 内存受限时训练模型非常有帮助。正如你在上面代码中看到的那样（在注释 `# Gradient accumulation` 后），其实也不需要你写很多代码。
+
+
+```python
+# 练习：试试你能不能把梯度累积加到第一单元的训练循环中
+# 怎么做呢？你应该怎么基于梯度累积的步数来调整学习率？
+# 学习率应该和之前一样吗？
+```
+
+**考虑因素3：** 即使这样，我们的训练还是挺慢的，而且每遍历完一轮数据集才打印出一行更新，这也不足以让我们知道我们的训练到底怎样了。我们也许还应该：
+
+* 训练过程中时不时地生成点图像样本，供我们检查模型性能
+* 在训练过程中，把诸如损失值和生成的图片样本在内的一些东西记录到日志里。你可以使用诸如 Weights and Biases 或 tensorboard 之类的工具
+
+我创建了一个快速的脚本程序([`finetune_model.py`](https://github.com/huggingface/diffusion-models-class/blob/main/unit2/finetune_model.py))，使用了上述的训练代码并加入了少量日志记录功能。你可以[在这里看看一次训练的日志](https://wandb.ai/johnowhitaker/dm_finetune/runs/2upaa341)：
+
+
+```python
+%wandb johnowhitaker/dm_finetune/2upaa341 # You'll need a W&B account for this to work - skip if you don't want to log in
+```
+
+
+
+
+
+观察随着训练进展生成的样本图片如何变化也挺好玩 —— 即使从损失值看它好像并没有改进，但我们也能看到一个从原有图像分布（卧室图片）到新的数据集（wikiart 数据集）逐渐演变的过程。在这一节笔记本最后还有一些被注释掉的用于微调的代码，可以使用该脚本程序替代你运行上面的代码块。
+
+
+```python
+# 练习： 看看你能不能修改第一单元的官方示例训练脚本程序
+# 尝试使用预训练的模型，而不是从头开始训练
+# 对比一下上面链接的最小化脚本 —— 对比一下哪些额外功能是最小化脚本没有的？
+```
+
+用这个模型生成点图片，我们可以看到这些脸看起来极其奇怪！
+
+
+```python
+# @markdown Generate and plot some images:
+x = torch.randn(8, 3, 256, 256).to(device) # Batch of 8
+for i, t in tqdm(enumerate(scheduler.timesteps)):
+ model_input = scheduler.scale_model_input(x, t)
+ with torch.no_grad():
+ noise_pred = image_pipe.unet(model_input, t)["sample"]
+ x = scheduler.step(noise_pred, t, x).prev_sample
+grid = torchvision.utils.make_grid(x, nrow=4)
+plt.imshow(grid.permute(1, 2, 0).cpu().clip(-1, 1) * 0.5 + 0.5);
+```
+
+
+ 0it [00:00, ?it/s]
+
+
+
+
+
+
+
+
+**考虑因素4：** 微调这个过程可能是难以预知的。如果我们训练很长时间，我们也许能看见一些生成得很完美的蝴蝶，但中间过程从模型自身讲也极其有趣，尤其是你对艺术风格感兴趣时！你可以试试短时间或长时间地观察一下训练过程，并试着该百年学习率，看看这会怎么影响模型的最终输出。
+
+#### 5.5.2 使用最小化样例脚本微调模型
+
+如果你想训练一个和我在 WikiArt 类似的模型，你可以下载这个微调程序，然后运行下面的训练命令（这个训练就很耗时间和 GPU 内存了）。
+
+```python
+## 下载微调用的脚本:
+!wget https://github.com/huggingface/diffusion-models-class/raw/main/unit2/finetune_model.py
+```
+
+```python
+## 运行脚本，在Vintage Face数据集上训练脚本
+## (最好在终端里跑):
+!python finetune_model.py --image_size 128 --batch_size 8 --num_epochs 16\
+ --grad_accumulation_steps 2 --start_model "google/ddpm-celebahq-256"\
+ --dataset_name "Norod78/Vintage-Faces-FFHQAligned" --wandb_project 'dm-finetune'\
+ --log_samples_every 100 --save_model_every 1000 --model_save_name 'vintageface'
+```
+
+#### 5.5.3 保存和载入微调过的管线
+
+现在我们已经微调好了我们扩散模型中的 U-Net，我们可以通过下面代码将它保存到本地文件夹中：
+
+```python
+image_pipe.save_pretrained("my-finetuned-model")
+```
+
+和我们在前面几章看到的一样，这个过程保存了配置文件、模型、调度器三个东西。
+
+```python
+!ls {"my-finetuned-model"}
+```
+
+ model_index.json scheduler unet
+
+接下来你可以仿照第一单元 [Introduction to Diffusers](https://github.com/darcula1993/diffusion-models-class-CN/blob/main/unit1/01_introduction_to_diffusers_CN.ipynb) 中的内容把模型上传到Hub中：
+
+```
+# @title Upload a locally saved pipeline to the hub
+
+# Code to upload a pipeline saved locally to the hub
+from huggingface_hub import HfApi, ModelCard, create_repo, get_full_repo_name
+
+# Set up repo and upload files
+model_name = "ddpm-celebahq-finetuned-butterflies-2epochs" # @param What you want it called on the hub
+local_folder_name = "my-finetuned-model" # @param Created by the script or one you created via image_pipe.save_pretrained('save_name')
+description = "Describe your model here" # @param
+hub_model_id = get_full_repo_name(model_name)
+create_repo(hub_model_id)
+api = HfApi()
+api.upload_folder(
+ folder_path=f"{local_folder_name}/scheduler", path_in_repo="", repo_id=hub_model_id
+)
+api.upload_folder(
+ folder_path=f"{local_folder_name}/unet", path_in_repo="", repo_id=hub_model_id
+)
+api.upload_file(
+ path_or_fileobj=f"{local_folder_name}/model_index.json",
+ path_in_repo="model_index.json",
+ repo_id=hub_model_id,
+)
+
+# Add a model card (optional but nice!)
+content = f"""
+---
+license: mit
+tags:
+- pytorch
+- diffusers
+- unconditional-image-generation
+- diffusion-models-class
+---
+
+## Usage
+
+from diffusers import DDPMPipeline
+
+pipeline = DDPMPipeline.from_pretrained('{hub_model_id}')
+image = pipeline().images[0]
+image
+
+"""
+
+card = ModelCard(content)
+card.push_to_hub(hub_model_id)
+```
+
+#### 5.6 扩散模型-引导
+
+祝贺！你现在微调完了你的第一个扩散模型！
+
+剩下的部分我将使用一个从[这个在 LSUM bedrooms 数据集上训练过的模型](https://huggingface.co/google/ddpm-bedroom-256)开始在 WikiArt 数据集上微调了大约一轮的[新模型](https://huggingface.co/johnowhitaker/sd-class-wikiart-from-bedrooms)。你也可以跳过这部分代码，使用我们微调过的人脸或蝴蝶管线，或者直接从 Hub 上加载一个模型。
+
+
+```python
+# Load the pretrained pipeline
+pipeline_name = "johnowhitaker/sd-class-wikiart-from-bedrooms"
+image_pipe = DDPMPipeline.from_pretrained(pipeline_name).to(device)
+
+# Sample some images with a DDIM Scheduler over 40 steps
+scheduler = DDIMScheduler.from_pretrained(pipeline_name)
+scheduler.set_timesteps(num_inference_steps=40)
+
+# Random starting point (batch of 8 images)
+x = torch.randn(8, 3, 256, 256).to(device)
+
+# Minimal sampling loop
+for i, t in tqdm(enumerate(scheduler.timesteps)):
+ model_input = scheduler.scale_model_input(x, t)
+ with torch.no_grad():
+ noise_pred = image_pipe.unet(model_input, t)["sample"]
+ x = scheduler.step(noise_pred, t, x).prev_sample
+
+# View the results
+grid = torchvision.utils.make_grid(x, nrow=4)
+plt.imshow(grid.permute(1, 2, 0).cpu().clip(-1, 1) * 0.5 + 0.5);
+```
+
+
+ Downloading: 0%| | 0.00/180 [00:00 more time for the guidance to have an effect
+scheduler.set_timesteps(50)
+
+# We embed a prompt with CLIP as our target
+text = open_clip.tokenize([prompt]).to(device)
+with torch.no_grad(), torch.cuda.amp.autocast():
+ text_features = clip_model.encode_text(text)
+
+
+x = torch.randn(4, 3, 256, 256).to(
+ device
+) # RAM usage is high, you may want only 1 image at a time
+
+for i, t in tqdm(enumerate(scheduler.timesteps)):
+
+ model_input = scheduler.scale_model_input(x, t)
+
+ # predict the noise residual
+ with torch.no_grad():
+ noise_pred = image_pipe.unet(model_input, t)["sample"]
+
+ cond_grad = 0
+
+ for cut in range(n_cuts):
+
+ # Set requires grad on x
+ x = x.detach().requires_grad_()
+
+ # Get the predicted x0:
+ x0 = scheduler.step(noise_pred, t, x).pred_original_sample
+
+ # Calculate loss
+ loss = clip_loss(x0, text_features) * guidance_scale
+
+ # Get gradient (scale by n_cuts since we want the average)
+ cond_grad -= torch.autograd.grad(loss, x)[0] / n_cuts
+
+ if i % 25 == 0:
+ print("Step:", i, ", Guidance loss:", loss.item())
+
+ # Modify x based on this gradient
+ alpha_bar = scheduler.alphas_cumprod[i]
+ x = (
+ x.detach() + cond_grad * alpha_bar.sqrt()
+ ) # Note the additional scaling factor here!
+
+ # Now step with scheduler
+ x = scheduler.step(noise_pred, t, x).prev_sample
+
+
+grid = torchvision.utils.make_grid(x.detach(), nrow=4)
+im = grid.permute(1, 2, 0).cpu().clip(-1, 1) * 0.5 + 0.5
+Image.fromarray(np.array(im * 255).astype(np.uint8))
+```
+
+
+ 0it [00:00, ?it/s]
+
+
+ Step: 0 , Guidance loss: 7.437869548797607
+ Step: 25 , Guidance loss: 7.174620628356934
+
+
+
+
+
+
+
+
+
+
+
+看起来有点像玫瑰！虽然还不够完美，但你如果接着调一调设定参数，你可以得到一些更令人满意的图片。
+
+如果你仔细看上面的代码，你会发现我在使用`alpha_bar.sqrt()`作为因子去缩放梯度。虽然理论上有所谓正确的缩放这些梯度的方法，但在实践中，你可以用实验去验证。对于有些引导来说，你可能希望大部分的引导作用都集中在刚开始的几步里，对于另一些（比如一些关注点在纹理方面的风格损失函数）来讲，你可能希望它仅在生成过程的结束部分加入进来。对此，下面展示一些可能的方案：
+
+
+```python
+# @markdown Plotting some possible schedules:
+plt.plot([1 for a in scheduler.alphas_cumprod], label="no scaling")
+plt.plot([a for a in scheduler.alphas_cumprod], label="alpha_bar")
+plt.plot([a.sqrt() for a in scheduler.alphas_cumprod], label="alpha_bar.sqrt()")
+plt.plot(
+ [(1 - a).sqrt() for a in scheduler.alphas_cumprod], label="(1-alpha_bar).sqrt()"
+)
+plt.legend()
+plt.title("Possible guidance scaling schedules");
+```
+
+
+
+
+
+
+
+你可以做点实验，针对不同的调整方案、引导规模大小（`guidance_scale`），以及任何你能想到的小技巧（比如用一个范围去截断梯度也很常见），试试你能把效果做到多好。也可以在其它模型上试试，比如我们最开始使用的那个人脸模型，你能很可靠地让它生成男性脸吗？如果你把 CLIP 引导和前面我们用过地基于颜色的损失函数结合起来用呢？
+
+如果你看[一些实操的 CLIP 引导的扩散模型代码](https://huggingface.co/spaces/EleutherAI/clip-guided-diffusion/blob/main/app.py)，你会发现一种更复杂的方法：使用更好的类别去选取随机图像裁剪，并对损失函数进行许多额外的调整以获得更好的性能。在文本条件扩散模型出现前，这可是最好的文本到图像转换系统！我们这里的“玩具级”项目有很多可改进的空间，但不管怎样，它抓住了核心要点：借助于我们的引导和 CLIP 惊人的能力，我们可以给一个没有条件约束的扩散模型加上文本级的控制 🎨
+
+#### 5.7 分享你的自定义采样训练
+
+也许你现在已经想出了一个很好玩的损失函数去引导生成过程，现在你想把你的微调模型和自定义的采样策略分享给全世界......
+
+[Gradio](https://gradio.app/) 是一个免费的开源工具，让用户可以方便地通过一个简单的网页界面来创建和分享交互式的机器学习模型。使用Gradio，用户可以为自己的机器学习模型自定义接口，然后通过一个唯一的URL共享给他人。Gradio 也别集成入了 🤗 Spaces，使得创建 Demo 和共享给他人变得更容易。
+
+我们将把我们需要的核心逻辑放在一个函数中，这个函数接收一些输入然后输出一张图片作为输出。然后这个函数会被封装在一个简单的接口中，让用户能自己定义一些参数（这些参数是作为输入提供给 generate 函数的）。这里有很多[组件](https://gradio.app/docs/#components) 可以用 —— 在这个例子中我们就加入了一个滑杆来控制引导的力度（guidance scale），以及一个颜色选择器供我们定义目标颜色。
+
+
+```python
+!pip install -q gradio # Install the library
+```
+
+
+```python
+import gradio as gr
+from PIL import Image, ImageColor
+
+
+# The function that does the hard work
+def generate(color, guidance_loss_scale):
+ target_color = ImageColor.getcolor(color, "RGB") # Target color as RGB
+ target_color = [a / 255 for a in target_color] # Rescale from (0, 255) to (0, 1)
+ x = torch.randn(1, 3, 256, 256).to(device)
+ for i, t in tqdm(enumerate(scheduler.timesteps)):
+ model_input = scheduler.scale_model_input(x, t)
+ with torch.no_grad():
+ noise_pred = image_pipe.unet(model_input, t)["sample"]
+ x = x.detach().requires_grad_()
+ x0 = scheduler.step(noise_pred, t, x).pred_original_sample
+ loss = color_loss(x0, target_color) * guidance_loss_scale
+ cond_grad = -torch.autograd.grad(loss, x)[0]
+ x = x.detach() + cond_grad
+ x = scheduler.step(noise_pred, t, x).prev_sample
+ grid = torchvision.utils.make_grid(x, nrow=4)
+ im = grid.permute(1, 2, 0).cpu().clip(-1, 1) * 0.5 + 0.5
+ im = Image.fromarray(np.array(im * 255).astype(np.uint8))
+ im.save("test.jpeg")
+ return im
+
+
+# See the gradio docs for the types of inputs and outputs available
+inputs = [
+ gr.ColorPicker(label="color", value="55FFAA"), # Add any inputs you need here
+ gr.Slider(label="guidance_scale", minimum=0, maximum=30, value=3),
+]
+outputs = gr.Image(label="result")
+
+# And the minimal interface
+demo = gr.Interface(
+ fn=generate,
+ inputs=inputs,
+ outputs=outputs,
+ examples=[
+ ["#BB2266", 3],
+ ["#44CCAA", 5], # You can provide some example inputs to get people started
+ ],
+)
+demo.launch(debug=True) # debug=True allows you to see errors and output in Colab
+```
+
+当然你也可以做出点复杂得多的接口，并加入点炫酷的风格和很长的输入序列。这里我们只做最简单的演示。
+
+在 🤗 Spaces 上的演示 demo 都是默认用 CPU 跑的，所以在你移交之前，把你的接口在 Colab 上制作原型（如上所示）也是很不错的选择。当你准备好你的 demo 时，你需要创建一个 space，按照 `requirements.txt` 安装程序所需的库，然后把所都代码都放在一个名为 `app.py` 的文件里，这个文件是用来定义相关函数和接口的。
+
+
+
+幸运的是，你也可以复制一个 space。你可以在[这里](https://huggingface.co/spaces/johnowhitaker/color-guided-wikiart-diffusion) 看看其中一个 demo，然后点击 “Duplicate this Space” 用这里的代码作为一个模板，用于你后续修改代码来添加你自己的模型和引导函数。
+
+在设置选项中，你也可以配置你的 space，让它在更厉害的硬件上跑（当然会按小时收费）。如果你确实做出了一些很惊艳的东西、想在更好的硬件上分享它，可是你却不想花钱？那你可以在 Discord 上告诉我们，看我们能不能提供点帮助。
+
+#### 5.8 本章小结
+
+本节笔记本涵盖了很多内容！让我们回顾一下核心要点：
+- 载入一个现有模型并用不同的调度器（scheduler）去采样其实很容易
+- 微调（fine-tuning）看起来很像从头训练一个模型，唯一不同的是我们用已有的模型做初始化，以此我们希望能快点得到更好效果
+- 如果在大尺寸图片上微调大模型，我们可以用诸如梯度累积（gradient accumulation）的方法去应对训练时batch size太小的问题
+- 把采样的图片保存到日志里对微调很重要，而损失值曲线却可能无法反映有用的信息
+- 引导（guidance）可以让我们在使用一个没有条件约束的模型时，通过一些引导或损失函数来掌控生成过程。这里我们每步都会找一个损失对于带噪图片x的梯度，然后用梯度更新这个带噪图片，之后再进入下一个生成迭代
+- 用CLIP引导让我们可以用文字描述去控制一个没有条件约束的模型的生成过程！
+
+
+如果你想在实践中运用这些知识，你还可以做这些：
+- 微调你自己的模型并把它上传到 Hub。这包括：首先找一个起始点（比如一个在 [faces](https://huggingface.co/google/ddpm-celebahq-256）、[bedrooms](https://huggingface.co/fusing/ddpm-lsun-bedroom)、[cats](https://huggingface.co/fusing/ddpm-lsun-cat) 或 [wikiart example above](https://huggingface.co/johnowhitaker/sd-class-wikiart-from-bedrooms) 数据集上训练过的模型）和一个新的数据集（也许你可以用这个 [animal faces](https://huggingface.co/datasets/huggan/AFHQv2)，或者你自己的图片）；然后跑一跑这个笔记本中的代码或样例脚本程序。
+- 用你的微调过的模型探索一下引导，你可以用我们例子中的引导函数（颜色损失函数或 CLIP），也可以自己创造一个。
+- 把你的 demo 分享到 Gradio 上，你可以通过修改这里的 [space示例](https://huggingface.co/spaces/johnowhitaker/color-guided-wikiart-diffusion)，也��以创建你自己的有更多功能的 space
+
+#### 5.9 实战：创建一个类别条件扩散模型
+
+在这节实战课程中，我们将阐述一种给扩散模型加条件信息的方法。具体来说，我们将接着[这个从头训练的例子](../unit1/02_diffusion_models_from_scratch_CN.ipynb)在 MNIST 上训练一个以类别为条件的扩散模型。这里我们可以在推理时指定我们要生成的是哪个数字。
+
+就像本单元介绍中说的那样，这只是很多给扩散模型添加额外条件信息的方法中的一种，这里用它做示例是因为它比较简单。就像第一单元中“从走训练”的例子一样，这节笔记本也是为了解释说明的目的。如果你想，你也可以安全地跳过本节。
+
+#### 5.9.1 配置和数据准备
+
+
+```python
+!pip install -q diffusers
+```
+
+ [K |████████████████████████████████| 503 kB 7.2 MB/s
+ [K |████████████████████████████████| 182 kB 51.3 MB/s
+ [?25h
+
+
+```python
+import torch
+import torchvision
+from torch import nn
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from diffusers import DDPMScheduler, UNet2DModel
+from matplotlib import pyplot as plt
+from tqdm.auto import tqdm
+
+device = 'mps' if torch.backends.mps.is_available() else 'cuda' if torch.cuda.is_available() else 'cpu'
+print(f'Using device: {device}')
+```
+ Using device: cuda
+```python
+# Load the dataset
+dataset = torchvision.datasets.MNIST(root="mnist/", train=True, download=True, transform=torchvision.transforms.ToTensor())
+
+# Feed it into a dataloader (batch size 8 here just for demo)
+train_dataloader = DataLoader(dataset, batch_size=8, shuffle=True)
+
+# View some examples
+x, y = next(iter(train_dataloader))
+print('Input shape:', x.shape)
+print('Labels:', y)
+plt.imshow(torchvision.utils.make_grid(x)[0], cmap='Greys');
+```
+
+ Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
+ Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to mnist/MNIST/raw/train-images-idx3-ubyte.gz
+
+
+
+ 0%| | 0/9912422 [00:00]
+
+
+
+
+
+
+
+
+
+一旦训练结束，我们就可以通过输入不同的标签作为条件，来采样图片了：
+
+
+```python
+#@markdown Sampling some different digits:
+
+# Prepare random x to start from, plus some desired labels y
+x = torch.randn(80, 1, 28, 28).to(device)
+y = torch.tensor([[i]*8 for i in range(10)]).flatten().to(device)
+
+# Sampling loop
+for i, t in tqdm(enumerate(noise_scheduler.timesteps)):
+
+ # Get model pred
+ with torch.no_grad():
+ residual = net(x, t, y) # Again, note that we pass in our labels y
+
+ # Update sample with step
+ x = noise_scheduler.step(residual, t, x).prev_sample
+
+# Show the results
+fig, ax = plt.subplots(1, 1, figsize=(12, 12))
+ax.imshow(torchvision.utils.make_grid(x.detach().cpu().clip(-1, 1), nrow=8)[0], cmap='Greys')
+```
+
+
+ 0it [00:00, ?it/s]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+就是这么简单！我们现在已经对要生成的图片有所控制了。
+
+希望你喜欢这个例子。一如既往地，如果你有问题，你随时可以在 Discord 上提出来。
+
+
+```python
+# 练习（选做）：用同样方法在 FashionMNIST 数据集上试试。调节学习率、batch size 和训练的轮数（epochs）。
+# 你能用比例子更少的训练时间得到些看起来不错的时尚相关的图片吗？
+```
+
+
+### 第六章 Stable Diffusion
+#### 6.1 章节概述
+
+_示例图片，由 Stable Diffusion 生成_
+
+Stable Diffusion 是一个强大的文本条件隐式扩散模型（text-conditioned latent diffusion model）。它根据文字描述生成惊艳图片的能力震惊了整个互联网。在本章，我们将会一探 SD 的工作原理并了解一些相关使用技巧。
+
+#### 6.1.1 隐式扩散（Latent Diffusion）
+
+当图片尺寸变大时，需要的计算能力也随之增加。这种现象在自注意力机制（self-attention）这种操作的影响下尤为突出，因为操作数随着输入量的增大呈平方地增加。一个 128px 的正方形图片有着四倍于 64px 正方形图片的像素数量，所以在自注意力层就需要16倍（42）的内存和计算量。这是高分辨率图片生成任务的普遍问题。
+
+
+_Diagram from the [Latent Diffusion paper](http://arxiv.org/abs/2112.10752)_
+
+隐式扩散致力于克服这一难题，它使用一个独立的模型 Variational Auto-Encoder（VAE）**压缩**图片到一个更小的空间维度。这背后的原理是，图片通场都包含了大量的冗余信息。因此，我们可以训练一个 VAE，并通过大量足够的图片数据训练，使得它可以将图片映射到一个较小的**隐式**空间，并将这个较小的特征映射回原图片。SD 模型中的 VAE 接收一个三通道图片输入，生成出一个四通道的隐式表征，同时每一个空间维度上都减少为原来的八分之一。比如，一个 512px 的正方形图片将会被压缩到一个 4×64×64 的隐式表征上。
+
+通过在**隐式表征**上（而不是完整图像上）进行扩散过程，我们可以使用更少内存、减少 UNet 层数、加速生成。同时我们仍能把结果输入 VAE 的解码器，解码得到高分辨率图片。这一创新点极大地降低了训练和推理成本。
+
+#### 6.1.2 以文本为生成条件
+
+在第二单元，我们展示了如何将额外信息输入到 UNet，让我们对生成的图片有了额外的控制。我们把这种方法叫做条件生成。给定一个带噪图片，我们让模型**基于额外的线索**（比如类别标签，或 Stable Diffusion 中的文字描述）去预测去噪后的图片。
+在推理阶段，我们可以输入对期望图片的文字表述，使用纯噪声数据作为起始点，然后模型就开始全力对噪声输入进行“去噪”，生成能匹配上文字描述的图片。
+
+
+_图表：文本编码过程，即将输入的文本提示转化为一系列的文本嵌入（即图中的 encoder_hidden_states)，然后输入 Unet 作为生成条件_
+
+为了达成这一目的，我们首先需要为文本创建一个数值的表示形式，用来获取文字描述的相关信息。为此，SD 利用了一个名为 CLIP 的预训练 transformer 模型。CLIP 的文本编码器可以将文字描述转化为特征向量形式，这个特征向量可以用来和图片的特征向量对比相似度。所以这个模型非常适合用来从文字描述来为图像创建有用的表征信息。一个输入文字提示会首先被分词（tokenize，基于一个很大的词汇库把句中的词语或短语转化为一个个的token），然后被输入进 CLIP 的文字编码器，为每个token产出一个 768 维（针对 SD 1.X版本）或1024维（针对SD 2.X版本）的向量。为了使得输入格式一致，文本提示总是被补全或截断到含有 77 个 token 的长度，所以每个文字提示最终作为生成条件的表示形式是一个形状为 77×1024 的张量。
+
+
+
+那我们如何实际地将这些条件信息输入到 UNet 里让它预测使用呢？答案是使用交叉注意力机制（cross-attention）。交叉注意力层从头到尾贯穿了 UNet 结构。UNet 中的每个空间位置都可以“注意”文字条件中不同的token，以此从文字提示中获取到了不同位置的相互关联信息。上面的图表就展示了文字条件信息（以及基于时间周期 time-step 的条件）是如何在不同的位置点输入的。可以看到，UNet 的每一层都有机会去利用这些条件信息！
+
+#### 6.1.3 无分类器的引导
+
+然而很多时候，即使我们付出了很多努力尽可能让文本成为生成的条件，但模型仍然会在预测时大量地基于带噪输入图片，而不是文字。在某种程度上，这其实是可以解释得通的：很多说明文字和与之关联的图片相关性很弱，所以模型就学着不去过度依赖文字描述！可是这并不是我们期望的效果。如果模型不遵从文本提示，那么我们很可能得到与我们描述根本不相关的图片。
+
+
+_由描述 "An oil painting of a collie in a top hat" 生成的图片（从左到右的 CFG scale 分别是 0、1、2、10)_
+
+为了解决这一问题，我们使用了一个小技巧，叫做无分类器的引导（Classifie-free Guidance，CGF）。在训练时，我们时不时把文字条件置空，强迫模型去学着在无文字信息的情况下对图片去噪（无条件生成）。在推理阶段，我们分别做两个预测：一个有文字条件，一个没有。我们可以用这两者的差异来建立一个最终结合版的预测，让最终结果在文本条件预测所指明的方向上依据一个缩放系数（即引导尺度）去“走得更远”，希望最终生成一个更好地匹配文字提示的结果。上图就展示了在同一个文本提示下使用不同引导尺度得到的不同结果。可以看到，更高的引导尺度能让生成的图片更接近文字描述。
+
+#### 6.1.4 其它类型的条件生成：超分辨率、图像修补、深度图到图像的转换
+
+我们也可以创建各种接收不同生成条件的 Stable Diffusion 模型。比如[深度图到图像转换模型](https://huggingface.co/stabilityai/stable-diffusion-2-depth)使用深度信息作为生成条件。在推理阶段，可以输入一个目标图片的深度图，以此来让模型生成一个有相似全局结构的图片。
+
+
+_基于深度的 SD 模型可以根据同一个全局结构生成不同的图片（示例来自StabilityAI)_
+
+用相似的方式，我们也可以输入一个低分辨率图片作为条件，让模型生成对应的高分辨率图片（[正如Stable Diffusion Upscaler](https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler)一样）。此外，我们还可以输入一个掩膜（mask），让模型知道图像相应的区域需要让模型用in-painting 的方式重新生成一下：掩膜外的区域要和原图片保持一致，掩膜内的区域要生成出新的内容。
+
+#### 6.1.5 使用 DreamBooth 微调
+
+
+_由 Imagen model 生成的图片，来自[dreambooth 项目页](https://dreambooth.github.io/)_
+
+DreamBooth 可以用来微调文字到图像的生成模型，教它一些新的概念，比如某一特定物体或某种特定风格。这一技术一开始是为 Google 的 Imagen Model 开发的，但被很快应用于 [stable diffusion](https://huggingface.co/docs/diffusers/training/dreambooth) 中。效果十分惊艳（如果你最近在社交媒体上看到谁使用了 AI 生成的头像，那这个头像有很大概率是出自于基于 DreamBooth 的服务），但该技术也对各种设置十分敏感。所以请学习我们这一单元的笔记本，并阅读[这个对不同训练参数的调研资料](https://huggingface.co/blog/dreambooth)来获取些参考，让模型尽可能地起作用。
+
+#### 6.2 环境准备
+
+```python
+!pip install -Uq diffusers ftfy accelerate
+```
+
+
+```python
+# Installing transformers from source for now since we need the latest version for Depth2Img:
+!pip install -Uq git+https://github.com/huggingface/transformers
+```
+
+
+```python
+import torch
+import requests
+from PIL import Image
+from io import BytesIO
+from matplotlib import pyplot as plt
+
+# We'll be exploring a number of pipelines today!
+from diffusers import (
+ StableDiffusionPipeline,
+ StableDiffusionImg2ImgPipeline,
+ StableDiffusionInpaintPipeline,
+ StableDiffusionDepth2ImgPipeline
+ )
+
+# We'll use a couple of demo images later in the notebook
+def download_image(url):
+ response = requests.get(url)
+ return Image.open(BytesIO(response.content)).convert("RGB")
+
+# Download images for inpainting example
+img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
+mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
+
+init_image = download_image(img_url).resize((512, 512))
+mask_image = download_image(mask_url).resize((512, 512))
+```
+
+
+```python
+# Set device
+device = (
+ "mps"
+ if torch.backends.mps.is_available()
+ else "cuda"
+ if torch.cuda.is_available()
+ else "cpu"
+)
+```
+
+#### 6.3 从文本生成图像
+
+我们先载入 Stable Diffusion 的管线。现有的 Stable Diffusion 模型有好多不同版本，截至本书编写时的最新版本是第2.1版。修改版本只需要在 `model_id` 处修改即可（比如你可以试试将其改成 `CompVis/stable-diffusion-v1-4` 或从[dreambooth concepts library](https://huggingface.co/sd-dreambooth-library)选一个模型）。
+
+
+```python
+# Load the pipeline
+model_id = "stabilityai/stable-diffusion-2-1-base"
+pipe = StableDiffusionPipeline.from_pretrained(model_id).to(device)
+```
+
+如果你的GPU内存不够用，可以尝试这些方法减少内存使用：
+
+- 载入 FP16 精度的版本（但并不是所有的系统上都支持），此时你也需要保证所有的张量也被改成了 torch.float16 精度：
+
+ `pipe = StableDiffusionPipeline.from_pretrained(model_id, revision="fp16", torch_dtype=torch.float16).to(device)`
+
+
+- 开启注意力机制切分（attention slicing）。这会牺牲一点点速度来减少GPU内存的使用：
+
+ `pipe.enable_attention_slicing()`
+
+
+- 降低生成结果的图片尺寸
+
+当管线加载好了以后，我们可以用以下代码去使用文字提示生成图片：
+
+
+```python
+# Set up a generator for reproducibility
+generator = torch.Generator(device=device).manual_seed(42)
+
+# Run the pipeline, showing some of the available arguments
+pipe_output = pipe(
+ prompt="Palette knife painting of an autumn cityscape", # What to generate
+ negative_prompt="Oversaturated, blurry, low quality", # What NOT to generate
+ height=480, width=640, # Specify the image size
+ guidance_scale=8, # How strongly to follow the prompt
+ num_inference_steps=35, # How many steps to take
+ generator=generator # Fixed random seed
+)
+
+# View the resulting image:
+pipe_output.images[0]
+```
+
+
+ 0%| | 0/35 [00:00 decoded token")
+for input_id in input_ids[0]:
+ print(f"{input_id} -> {pipe.tokenizer.decode(input_id)}")
+
+# Feed through CLIP text encoder
+input_ids = torch.tensor(input_ids).to(device)
+with torch.no_grad():
+ text_embeddings = pipe.text_encoder(input_ids)['last_hidden_state']
+print("Text embeddings shape:", text_embeddings.shape)
+```
+
+ Input ID -> decoded token
+ 49406 -> <|startoftext|>
+ 320 -> a
+ 3086 -> painting
+ 539 -> of
+ 320 -> a
+ 4062 -> floo
+ 1059 -> ble
+ 49407 -> <|endoftext|>
+ Text embeddings shape: torch.Size([1, 8, 1024])
+
+
+
+```python
+# Get the final text embeddings using the pipeline's _encode_prompt function:
+text_embeddings = pipe._encode_prompt("A painting of a flooble", device, 1, False, '')
+text_embeddings.shape
+```
+
+
+
+
+ torch.Size([1, 77, 1024])
+
+
+
+这些文本嵌入（text embedding），也即文本编码器中最后一个transformer模块的“隐状态（hidden state）”，将会被送入 UNet 中作为 `forward` 函数的一个额外输入，稍后我们会详细看到。
+
+#### 6.4.3 UNet
+
+
+
+在扩散模型中，UNet 模型接收一个带噪的输入，并预测噪声，以此实现去噪。但与以往例子不同的是，这里的输入并不是图片了，而是图片的隐式表示形式（latent representation）。此外，除了把用于暗示带噪程度的 timestep 输入进 UNet 作为条件外，这里模型也把文字提示（prompt）的文本嵌入（text embeddings）也作为输入。这里我们用假数据试着让它预测一下，请注意这一过程中各个输入输出的形状大小：
+
+
+```python
+# Dummy inputs:
+timestep = pipe.scheduler.timesteps[0]
+latents = torch.randn(1, 4, 64, 64).to(device)
+text_embeddings = torch.randn(1, 77, 1024).to(device)
+
+# Model prediction:
+with torch.no_grad():
+ unet_output = pipe.unet(latents, timestep, text_embeddings).sample
+print('UNet output shape:', unet_output.shape) # Same shape as the input latents
+```
+
+ UNet output shape: torch.Size([1, 4, 64, 64])
+
+#### 6.4.4 调度器(Scheduler)
+
+调度器保存了如何加噪这一信息，管理着如何基于模型的预测更新带噪样本。默认的调度器是 `PNDMScheduler` 调度器，但你也可以用其它的（比如 `LMSDiscreteScheduler` 调度器），只要它们用相同的配置初始化。
+
+我们可以画出图像来观察如何随着 timestep 添加噪声，看看噪声水平（基于$\bar{\alpha}$这个参数）是怎样变动的：
+
+
+```python
+plt.plot(pipe.scheduler.alphas_cumprod, label=r'$\bar{\alpha}$')
+plt.xlabel('Timestep (high noise to low noise ->)');
+plt.title('Noise schedule');plt.legend();
+```
+
+
+
+
+
+
+
+如果你想尝试不同的调度器，可以参考下面代码修改：
+
+
+```python
+from diffusers import LMSDiscreteScheduler
+
+# Replace the scheduler
+pipe.scheduler = LMSDiscreteScheduler.from_config(pipe.scheduler.config)
+
+# Print the config
+print('Scheduler config:', pipe.scheduler)
+
+# Generate an image with this new scheduler
+pipe(prompt="Palette knife painting of an winter cityscape", height=480, width=480,
+ generator=torch.Generator(device=device).manual_seed(42)).images[0]
+```
+
+ Scheduler config: LMSDiscreteScheduler {
+ "_class_name": "LMSDiscreteScheduler",
+ "_diffusers_version": "0.11.1",
+ "beta_end": 0.012,
+ "beta_schedule": "scaled_linear",
+ "beta_start": 0.00085,
+ "clip_sample": false,
+ "num_train_timesteps": 1000,
+ "prediction_type": "epsilon",
+ "set_alpha_to_one": false,
+ "skip_prk_steps": true,
+ "steps_offset": 1,
+ "trained_betas": null
+ }
+
+
+
+
+ 0%| | 0/50 [00:00 x_t-1
+ latents = pipe.scheduler.step(noise_pred, t, latents).prev_sample
+
+# Decode the resulting latents into an image
+with torch.no_grad():
+ image = pipe.decode_latents(latents.detach())
+
+# View
+pipe.numpy_to_pil(image)[0]
+```
+
+
+
+
+
+
+
+
+
+
+当然大多数情况下，还是使用现有的管线更方便。如果你想看看实际的代码以及深入了解如何修改这些组成部分，你可以参考 Stable Diffusion Deep Dive 这个[笔记本](https://github.com/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb)和[视频](https://m.youtube.com/watch?v=0_BBRNYInx8)。这里有对相关内容更全面彻底的探究。
+
+#### 6.5 其他管线介绍
+
+除了从文字提示生成图片外，我们还能做点什么呢？其实还有很多！下面还会向你展示几个管线，让你了解一些 Stable Diffusion 的应用。
+
+#### 6.5.1 Img2Img
+
+直到现在，我们��成的图片还都是完全从随机的隐变量来开始生成的，而且也都使用了完整的扩散模型采样循环。但如果使用 Img2Img 管线，我们其实不必从头开始。Img2Img 这个管线首先将一张已有的图片进行编码，编码成一系列的隐变量，然后在这些隐变量上随机加噪声，以这些作为起始点。噪声加多大量、去噪需要多少步数（timestep）决定了这个 img2img 过程的“强度”。只加一点点噪声（强度低）只会带来微小改变，而加入大量噪声并跑完完整去噪过程又会让生成出几乎完全不像原始图片，仅在整体结构上还有点相似。
+
+这个管线无需什么特殊模型，只要模型的 ID 和我们的文字到图像模型一样就行，没有新的需要下载的文件。
+
+
+```python
+# Loading an Img2Img pipeline
+model_id = "stabilityai/stable-diffusion-2-1-base"
+img2img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id).to(device)
+```
+
+
+ Fetching 16 files: 0%| | 0/16 [00:00