关于人工智能:中文版扩散模型课程第一单元

于 11 月底正式开课的扩散模型课程正在炽热进行中，在中国社区成员们的帮忙下，咱们组织了「抱抱脸中文本地化志愿者小组」并实现了扩散模型课程的中文翻译，感激 @darcula1993、@XhrLeokk、@hoi2022、@SuSung-boy 对课程的翻译！

第一单元：扩散模型简介

欢送来到 Hugging Face 扩散模型课程第一单元！在本单元中，你将学习无关扩散模型如何工作的基础知识，以及如何应用 🤗 diffusers 库。

什么是扩散模型？

扩散模型是「生成模型」算法家族的新成员通过学习给定的训练样本，生成模型能够学会如何 生成 数据，比方生成图片或者声音。一个好的生成模型能生成一组 款式不同 的输入。这些输入会与训练数据类似，但不是截然不同的正本。扩散模型如何实现这一点？为了便于阐明，让咱们先看看图像生成的案例。

图片起源: DDPM paper (https://arxiv.org/abs/2006.11239)

扩散模型胜利的秘诀在于扩散过程的迭代实质。最先生成的只是一组随机噪声，但通过若干步骤逐步改善，有意义的图像将最终会呈现。在每一步中，模型都会预计如何从以后的输出生成齐全去噪的后果。因为咱们在每一步都只做了一个小小的变动，所以在晚期阶段（预测最终输入实际上十分艰难），这个预计中的任何 error 都能够在当前的更新中失去纠正。

与其余类型的生成模型相比，训练扩散模型绝对较为容易。咱们只须要反复以下步骤即可：

1. 从训练数据中加载一些图像
2. 增加不同级别的噪声。请记住，咱们心愿模型在面对增加了极其噪声和简直没有增加噪声的带噪图像时，都可能很好地预计如何「修复」(去噪)。
3. 将带噪输出送入模型中
4. 评估模型对这些输出进行去噪的成果
5. 应用此信息更新模型权重

为了用训练好的模型生成新的图像，咱们从齐全随机的输出开始，重复将其输出模型，每次依据模型预测进行大量更新。咱们之后会学到有许多采样办法试图简化这个过程，以便咱们能够用尽可能少的步骤生成好的图像。

咱们将在第一单元的实际笔记本中具体介绍这些步骤。在第二单元中，咱们将理解如何批改此过程，来通过额定的条件（例如类标签）或应用领导等技术来减少对模型输入的额定管制。第三单元和第四单元将摸索一种十分弱小的扩散模型，称为稳固扩散 (stable diffusion)，它能够生成给定文本形容的图像。

实际笔记本

到这里，您曾经足够理解如何开始应用附带的笔记本了！这里的两个笔记本以不同的形式表白了雷同的想法。

在 Diffuser 介绍 这个 Notebook 中，咱们应用 diffusers 库中的结构模块显示了与上述不同的步骤。你将很快看到如何依据您抉择的任何数据创立、训练和采样您本人的扩散模型。在笔记本完结时，您将可能浏览和批改示例训练脚本，以训练扩散模型，并将其与全世界独特分享！本笔记本还介绍了与本单元相干的次要练习，在这里，咱们将独特尝试为不同规模的扩散模型找出好的「训练脚本」—— 请参阅下一节理解更多信息。

在 扩散模型从零到一 这个 Notebook 中，咱们展现了雷同的步骤（向数据增加噪声、创立模型、训练和采样），并尽可能简略地在 PyTorch 中从头开始实现。而后，咱们将这个「玩具示例」与 diffusers 版本进行比拟，并关注两者的区别以及改良之处。这里的指标是相熟不同的组件和其中的设计决策，以便在查看新的实现时可能疾速确定要害思维。咱们也会在接下来的推送中公布这个 Notebook 的内容。

实际和分享

当初，你曾经把握了基本知识，能够开始训练你本人的扩散模型了！Diffuser 介绍 笔记本的开端有一些小提示，心愿您能与社区分享您的成绩、训练脚本和发现，以便咱们可能一起找出训练这些模型的最佳办法。

一些额定的资料

• 《Hugging Face 博客: 带正文的扩散模型》是对 DDPM 背地的代码和实践的十分深刻的介绍，其中包含数学和显示了所有不同的组件的代码。它还链接了 一些论文 供进一步浏览
• Hugging Face 文档: 无条件图像生成 (Unconditional Image-Generation)，蕴含了无关如何应用官网训练示例脚本训练扩散模型的一些示例，包含演示 如何创立本人的数据集的代码：
• AI Coffee Break video on Diffusion Models
• Yannic Kilcher Video on DDPMs
• • *

Diffuser 介绍 Notebook

在这个 Notebook 里，你将训练你的第一个扩散模型来 生成漂亮的蝴蝶的图片 🦋。在此过程中，你将理解 🤗 Diffuers 库，它将为咱们稍后将在课程中介绍的更高级的应用程序提供良好的根底

让咱们开始吧！

你将学习到

• 看到一个弱小的自定义扩散模型管道 (并理解到如何制作一个本人的版本)
• 通过以下形式创立你本人的迷你管道:
• 回顾扩散模型背地的核心思想
• 从 Hub 中加载数据进行训练
• 摸索如何应用 scheduler 将噪声增加到数据中
• 创立和训练一个 UNet 模型
• 将各个组件拼装在一起来造成一个工作管道 (working pipelines)
• 编辑并运行一个脚本，用于初始化一个较长的训练，该脚本将解决
• 应用 Accelerate 来进行多 GPU 减速训练
• 试验日志记录以跟踪要害统计数据
• 将最终的模型上传到 Hugging Face Hub

❓如果你有任何问题，请公布在 Hugging Face 的 Discord 服务器 #diffusion-models-class 频道中。你能够 点击这里 实现注册。

准备常识

在进入 Notebook 之前，你须要:

• 📖 浏览完下面的的资料
• 🤗 在 Hugging Face Hub 上创立一个账户。你能够 点击这里 实现注册

步骤 1: 设置

运行以下单元以装置 diffusers 库以及一些其余要求：

%pip install -qq -U diffusers datasets transformers accelerate ftfy pyarrow

接下来，请返回 https://huggingface.co/settings/tokens 创立具备写权限的拜访令牌：

你能够应用命令行来通过此令牌登录 (huggingface-cli login) 或者运行以下单元来登录：

from huggingface_hub import notebook_login
notebook_login()

Login successful
Your token has been saved to /root/.huggingface/token

而后你须要装置 Git LFS 来上传模型检查点：

%%capture
!sudo apt -qq install git-lfs
!git config --global credential.helper store

最初，让咱们导入将要应用的库，并定义一些不便函数，稍后咱们将会在 Notebook 中应用这些函数：

import numpy as np
import torch
import torch.nn.functional as F
from matplotlib import pyplot as plt
from PIL import Image


def show_images (x):
   """Given a batch of images x, make a grid and convert to PIL"""
   x = x * 0.5 + 0.5  # Map from (-1, 1) back to (0, 1)
   grid = torchvision.utils.make_grid(x)
   grid_im = grid.detach().cpu().permute (1, 2, 0).clip (0, 1) * 255
   grid_im = Image.fromarray(np.array (grid_im).astype (np.uint8))
   return grid_im


def make_grid(images, size=64):
   """Given a list of PIL images, stack them together into a line for easy viewing"""
   output_im = Image.new("RGB", (size * len (images), size))
   for i, im in enumerate(images):
      output_im.paste(im.resize((size, size)), (i * size, 0))
   return output_im


# Mac users may need device = 'mps' (untested)
device = torch.device("cuda" if torch.cuda.is_available () else "cpu")

好了，咱们都筹备好了！

Dreambooth：行将到来的巅峰

如果你在过来几个月里看过人工智能相干的社交媒体，你就会据说过 Stable Diffusion 模型。这是一个弱小的文本条件隐式扩散模型（别放心，咱们将会学习这些概念）。但它有一个毛病：它不晓得你或我长什么样，除非咱们足够闻名以至于互联网上公布咱们的照片。

Dreambooth 容许咱们创立本人的模型变体，并对特定的面部、对象或款式有一些额定的理解。Corridor Crew 制作了一段杰出的视频，用统一的工作形象来讲故事，这是一个很好的阐明了这种技术的能力的例子：

from IPython.display import YouTubeVideo
YouTubeVideo("W4Mcuh38wyM")

这是一个应用了一个名为「Mr Potato Head」的模型作为例子。该模型的训练应用了 5 张驰名的儿童玩具 “Mr Potato Head” 的照片。模型地址: https://hf.co/sd-dreambooth-library/mr-potato-head

首先，让咱们来加载这个管道。这些代码会主动从 Hub 下载模型权重等须要的文件。因为这个只有一行的 demo 须要下载数 GB 的数据，因而你能够跳过此单元格，只需观赏样例输入即可！

from diffusers import StableDiffusionPipeline

# Check out https://hf.co/sd-dreambooth-library for loads of models from the community
model_id = "sd-dreambooth-library/mr-potato-head"

# Load the pipeline
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to (device)

Fetching 15 files:   0%|          | 0/15 [00:00<?, ?it/s]

管道加载实现后，咱们能够应用以下命令生成图像：

prompt = "an abstract oil painting of sks mr potato head by picasso"
image = pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0]
image

