diff --git "a/markdown/unit3/01_stable_diffusion_introduction_CN.md" "b/markdown/unit3/01_stable_diffusion_introduction_CN.md" new file mode 100644--- /dev/null +++ "b/markdown/unit3/01_stable_diffusion_introduction_CN.md" @@ -0,0 +1,583 @@ +# 简介 + +本节笔记本将会涵盖一些基础性的内容,介绍如何利用现有的管线(pipeline)借助 Stable Diffusion 模型来创造和修改图片。我们也将简要一览管线内的关键组成部分,把更进一步的探究任务留给更深入介绍的一节笔记本中。特别地,我们将涵盖以下内容: +- 利用 `StableDiffusionPipeline` 根据文字描述生成图片,并通过修改各个输入参数来进行探究实验 +- 实操了解管线的一些关键组成部分: + - 让这个模型成为“隐编码扩散模型(latent diffusion model)”的可变分自编码器(VAE) + - 处理文本提示的分词器(tokenizer)和文本编码器 + - UNet 模型本身 + - 使用的调度器(scheduler),以及其它不同的调度器 +- 使用管线的组成部分来复现采样循环 +- 用Img2Im管线来编辑现有图片 +- 使用inpainting管线和Depth2Img管线 + +❓如果你有问题,请在 Hugging Face Discord 的 `#diffusion-models-class` 频道提出。如果你还没有 Hugging Face 的账号,你可以在这里注册:https://huggingface.co/join/discord + + +# 配置 + + +```python +!pip install -Uq diffusers ftfy accelerate +``` + + +```python +# Installing transformers from source for now since we need the latest version for Depth2Img: +!pip install -Uq git+https://github.com/huggingface/transformers +``` + + +```python +import torch +import requests +from PIL import Image +from io import BytesIO +from matplotlib import pyplot as plt + +# We'll be exploring a number of pipelines today! +from diffusers import ( + StableDiffusionPipeline, + StableDiffusionImg2ImgPipeline, + StableDiffusionInpaintPipeline, + StableDiffusionDepth2ImgPipeline + ) + +# We'll use a couple of demo images later in the notebook +def download_image(url): + response = requests.get(url) + return Image.open(BytesIO(response.content)).convert("RGB") + +# Download images for inpainting example +img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png" +mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png" + +init_image = download_image(img_url).resize((512, 512)) +mask_image = download_image(mask_url).resize((512, 512)) +``` + + +```python +# Set device +device = ( + "mps" + if torch.backends.mps.is_available() + else "cuda" + if torch.cuda.is_available() + else "cpu" +) +``` + +# 从文本生成图像 + +我们先载入 Stable Diffusion 的管线,看看我们能做点什么。现有的 Stable Diffusion 模型有好多不同版本,截至本文书写时的最新版本是第2.1版。如果你想探究更旧的版本,只需要在 `model_id` 处修改即可(比如你可以试试将其改成 `CompVis/stable-diffusion-v1-4` 或从[dreambooth concepts library](https://huggingface.co/sd-dreambooth-library)选一个模型)。 + + +```python +# Load the pipeline +model_id = "stabilityai/stable-diffusion-2-1-base" +pipe = StableDiffusionPipeline.from_pretrained(model_id).to(device) +``` + +如果你的GPU内存不够用,这里有些办法也许可以减少内存使用: +- 载入 FP16 精度的版本(但并不是所有的系统上都支持)。与此同时,在你对管线的某个特定部分实验时,你也需要把所有的张量换成 torch.float16 精度: + + `pipe = StableDiffusionPipeline.from_pretrained(model_id, revision="fp16", torch_dtype=torch.float16).to(device)` + + +- 开启注意力机制切分(attention slicing)。这会牺牲一点点速度来减少GPU内存的使用: + + `pipe.enable_attention_slicing()` + + +- 降低要生成的图片的尺寸 + +当管线加载好了以后,我们可以用以下代码去使用文字提示生成图片: + + +```python +# Set up a generator for reproducibility +generator = torch.Generator(device=device).manual_seed(42) + +# Run the pipeline, showing some of the available arguments +pipe_output = pipe( + prompt="Palette knife painting of an autumn cityscape", # What to generate + negative_prompt="Oversaturated, blurry, low quality", # What NOT to generate + height=480, width=640, # Specify the image size + guidance_scale=8, # How strongly to follow the prompt + num_inference_steps=35, # How many steps to take + generator=generator # Fixed random seed +) + +# View the resulting image: +pipe_output.images[0] +``` + + + 0%| | 0/35 [00:00 decoded token") +for input_id in input_ids[0]: + print(f"{input_id} -> {pipe.tokenizer.decode(input_id)}") + +# Feed through CLIP text encoder +input_ids = torch.tensor(input_ids).to(device) +with torch.no_grad(): + text_embeddings = pipe.text_encoder(input_ids)['last_hidden_state'] +print("Text embeddings shape:", text_embeddings.shape) +``` + + Input ID -> decoded token + 49406 -> <|startoftext|> + 320 -> a + 3086 -> painting + 539 -> of + 320 -> a + 4062 -> floo + 1059 -> ble + 49407 -> <|endoftext|> + Text embeddings shape: torch.Size([1, 8, 1024]) + + + +```python +# Get the final text embeddings using the pipeline's _encode_prompt function: +text_embeddings = pipe._encode_prompt("A painting of a flooble", device, 1, False, '') +text_embeddings.shape +``` + + + + + torch.Size([1, 77, 1024]) + + + +这些文本嵌入(text embedding),也即文本编码器中最后一个transformer模块的“隐状态(hidden state)”,将会被送入 UNet 中作为 `forward` 函数的一个额外输入,下面部分我们会详细看到。 + +### UNet + +![unet.png](data:image/png;base64,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) + +UNet 模型接收一个带噪的输入,并预测噪声,和我们之前单元中看到的 UNet 一样。但与以往例子不同的是,这里的输入并不是图片了,而是图片的隐式表示形式(latent representation)。此外,除了把用于暗示带噪程度的timestep输入进 UNet 作为条件外,这里模型也把文字提示(prompt)的文本嵌入(text embeddings)作为了额外输入。这里我们假数据试着让它预测一下: + + +```python +# Dummy inputs: +timestep = pipe.scheduler.timesteps[0] +latents = torch.randn(1, 4, 64, 64).to(device) +text_embeddings = torch.randn(1, 77, 1024).to(device) + +# Model prediction: +with torch.no_grad(): + unet_output = pipe.unet(latents, timestep, text_embeddings).sample +print('UNet output shape:', unet_output.shape) # Same shape as the input latents +``` + + UNet output shape: torch.Size([1, 4, 64, 64]) + + +### 调度器(Scheduler) + +调度器保存了如何加噪的计划安排,管理着如何基于模型的预测更新带噪样本。默认的调度器是 `PNDMScheduler` 调度器,但你也可以用其它的(比如 `LMSDiscreteScheduler` 调度器),只要它们用相同的配置初始化。 + +我们可以画出图像来观察随着timestep添加噪声的计划安排,看看不同时间的噪声水平(基于$\bar{\alpha}$这个参数)是什么样的: + + +```python +plt.plot(pipe.scheduler.alphas_cumprod, label=r'$\bar{\alpha}$') +plt.xlabel('Timestep (high noise to low noise ->)'); +plt.title('Noise schedule');plt.legend(); +``` + + + +![png](01_stable_diffusion_introduction_CN_files/01_stable_diffusion_introduction_CN_35_0.png) + + + +如果你想尝试不同的调度器,你可以像下面代码中一样换一个新的: + + +```python +from diffusers import LMSDiscreteScheduler + +# Replace the scheduler +pipe.scheduler = LMSDiscreteScheduler.from_config(pipe.scheduler.config) + +# Print the config +print('Scheduler config:', pipe.scheduler) + +# Generate an image with this new scheduler +pipe(prompt="Palette knife painting of an winter cityscape", height=480, width=480, + generator=torch.Generator(device=device).manual_seed(42)).images[0] +``` + + Scheduler config: LMSDiscreteScheduler { + "_class_name": "LMSDiscreteScheduler", + "_diffusers_version": "0.11.1", + "beta_end": 0.012, + "beta_schedule": "scaled_linear", + "beta_start": 0.00085, + "clip_sample": false, + "num_train_timesteps": 1000, + "prediction_type": "epsilon", + "set_alpha_to_one": false, + "skip_prk_steps": true, + "steps_offset": 1, + "trained_betas": null + } + + + + + 0%| | 0/50 [00:00 x_t-1 + latents = pipe.scheduler.step(noise_pred, t, latents).prev_sample + +# Decode the resulting latents into an image +with torch.no_grad(): + image = pipe.decode_latents(latents.detach()) + +# View +pipe.numpy_to_pil(image)[0] +``` + + + + + +![png](01_stable_diffusion_introduction_CN_files/01_stable_diffusion_introduction_CN_40_0.png) + + + + +大多数情况下,还是使用现有的管线更方便,但我们这里手动拼装采样循环会更有益于我们理解每个部分如何工作、以及如何根据需要修改这些组件。如果你想看看实际的代码以及深入了解如何修改这些组成部分,你可以参考 Stable Diffusion Deep Dive 这个[笔记本](https://github.com/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb)和[视频](https://m.youtube.com/watch?v=0_BBRNYInx8)。这里有对相关内容更全面彻底的探究。 + +# 其它的一些管线 + +那我们除了从文字提示生成图片外还能做点什么呢?其实还有很多!这一部分还会向你展示几个很酷的管线,让你了解一些其它的可以应用 Stable Diffusion 的任务。这里面有几个管线需要你下载新的模型,所以你要是着急的话你也可以跳过这一部分,只看看现有的输出展示就行,不必亲自下载和运行模型。 + +## Img2Img + +直到现在,我们生成的图片还都是完全从随机的隐变量来开始生成的,而且也都使用了完整的扩散模型采样循环。但其实我们不必从头开始。Img2Img 这个管线首先将一张已有的图片进行编码,编码成一系列的隐变量,然后在这些隐变量上随机加噪声,以这些作为起始点。噪声加多大量、去噪需要的步数决定了这个 img2img 过程的“强度”。只加一点点噪声(强度低)只会带来微小改变,而加入最大量的噪声并跑完完整的去噪过程又会生成出几乎完全不像原始图片的结果,即使可能在整体结构上还多少有点相似。 + +这个管线无需什么特殊模型,只要模型的 ID 和我们的文字到图像模型一样就行,没有新的需要下载的文件。 + + +```python +# Loading an Img2Img pipeline +model_id = "stabilityai/stable-diffusion-2-1-base" +img2img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id).to(device) +``` + + + Fetching 16 files: 0%| | 0/16 [00:00