+ +$q(\mathbf{x}_t \vert \mathbf{x}_{t-1}) = \mathcal{N}(\mathbf{x}_t; \sqrt{1 - \beta_t} \mathbf{x}_{t-1}, \beta_t\mathbf{I}) \quad +q(\mathbf{x}_{1:T} \vert \mathbf{x}_0) = \prod^T_{t=1} q(\mathbf{x}_t \vert \mathbf{x}_{t-1})$
+ + +这就是说，我们取 $x_{t-1}$, 给他一个$\sqrt{1 - \beta_t}$ 的系数，然后加上带有 $\beta_t$系数的噪声。 这里 $\beta$ 是根据一些管理器来为每一个t设定的，来决定每一个迭代周期中添加多少噪声。 现在，我们不想把这个推演进行500次来得到 $x_{500}$，所以我们用另一个公式来根据给出的 $x_0$ 计算得到任意t时刻的 $x_t$:
+ +$\begin{aligned} +q(\mathbf{x}_t \vert \mathbf{x}_0) &= \mathcal{N}(\mathbf{x}_t; \sqrt{\bar{\alpha}_t} \mathbf{x}_0, \sqrt{(1 - \bar{\alpha}_t)} \mathbf{I}) +\end{aligned}$ where $\bar{\alpha}_t = \prod_{i=1}^T \alpha_i$ and $\alpha_i = 1-\beta_i$
+ +数学符号看起来总是很吓人！幸运的是，调度器为我们处理了所有这些（取消下一个单元格的注释以检查代码）。我们可以画出 $\sqrt{\bar{\alpha}_t}$ (标记为 `sqrt_alpha_prod`) 和 $\sqrt{(1 - \bar{\alpha}_t)}$ (标记为 `sqrt_one_minus_alpha_prod`) 来看一下输入(x)与噪声是如何在不同迭代周期中量化和叠加的: + + + +```python +#??noise_scheduler.add_noise +``` + + +```python +noise_scheduler = DDPMScheduler(num_train_timesteps=1000) +plt.plot(noise_scheduler.alphas_cumprod.cpu() ** 0.5, label=r"${\sqrt{\bar{\alpha}_t}}$") +plt.plot((1 - noise_scheduler.alphas_cumprod.cpu()) ** 0.5, label=r"$\sqrt{(1 - \bar{\alpha}_t)}$") +plt.legend(fontsize="x-large"); +``` + + + + + + + +一开始, 噪声x里绝大部分都是x自身的值 (sqrt_alpha_prod ~= 1)，但是随着时间的推移，x的成分逐渐降低而噪声的成分逐渐增加。与我们根据`amount`对x和噪声进行线性混合不同，这个噪声的增加相对较快。我们可以在一些数据上看到这一点： + + +```python +#@markdown visualize the DDPM noising process for different timesteps: + +# Noise a batch of images to view the effect +fig, axs = plt.subplots(3, 1, figsize=(16, 10)) +xb, yb = next(iter(train_dataloader)) +xb = xb.to(device)[:8] +xb = xb * 2. - 1. # Map to (-1, 1) +print('X shape', xb.shape) + +# Show clean inputs +axs[0].imshow(torchvision.utils.make_grid(xb[:8])[0].detach().cpu(), cmap='Greys') +axs[0].set_title('Clean X') + +# Add noise with scheduler +timesteps = torch.linspace(0, 999, 8).long().to(device) +noise = torch.randn_like(xb) # << NB: randn not rand +noisy_xb = noise_scheduler.add_noise(xb, noise, timesteps) +print('Noisy X shape', noisy_xb.shape) + +# Show noisy version (with and without clipping) +axs[1].imshow(torchvision.utils.make_grid(noisy_xb[:8])[0].detach().cpu().clip(-1, 1), cmap='Greys') +axs[1].set_title('Noisy X (clipped to (-1, 1)') +axs[2].imshow(torchvision.utils.make_grid(noisy_xb[:8])[0].detach().cpu(), cmap='Greys') +axs[2].set_title('Noisy X'); +``` + + X shape torch.Size([8, 1, 28, 28]) + Noisy X shape torch.Size([8, 1, 28, 28]) + + + + + + + + +在运行中的另一个变化：在DDPM版本中，加入的噪声是取自一个高斯分布（来自均值0方差1的torch.randn），而不是在我们原始 `corrupt`函数中使用的 0-1之间的均匀分布（torch.rand），当然对训练数据做正则化也可以理解。在另一篇笔记中，你会看到 `Normalize(0.5, 0.5)`函数在变化列表中，它把图片数据从(0, 1) 区间映射到 (-1, 1)，对我们的目标来说也‘足够用了’。我们在此篇笔记中没使用这个方法，但在上面的可视化中为了更好的展示添加了这种做法。 + + +```python + +``` + +### 训练目标 + +在我们的玩具示例中，我们让模型尝试预测去噪图像。在DDPM和许多其他扩散模型实现中，模型则会预测损坏过程中使用的噪声（在缩放之前，因此是单位方差噪声）。在代码中，它看起来像使这样： + +```python +noise = torch.randn_like(xb) # << NB: randn not rand +noisy_x = noise_scheduler.add_noise(x, noise, timesteps) +model_prediction = model(noisy_x, timesteps).sample +loss = mse_loss(model_prediction, noise) # noise as the target +``` + +你可能认为预测噪声（我们可以从中得出去噪图像的样子）等同于直接预测去噪图像。那么，为什么要这么做呢？这仅仅是为了数学上的方便吗？ + +这里其实还有另一些精妙之处。我们在训练过程中，会计算不同（随机选择）timestep的loss。这些不同的目标将导致这些loss的不同的“隐含权重”，其中预测噪声会将更多的权重放在较低的噪声水平上。你可以选择更复杂的目标来改变这种“隐性损失权重”。或者，您选择的噪声管理器将在较高的噪声水平下产生更多的示例。也许你让模型设计成预测“velocity”v，我们将其定义为由噪声水平影响的图像和噪声组合（请参阅“扩散模型快速采样的渐进蒸馏”- 'PROGRESSIVE DISTILLATION FOR FAST SAMPLING OF DIFFUSION MODELS'）。也许你将模型设计成预测噪声，然后基于某些因子来对loss进行缩放：比如有些理论指出可以参考噪声水平（参见“扩散模型的感知优先训练”-'Perception Prioritized Training of Diffusion Models'），或者基于一些探索模型最佳噪声水平的实验（参见“基于扩散的生成模型的设计空间说明”-'Elucidating the Design Space of Diffusion-Based Generative Models'）。 + +一句话解释：选择目标对模型性能有影响，现在有许多研究者正在探索“最佳”选项是什么。 +目前，预测噪声（epsilon或eps）是最流行的方法，但随着时间的推移，我们很可能会看到库中支持的其他目标，并在不同的情况下使用。 + +### 迭代周期（Timestep）调节 + +UNet2DModel以x和timestep为输入。后者被转化为一个嵌入（embedding），并在多个地方被输入到模型中。 + +这背后的理论支持是这样的：通过向模型提供有关噪声水平的信息，它可以更好地执行任务。虽然在没有这种timestep条件的情况下也可以训练模型，但在某些情况下，它似乎确实有助于性能，目前来说绝大多数的模型实现都包括了这一输入。 + +### 取样（采样） + +有一个模型可以用来预测在带噪样本中的噪声（或者说能预测其去噪版本），我们怎么用它来生成图像呢？ + +我们可以给入纯噪声，然后就希望模型能一步就输出一个不带噪声的好图像。但是，就我们上面所见到的来看，这通常行不通。所以，我们在模型预测的基础上使用足够多的小步，迭代着来每次去除一点点噪声。 + +具体我们怎么走这些小步，取决于使用上面取样方法。我们不会去深入讨论太多的理论细节，但是一些顶层想法是这样： +- 每一步你想走多大？也就是说，你遵循什么样的“噪声计划（噪声管理）”？ +- 你只使用模型当前步的预测结果来指导下一步的更新方向吗（像DDPM，DDIM或是其他的什么那样）？你是否要使用模型来多预测几次来估计一个更高阶的梯度来更新一步更大更准确的结果（更高阶的方法和一些离散ODE处理器）？或者保留历史预测值来尝试更好的指导当前步的更新（线性多步或遗传取样器）？ +- 你是否会在取样过程中额外再加一些随机噪声，或你完全已知得（deterministic）来添加噪声？许多取样器通过参数（如DDIM中的'eta'）来供用户选择。 + +对于扩散模型取样器的研究演进的很快，随之开发出了越来越多可以使用更少步就找到好结果的方法。勇敢和有好奇心的人可能会在浏览diffusers library中不同部署方法时感到非常有意思 [here](https://github.com/huggingface/diffusers/tree/main/src/diffusers/schedulers) 或看看 [docs](https://huggingface.co/docs/diffusers/api/schedulers) 这里经常有一些相关的paper. + +## 结语 + +希望这可以从一些不同的角度来审视扩散模型提供一些帮助。 +这篇笔记是Jonathan Whitaker为Hugging Face 课程所写的，同时也有 [version included in his own course](https://johnowhitaker.github.io/tglcourse/dm1.html),“风景的生成”- 'The Generative Landscape'。如果你对从噪声和约束分类来生成样本的例子感兴趣。问题与bug可以通过GitHub issues 或 Discord来交流。 也同时欢迎通过Twitter联系 [@johnowhitaker](https://twitter.com/johnowhitaker). diff --git a/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_24_1.png b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_24_1.png new file mode 100644 index 0000000000000000000000000000000000000000..3fdc5446bd7401de802058a4cc875f6a51df4731 --- /dev/null +++ b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_24_1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f3ec8a31b370ba4ba59dfd3072d3ab387e23b05e283f5917b69582206e136b4 +size 12507 diff --git a/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_26_0.png b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_26_0.png new file mode 100644 index 0000000000000000000000000000000000000000..f50733abe35352c7691f23b28a89c6cde32ea5cc --- /dev/null +++ b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_26_0.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:255f039788b323b65c69bac27e104edf75e9cbd3f958591d708baaa53e02ba2a +size 119652 diff --git a/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_29_0.png b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_29_0.png new file mode 100644 index 0000000000000000000000000000000000000000..af3a7f816576c01be89da9e2cbbc4b58bb0254de --- /dev/null +++ b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_29_0.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf3e6c0c3c6db742b4c076f2744a0b86f92355bd9a6c3d7c9ddff2e1d4d7246d +size 125212 diff --git a/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_31_1.png b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_31_1.png new file mode 100644 index 0000000000000000000000000000000000000000..7d907b091ace91390f84e97a528b1838324aae59 --- /dev/null +++ b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_31_1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12d49a7db75ef5917c95fdb4a656218a8e457468b253fb58b6f8e232f627a3c8 +size 216298 diff --git a/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_39_1.png b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_39_1.png new file mode 100644 index 0000000000000000000000000000000000000000..1f62969442b68c9e919e0b2ea1f4762ca29d84bb --- /dev/null +++ b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_39_1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69d75b23c16679efb2d03aa4c71a24aa42ecb19d25bf61a5e729a321cd56001e +size 81314 diff --git a/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_43_0.png b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_43_0.png new file mode 100644 index 0000000000000000000000000000000000000000..5a3c09eb03d06ff95c6aea71f8b32e2ce068d572 --- /dev/null +++ b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_43_0.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:66b716d94b45e7812e7d8cf1f31b097fed9bd21b854203e80e7920c5f01115ca +size 14564 diff --git a/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_45_1.png b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_45_1.png new file mode 100644 index 0000000000000000000000000000000000000000..2f156d497386fa0d26503c9d9c2fbb06615aa74d --- /dev/null +++ b/markdown/unit1/02_diffusion_models_from_scratch_CN_files/02_diffusion_models_from_scratch_CN_45_1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d18d95dcc9ab62110c54e50370bd72d7cde9c902fb40e690ab6ff0bef93c875 +size 53066 diff --git a/markdown/unit1/README_CN.md b/markdown/unit1/README_CN.md new file mode 100644 index 0000000000000000000000000000000000000000..90c5accfe8c4c2b5aa8d56e83af0b337641e7dd7 --- /dev/null +++ b/markdown/unit1/README_CN.md @@ -0,0 +1,65 @@ +# 单元 1: 扩散模型简介 + +欢迎来到 Hugging Face 扩散模型课程第一单元！在本单元中，你将学习到有关扩散模型如何运作的基础知识，同时也会学到如何使用 🤗 diffusers 库。 + +## 开始本单元 :rocket: + +以下是本单元的学习步骤: + +- 请确保你已经 [注册了该课程](https://huggingface.us17.list-manage.com/subscribe?u=7f57e683fa28b51bfc493d048&id=ef963b4162)。这样当有新课程材料发布的时候你就会收到通知 +- 通读下面的介绍材料以及任何你感兴趣的其他资源 +- 查看下面的 _**Introduction to Diffusers**_ Notebook 链接，以使用 `diffuers` 库将理论应用到实践中 +- 使用 Notebook 或链接的训练脚本来训练和分享你自己的扩散模型 +- (可选) 如果你有兴趣看到一个极简的从头开始的项目实现，并探索所涉及的不同设计决策，你可以深入研究 _**Diffusion Models from Scratch**_ 这个 Notebook + + +:loudspeaker: 请不要忘了加入我们的频道 [Discord](https://huggingface.co/join/discord), 你可以在 `#diffusion-models-class` 频道来讨论课程内容以及分享你的作品。 + +## 什么是扩散模型？ + +扩散模型是「生成模型」算法家族的新成员通过学习给定的训练样本，生成模型可以学会如何 **生成** 数据，比如生成图片或者声音。一个好的生成模型能生成一组 **样式不同** 的输出。这些输出会与训练数据相似，但不是一模一样的副本。扩散模型如何实现这一点？为了便于说明，让我们先看看图像生成的案例。 + +
+ 
+
+ 图片来源于 DDPM paper (https://arxiv.org/abs/2006.11239)。
+
+
+扩散模型成功的秘诀在于扩散过程的迭代本质。最先生成的只是一组随机噪声，但是经过若干步的逐渐改善之后，最终会出现有意义的图像。在每一步中，模型都会估计如何从当前的输入生成完全去噪的结果。因为我们在每一步都只做了一个小小的变动，所以在早期阶段（预测最终输出实际上非常困难），这个估计中的任何 error 都可以在以后的更新中得到纠正。
+
+与其他类型的生成模型相比，训练扩散模型相对较为容易。我们只需要重复以下步骤即可：
+
+1) 从训练数据中加载一些图像
+2) 添加不同级别的噪声。请记住，我们希望模型在面对添加了极端噪声和几乎没有添加噪声的带噪图像时，都能够很好地估计如何 “修复”（去噪）。
+3) 将带噪输入送入模型中
+4) 评估模型对这些输入进行去噪的效果
+5) 使用此信息更新模型权重
+
+为了用训练好的模型生成新的图像，我们从完全随机的输入开始，反复将其输入模型，每次根据模型预测进行少量更新。我们之后会学到有许多采样方法试图简化这个过程，以便我们可以用尽可能少的步骤生成好的图像。
+我们将在第一单元的实践笔记本中详细介绍这些步骤。在第二单元中，我们将了解如何修改此过程，来通过额外的条件（例如类标签）或使用指导等技术来增加对模型输出的额外控制。第三单元和第四单元将探索一种非常强大的扩散模型，称为稳定扩散 (stable diffusion)，它可以生成给定文本描述的图像。
+
+## 实践笔记本
+
+到这里，你已经足够了解如何开始使用附带的笔记本了！这里的两个笔记本以不同的方式表达了相同的想法。
+
+| Chapter | Colab | Kaggle | Gradient | Studio Lab |
+|:--------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Introduction to Diffusers | [](https://colab.research.google.com/github/darcula1993/diffusion-models-class-CN/blob/main/unit1/01_introduction_to_diffusers_CN.ipynb) | [](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit1/01_introduction_to_diffusers_CN.ipynb) | [](https://console.paperspace.com/github/darcula1993/diffusion-models-class-CN/blob/main/unit1/01_introduction_to_diffusers_CN.ipynb) | [](https://studiolab.sagemaker.aws/import/github/darcula1993/diffusion-models-class-CN/blob/main/unit1/01_introduction_to_diffusers_CN.ipynb) |
+| Diffusion Models from Scratch | [](https://colab.research.google.com/github/darcula1993/diffusion-models-class-CN/blob/main/unit1/02_diffusion_models_from_scratch_CN.ipynb) | [](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit1/02_diffusion_models_from_scratch_CN.ipynb) | [](https://console.paperspace.com/github/darcula1993/diffusion-models-class-CN/blob/main/unit1/02_diffusion_models_from_scratch_CN.ipynb) | [](https://studiolab.sagemaker.aws/import/github/darcula1993/diffusion-models-class-CN/blob/main/unit1/02_diffusion_models_from_scratch_CN.ipynb) |
+
+在 _**Introduction to Diffusers**_ 这个 Notebook 中，我们使用 diffusers 库中的构造模块显示了与上述不同的步骤。你将很快看到如何根据你选择的任何数据创建、训练和采样你自己的扩散模型。 在笔记本结束时，你将能够阅读和修改示例训练脚本，以训练扩散模型，并将其与全世界共同分享！ 本笔记本还介绍了与本单元相关的主要练习，在这里，我们将共同尝试为不同规模的扩散模型找出好的「训练脚本」- 请参阅下一节了解更多信息。
+
+在 _**Diffusion Models from Scratch**_ 这个 Notebook 中，我们展示了相同的步骤（向数据添加噪声、创建模型、训练和采样），并尽可能简单地在 PyTorch 中从头开始实现。然后，我们将这个「玩具示例」与 `diffusers` 版本进行比较，并关注两者的区别以及改进之处。这里的目标是熟悉不同的组件和其中的设计决策，以便在查看新的实现时能够快速确定关键思想。
+
+## 项目时间
+
+现在，你已经掌握了基本知识，可以开始训练你自己的扩散模型了！ _**Introduction to Diffusers**_ 这个 Notebook 的末尾有一些小提示，希望你能与社区分享你的成果、训练脚本和发现，以便我们能够一起找出训练这些模型的最佳方法。
+
+## 一些额外的材料
+
+- [《Hugging Face 博客: 带注释的扩散模型》](https://huggingface.co/blog/annotated-diffusion)是对 DDPM 背后的代码和理论的非常深入的介绍，其中包括数学和显示了所有不同的组件的代码。它还链接了一些论文供进一步阅读:
+- [Hugging Face 文档: 无条件图像生成 (Unconditional Image-Generation)](https://huggingface.co/docs/diffusers/training/unconditional_training)，包含了有关如何使用官方训练示例脚本训练扩散模型的一些示例，包括演示如何创建自己的数据集的代码：
+- AI Coffee Break video on Diffusion Models: https://www.youtube.com/watch?v=344w5h24-h8
+- Yannic Kilcher Video on DDPMs: https://www.youtube.com/watch?v=W-O7AZNzbzQ
+
+发现了有其他任何有帮助的资源？请 [向我们提出](https://github.com/huggingface/diffusion-models-class/issues)，我们会将其加入到上面的列表中。
\ No newline at end of file
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN.md b/markdown/unit2/01_finetuning_and_guidance_CN.md
new file mode 100644
index 0000000000000000000000000000000000000000..800bd89d67ebb023dd1ca2d087efc6d8315fd105
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN.md
@@ -0,0 +1,1048 @@
+# Fine-Tuning and Guidance
+
+在这一节的笔记本中，我们将讲解两种主要的基于现有模型实现改造的方法：
+
+* 通过**微调（fine-tuning）**，我们将在新的数据集上重新训练已有的模型，来改变它原有的输出类型
+* 通过**引导（guidance）**，我们将在推理阶段引导现有模型的生成过程，以此来获取额外的控制
+
+## 你将学到：
+
+在阅读完这一节笔记本后，你将学会：
+
+- 创建一个采样循环，并使用调度器（scheduler）更快地生成样本
+- 在新数据集上微调一个现有的扩散模型，这包括：
+ - 使用累积梯度的方法去应对训练的 batch 太小所带来的一些问题
+ - 在训练过程中，将样本上传到 [Weights and Biases](https://wandb.ai/site) 来记录日志，以此来监控训练过程（通过附加的实例脚本程序）
+ - 将最终结果管线（pipeline）保存下来，并上传到Hub
+- 通过新加的损失函数来引导采样过程，以此对现有模型施加控制，这包括：
+ - 通过一个简单的基于颜色的损失来探索不同的引导方法
+ - 使用 CLIP，用文本来引导生成过程
+ - 用 Gradio 和 🤗 Spaces 来分享你的定制的采样循环
+
+❓如果你有问题，请在 Hugging Face Discord 的 `#diffusion-models-class` 频道提出。如果你还没有 Hugging Face 的账号，你可以在这里注册：https://huggingface.co/join/discord
+
+## 配置过程和需要引入的库
+
+为了将你的微调过的模型保存到 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"
+)
+```
+
+## 载入一个预训练过的管线
+
+在本节笔记本的开始，我们先载入一个现有的管线，来看看我们能用它做些什么：
+
+
+
+```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：** 微调这个过程可能是难以预知的。如果我们训练很长时间，我们也许能看见一些生成得很完美的蝴蝶，但中间过程从模型自身讲也极其有趣，尤其是你对艺术风格感兴趣时！你可以试试短时间或长时间地观察一下训练过程，并试着该百年学习率，看看这会怎么影响模型的最终输出。
+
+### 代码：用我们在WikiArt上面使用最小化样例脚本去微调一个模型
+
+如果你想训练一个和我在 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'
+```
+
+### 保存和载入微调过的管线
+
+现在我们已经微调好了我们扩散模型中的 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中：
+
+
+```python
+# @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
+---
+
+# Example Fine-Tuned Model for Unit 2 of the [Diffusion Models Class 🧨](https://github.com/huggingface/diffusion-models-class)
+
+{description}
+
+## Usage
+
+```python
+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)
+```
+
+
+
+
+ 'https://huggingface.co/lewtun/ddpm-celebahq-finetuned-butterflies-2epochs/blob/main/README.md'
+
+
+
+祝贺！你现在微调完了你的第一个扩散模型！
+
+剩下的部分我将使用一个从[这个在 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 惊人的能力，我们可以给一个没有条件约束的扩散模型加上文本级的控制 🎨
+
+## 把自定义的采样训练做成 Gradio 上的展示来分享
+
+也许你现在已经想出了一个很好玩的损失函数去引导生成过程，现在你想把你的微调模型和自定义的采样策略分享给全世界......
+
+点击这里了解 [Gradio](https://gradio.app/)。Gradio 是一个免费的开源工具，让用户可以方便地通过一个简单的网页界面来创建和分享交互式的机器学习模型。使用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 上告诉我们，看我们能不能提供点帮助。
+
+## 总结和下一步的工作
+
+本节笔记本涵盖了好多内容啊！让我们回顾一下核心要点：
+- 载入一个现有模型并用不同的调度器（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
+
+我们期待在 Discord、Twitter 或其它地方看到你的作品！🤗
+
+
+```python
+
+```
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_1.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..c228a19e2a0f7c91c38e05b24bd148c42551e3e2
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4dcdabf9d36dea189f287d9fcf89d6f0ec610d11ffecbddabf8e53ac731a0fbf
+size 270845
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_2.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..a58e89bfd76d2ecb6e90e67779cddcac50c00c0c
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ff0d9e4f3ab0f7dda7364bcc13e80623932508af68a9e690f7e5de8297262b3
+size 242990
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_3.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_3.png
new file mode 100644
index 0000000000000000000000000000000000000000..b7275d5a242335efded008cc714c7b239027b2c8
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_3.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0333f5898afdad1a280462a2aa149160bf0572b1617d6de597bcf3ab55c3b72d
+size 239058
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_4.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_4.png
new file mode 100644
index 0000000000000000000000000000000000000000..30cda52503227fc662f4a51d07ae36e6d409cfac
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_4.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:577cf30a7704bb7b363eefbbd9c9f50e64d5f03bad73e8365e8c25f38cd01769
+size 233565
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_5.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_5.png
new file mode 100644
index 0000000000000000000000000000000000000000..d296ccfb032d1a946bdcc70e817493f03dd0926d
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_17_5.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f29b2d4140b7b45e4981e7c94aff18f9f048108046f8e22cbfb6ebb4e70f576
+size 104020
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_21_1.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_21_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..8a37ed5cd63520b727255f3b9c4f69ab86d3ae4f
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_21_1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d449820a0486e1f994899e3ba14082c63c4668e29e57f8111f440161a02eefe4
+size 87803
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_25_2.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_25_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..65e7bbb13082149992daef20bf912de492e06fae
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_25_2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb0823471f82961aa59c6b38c91d0fdc6310e7cf72fc370ba5490a2e4043d905
+size 109317
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_28_5.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_28_5.png
new file mode 100644
index 0000000000000000000000000000000000000000..75944bfcb04f9790651bd4e7f64d2ce50e524a2c
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_28_5.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcddc476caaa7391ccef6e9080dd198b56edee8de438c9225f2b5e0b0168f274
+size 40066
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_36_1.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_36_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..3a9bc84ed414f72e315a7310869f7ca7998842ae
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_36_1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3f81400d08e6ea2ccfcee780e90bc105a3cd30f09129fd6e97a02c1f70ae53d
+size 268774
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_48_6.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_48_6.png
new file mode 100644
index 0000000000000000000000000000000000000000..2374cd014b58570a423d0cbb1fc58218367310d5
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_48_6.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:366a73b8a8f0e3f37df3f493ea38e3622f237679f05c0922ed9f86aa2163e204
+size 196243
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_54_2.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_54_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..b3d2f97572d9ecdeb3ff385247bd9a55388c3272
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_54_2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:750fd94a9f78e7b3949f2cc7c2a8ee7469756d7fa5338429f5ee806e8142ea7a
+size 862827
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_56_2.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_56_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..28860f663a19a5a76bd9461771d30a2da2e4277c
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_56_2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8031c0e6d6d93c7e8858789d201792c579aa0131b05123ae1641de6db844238a
+size 284275
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_62_2.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_62_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..7cd55104bbaf2b2233eaba123a8af239b5a83474
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_62_2.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96c4fadae520fd3dfb28201758051ac414b86ab98ab215f2a0d48825ce3f4420
+size 478928
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_65_0.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_65_0.png
new file mode 100644
index 0000000000000000000000000000000000000000..8bc9df1e832472775c3bf0bcfaebc9fa795203e4
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_65_0.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aad9f24954016b1d845dfde5bab7dcabdd14a4b98db0b6b578f4fc6144fefb09
+size 42367
diff --git a/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_9_1.png b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_9_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..628be09542390cbf7f25defeba276f8a1fb5e51e
--- /dev/null
+++ b/markdown/unit2/01_finetuning_and_guidance_CN_files/01_finetuning_and_guidance_CN_9_1.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:598a81891988e5df696b096350f4bd9e8c66474af172ad947ff24399adfc0537
+size 82947
diff --git a/markdown/unit2/02_class_conditioned_diffusion_model_example_CN.md b/markdown/unit2/02_class_conditioned_diffusion_model_example_CN.md
new file mode 100644
index 0000000000000000000000000000000000000000..7c048b56d3e6fe16a89f762be8367ee61205329a
--- /dev/null
+++ b/markdown/unit2/02_class_conditioned_diffusion_model_example_CN.md
@@ -0,0 +1,360 @@
+# 创建一个类别条件扩散模型
+
+在这节笔记本中，我们将阐述一种给扩散模型加条件信息的方法。具体来说，我们将接着[这个从头训练的例子](../unit1/02_diffusion_models_from_scratch_CN.ipynb)在 MNIST 上训练一个以类别为条件的扩散模型。这里我们可以在推理时指定我们要生成的是哪个数字。
+
+就像本单元介绍中说的那样，这只是很多给扩散模型添加额外条件信息的方法中的一种，这里用它做示例是因为它比较简单。就像第一单元中“从走训练”的例子一样，这节笔记本也是为了解释说明的目的。如果你想，你也可以安全地跳过本节。
+
+## 配置和数据准备
+
+
+```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]
+
+
+
+
+
+
+_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 中的解码器解码到高分辨率图片上来查看最终结果。这一创新点极大地降低了训练和运行这些模型的成本。
+
+## 以文本为生成条件
+
+在第二单元，我们展示了如何将额外信息输入到 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 的每一层都由充足的机会去利用这些条件信息！
+
+## 无分类器的引导
+
+然而很多时候，即使我们付出了很多努力尽可能让文本成为生成的条件，但模型仍然会在预测时大量地基于带噪输入图片，而不是文字。在某种程度上，这其实是可以解释得通的 —— 很多说明文字和与之关联的图片相关性很弱，所以模型就学着不去过度依赖文字描述！可是这并不是我们期望的效果。如果模型不遵从文本提示，那么我们很可能得到与我们描述根本不相关的图片。
+
+
+_由描述 "An oil painting of a collie in a top hat" 生成的图片（从左到右的 CFG scale 分别是 0、1、2、10)_
+
+为了解决这一问题，我们使用了一个小技巧，叫做无分类器的引导（Classifie-free Guidance，CGF）。在训练时，我们时不时把文字条件置空，强迫模型去学着在无文字信息的情况下对图片去噪（无条件生成）。在推理阶段，我们分别做两个预测：一个有文字条件，一个没有。我们可以用这两者的差异来建立一个最终结合版的预测，让最终结果在文本条件预测所指明的方向上依据一个缩放系数（即引导尺度）去“走得更远”，希望最终生成一个更好地匹配文字提示的结果。上图就展示了在同一个文本提示下使用不同引导尺度得到的不同结果。可以看到，更高的引导尺度能让生成的图片更接近文字描述。
+
+## 其它类型的条件生成：超分辨率、图像修补、深度图到图像的转换
+
+我们也可以创建各种接收不同生成条件的 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的方式重新生成一下：掩膜外的区域要和原图片保持一致，掩膜内的区域要生成出新的内容。
+
+## 使用 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)来获取些参考，让模型尽可能地起作用。
+
+## 用来上手的笔记本示例
+
+| Chapter | Colab | Kaggle | Gradient | Studio Lab |
+|:--------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Stable Diffusion Introduction | [](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit3/01_stable_diffusion_introduction.ipynb) | [](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit3/01_stable_diffusion_introduction.ipynb) | [](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/unit3/01_stable_diffusion_introduction.ipynb) | [](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/unit3/01_stable_diffusion_introduction.ipynb) |
+| DreamBooth Hackathon Notebook | [](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb) | [](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb) | [](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb) | [](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb) |
+| Stable Diffusion Deep Dive | [](https://colab.research.google.com/github/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb ) | [](https://kaggle.com/kernels/welcome?src=https://github.com/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb ) | [](https://console.paperspace.com/github/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb ) | [](https://studiolab.sagemaker.aws/import/github/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb ) |
+
+至此，你已经准备好学习相关笔记本了！通过上面的链接使用你选择的平台打开它们！DreamBooth 需要的算力比较多，所以如果你是用的 Kaggle 或 Google Colab，那请确保将运行时模式设为 GPU 来获得最好效果。
+
+Stable Diffusion Introduction 这节笔记本是使用🤗 Diffusers 库对 Stable Diffusion 所作的一个简短介绍，包含了一些基本的使用管线生成和修改图片的示例。
+
+在 DreamBooth Hackathon 这节笔记本(在 [hackathon 文件夹里](../hackathon))中，我们展示了如何使用你自己的图片微调 SD，来获取一个涵盖新的风格或内容的自定义版本模型。
+
+最后，在 Stable Diffusion Deep Dive 笔记本中和视频中，我们分解了一个典型的生成管线中的每一个步骤，并提出了一些新奇的方法去对每一步进行修改，来有创造性地控制生成。
+
+## 项目时间
+
+仿照 **DreamBooth** 笔记本中的指导，针对某个特定种类的数据训练你自己的模型。请确保在提交时加入一些输出的例子，以便我们为不同的种类数据选出最好的模型！请查阅 [hackathon 信息](../hackathon)，进一步了解关于奖项、GPU额度等信息。
+
+## 一些其它学习资源
+
+- [High-Resolution Image Synthesis with Latent Diffusion Models](http://arxiv.org/abs/2112.10752) - 这篇论文介绍了 Stable Diffusion 背后的方法
+
+- [CLIP](https://openai.com/blog/clip/) - CLIP 学习着去将文字和图片联系起来，CLIP 文本编码器被用来将文本提示转化为 SD 使用的信息量丰富的数值表征形式。也可查阅 [这篇关于 OpenCLIP 的文献](https://wandb.ai/johnowhitaker/openclip-benchmarking/reports/Exploring-OpenCLIP--VmlldzoyOTIzNzIz)，了解最近的一些 CLIP 开源版本（其中一个被用于第二版 SD 模型）。
+
+- [GLIDE: Towards Photorealistic Image Generation and Editing with Text-Guided Diffusion Models](https://arxiv.org/abs/2112.10741) 是一篇较早的论文，介绍了把文本作为生成条件以及 CFG 相关内容。
+
+如果你找到了更好的学习资源，也别忘了告诉我们让我们加到这个列表里！
diff --git a/markdown/unit3/cfg_example_0_1_2_10.jpeg b/markdown/unit3/cfg_example_0_1_2_10.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..b685f6157517a933e19755425d207fc6dea72a35
--- /dev/null
+++ b/markdown/unit3/cfg_example_0_1_2_10.jpeg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5d9636a1381fe0e9570774ddda7a88d23fe01c52fa4ae563850686efc84a685
+size 204059
diff --git a/markdown/unit3/sd_demo_images.jpg b/markdown/unit3/sd_demo_images.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5f2770e21c196774cb52ab55d5dfee2bf9721bd6
--- /dev/null
+++ b/markdown/unit3/sd_demo_images.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfd6aca118d829e505cfb60167f6020c5e9680690bd747b50e38350b8377d6a8
+size 227696
diff --git a/markdown/unit3/sd_unet_color.png b/markdown/unit3/sd_unet_color.png
new file mode 100644
index 0000000000000000000000000000000000000000..4ac89f297f2b9a6c90933a84db65d6d3380387fa
--- /dev/null
+++ b/markdown/unit3/sd_unet_color.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a66f5943946a88a8e39ac686fb7d4d7d13acd740b2f8f146c7f1e01dec340a7
+size 190494
diff --git a/markdown/unit3/text_encoder_noborder.png b/markdown/unit3/text_encoder_noborder.png
new file mode 100644
index 0000000000000000000000000000000000000000..9c534a526fc61c0aafc0ded3eefb3d18365d5edb
--- /dev/null
+++ b/markdown/unit3/text_encoder_noborder.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:befb00d52c33291fb23739e1214ab4977a1b6476d56b199b13a1e310997f6a0f
+size 55584
diff --git a/markdown/unit4/01_ddim_inversion_CN.md b/markdown/unit4/01_ddim_inversion_CN.md
new file mode 100644
index 0000000000000000000000000000000000000000..9802309d168520a4e7c6fb7b39dc6937e922a49d
--- /dev/null
+++ b/markdown/unit4/01_ddim_inversion_CN.md
@@ -0,0 +1,570 @@
+# DDIM反转
+
+在此篇笔记我们会来探索**反转**，看看它是如何影响取样的，并把它应用到扩散模型的编辑图像功能中去。
+
+## 你将会学到什么
+
+- DDIM采样是怎么工作的
+- 确定性vs随机性取样器
+- DDIM反转的理论支撑
+- 使用反转来编辑图像
+
+我们开始吧！
+
+## 设置
+
+
+```python
+# !pip install -q transformers diffusers accelerate
+```
+
+
+```python
+import torch
+import requests
+import torch.nn as nn
+import torch.nn.functional as F
+from PIL import Image
+from io import BytesIO
+from tqdm.auto import tqdm
+from matplotlib import pyplot as plt
+from torchvision import transforms as tfms
+from diffusers import StableDiffusionPipeline, DDIMScheduler
+
+# Useful function for later
+def load_image(url, size=None):
+ response = requests.get(url,timeout=0.2)
+ img = Image.open(BytesIO(response.content)).convert('RGB')
+ if size is not None:
+ img = img.resize(size)
+ return img
+```
+
+
+```python
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+```
+
+## 加载一个已训练的pipeline
+
+
+```python
+# Load a pipeline
+pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5").to(device)
+```
+
+
+```python
+# Set up a DDIM scheduler:
+pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
+```
+
+
+```python
+# Sample an image to make sure it is all working
+prompt = 'Beautiful DSLR Photograph of a penguin on the beach, golden hour'
+negative_prompt = 'blurry, ugly, stock photo'
+im = pipe(prompt, negative_prompt=negative_prompt).images[0]
+im.resize((256, 256)) # resize for convenient viewing
+```
+
+## DDIM取样过程
+
+在给定时间 $t$, 带噪图像 $x_t$ 是原始图像（$x_0$）与一些噪声 ($\epsilon$)的叠加。这是在DDIM论文中$x_t$的定义式，我们把它引用到此节里：
+
+$$ x_t = \sqrt{\alpha_t}x_0 + \sqrt{1-\alpha_t}\epsilon $$
+
+$\epsilon$ 是一些归一方差的高斯噪声
+$\alpha_t$ ('alpha')在DDPM论文中也被叫做$\bar{\alpha}$ ('alpha_bar')，被用来定义噪声调度器（scheduler）。在扩散模型中，alpha调度器是被计算出来并排序存储在`scheduler.alphas_cumprod`中。这令人费解，我理解！我们把这些值画出来，然后在下文中我们会使用DDIM的标注方式。
+
+
+```python
+# Plot 'alpha' (alpha_bar in DDPM language, alphas_cumprod in diffusers for clarity)
+timesteps = pipe.scheduler.timesteps.cpu()
+alphas = pipe.scheduler.alphas_cumprod[timesteps]
+plt.plot(timesteps, alphas, label='alpha_t');
+plt.legend();
+```
+
+最初（timestep 0 ，图中左侧）是从一个无噪的干净图像开始，$\alpha_t = 1$。当我们到达更高的timesteps，我们得到一个几乎全是噪声的图像，$\alpha_t$也几乎下降到0。
+
+在采样过程，我们从timestep1000的纯噪声开始，慢慢地向timestep0前进。为了计算采样轨迹中的下一时刻($x_{t-1}$因为我们是从后向前移动)的值，我们预测噪声($\epsilon_\theta(x_t)$，这就是我们模型的输出），用它来预测出无噪的图片$x_0$。在这之后我们用这个预测结果朝着'$x_t$的方向'方向移动一小步。最终，我们可以加一些带$\sigma_t$系数的额外噪声。这是论文中与上述操作相关的章节内容：
+
+
+
+好，我们有了在可控量度噪声下，从$x_t$ 移动到 $x_{t-1}$的公式。今天我们所说案例是不需要再额外添加噪声的 - 即完全确定的DDIM采样。我们来看看这些是如何用代码表达的。
+
+
+```python
+# Sample function (regular DDIM)
+@torch.no_grad()
+def sample(prompt, start_step=0, start_latents=None,
+ guidance_scale=3.5, num_inference_steps=30,
+ num_images_per_prompt=1, do_classifier_free_guidance=True,
+ negative_prompt='', device=device):
+
+ # Encode prompt
+ text_embeddings = pipe._encode_prompt(
+ prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt
+ )
+
+ # Set num inference steps
+ pipe.scheduler.set_timesteps(num_inference_steps, device=device)
+
+ # Create a random starting point if we don't have one already
+ if start_latents is None:
+ start_latents = torch.randn(1, 4, 64, 64, device=device)
+ start_latents *= pipe.scheduler.init_noise_sigma
+
+ latents = start_latents.clone()
+
+ for i in tqdm(range(start_step, num_inference_steps)):
+
+ t = pipe.scheduler.timesteps[i]
+
+ # expand the latents if we are doing classifier free guidance
+ latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
+ latent_model_input = pipe.scheduler.scale_model_input(latent_model_input, t)
+
+ # predict the noise residual
+ noise_pred = pipe.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+
+ # perform guidance
+ if do_classifier_free_guidance:
+ noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+ noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+
+
+ # Normally we'd rely on the scheduler to handle the update step:
+ # latents = pipe.scheduler.step(noise_pred, t, latents).prev_sample
+
+ # Instead, let's do it ourselves:
+ prev_t = max(1, t.item() - (1000//num_inference_steps)) # t-1
+ alpha_t = pipe.scheduler.alphas_cumprod[t.item()]
+ alpha_t_prev = pipe.scheduler.alphas_cumprod[prev_t]
+ predicted_x0 = (latents - (1-alpha_t).sqrt()*noise_pred) / alpha_t.sqrt()
+ direction_pointing_to_xt = (1-alpha_t_prev).sqrt()*noise_pred
+ latents = alpha_t_prev.sqrt()*predicted_x0 + direction_pointing_to_xt
+
+ # Post-processing
+ images = pipe.decode_latents(latents)
+ images = pipe.numpy_to_pil(images)
+
+ return images
+```
+
+
+```python
+# Test our sampling function by generating an image
+sample('Watercolor painting of a beach sunset', negative_prompt=negative_prompt, num_inference_steps=50)[0].resize((256, 256))
+```
+
+看看你是否能把这些代码和论文中的公式对应起来。注意$\sigma$=0是因为我们只注意 无-额外-噪声 的场景，所以我们略去了公式中的那部分。
+
+## 反转
+
+反转的目标就是'颠倒'取样的过程。我们想最终得到一个带噪的隐式（latent），如果把它作为我们正常取样过程的起始点，结果将生成一副原图像。
+
+这里我们先加载一个原始图像，当然你也可以生成一副图像来代替。
+
+
+```python
+# https://www.pexels.com/photo/a-beagle-on-green-grass-field-8306128/
+input_image = load_image('https://images.pexels.com/photos/8306128/pexels-photo-8306128.jpeg', size=(512, 512))
+input_image
+```
+
+我们可以用包含随意分类指引（classifier-free-guidance）的prompt来做反转操作，输入一个图片的描述：
+
+
+```python
+input_image_prompt = "Photograph of a puppy on the grass"
+```
+
+接下来我们来把这个PIL图像变成一些列隐式，它们会被用来当作反转的起点：
+
+
+```python
+# encode with VAE
+with torch.no_grad(): latent = pipe.vae.encode(tfms.functional.to_tensor(input_image).unsqueeze(0).to(device)*2-1)
+l = 0.18215 * latent.latent_dist.sample()
+```
+
+好了，到有趣的部分了。这个函数看起来和上面的取样函数很像，但我们在timesteps上是在向相反的方向移动，从t=0开始，向越来越多的噪声前进。代替更新隐式时噪声会越来越少，我们估计所预测出的噪声，用它来撤回一步更新操作，把它们从t移动到t+1。
+
+
+```python
+## Inversion
+@torch.no_grad()
+def invert(start_latents, prompt, guidance_scale=3.5, num_inference_steps=80,
+ num_images_per_prompt=1, do_classifier_free_guidance=True,
+ negative_prompt='', device=device):
+
+ # Encode prompt
+ text_embeddings = pipe._encode_prompt(
+ prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt
+ )
+
+ # latents are now the specified start latents
+ latents = start_latents.clone()
+
+ # We'll keep a list of the inverted latents as the process goes on
+ intermediate_latents = []
+
+ # Set num inference steps
+ pipe.scheduler.set_timesteps(num_inference_steps, device=device)
+
+ # Reversed timesteps <<<<<<<<<<<<<<<<<<<<
+ timesteps = reversed(pipe.scheduler.timesteps)
+
+ for i in tqdm(range(1, num_inference_steps), total=num_inference_steps-1):
+
+ # We'll skip the final iteration
+ if i >= num_inference_steps - 1: continue
+
+ t = timesteps[i]
+
+ # expand the latents if we are doing classifier free guidance
+ latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
+ latent_model_input = pipe.scheduler.scale_model_input(latent_model_input, t)
+
+ # predict the noise residual
+ noise_pred = pipe.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
+
+ # perform guidance
+ if do_classifier_free_guidance:
+ noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+ noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+
+ current_t = max(0, t.item() - (1000//num_inference_steps))#t
+ next_t = t # min(999, t.item() + (1000//num_inference_steps)) # t+1
+ alpha_t = pipe.scheduler.alphas_cumprod[current_t]
+ alpha_t_next = pipe.scheduler.alphas_cumprod[next_t]
+
+ # Inverted update step (re-arranging the update step to get x(t) (new latents) as a function of x(t-1) (current latents)
+ latents = (latents - (1-alpha_t).sqrt()*noise_pred)*(alpha_t_next.sqrt()/alpha_t.sqrt()) + (1-alpha_t_next).sqrt()*noise_pred
+
+
+ # Store
+ intermediate_latents.append(latents)
+
+ return torch.cat(intermediate_latents)
+
+```
+
+把它在小狗图片的隐式表达上运行，我们可以在反转的中间过程得到一系列的隐式：
+
+
+```python
+inverted_latents = invert(l, input_image_prompt,num_inference_steps=50)
+inverted_latents.shape
+```
+
+
+ 0%| | 0/49 [00:00
+