练习: 你能够应用不同的提醒 (prompt) 自行尝试。在这个 demo 中，sks 是一个新概念的惟一标识符 (UID) – 那么如果把它留空的话会产生什么事呢？你还能够尝试扭转 num_inference_steps 和 guidance_scale。这两个参数别离代表了采样步骤的数量（试试最多能够设为多低？）和模型将花多大的致力来尝试匹配提醒。

这条神奇的管道里有很多事件！课程完结时，你将晓得这所有是如何运作的。当初，让咱们看看如何从头开始训练扩散模型。

MVP (最简可履行管道)

🤗 Diffusers 的外围 API 被分为三个次要局部:

1. 管道: 从高层登程设计的多品种函数，旨在以易部署的形式，可能做到疾速通过支流预训练好的扩散模型来生成样本。
2. 模型 : 训练新的扩散模型时用到的支流网络架构， 举个例子 UNet: https://arxiv.org/abs/1505.04597
3. 管理器 (or 调度器): 在 推理 中应用多种不同的技巧来从噪声中生成图像，同时也能够生成在 训练 中所需的带噪图像。

管道对于末端使用者来说曾经十分棒，但你既然曾经加入了这门课程，咱们就索性认为你想理解更多其中的神秘！在此篇笔记完结之后，咱们会来构建属于你本人，可能生成小蝴蝶图片的管道。上面这里会是最终的后果：

