中文版扩散模型课程：第一单元

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

榜首单元：分散模型简介

欢迎来到 Hugging Face 分散模型课程榜首单元！在本单元中，你将学习有关分散模型怎样工作的根底知识，以及怎样运用 diffusers 库。

什么是分散模型？

分散模型是「生成模型」算法宗族的新成员经过学习给定的操练样本，生成模型可以学会怎样 生成 数据，比方生成图片或者声音。一个好的生成模型能生成一组 款式不同 的输出。这些输出会与操练数据类似，但不是一模一样的副本。分散模型怎样完结这一点？为了便于阐明，让咱们先看看图画生成的事例。

图片来源: DDPM paper (arxiv.org/abs/2006.11…)

分散模型成功的诀窍在于分散进程的迭代本质。最先生成的仅仅一组随机噪声，但经过若干进程逐渐改善，有意义的图画将终究会出现。在每一步中，模型都会估量怎样从当前的输入生成彻底去噪的效果。因为咱们在每一步都只做了一个小小的改变，所以在早期阶段（猜测终究输出实际上十分困难），这个估量中的任何 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 库以及一些其他要求：

%pipinstall-qq-Udiffusersdatasetstransformersaccelerateftfypyarrow

接下来，请前往 huggingface.co/settings/to… 创立具有写权限的访问令牌：

你可以运用指令行来经过此令牌登录 (huggingface-cli login) 或者运转以下单元来登录：

fromhuggingface_hubimportnotebook_login
notebook_login()

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

然后你需求安装 Git LFS 来上传模型查看点：

%%capture
!sudoapt-qqinstallgit-lfs
!gitconfig--globalcredential.helperstore

最终，让咱们导入将要运用的库，并界说一些方便函数，稍后咱们将会在 Notebook 中运用这些函数：

importnumpyasnp
importtorch
importtorch.nn.functionalasF
frommatplotlibimportpyplotasplt
fromPILimportImage
defshow_images(x):
   """Givenabatchofimagesx,makeagridandconverttoPIL"""
   x=x*0.5+0.5#Mapfrom(-1,1)backto(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))
  returngrid_im
defmake_grid(images,size=64):
   """GivenalistofPILimages,stackthemtogetherintoalineforeasyviewing"""
  output_im=Image.new("RGB",(size*len(images),size))
 fori,iminenumerate(images):
  output_im.paste(im.resize((size,size)),(i*size,0))
 returnoutput_im
#Macusersmayneeddevice='mps'(untested)
device=torch.device("cuda" iftorch.cuda.is_available()else"cpu")

好了，咱们都准备好了！

Dreambooth：行将到来的巅峰

假如你在曩昔几个月里看过人工智能相关的交际媒体，你就会听说过 Stable Diffusion 模型。这是一个强大的文本条件隐式分散模型（别忧虑，咱们将会学习这些概念）。但它有一个缺陷：它不知道你或我长什么样，除非咱们满足知名以至于互联网上发布咱们的相片。

Dreambooth 允许咱们创立自己的模型变体，并对特定的面部、目标或款式有一些额外的了解。Corridor Crew 制造了一段出色的视频，用一致的任务形象来讲故事，这是一个很好的阐明晰这种技能的才能的比方：

fromIPython.displayimportYouTubeVideo
YouTubeVideo("W4Mcuh38wyM")

这是一个运用了一个名为「Mr Potato Head」的模型作为比方。该模型的操练运用了 5 张闻名的儿童玩具 “Mr Potato Head”的相片。模型地址: hf.co/sd-dreamboo…

首要，让咱们来加载这个管道。这些代码会自动从 Hub 下载模型权重等需求的文件。因为这个只要一行的 demo 需求下载数 GB 的数据，因而你可以越过此单元格，只需赏识样例输出即可！

fromdiffusersimportStableDiffusionPipeline
#Checkouthttps://hf.co/sd-dreambooth-libraryforloadsofmodelsfromthecommunity
model_id="sd-dreambooth-library/mr-potato-head"
#Loadthepipeline
pipe=StableDiffusionPipeline.from_pretrained(model_id,torch_dtype=torch.float16).to(
 device
)

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

管道加载完结后，咱们可以运用以下指令生成图画：

prompt="anabstractoilpaintingofsksmrpotatoheadbypicasso"
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: arxiv.org/abs/1505.04…

3. 管理器 (or 调度器): 在 推理 中运用多种不同的技巧来从噪声中生成图画，同时也可以生成在 操练 中所需的带噪图画。

管道关于末端运用者来说现已十分棒，但你已然现已参加了这门课程，咱们就干脆以为你想了解更多其间的奥秘！在此篇笔记完毕之后，咱们会来构建归于你自己，可以生成小蝴蝶图片的管道。下面这儿会是终究的效果：

fromdiffusersimportDDPMPipeline
#Loadthebutterflypipeline
butterfly_pipeline=DDPMPipeline.from_pretrained(
 "johnowhitaker/ddpm-butterflies-32px"
).to(device)
#Create8images
images=butterfly_pipeline(batch_size=8).images
#Viewtheresult
make_grid(images)