from diffusers import DDPMPipeline

# Load the butterfly pipeline
butterfly_pipeline = DDPMPipeline.from_pretrained("johnowhitaker/ddpm-butterflies-32px").to (device)

# Create 8 images
images = butterfly_pipeline(batch_size=8).images

# View the result
make_grid(images)

兴许这看起来并不如 DreamBooth 所展现的样例那样惊艳，但要晓得咱们在训练这些图画时只用了不到训练稳固扩散模型用到数据的 0.0001%。说到模型训练，从引入介绍直到本单元，训练一个扩散模型的流程看起来像是这样：

1. 从训练集中加载一些图像
2. 退出噪声，从不同水平上
3. 把带了不同版本噪声的数据送进模型
4. 评估模型在对这些数据做加强去噪时的体现
5. 应用这个信息来更新模型权重，而后反复此步骤

咱们会在接下来几节中逐个实现这些步骤，直至训练循环能够残缺的运行，在这之后咱们会来摸索如何应用训练好的模型来生成样本，还有如何封装模型到管道中来轻松的分享给他人，上面咱们来从数据动手吧。

步骤 2：下载一个训练数据集

在这个例子中，咱们会用到一个来自 Hugging Face Hub 的 图像集。具体来说，是个 1000 张蝴蝶图像珍藏集。这是个十分小的数据集，咱们这里也同时蕴含了已被正文的内容指向一些规模更大的抉择。如果你想应用你本人的图像珍藏，你也能够应用这里被正文掉的示例代码，从一个指定的文件夹来装载图片。

import torchvision
from datasets import load_dataset
from torchvision import transforms

dataset = load_dataset("huggan/smithsonian_butterflies_subset", split="train")

# We'll train on 32-pixel square images, but you can try larger sizes too
image_size = 32
# You can lower your batch size if you're running out of GPU memory
batch_size = 64

# Define data augmentations
preprocess = transforms.Compose (
   [transforms.Resize((image_size, image_size)),  # Resize
      transforms.RandomHorizontalFlip(),  # Randomly flip (data augmentation)
      transforms.ToTensor(),  # Convert to tensor (0, 1)
      transforms.Normalize([0.5], [0.5]),  # Map to (-1, 1)
   ]
)


def transform(examples):
   images = [preprocess(image.convert("RGB")) for image in examples["image"]]
   return {"images": images}


dataset.set_transform(transform)

# Create a dataloader from the dataset to serve up the transformed images in batches
train_dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)

咱们能够从中取出一批图像数据来看一看他们是什么样子:

xb = next(iter(train_dataloader))["images"].to(device)[:8]
print("X shape:", xb.shape)
show_images(xb).resize((8 * 64, 64), resample=Image.NEAREST)

X shape: torch.Size([8, 3, 32, 32])

/tmp/ipykernel_4278/3975082613.py:3: DeprecationWarning: NEAREST is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.NEAREST or Dither.NONE instead.
show_images (xb).resize ((8 * 64, 64), resample=Image.NEAREST)

咱们在此篇 Notebook 中应用一个只有 32 像素的小图片集来保障训练时长是可控的。

步骤 3：定义管理器

咱们的训练打算是，取出这些输出图片而后对它们削减噪声，在这之后把带噪的图片送入模型。在推理阶段，咱们将用模型的预测值来一直迭代去除这些噪点。在 diffusers 中，这两个步骤都是由 管理器（调度器） 来解决的。

噪声管理器决定在不同的迭代周期时别离退出多少噪声。咱们能够这样创立一个管理器，是取自于训练并能取样 ‘DDPM’ 的默认配置。基于 此篇论文 Denoising Diffusion Probabalistic Models:

from diffusers import DDPMScheduler
noise_scheduler = DDPMScheduler(num_train_timesteps=1000)

DDPM 论文这样来形容一个损坏过程，为每一个「迭代周期」(timestep) 削减一点大量的噪声。设在某个迭代周期有 , 咱们能够失去它的下一个版本（比之前更多一点点噪声）:

这就是说，咱们取 , 给他一个 的系数，而后加上带有 系数的噪声。这里 是依据一些管理器来为每一个 t 设定的，来决定每一个迭代周期中增加多少噪声。当初，咱们不想把这个推演进行 500 次来失去，所以咱们用另一个公式来依据给出的 计算失去任意 t 时刻的 :

数学符号看起来总是很可怕！好在有管理器来为咱们实现这些运算。咱们能够画出 (标记为sqrt_alpha_prod) 和 (标记为sqrt_one_minus_alpha_prod) 来看一下输出 (x) 与噪声是如何在不同迭代周期中量化和叠加的:

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");

练习: 你能够摸索一下应用不同的 beta_start 时曲线是如何变动的，beta_end 与 beta_schedule 能够通过以下正文内容来批改:

# One with too little noise added:
# noise_scheduler = DDPMScheduler (num_train_timesteps=1000, beta_start=0.001, beta_end=0.004)
# The 'cosine' schedule, which may be better for small image sizes:
# noise_scheduler = DDPMScheduler (num_train_timesteps=1000, beta_schedule='squaredcos_cap_v2')

不管你抉择了哪一个管理器 (调度器)，咱们当初都能够应用 noise_scheduler.add_noise 性能来增加不同水平的噪声，就像这样：

timesteps = torch.linspace(0, 999, 8).long().to(device)
noise = torch.randn_like(xb)
noisy_xb = noise_scheduler.add_noise(xb, noise, timesteps)
print("Noisy X shape", noisy_xb.shape)
show_images (noisy_xb).resize((8 * 64, 64), resample=Image.NEAREST)

Noisy X shape torch.Size ([8, 3, 32, 32])

再来，在这里摸索应用这里不同噪声管理器和预设参数带来的成果。这个视频很好的解释了一些上述数学运算的细节，同时也是对此类概念的一个很好引入介绍。视频地址: https://www.youtube.com/watch?v=fbLgFrlTnGU

步骤 4：定义模型

当初咱们来到了外围局部：模型自身。

大多数扩散模型应用的模型构造都是一些 U-net 的变形，也是咱们在这里会用到的构造。

概括来说:

• 输出模型中的图片通过几个由 ResNetLayer 形成的层，其中每层都使图片尺寸减半。
• 之后在通过同样数量的层把图片升采样。
• 其中还有对特色在雷同地位的上、下采样层残差连贯模块。

模型一个要害特色既是，输入图片尺寸与输出图片雷同，这正是咱们这里须要的。

Diffusers 为咱们提供了一个易用的 UNet2DModel 类，用来在 PyTorch 创立所须要的构造。

咱们来应用 U-net 为咱们生成指标大小的图片吧。留神这里 down_block_types 对应下采样模块 (上图中绿色局部), 而 up_block_types 对应上采样模块 (上图中红色局部):