或许这看起来并不如 DreamBooth 所展示的样例那样冷艳，但要知道咱们在操练这些图画时只用了不到操练稳定分散模型用到数据的 0.0001%。提到模型操练，从引进介绍直到本单元，操练一个分散模型的流程看起来像是这样：

1. 从操练会集加载一些图画
2. 参加噪声，从不同程度上
3. 把带了不同版别噪声的数据送进模型
4. 评价模型在对这些数据做增强去噪时的体现
5. 运用这个信息来更新模型权重，然后重复此进程

咱们会在接下来几节中逐一完结这些进程，直至操练循环可以完整的运转，在这之后咱们会来探究怎样运用操练好的模型来生成样本，还有怎样封装模型到管道中来轻松的共享给别人，下面咱们来从数据入手吧。

进程 2：下载一个操练数据集

在这个比方中，咱们会用到一个来自 Hugging Face Hub 的 图画集。具体来说，是个 1000 张蝴蝶图画保藏集。这是个十分小的数据集，咱们这儿也同时包含了已被注释的内容指向一些规划更大的挑选。假如你想运用你自己的图画保藏，你也可以运用这儿被注释掉的示例代码，从一个指定的文件夹来装载图片。

importtorchvision
fromdatasetsimportload_dataset
fromtorchvisionimporttransforms
dataset=load_dataset("huggan/smithsonian_butterflies_subset",split="train")
#We'lltrainon32-pixelsquareimages,butyoucantrylargersizestoo
image_size=32
#Youcanloweryourbatchsizeifyou'rerunningoutofGPUmemory
batch_size=64
#Definedataaugmentations
preprocess=transforms.Compose(
 [
  transforms.Resize((image_size,image_size)),#Resize
  transforms.RandomHorizontalFlip(),#Randomlyflip(dataaugmentation)
  transforms.ToTensor(),#Converttotensor(0,1)
  transforms.Normalize([0.5],[0.5]),#Mapto(-1,1)
 ]
)
deftransform(examples):
 images=[preprocess(image.convert("RGB"))forimageinexamples["image"]]
 return{"images":images}
dataset.set_transform(transform)
#Createadataloaderfromthedatasettoserveupthetransformedimagesinbatches
train_dataloader=torch.utils.data.DataLoader(
 dataset,batch_size=batch_size,shuffle=True
)

咱们可以从中取出一批图画数据来看一看他们是什么姿态:

xb=next(iter(train_dataloader))["images"].to(device)[:8]
print("Xshape:",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:

fromdiffusersimportDDPMScheduler
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 可以经过以下注释内容来修正:

#Onewithtoolittlenoiseadded:
#noise_scheduler=DDPMScheduler(num_train_timesteps=1000,beta_start=0.001,beta_end=0.004)
#The'cosine'schedule,whichmaybebetterforsmallimagesizes:
#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("NoisyXshape",noisy_xb.shape)
show_images(noisy_xb).resize((8*64,64),resample=Image.NEAREST)

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

再来，在这儿探究运用这儿不同噪声管理器和预设参数带来的效果。这个视频很好的解说了一些上述数学运算的细节，同时也是对此类概念的一个很好引进介绍。视频地址: www.youtube.com/watch?v=fbL…

进程 4：界说模型

现在咱们来到了中心部分：模型本身。

大多数分散模型运用的模型结构都是一些 U-net 的变形，也是咱们在这儿会用到的结构。

归纳来说:

• 输入模型中的图片经过几个由 ResNetLayer 构成的层，其间每层都使图片尺寸减半。
• 之后在经过同样数量的层把图片升采样。
• 其间还有对特征在相同位置的上、下采样层残差连接模块。

模型一个要害特征既是，输出图片尺寸与输入图片相同，这正是咱们这儿需求的。

Diffusers 为咱们供给了一个易用的UNet2DModel类，用来在 PyTorch 创立所需求的结构。

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

fromdiffusersimportUNet2DModel
#Createamodel
model=UNet2DModel(
 sample_size=image_size,#thetargetimageresolution
 in_channels=3,#thenumberofinputchannels,3forRGBimages
 out_channels=3,#thenumberofoutputchannels
 layers_per_block=2,#howmanyResNetlayerstouseperUNetblock
 block_out_channels=(64,128,128,256),#Morechannels->moreparameters
 down_block_types=(
  "DownBlock2D",#aregularResNetdownsamplingblock
  "DownBlock2D",
  "AttnDownBlock2D",#aResNetdownsamplingblockwithspatialself-attention
  "AttnDownBlock2D",
),
 up_block_types=(
  "AttnUpBlock2D",
  "AttnUpBlock2D",#aResNetupsamplingblockwithspatialself-attention
  "UpBlock2D",
  "UpBlock2D",#aregularResNetupsamplingblock
 ),
)
model.to(device);

当在处理更高分辨率的输入时，你或许想用更多层的下、上采样模块，让留意力层只聚焦在最低分辨率（最底）层来削减内存消耗。咱们在之后会评论该怎样试验来找到最适用与你手头场景的装备办法。

咱们可以经过输入一批数据和随机的迭代周期数来看输出是否与输入尺寸相同：

withtorch.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 分钟来运转 – 你也可以越过以下两块操作直接运用预操练好的模型。供你挑选，你可以探究下经过缩小模型层中的通道数会对运转速度有多少提高。

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

#Setthenoisescheduler
noise_scheduler=DDPMScheduler(
 num_train_timesteps=1000,beta_schedule="squaredcos_cap_v2"
)
#Trainingloop
optimizer=torch.optim.AdamW(model.parameters(),lr=4e-4)
losses=[]
forepochinrange(30):
 forstep,batchinenumerate(train_dataloader):
  clean_images=batch["images"].to(device)
  #Samplenoisetoaddtotheimages
  noise=torch.randn(clean_images.shape).to(clean_images.device)
  bs=clean_images.shape[0]
  #Samplearandomtimestepforeachimage
  timesteps=torch.randint(
  0,noise_scheduler.num_train_timesteps,(bs,),device=clean_images.device
  ).long()
  #Addnoisetothecleanimagesaccordingtothenoisemagnitudeateachtimestep
  noisy_images=noise_scheduler.add_noise(clean_images,noise,timesteps)
  #Getthemodelprediction
  noise_pred=model(noisy_images,timesteps,return_dict=False)[0]
  #Calculatetheloss
  loss=F.mse_loss(noise_pred,noise)
  loss.backward(loss)
  losses.append(loss.item())
  #Updatethemodelparameterswiththeoptimizer
  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>]