from diffusers import UNet2DModel

# Create a model
model = UNet2DModel(
   sample_size=image_size,  # the target image resolution
   in_channels=3,  # the number of input channels, 3 for RGB images
   out_channels=3,  # the number of output channels
   layers_per_block=2,  # how many ResNet layers to use per UNet block
   block_out_channels=(64, 128, 128, 256),  # More channels -> more parameters
   down_block_types=(
      "DownBlock2D",  # a regular ResNet downsampling block
      "DownBlock2D",
      "AttnDownBlock2D",  # a ResNet downsampling block with spatial self-attention
      "AttnDownBlock2D",
),
   up_block_types=(
      "AttnUpBlock2D",
      "AttnUpBlock2D",  # a ResNet upsampling block with spatial self-attention
      "UpBlock2D",
      "UpBlock2D",  # a regular ResNet upsampling block
   ),
)
model.to(device);

当在解决更高分辨率的输出时，你可能想用更多层的下、上采样模块，让注意力层只聚焦在最低分辨率（最底）层来缩小内存耗费。咱们在之后会探讨该如何试验来找到最实用与你手头场景的配置办法。

咱们能够通过输出一批数据和随机的迭代周期数来看输入是否与输出尺寸雷同：

with torch.no_grad():
   model_prediction = model (noisy_xb, timesteps).sample
model_prediction.shape

torch.Size ([8, 3, 32, 32])

在下一步中，咱们来看如何训练这个模型。

步骤 5：创立训练循环

终于能够训练了！上面这是 PyTorch 中经典的优化迭代循环，在这里一批一批的送入数据而后通过优化器来一步步更新模型参数 – 在这个样例中咱们应用学习率为 0.0004 的 AdamW 优化器。

对于每一批的数据，咱们要

• 随机取样几个迭代周期
• 依据预设为数据退出噪声
• 把带噪数据送入模型
• 应用 MSE 作为损失函数来比拟指标后果与模型预测后果（在这里是退出噪声的场景）
• 通过 loss.backward() 与optimizer.step()来更新模型参数

在这个过程中咱们记录 Loss 值用来后续的绘图。

NB: 这段代码大略需 10 分钟来运行 – 你也能够跳过以下两块操作间接应用预训练好的模型。供你抉择，你能够摸索下通过放大模型层中的通道数会对运行速度有多少晋升。

官网扩散模型示例训练了在更高分辨率数据集上的一个更大的模型，这也是一个极为精简训练循环的 优良示例

# Set the noise scheduler
noise_scheduler = DDPMScheduler (num_train_timesteps=1000, beta_schedule="squaredcos_cap_v2")

# Training loop
optimizer = torch.optim.AdamW(model.parameters (), lr=4e-4)

losses = []

for epoch in range(30):
   for step, batch in enumerate(train_dataloader):
      clean_images = batch["images"].to(device)
      # Sample noise to add to the images
      noise = torch.randn(clean_images.shape).to(clean_images.device)
      bs = clean_images.shape[0]

      # Sample a random timestep for each image
      timesteps = torch.randint (0, noise_scheduler.num_train_timesteps, (bs,), device=clean_images.device
      ).long()

      # Add noise to the clean images according to the noise magnitude at each timestep
      noisy_images = noise_scheduler.add_noise(clean_images, noise, timesteps)

      # Get the model prediction
      noise_pred = model(noisy_images, timesteps, return_dict=False)[0]

      # Calculate the loss
      loss = F.mse_loss(noise_pred, noise)
      loss.backward(loss)
      losses.append(loss.item())

      # Update the model parameters with the optimizer
      optimizer.step()
      optimizer.zero_grad()

   if (epoch + 1) % 5 == 0:
      loss_last_epoch = sum(losses [-len (train_dataloader) :]) /len (train_dataloader)
      print (f"Epoch:{epoch+1}, loss: {loss_last_epoch}")

Epoch:5, loss: 0.16273280512541533

Epoch:10, loss: 0.11161588924005628

Epoch:15, loss: 0.10206522420048714

Epoch:20, loss: 0.08302505919709802

Epoch:25, loss: 0.07805309211835265

Epoch:30, loss: 0.07474562455900013

绘制 loss 曲线，咱们能看到模型在一开始疾速的收敛，接下来以一个较慢的速度继续优化（咱们用左边 log 坐标轴的视图能够看的更分明）：