你可以挑选运转上面的代码，也可以这样经过管道来调用模型：

#UncommenttoinsteadloadthemodelItrainedearlier:
#model=butterfly_pipeline.unet

进程 6：生成图画

咱们怎样从这个模型中得到图画呢？

办法 1：树立一个管道：

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

查看文件夹的内容：

!lsmy_pipeline/

model_index.json scheduler unet

这儿scheduler与unet子文件夹中包含了生成图画所需的全部组件。比方，在unet文件中能看到模型参数 (diffusion_pytorch_model.bin) 与描绘模型结构的装备文件。

!lsmy_pipeline/unet/

config.json diffusion_pytorch_model.bin

以上，这些文件包含了从头树立一个管道的全部内容。你可以手动把它们上传到 hub 来与别人共享你制造的管道，或运用下一节的 API 办法来记载。

办法 2：写一个取样循环

假如你去查看了管道中的 forward 办法，你可以看到在运转image_pipe()时发生了什么：

#??image_pipe.forward

从随机噪声开端，遍历管理器的迭代周期来看从最喧闹直到最微小的噪声改变，根据模型的猜测一步步削减一些噪声：

#Randomstartingpoint(8randomimages):
sample=torch.randn(8,3,32,32).to(device)
fori,tinenumerate(noise_scheduler.timesteps):
 #Getmodelpred
 withtorch.no_grad():
  residual=model(sample,t).sample
 #Updatesamplewithstep
 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()会帮你做到）：

fromhuggingface_hubimportget_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 它吧：

fromhuggingface_hubimportHfApi,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,
)

‘huggingface.co/lewtun/sd-c…’

最终一件事是创立一个超棒的模型卡，如此，咱们的蝴蝶生成器可以轻松的在 Hub 上被找到（请在描绘中随意发挥！）：

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

#ModelCardforUnit1ofthe[DiffusionModelsClass](https://github.com/huggingface/diffusion-models-class)
Thismodelisadiffusionmodelforunconditionalimagegenerationofcute.
##Usage

python fromdiffusersimportDDPMPipeline

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()办法来下来它：

fromdiffusersimportDDPMPipeline
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.

你可以这样下载该文件：

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

打开文件，你就可以看到模型是怎样界说的，以及有哪些可选的装备参数。我运用如下指令运转了该代码：

#Let'sgiveournewmodelanamefortheHub
model_name="sd-class-butterflies-64"
hub_model_id=get_full_repo_name(model_name)
hub_model_id

‘lewtun/sd-class-butterflies-64’

!acceleratelaunchtrain_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
---
#ModelCardforUnit1ofthe[DiffusionModelsClass](https://github.com/huggingface/diffusion-models-class)
Thismodelisadiffusionmodelforunconditionalimagegenerationofcute.
##Usage
python
fromdiffusersimportDDPMPipeline
pipeline=DDPMPipeline.from_pretrained('{hub_model_id}')
image=pipeline().images[0]
image
"""
card=ModelCard(content)
card.push_to_hub(hub_model_id)

‘huggingface.co/lewtun/sd-c…’

大约 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 dffusers 这个 Notebook

• 修正操练脚原本探究运用不同的 UNet 超参数（层数深度，通道数等等），不同的噪声管理器等等。

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

---

榜首单元译者:
@darcula1993、@XhrLeokk：魔都强人工智能孵化者，二里街调参记载保持人，全部爱好使然的 AIGC 色图创作家的保护者，图灵神在五角场的唯一指定路上行走。

感谢茶叶蛋蛋对本文奉献规划素材！

再次感谢社区成员们对本课程的奉献，欢迎经过链接参加咱们的本地化小组与咱们一起交流:
bit.ly/3G40j6U