fig, axs = plt.subplots(1, 2, figsize=(12, 4))
axs [0].plot(losses)
axs [1].plot(np.log (losses))
plt.show()

[<matplotlib.lines.Line2D at 0x7f40fc40b7c0>]

你能够抉择运行下面的代码，也能够这样通过管道来调用模型：

# Uncomment to instead load the model I trained earlier:
# model = butterfly_pipeline.unet

步骤 6：生成图像

咱们怎么从这个模型中失去图像呢？

办法 1：建设一个管道：

from diffusers import DDPMPipeline
image_pipe = DDPMPipeline(unet=model, scheduler=noise_scheduler)

pipeline_output = image_pipe()
pipeline_output.images[0]

0%| | 0/1000 [00:00<?, ?it/s]

咱们能够在本地文件夹这样保留一个管道：

image_pipe.save_pretrained("my_pipeline")

查看文件夹的内容：

!ls my_pipeline/

model_index.json scheduler unet

这里 scheduler 与unet子文件夹中蕴含了生成图像所需的全副组件。比方，在 unet 文件中能看到模型参数 (diffusion_pytorch_model.bin) 与形容模型构造的配置文件。

!ls my_pipeline/unet/

config.json diffusion_pytorch_model.bin

以上，这些文件蕴含了从新建设一个管道的全部内容。你能够手动把它们上传到 hub 来与别人分享你制作的管道，或应用下一节的 API 办法来记录。

办法 2：写一个取样循环

如果你去查看了管道中的 forward 办法，你能够看到在运行 image_pipe() 时产生了什么：

# ??image_pipe.forward

从随机噪声开始，遍历管理器的迭代周期来看从最嘈杂直到最渺小的噪声变动，基于模型的预测一步步缩小一些噪声：

# Random starting point (8 random images):
sample = torch.randn(8, 3, 32, 32).to(device)

for i, t in enumerate(noise_scheduler.timesteps):

   # Get model pred
   with torch.no_grad():
      residual = model(sample, t).sample

   # Update sample with step
   sample = noise_scheduler.step(residual, t, sample).prev_sample

show_images(sample)

noise_scheduler.step() 函数相应做了 sample（取样）时的数学运算。其实有很多取样的办法 – 在下一个单元咱们将看到在已有模型的根底上如何换一个不同的取样器来减速图片生成，也会讲到更多从扩散模型中取样的背地原理。

步骤 7：把你的模型 Push 到 Hub

在下面的例子中咱们把管道保留在了本地。把模型 push 到 hub 上，咱们会须要建设模型和相应文件的仓库名。咱们依据你的抉择（模型 ID）来决定仓库的名字（大胆的去替换掉 model_name 吧；须要蕴含你的用户名，get_full_repo_name()会帮你做到）：

from huggingface_hub import get_full_repo_name

model_name = "sd-class-butterflies-32"
hub_model_id = get_full_repo_name(model_name)
hub_model_id

‘lewtun/sd-class-butterflies-32’

而后，在 🤗 Hub 上创立模型仓库并 push 它吧：

from huggingface_hub import HfApi, create_repo

create_repo(hub_model_id)
api = HfApi()
api.upload_folder(folder_path="my_pipeline/scheduler", path_in_repo="", repo_id=hub_model_id)
api.upload_folder(folder_path="my_pipeline/unet", path_in_repo="", repo_id=hub_model_id)
api.upload_file(
   path_or_fileobj="my_pipeline/model_index.json",
   path_in_repo="model_index.json",
   repo_id=hub_model_id,
)

‘https://huggingface.co/lewtun…’

最初一件事是创立一个超棒的模型卡，如此，咱们的蝴蝶生成器能够轻松的在 Hub 上被找到（请在形容中随便施展！）：

from huggingface_hub import ModelCard

content = f"""
---
license: mit
tags:
- pytorch
- diffusers
- unconditional-image-generation
- diffusion-models-class
---

# Model Card for Unit 1 of the [Diffusion Models Class 🧨](https://github.com/huggingface/diffusion-models-class)

This model is a diffusion model for unconditional image generation of cute 🦋.

## 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)

当初模型曾经在 Hub 上了，你能够这样从任何中央应用 DDPMPipeline 的from_pretrained()办法来下来它：

from diffusers import DDPMPipeline

image_pipe = DDPMPipeline.from_pretrained(hub_model_id)
pipeline_output = image_pipe()
pipeline_output.images[0]

Fetching 4 files: 0%| | 0/4 [00:00<?, ?it/s]
0%| | 0/1000 [00:00<?, ?it/s]

太棒了，胜利了！

应用 🤗 Accelerate 来进行大规模应用

这篇笔记是用来教学，为此我尽力保障代码的简洁与轻量化。但也因为这样，咱们也略去了一些内容你兴许在应用更多数据训练一个更大的模式时，可能所须要用到的内容，如多块 GPU 反对，进度记录和样例图片，用于反对更大 batchsize 的导数记录性能，主动上传模型等等。好在这些性能大多数在这个示例代码中蕴含 here.

你能够这样下载该文件：

!wget https://github.com/huggingface/diffusers/raw/main/examples/unconditional_image_generation/train_unconditional.py

关上文件，你就能够看到模型是怎么定义的，以及有哪些可选的配置参数。我应用如下命令运行了该代码：

# Let's give our new model a name for the Hub
model_name = "sd-class-butterflies-64"
hub_model_id = get_full_repo_name(model_name)
hub_model_id

‘lewtun/sd-class-butterflies-64’

!accelerate launch train_unconditional.py \
   --dataset_name="huggan/smithsonian_butterflies_subset"\
   --resolution=64 \
   --output_dir={model_name} \
   --train_batch_size=32 \
   --num_epochs=50 \
   --gradient_accumulation_steps=1 \
   --learning_rate=1e-4 \
   --lr_warmup_steps=500 \
   --mixed_precision="no"

如之前一样，把模型 push 到 hub，并且创立一个超酷的模型卡（按你的想法随便填写！）：

create_repo(hub_model_id)
api = HfApi()
api.upload_folder(folder_path=f"{model_name}/scheduler", path_in_repo="", repo_id=hub_model_id
)
api.upload_folder (folder_path=f"{model_name}/unet", path_in_repo="", repo_id=hub_model_id
)
api.upload_file (path_or_fileobj=f"{model_name}/model_index.json",
   path_in_repo="model_index.json",
   repo_id=hub_model_id,
)

content = f"""
---
license: mit
tags:
- pytorch
- diffusers
- unconditional-image-generation
- diffusion-models-class
---

# Model Card for Unit 1 of the [Diffusion Models Class 🧨](https://github.com/huggingface/diffusion-models-class)

This model is a diffusion model for unconditional image generation of cute 🦋.

## 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…’

大略 45 分钟之后，失去这样的后果：

pipeline = DDPMPipeline.from_pretrained(hub_model_id).to (device)
images = pipeline(batch_size=8).images
make_grid(images)

0%| | 0/1000 [00:00<?, ?it/s]

练习: 看看你能不能找到训练出在短时内能失去称心后果的模型训练设置参数，并与社群分享你的发现。浏览这些脚本看看你能不能了解它们，如果遇到了一些看上去令人蛊惑的中央，请向大家发问来寻求解释。

更高阶的摸索之路

心愿这些可能让你初步理解能够应用 🤗 Diffusers library 来做什么！可能一些后续的步骤是这样：

• 尝试在新数据集上训练一个无限度的扩散模型 —— 如果你能间接本人实现那就太好了！你能够在 Hub 上的 HugGan 社区小组页面找到一些能实现这个工作的超棒图像数据集。如果你不想期待模型训练太久的话，肯定记得对图片做下采样！
• 创立本人的图片数据集
• HugGan 社区小组页面

• 试试用 DreamBooth 来创立你本人定制的扩散模型管道，请查看上面两个链接：

  1. Dreambooth Training Space 利用
  2. Dreambooth fine-tuning for Stable Diffusion using d🧨ffusers 这个 Notebook
• 批改训练脚本来摸索应用不同的 UNet 超参数（层数深度，通道数等等），不同的噪声管理器等等。

接下来咱们将公布第一单元课程的第二个 Notebook 内容，敬请关注！

第一单元译者:
@darcula1993、@XhrLeokk：魔都强人工智能孵化者，二里街调参记录放弃人，所有趣味使然的 AIGC 色图创作家的包庇者，图灵神在五角场的惟一指定路上行走。

感激茶叶蛋蛋对本文奉献设计素材！

再次感激社区成员们对本课程的奉献，欢送通过链接退出咱们的本地化小组与大家独特交换:
https://bit.ly/3G40j6U