# Diffusion-Course

## Docs

- [Hugging Face Diffusion Models Course](https://huggingface.co/learn/diffusion-course/README.md)
- [Making a Class-Conditioned Diffusion Model](https://huggingface.co/learn/diffusion-course/unit2/3.md)
- [Fine-Tuning and Guidance](https://huggingface.co/learn/diffusion-course/unit2/2.md)
- [Unit 2: Fine-Tuning, Guidance and Conditioning](https://huggingface.co/learn/diffusion-course/unit2/1.md)
- [Introduction](https://huggingface.co/learn/diffusion-course/unit3/2.md)
- [Unit 3: Stable Diffusion](https://huggingface.co/learn/diffusion-course/unit3/1.md)
- [Diffusion for Audio](https://huggingface.co/learn/diffusion-course/unit4/3.md)
- [DDIM Inversion](https://huggingface.co/learn/diffusion-course/unit4/2.md)
- [Unit 4: Going Further with Diffusion Models](https://huggingface.co/learn/diffusion-course/unit4/1.md)
- [DreamBooth Hackathon 🏆](https://huggingface.co/learn/diffusion-course/hackathon/dreambooth.md)
- [DreamBooth Hackathon 🏆](https://huggingface.co/learn/diffusion-course/hackathon/introduction.md)
- [Diffusion Models from Scratch](https://huggingface.co/learn/diffusion-course/unit1/3.md)
- [Introduction to 🤗 Diffusers](https://huggingface.co/learn/diffusion-course/unit1/2.md)
- [Unit 1: An Introduction to Diffusion Models](https://huggingface.co/learn/diffusion-course/unit1/1.md)
- [Hugging Face Diffusion Models Course](https://huggingface.co/learn/diffusion-course/unit0/1.md)

### Hugging Face Diffusion Models Course
https://huggingface.co/learn/diffusion-course/README.md

# Hugging Face Diffusion Models Course

[![License](https://img.shields.io/static/v1?label=License&message=Apache&color=)](https://github.com/huggingface/diffusion-models-class/blob/main/LICENSE) &nbsp;
[![GitHub forks](https://img.shields.io/github/forks/huggingface/diffusion-models-class.svg?style=social&label=Fork&maxAge=2592000)](https://github.com/dhakalnirajan/diffusion-models-class) &nbsp;
[![Made with Jupyter](https://img.shields.io/badge/Made%20with-Jupyter-red?style=flat-square&logo=Jupyter)](https://jupyter.org/try) &nbsp;
![PyTorch](https://img.shields.io/badge/PyTorch-%23EE4C2C.svg?style=flat-square&logo=PyTorch&logoColor=white)

In this free course, you will:
- 👩‍🎓 Study the theory behind diffusion models
- 🧨 Learn how to generate images and audio with the popular 🤗 Diffusers library
- 🏋️‍♂️ Train your own diffusion models from scratch
- 📻 Fine-tune existing diffusion models on new datasets
- 🗺 Explore conditional generation and guidance
- 🧑‍🔬 Create your own custom diffusion model pipelines

Register via the **[signup form](https://huggingface.us17.list-manage.com/subscribe?u=7f57e683fa28b51bfc493d048&id=ef963b4162)** and then join us on **[Discord](https://discord.gg/aYka4Yhff9)** to get the conversations started. Instructions on how to join specific categories/channels **[are here.](https://discord.com/channels/879548962464493619/1014509271255367701)**

## Syllabus

| 📆 Publishing date  | 📘 Unit           | 👩‍💻 Hands-on |
|---------------|----------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
| November 28, 2022  | [An Introduction to Diffusion Models](https://github.com/huggingface/diffusion-models-class/tree/main/unit1)| Introduction to Diffusers and Diffusion Models From Scratch |
| December 12, 2022  | [Fine-Tuning and Guidance](https://github.com/huggingface/diffusion-models-class/tree/main/unit2) | Fine-Tuning a Diffusion Model on New Data and Adding Guidance |
| December 21, 2022  | [Stable Diffusion](https://github.com/huggingface/diffusion-models-class/tree/main/unit3) | Exploring a Powerful Text-Conditioned Latent Diffusion Model |
| January 2023 (TBC)  | [Doing More with Diffusion](https://github.com/huggingface/diffusion-models-class/tree/main/unit4) | Advanced Techniques to Take Diffusion Further |

More information coming soon!

## Prerequisites
- Good skills in Python 🐍
- Basics in Deep Learning and Pytorch

If it's not the case yet, you can check these free resources:
- Python: https://www.udacity.com/course/introduction-to-python--ud1110
- Intro to Deep Learning with PyTorch: https://www.udacity.com/course/deep-learning-pytorch--ud188
- PyTorch in 60 min: https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html

## FAQ
**Is this class free?**

Yes, totally free 🥳.

**Do I need to have a Hugging Face account to follow the course?**

Yes, to push your custom models and pipelines to the hub, you need an account (it's free) 🤗.

You can create one here 👉 [https://huggingface.co/join](https://huggingface.co/join)

**What’s the format of the class?**

The course will consist of at least **4 Units.** More will be added as time goes on, on topics like diffusion for audio. 

Each unit consists of some theory and background alongside one or more hands-on notebooks. Some units will also contain suggested projects and we'll have competitions and swag for the best pipelines and demos (more details TDB).

## 🌎 Languages and translations

Members of the 🤗 community have begun translating the course! We're planning to host this course on the [Hugging Face website](https://huggingface.co/), so if you're interested in contributing a translation, we recommend waiting until we've formatted the English content in it's final form.

| Language                                                                      | Authors |
|:------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|
| [Chinese](https://github.com/darcula1993/diffusion-models-class-CN/blob/main/README_CN.md)     | [@darcula1993](https://github.com/darcula1993) [@XhrLeokk](https://github.com/XhrLeokk) [@SuSung-boy](https://github.com/SuSung-boy) [@Hoi2022](https://github.com/Hoi2022)|
| [Japanese](https://github.com/eltociear/diffusion-models-class-JA/blob/main/README_JA.md)     | [@eltociear](https://github.com/eltociear) [@nazuki155](https://github.com/nazuki155)|
| [Korean](https://github.com/deep-diver/diffusion-models-class/blob/main/README_KR.md)     | [@deep-diver](https://github.com/deep-diver)

### Making a Class-Conditioned Diffusion Model
https://huggingface.co/learn/diffusion-course/unit2/3.md

# Making a Class-Conditioned Diffusion Model

In this notebook we're going to illustrate one way to add conditioning information to a diffusion model. Specifically, we'll train a class-conditioned diffusion model on MNIST following on from the ['from-scratch' example in Unit 1](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit1/02_diffusion_models_from_scratch.ipynb), where we can specify which digit we'd like the model to generate at inference time. 

As mentioned in the introduction to this unit, this is just one of many ways we could add additional conditioning information to a diffusion model, and has been chosen for its relative simplicity. Just like the 'from-scratch' notebook in Unit 1, this notebook is mostly for illustrative purposes and you can safely skip it if you'd like.

## Setup and Data Prep

```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

## Creating a Class-Conditioned UNet

The way we'll feed in the class conditioning is as follows:
- Create a standard `UNet2DModel` with some additional input channels  
- Map the class label to a learned vector of shape `(class_emb_size)`via an embedding layer
- Concatenate this information as extra channels for the internal UNet input with `net_input = torch.cat((x, class_cond), 1)`
- Feed this `net_input` (which has (`class_emb_size+1`) channels in total) into the UNet to get the final prediction

In this example I've set the class_emb_size to 4, but this is completely arbitrary and you could explore having it size 1 (to see if it still works), size 10 (to match the number of classes), or replacing the learned nn.Embedding with a simple one-hot encoding of the class label directly. 

This is what the implementation looks like:

```python
class ClassConditionedUnet(nn.Module):
  def __init__(self, num_classes=10, class_emb_size=4):
    super().__init__()
    
    # The embedding layer will map the class label to a vector of size class_emb_size
    self.class_emb = nn.Embedding(num_classes, class_emb_size)

    # Self.model is an unconditional UNet with extra input channels to accept the conditioning information (the class embedding)
    self.model = UNet2DModel(
        sample_size=28,           # the target image resolution
        in_channels=1 + class_emb_size, # Additional input channels for class cond.
        out_channels=1,           # the number of output channels
        layers_per_block=2,       # how many ResNet layers to use per UNet block
        block_out_channels=(32, 64, 64), 
        down_block_types=( 
            "DownBlock2D",        # a regular ResNet downsampling block
            "AttnDownBlock2D",    # a ResNet downsampling block with spatial self-attention
            "AttnDownBlock2D",
        ), 
        up_block_types=(
            "AttnUpBlock2D", 
            "AttnUpBlock2D",      # a ResNet upsampling block with spatial self-attention
            "UpBlock2D",          # a regular ResNet upsampling block
          ),
    )

  # Our forward method now takes the class labels as an additional argument
  def forward(self, x, t, class_labels):
    # Shape of x:
    bs, ch, w, h = x.shape
    
    # class conditioning in right shape to add as additional input channels
    class_cond = self.class_emb(class_labels) # Map to embedding dimension
    class_cond = class_cond.view(bs, class_cond.shape[1], 1, 1).expand(bs, class_cond.shape[1], w, h)
    # x is shape (bs, 1, 28, 28) and class_cond is now (bs, 4, 28, 28)

    # Net input is now x and class cond concatenated together along dimension 1
    net_input = torch.cat((x, class_cond), 1) # (bs, 5, 28, 28)

    # Feed this to the UNet alongside the timestep and return the prediction
    return self.model(net_input, t).sample # (bs, 1, 28, 28)
```

If any of the shapes or transforms are confusing, add in print statements to show the relevant shapes and check that they match your expectations. I've also annotated the shapes of some intermediate variables in the hopes of making things clearer.

## Training and Sampling

Where previously we'd do something like `prediction = unet(x, t)` we'll now add the correct labels as a third argument (`prediction = unet(x, t, y)`) during training, and at inference we can pass whatever labels we want and if all goes well the model should generate images that match. `y` in this case is the labels of the MNIST digits, with values from 0 to 9.

The training loop is very similar to the [example from Unit 1](https://github.com/huggingface/diffusion-models-class/blob/unit2/unit1/02_diffusion_models_from_scratch.ipynb). We're now predicting the noise (rather than the denoised image as in Unit 1) to match the objective expected by the default DDPMScheduler which we're using to add noise during training and to generate samples at inference time. Training takes a while - speeding this up could be a fun mini-project, but most of you can probably just skim the code (and indeed this whole notebook) without running it since we're just illustrating an idea.

```python
# Create a scheduler
noise_scheduler = DDPMScheduler(num_train_timesteps=1000, beta_schedule='squaredcos_cap_v2')
```

```python
>>> #@markdown Training loop (10 Epochs):

>>> # Redefining the dataloader to set the batch size higher than the demo of 8
>>> train_dataloader = DataLoader(dataset, batch_size=128, shuffle=True)

>>> # How many runs through the data should we do?
>>> n_epochs = 10

>>> # Our network 
>>> net = ClassConditionedUnet().to(device)

>>> # Our loss function
>>> loss_fn = nn.MSELoss()

>>> # The optimizer
>>> opt = torch.optim.Adam(net.parameters(), lr=1e-3) 

>>> # Keeping a record of the losses for later viewing
>>> losses = []

>>> # The training loop
>>> for epoch in range(n_epochs):
...     for x, y in tqdm(train_dataloader):
        
...         # Get some data and prepare the corrupted version
...         x = x.to(device) * 2 - 1 # Data on the GPU (mapped to (-1, 1))
...         y = y.to(device)
...         noise = torch.randn_like(x)
...         timesteps = torch.randint(0, 999, (x.shape[0],)).long().to(device)
...         noisy_x = noise_scheduler.add_noise(x, noise, timesteps)

...         # Get the model prediction
...         pred = net(noisy_x, timesteps, y) # Note that we pass in the labels y

...         # Calculate the loss
...         loss = loss_fn(pred, noise) # How close is the output to the noise

...         # Backprop and update the params:
...         opt.zero_grad()
...         loss.backward()
...         opt.step()

...         # Store the loss for later
...         losses.append(loss.item())

...     # Print out the average of the last 100 loss values to get an idea of progress:
...     avg_loss = sum(losses[-100:])/100
...     print(f'Finished epoch {epoch}. Average of the last 100 loss values: {avg_loss:05f}')

>>> # View the loss curve
>>> plt.plot(losses)
```

Finished epoch 0. Average of the last 100 loss values: 0.052451

Once training finishes, we can sample some images feeding in different labels as our conditioning:

```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')
```

There we go! We can now have some control over what images are produced. 

I hope you've enjoyed this example. As always, feel free to ask questions in the Discord.

```python
# Exercise (optional): Try this with FashionMNIST. Tweak the learning rate, batch size and number of epochs.
# Can you get some decent-looking fashion images with less training time than the example above?
```

### Fine-Tuning and Guidance
https://huggingface.co/learn/diffusion-course/unit2/2.md

# Fine-Tuning and Guidance

In this notebook, we're going to cover two main approaches for adapting existing diffusion models:

* With **fine-tuning**, we'll re-train existing models on new data to change the type of output they produce
* With **guidance**, we'll take an existing model and steer the generation process at inference time for additional control

## What You Will Learn:

By the end of this notebook, you will know how to:

- Create a sampling loop and generate samples faster using a new scheduler
- Fine-tune an existing diffusion model on new data, including:
  - Using gradient accumulation to get around some of the issues with small batches
  - Logging samples to [Weights and Biases](https://wandb.ai/site) during training to monitor progress (via the accompanying example script)
  - Saving the resulting pipeline and uploading it to the hub
- Guide the sampling process with additional loss functions to add control over existing models, including:
  - Exploring different guidance approaches with a simple color-based loss
  - Using CLIP to guide generation using a text prompt
  - Sharing a custom sampling loop using Gradio and 🤗 Spaces

❓If you have any questions, please post them on the `#diffusion-models-class` channel on the Hugging Face Discord server. If you haven't signed up yet, you can do so here: https://huggingface.co/join/discord

## Setup and Imports

To save your fine-tuned models to the Hugging Face Hub, you'll need to login with a **token that has write access**. The code below will prompt you for this and link to the relevant tokens page of your account. You'll also need a Weights and Biases account if you'd like to use the training script to log samples as the model trains - again, the code should prompt you to sign in where needed.

Apart from that, the only set-up is installing a few dependencies, importing everything we'll need and specifying which device we'll use:

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

## Loading A Pre-Trained Pipeline

To begin this notebook, let's load an existing pipeline and see what we can do with it:

```python
image_pipe = DDPMPipeline.from_pretrained("google/ddpm-celebahq-256")
image_pipe.to(device);
```

Generating images is as simple as running the [`__call__`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/ddpm/pipeline_ddpm.py#L42) method of the pipeline by calling it like a function:

```python
>>> images = image_pipe().images
>>> images[0]
```

Neat, but SLOW! So, before we get to the main topics of today, let's take a peek at the actual sampling loop and see how we can use a fancier sampler to speed this up:

## Faster Sampling with DDIM

At every step, the model is fed a noisy input and asked to predict the noise (and thus an estimate of what the fully denoised image might look like). Initially these predictions are not very good, which is why we break the process down into many steps. However, using 1000+ steps has been found to be unnecessary, and a flurry of recent research has explored how to achieve good samples with as few steps as possible. 

In the 🤗 Diffusers library, these **sampling methods are handled by a scheduler**, which must perform each update via the `step()` function. To generate an image, we begin with random noise $x$. Then, for every timestep in the scheduler's noise schedule, we feed the noisy input $x$ to the model and pass the resulting prediction to the `step()` function. This returns an output with a `prev_sample` attribute - previous because we're going "backwards" in time from high noise to low noise (the opposite of the forward diffusion process). 

Let's see this in action! First, we load a scheduler, here a DDIMScheduler based on the paper [Denoising Diffusion Implicit Models](https://arxiv.org/abs/2010.02502) which can give decent samples in much fewer steps than the original DDPM implementation:

```python
# Create new scheduler and set num inference steps
scheduler = DDIMScheduler.from_pretrained("google/ddpm-celebahq-256")
scheduler.set_timesteps(num_inference_steps=40)
```

You can see that this model does 40 steps total, each jumping the equivalent of 25 steps of the original 1000-step schedule:

```python
scheduler.timesteps
```

Let's create 4 random images and run through the sampling loop, viewing both the current $x$ and the predicted denoised version as the process progresses:

```python
>>> # The random starting point
>>> x = torch.randn(4, 3, 256, 256).to(device)  # Batch of 4, 3-channel 256 x 256 px images

>>> # Loop through the sampling timesteps
>>> for i, t in tqdm(enumerate(scheduler.timesteps)):

...     # Prepare model input
...     model_input = scheduler.scale_model_input(x, t)

...     # Get the prediction
...     with torch.no_grad():
...         noise_pred = image_pipe.unet(model_input, t)["sample"]

...     # Calculate what the updated sample should look like with the scheduler
...     scheduler_output = scheduler.step(noise_pred, t, x)

...     # Update x
...     x = scheduler_output.prev_sample

...     # Occasionally display both x and the predicted denoised images
...     if i % 10 == 0 or i == len(scheduler.timesteps) - 1:
...         fig, axs = plt.subplots(1, 2, figsize=(12, 5))

...         grid = torchvision.utils.make_grid(x, nrow=4).permute(1, 2, 0)
...         axs[0].imshow(grid.cpu().clip(-1, 1) * 0.5 + 0.5)
...         axs[0].set_title(f"Current x (step {i})")

...         pred_x0 = (
...             scheduler_output.pred_original_sample
...         )  # Not available for all schedulers
...         grid = torchvision.utils.make_grid(pred_x0, nrow=4).permute(1, 2, 0)
...         axs[1].imshow(grid.cpu().clip(-1, 1) * 0.5 + 0.5)
...         axs[1].set_title(f"Predicted denoised images (step {i})")
...         plt.show()
```

As you can see, the initial predictions are not great but as the process goes on the predicted outputs get more and more refined. If you're curious what maths is happening inside that `step()` function, inspect the (well-commented) code with:

```python
# ??scheduler.step
```

You can also drop in this new scheduler in place of the original one that came with the pipeline, and sample like so:

```python
>>> image_pipe.scheduler = scheduler
>>> images = image_pipe(num_inference_steps=40).images
>>> images[0]
```

Alright - we can get samples in a reasonable time now! This should speed things up as we move through the rest of this notebook :)

## Fine-Tuning

Now for the fun bit! Given this pre-trained pipeline, how might we re-train the model to generate images based on new training data?

It turns out that this looks nearly identical to training a model from scratch (as we saw in [Unit 1](https://github.com/huggingface/diffusion-models-class/tree/main/unit1)) except that we begin with the existing model. Let's see this in action and talk about a few additional considerations as we go.

First, the dataset: you could try [this vintage faces dataset](https://huggingface.co/datasets/Norod78/Vintage-Faces-FFHQAligned) or [these anime faces](https://huggingface.co/datasets/huggan/anime-faces) for something closer to the original training data of this faces model, but just for fun let's instead use the same small butterflies dataset we used to train from scratch in Unit 1. Run the code below to download the butterflies dataset and create a dataloader we can sample a batch of images from:

```python
>>> # @markdown load and prepare a dataset:
>>> # Not on Colab? Comments with #@ enable UI tweaks like headings or user inputs
>>> # but can safely be ignored if you're working on a different platform.

>>> dataset_name = "huggan/smithsonian_butterflies_subset"  # @param
>>> dataset = load_dataset(dataset_name, split="train")
>>> image_size = 256  # @param
>>> batch_size = 4  # @param
>>> preprocess = transforms.Compose(
...     [
...         transforms.Resize((image_size, image_size)),
...         transforms.RandomHorizontalFlip(),
...         transforms.ToTensor(),
...         transforms.Normalize([0.5], [0.5]),
...     ]
... )

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

>>> dataset.set_transform(transform)

>>> train_dataloader = torch.utils.data.DataLoader(
...     dataset, batch_size=batch_size, shuffle=True
... )

>>> print("Previewing batch:")
>>> batch = next(iter(train_dataloader))
>>> grid = torchvision.utils.make_grid(batch["images"], nrow=4)
>>> plt.imshow(grid.permute(1, 2, 0).cpu().clip(-1, 1) * 0.5 + 0.5);
```

Previewing batch:

**Consideration 1:** our batch size here (4) is pretty small, since we're training at large image size (256px) using a fairly large model and we'll run out of GPU RAM if we push the batch size too high. You can reduce the image size to speed things up and allow for larger batches, but these models were designed and originally trained for 256px generation.

Now for the training loop. We'll update the weights of the pre-trained model by setting the optimization target to `image_pipe.unet.parameters()`. The rest is nearly identical to the example training loop from Unit 1. This takes about 10 minutes to run on Colab, so now is a good time to grab a coffee of tea while you wait:

```python
>>> num_epochs = 2  # @param
>>> lr = 1e-5  # @param
>>> grad_accumulation_steps = 2  # @param

>>> optimizer = torch.optim.AdamW(image_pipe.unet.parameters(), lr=lr)

>>> losses = []

>>> for epoch in range(num_epochs):
...     for step, batch in tqdm(enumerate(train_dataloader), total=len(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,
...             image_pipe.scheduler.num_train_timesteps,
...             (bs,),
...             device=clean_images.device,
...         ).long()

...         # Add noise to the clean images according to the noise magnitude at each timestep
...         # (this is the forward diffusion process)
...         noisy_images = image_pipe.scheduler.add_noise(clean_images, noise, timesteps)

...         # Get the model prediction for the noise
...         noise_pred = image_pipe.unet(noisy_images, timesteps, return_dict=False)[0]

...         # Compare the prediction with the actual noise:
...         loss = F.mse_loss(
...             noise_pred, noise
...         )  # NB - trying to predict noise (eps) not (noisy_ims-clean_ims) or just (clean_ims)

...         # Store for later plotting
...         losses.append(loss.item())

...         # Update the model parameters with the optimizer based on this loss
...         loss.backward(loss)

...         # Gradient accumulation:
...         if (step + 1) % grad_accumulation_steps == 0:
...             optimizer.step()
...             optimizer.zero_grad()

...     print(
...         f"Epoch {epoch} average loss: {sum(losses[-len(train_dataloader):])/len(train_dataloader)}"
...     )

>>> # Plot the loss curve:
>>> plt.plot(losses)
```

Epoch 0 average loss: 0.013324214214226231

**Consideration 2:** Our loss signal is extremely noisy, since we're only working with four examples at random noise levels for each step. This is not ideal for training. One fix is to use an extremely low learning rate to limit the size of the update each step. It would be even better if we could find some way to get the same benefit we would get from using a larger batch size _without_ the memory requirements skyrocketing... 

Enter [gradient accumulation](https://www.kozodoi.me/blog/gradient-accumulation-in-pytorch). If we call `loss.backward()` multiple times before running `optimizer.step()` and `optimizer.zero_grad()`, then PyTorch accumulates (sums) the gradients, effectively merging the signal from several batches to give a single (better) estimate which is then used to update the parameters. This results in fewer total updates being made, just like we'd see if we used a larger batch size. This is something many frameworks will handle for you (for example, [🤗 Accelerate makes this easy](https://huggingface.co/docs/accelerate/usage_guides/gradient_accumulation)) but it is nice to see it implemented from scratch since this is a useful technique for dealing with training under GPU memory constraints! As you can see from the code above (after the `# Gradient accumulation` comment) there really isn't much code needed.

```python
# Exercise: See if you can add gradient accumulation to the training loop in Unit 1.
# How does it perform? Think how you might adjust the learning rate based on the
# number of gradient accumulation steps - should it stay the same as before?
```

**Consideration 3:** This still takes a lot of time, and printing out a one-line update every epoch is not enough feedback to give us a good idea of what is going on. We should probably:

*   Generate some samples occasionally to visually examine the performance qualitatively as the model trains
*   Log things like the loss and sample generations during training, perhaps using something like Weights and Biases or tensorboard.

I created a quick script ([`finetune_model.py`](https://github.com/huggingface/diffusion-models-class/blob/main/unit2/finetune_model.py)) that takes the training code above and adds minimal logging functionality. You can see the [logs from one training run here](https://wandb.ai/johnowhitaker/dm_finetune/runs/2upaa341) below:

```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
```

It's fun to see how the generated samples change as training progresses - even though the loss doesn't appear to be improving much, we can see a progression away from the original domain (images of bedrooms) towards the new training data (wikiart). At the end of this notebook is commented-out code for fine-tuning a model using this script as an alternative to running the cell above.

```python
# Exercise: see if you can modify the official example training script we saw
# in Unit 1 to begin with a pre-trained model rather than training from scratch.
# Compare it to the minimal script linked above - what extra features is the minimal script missing?
```

Generating some images with this model, we can see that these faces are already looking mighty strange!

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

**Consideration 4:** Fine-tuning can be quite unpredictable! If we trained for a lot longer, we might see some perfect butterflies. But the intermediate steps can be extremely interesting in their own right, especially if your interests are more towards the artistic side! Explore training for very short or very long periods of time, and varying the learning rate to see how this affects the kinds of output the final model produces.

### Code for fine-tuning a model using the minimal example script we used on the WikiArt demo model

If you'd like to train a similar model to the one I made on WikiArt, you can uncomment and run the cells below. Since this takes a while and may exhaust your GPU memory, I recommend doing this _after_ working through the rest of this notebook.

```python
## To download the fine-tuning script:
# !wget https://github.com/huggingface/diffusion-models-class/raw/main/unit2/finetune_model.py
```

```python
## To run the script, training the face model on some vintage faces
## (ideally run this in a terminal):
# !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'
```

### Saving and Loading Fine-Tuned Pipelines

Now that we've fine-tuned the U-Net in our diffusion model, let's save it to a local folder by running: 

```python
image_pipe.save_pretrained("my-finetuned-model")
```

As we saw in Unit 1, this will save the config, model, scheduler:

```python
>>> !ls {"my-finetuned-model"}
```

model_index.json  scheduler  unet

Next, you can follow the same steps outlined in Unit 1's [Introduction to Diffusers](https://github.com/huggingface/diffusion-models-class/blob/main/unit1/01_introduction_to_diffusers.ipynb) to push the model to the Hub for later use:

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

Congratulations, you've now fine-tuned your first diffusion model!

For the rest of this notebook we'll use a [model](https://huggingface.co/johnowhitaker/sd-class-wikiart-from-bedrooms) I fine-tuned from [this model trained on LSUN bedrooms](https://huggingface.co/google/ddpm-bedroom-256) approximately one epoch on the [WikiArt dataset](https://huggingface.co/datasets/huggan/wikiart). If you'd prefer, you can skip this cell and use the faces/butterflies pipeline we fine-tuned in the previous section or load one from the Hub instead:

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

**Consideration 5:** It is often hard to tell how well fine-tuning is working, and what 'good performance' means may vary by use-case. For example, if you're fine-tuning a text-conditioned model like stable diffusion on a small dataset you probably want it to **retain** most of its original training so that it can understand arbitrary prompts not covered by your new dataset, while **adapting** to better match the style of your new training data. This could mean using a low learning rate alongside something like exponential model averaging, as demonstrated [in this great blog post about creating a pokemon version of stable diffusion](https://lambdalabs.com/blog/how-to-fine-tune-stable-diffusion-how-we-made-the-text-to-pokemon-model-at-lambda). In a different situation, you may want to completely re-train a model on new data (such as our bedroom -> wikiart example) in which case a larger learning rate and more training makes sense. Even though the [loss plot](https://wandb.ai/johnowhitaker/dm_finetune/runs/2upaa341) is not showing much improvement, the samples clearly show a move away from the original data and towards more 'artsy' outputs, although they remain mostly incoherent.

Which leads us to a the next section, as we examine how we might add additional guidance to such a model for better control over the outputs...

## Guidance

What do we do if we want some control over the samples generated? For example, say we wanted to bias the generated images to be a specific color. How would we go about that? Enter **guidance**, a technique for adding additional control to the sampling process.

Step one is to create our conditioning function: some measure (loss) which we'd like to minimize. Here's one for the color example, which compares the pixels of an image to a target color (by default a sort of light teal) and returns the average error:

```python
def color_loss(images, target_color=(0.1, 0.9, 0.5)):
    """Given a target color (R, G, B) return a loss for how far away on average
    the images' pixels are from that color. Defaults to a light teal: (0.1, 0.9, 0.5)"""
    target = (
        torch.tensor(target_color).to(images.device) * 2 - 1
    )  # Map target color to (-1, 1)
    target = target[
        None, :, None, None
    ]  # Get shape right to work with the images (b, c, h, w)
    error = torch.abs(
        images - target
    ).mean()  # Mean absolute difference between the image pixels and the target color
    return error
```

Next, we'll make a modified version of the sampling loop where, at each step, we do the following:
- Create a new version of x that has requires_grad = True
- Calculate the denoised version (x0)
- Feed the predicted x0 through our loss function
- Find the **gradient** of this loss function with respect to x
- Use this conditioning gradient to modify x before we step with the scheduler, hopefully pushing x in a direction that will lead to lower loss according to our guidance function

There are two variants here that you can explore. In the first, we set requires_grad on x **after** we get our noise prediction from the UNet, which is more memory efficient (since we don't have to trace gradients back through the diffusion model) but gives a less accurate gradient. In the second we set requires_grad on x **first**, then feed it through the UNet and calculate the predicted x0.

```python
>>> # Variant 1: shortcut method

>>> # The guidance scale determines the strength of the effect
>>> guidance_loss_scale = 40  # Explore changing this to 5, or 100

>>> x = torch.randn(8, 3, 256, 256).to(device)

>>> for i, t in tqdm(enumerate(scheduler.timesteps)):

...     # Prepare the model input
...     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"]

...     # Set x.requires_grad to True
...     x = x.detach().requires_grad_()

...     # Get the predicted x0
...     x0 = scheduler.step(noise_pred, t, x).pred_original_sample

...     # Calculate loss
...     loss = color_loss(x0) * guidance_loss_scale
...     if i % 10 == 0:
...         print(i, "loss:", loss.item())

...     # Get gradient
...     cond_grad = -torch.autograd.grad(loss, x)[0]

...     # Modify x based on this gradient
...     x = x.detach() + cond_grad

...     # Now step with scheduler
...     x = scheduler.step(noise_pred, t, x).prev_sample

>>> # View the output
>>> grid = torchvision.utils.make_grid(x, 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))
```

0 loss: 27.279136657714844
10 loss: 11.286816596984863
20 loss: 10.683112144470215
30 loss: 10.942476272583008

This second option requires nearly double the GPU RAM to run, even though we only generate a batch of four images instead of eight. See if you can spot the difference, and think through why this way is more 'accurate':

```python
>>> # Variant 2: setting x.requires_grad before calculating the model predictions

>>> guidance_loss_scale = 40
>>> x = torch.randn(4, 3, 256, 256).to(device)

>>> for i, t in tqdm(enumerate(scheduler.timesteps)):

...     # Set requires_grad before the model forward pass
...     x = x.detach().requires_grad_()
...     model_input = scheduler.scale_model_input(x, t)

...     # predict (with grad this time)
...     noise_pred = image_pipe.unet(model_input, t)["sample"]

...     # Get the predicted x0:
...     x0 = scheduler.step(noise_pred, t, x).pred_original_sample

...     # Calculate loss
...     loss = color_loss(x0) * guidance_loss_scale
...     if i % 10 == 0:
...         print(i, "loss:", loss.item())

...     # Get gradient
...     cond_grad = -torch.autograd.grad(loss, x)[0]

...     # Modify x based on this gradient
...     x = x.detach() + cond_grad

...     # Now step with scheduler
...     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
>>> Image.fromarray(np.array(im * 255).astype(np.uint8))
```

0 loss: 30.750328063964844
10 loss: 18.550724029541016
20 loss: 17.515094757080078
30 loss: 17.55681037902832

In the second variant, the memory requirements are higher and the effect is less pronounced, so you may think that this is inferior. However, the outputs are arguably closer to the types of images the model was trained on, and you can always increase the guidance scale for a stronger effect. Which approach you use will ultimately come down to what works best experimentally.

```python
# Exercise: pick your favourite colour and look up it's values in RGB space.
# Edit the `color_loss()` line in the cell above to receive these new RGB values and examine the outputs - do they match what you expect?
```

## CLIP Guidance

Guiding towards a color gives us a little bit of control, but what if we could just type some text describing what we want?

[CLIP](https://openai.com/blog/clip/) is a model created by OpenAI that allows us to compare images to text captions. This is extremely powerful, since it allows us to quantify how well an image matches a prompt. And since the process is differentiable, we can use this as a loss function to guide our diffusion model! 

We won't go too much into the details here. The basic approach is as follows:
- Embed the text prompt to get a 512-dimensional CLIP embedding of the text
- For every step in the diffusion model process:
  - Make several variants of the predicted denoised image (having multiple variations gives a cleaner loss signal)
  - For each one, embed the image with CLIP and compare this embedding with the text embedding of the prompt (using a measure called 'Great Circle Distance Squared')
- Calculate the gradient of this loss with respect to the current noisy x and use this gradient to modify x before updating it with the scheduler. 

For a deeper explanation of CLIP, check out [this lesson on the topic](https://johnowhitaker.github.io/tglcourse/clip.html) or [this report on the OpenCLIP project](https://wandb.ai/johnowhitaker/openclip-benchmarking/reports/Exploring-OpenCLIP--VmlldzoyOTIzNzIz) which we're using to load the CLIP model. Run the next cell to load a CLIP model:

```python
# @markdown load a CLIP model and define the loss function
import open_clip

clip_model, _, preprocess = open_clip.create_model_and_transforms(
    "ViT-B-32", pretrained="openai"
)
clip_model.to(device)

# Transforms to resize and augment an image + normalize to match CLIP's training data
tfms = torchvision.transforms.Compose(
    [
        torchvision.transforms.RandomResizedCrop(224),  # Random CROP each time
        torchvision.transforms.RandomAffine(
            5
        ),  # One possible random augmentation: skews the image
        torchvision.transforms.RandomHorizontalFlip(),  # You can add additional augmentations if you like
        torchvision.transforms.Normalize(
            mean=(0.48145466, 0.4578275, 0.40821073),
            std=(0.26862954, 0.26130258, 0.27577711),
        ),
    ]
)

# And define a loss function that takes an image, embeds it and compares with
# the text features of the prompt
def clip_loss(image, text_features):
    image_features = clip_model.encode_image(
        tfms(image)
    )  # Note: applies the above transforms
    input_normed = torch.nn.functional.normalize(image_features.unsqueeze(1), dim=2)
    embed_normed = torch.nn.functional.normalize(text_features.unsqueeze(0), dim=2)
    dists = (
        input_normed.sub(embed_normed).norm(dim=2).div(2).arcsin().pow(2).mul(2)
    )  # Squared Great Circle Distance
    return dists.mean()
```

With a loss function defined, our guided sampling loop looks similar to the previous examples, replacing `color_loss()` with our new clip-based loss function:

```python
>>> # @markdown applying guidance using CLIP

>>> prompt = "Red Rose (still life), red flower painting"  # @param

>>> # Explore changing this
>>> guidance_scale = 8  # @param
>>> n_cuts = 4  # @param

>>> # More steps -> 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))
```

Step: 0 , Guidance loss: 7.437869548797607
Step: 25 , Guidance loss: 7.174620628356934

Those look sort of like roses! It's not perfect, but if you play around with the settings you can get some pleasing images with this.

If you examine the code above you'll see I'm scaling the conditioning gradient by a factor of `alpha_bar.sqrt()`. There is some theory showing the 'right' way to scale these gradients, but in practice this is also something you can experiment with. For some types of guidance, you may want most of the effect concentrated in the early steps, for others (say, a style loss focused on textures) you may prefer that they only kick in towards the end of the generation process. Some possible schedules are shown below:

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

Experiment with different schedules, guidance scales and any other tricks you can think of (clipping the gradients within some range is a popular modification) to see how good you can get this! Also make sure you try swapping in other models. Perhaps the faces model we loaded at the start - can you reliably guide it to produce a male face? What if you combine CLIP guidance with the color loss we used earlier? Etc.

If you check out [some code for CLIP-guided diffusion in practice](https://huggingface.co/spaces/EleutherAI/clip-guided-diffusion/blob/main/app.py), you'll see a more complex approach with a better class for picking random cutouts from the images and lots of additional tweaks to the loss function for better performance. Before text-conditioned diffusion models came along, this was the best text-to-image system there was! Our little toy version here has lots of room to improve, but it captures the core idea: thanks to guidance plus the amazing capabilities of CLIP, we can add text control to an unconditional diffusion model 🎨.

## Sharing A Custom Sampling Loop as a Gradio Demo

Perhaps you've figured out a fun loss to guide generation with, and you now want to share both your fine-tuned model and this custom sampling strategy with the world...

Enter [Gradio](https://gradio.app/). Gradio is a free and open-source tool that allows users to easily create and share interactive machine learning models through a simple web interface. With Gradio, users can build custom interfaces for their machine learning models, which can then be shared with others through a unique URL. It is also integrated into 🤗 Spaces which makes it easy to host demos and share them with others. 

We'll put our core logic in a function that takes some inputs and produces an image as the output. This can then be wrapped in a simple interface that allows the user to specify some parameters (which are passed as inputs to the main generate function). There are many [components](https://gradio.app/docs/#components) available - for this example we'll use a slider for the guidance scale and a color picker to define the target color.

```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
```

It is possible to build much more complicated interfaces, with fancy styling and a wide array of possible inputs, but for this demo we're keeping it as simple as possible.

Demos on 🤗 Spaces run on CPU by default, so it's nice to prototype your interface in Colab (as above) before migrating over. When you're ready to share your demo, you'll create a space, set up a `requirements.txt` file listing the libraries your code will use and then place all the code in an `app.py` file which defines the relevant functions and the interface. 

![Screenshot from 2022-12-11 10-28-26.png](data:image/png;base64,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)

Lucky for you, there's also an option to 'Duplicate' a space. You can visit my demo space [here](https://huggingface.co/spaces/johnowhitaker/color-guided-wikiart-diffusion) (shown above) and click 'Duplicate this Space' to get a template which you can then modify to use your own model and guidance function. 

In the settings, you can configure your space to run on fancier hardware (which is charged per hour). Made something amazing and want to share it on better hardware but don't have the money? Let us know via Discord and we'll see if we can help!

## Summary and Next Steps

We've covered a lot in this notebook! Let's recap the core ideas:
- It's relatively easy to load in existing models and sample them with different schedulers
- Fine-tuning looks just like training from scratch, except that by starting from an existing model we hope to get better results more quickly
- To fine-tune large models on big images, we can use tricks like gradient accumulation to get around batch size limitations
- Logging sample images is important for fine-tuning, where a loss curve might not show much useful information
- Guidance allows us to take an unconditional model and steer the generation process based on some guidance/loss function, where at each step we find the gradient of the loss with respect to the noisy image x and update it according to this gradient before moving on to the next timestep
- Guiding with CLIP let's us control unconditional models with text!

To put this into practice, here are some specific next steps you can take:
- Fine-tune your own model and push it to the hub. This will involve picking a starting point (e.g. a model trained on [faces](https://huggingface.co/google/ddpm-celebahq-256), [bedrooms](https://huggingface.co/fusing/ddpm-lsun-bedroom), [cats](https://huggingface.co/fusing/ddpm-lsun-cat) or the [wikiart example above](https://huggingface.co/johnowhitaker/sd-class-wikiart-from-bedrooms)) and a dataset (perhaps these [animal faces](https://huggingface.co/datasets/huggan/AFHQv2) or your own images) and then running either the code in this notebook or the example script (demo usage below).
- Explore guidance using your fine-tuned model, either using one of the example guidance functions (color_loss or CLIP) or inventing your own. 
- Share a demo based on this using Gradio, either modifying the [example space](https://huggingface.co/spaces/johnowhitaker/color-guided-wikiart-diffusion) to use your own model or creating your own custom version with more functionality.

We look forward to seeing your results on Discord, Twitter, and elsewhere 🤗!

### Unit 2: Fine-Tuning, Guidance and Conditioning
https://huggingface.co/learn/diffusion-course/unit2/1.md

# Unit 2: Fine-Tuning, Guidance and Conditioning

Welcome to Unit 2 of the Hugging Face Diffusion Models Course! In this unit, you will learn how to use and adapt pre-trained diffusion models in new ways. You will also see how we can create diffusion models that take additional inputs as **conditioning** to control the generation process.

## Start this Unit 🚀

Here are the steps for this unit:

- Make sure you've [signed up for this course](https://huggingface.us17.list-manage.com/subscribe?u=7f57e683fa28b51bfc493d048&id=ef963b4162) so that you can be notified when new material is released.
- Read through the material below for an overview of the key ideas of this unit.
- Check out the _**Fine-tuning and Guidance**_ notebook to fine-tune an existing diffusion model on a new dataset using the 🤗 Diffusers library and to modify the sampling procedure using guidance.
- Follow the example in the notebook to share a Gradio demo for your custom model.
- (Optional) Check out the _**Class-conditioned Diffusion Model Example**_ notebook to see how we can add additional control to the generation process.
- (Optional) Check out [this video](https://www.youtube.com/watch?v=mY20iKOQ2zw) for an informal run-through of the material in this unit.

📢 Don't forget to join the [Discord](https://huggingface.co/join/discord), where you can discuss the material and share what you've made in the `#diffusion-models-class` channel.
 
## Fine-Tuning

As you may have seen in Unit 1, training diffusion models from scratch can be time-consuming! Especially as we push to higher resolutions, the time and data required to train a model from scratch can become impractical. Fortunately, there is a solution: begin with a model that has already been trained! This way we start from a model that has already learned to denoise images of some kind, and the hope is that this provides a better starting point than beginning from a randomly initialized model.

![Example images generated with a model trained on LSUN Bedrooms and fine-tuned for 500 steps on WikiArt](https://api.wandb.ai/files/johnowhitaker/dm_finetune/2upaa341/media/images/Sample%20generations_501_d980e7fe082aec0dfc49.png)

Fine-tuning typically works best if the new data somewhat resembles the base model's original training data (for example, beginning with a model trained on faces is probably a good idea if you're trying to generate cartoon faces) but surprisingly the benefits persist even if the domain is changed quite drastically. The image above is generated from a [model trained on the LSUN Bedrooms dataset](https://huggingface.co/google/ddpm-bedroom-256) and fine-tuned for 500 steps on [the WikiArt dataset](https://huggingface.co/datasets/huggan/wikiart). The [training script](https://github.com/huggingface/diffusion-models-class/blob/main/unit2/finetune_model.py) is included for reference alongside the notebooks for this unit.

## Guidance

Unconditional models don't give much control over what is generated. We can train a conditional model (more on that in the next section) that takes additional inputs to help steer the generation process, but what if we already have a trained unconditional model we'd like to use? Enter guidance, a process by which the model predictions at each step in the generation process are evaluated against some guidance function and modified such that the final generated image is more to our liking. 

![guidance example image](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/diffusion-course/guidance_eg.png)

This guidance function can be almost anything, making this a powerful technique! In the notebook, we build up from a simple example (controlling the color, as illustrated in the example output above) to one utilizing a powerful pre-trained model called CLIP which lets us guide generation based on a text description. 

## Conditioning

Guidance is a great way to get some additional mileage from an unconditional diffusion model, but if we have additional information (such as a class label or an image caption) available during training then we can also feed this to the model for it to use as it makes its predictions. In doing so, we create a **conditional** model, which we can control at inference time by controlling what is fed in as conditioning. The notebook shows an example of a class-conditioned model which learns to generate images according to a class label. 

![conditioning example](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/diffusion-course/conditional_digit_generation.png)

There are a number of ways to pass in this conditioning information, such as
- Feeding it in as additional channels in the input to the UNet. This is often used when the conditioning information is the same shape as the image, such as a segmentation mask, a depth map or a blurry version of the image (in the case of a restoration/superresolution model). It does work for other types of conditioning too. For example, in the notebook, the class label is mapped to an embedding and then expanded to be the same width and height as the input image so that it can be fed in as additional channels.
- Creating an embedding and then projecting it down to a size that matches the number of channels at the output of one or more internal layers of the UNet, and then adding it to those outputs. This is how the timestep conditioning is handled, for example. The output of each Resnet block has a projected timestep embedding added to it. This is useful when you have a vector such as a CLIP image embedding as your conditioning information. A notable example is the ['Image Variations' version of Stable Diffusion](https://huggingface.co/spaces/lambdalabs/stable-diffusion-image-variations) which does exactly this.
- Adding cross-attention layers that can 'attend' to a sequence passed in as conditioning. This is most useful when the conditioning is in the form of some text - the text is mapped to a sequence of embeddings using a transformer model, and then cross-attention layers in the UNet are used to incorporate this information into the denoising path. We'll see this in action in Unit 3 as we examine how Stable Diffusion handles text conditioning.

## Hands-On Notebook

| Chapter                                     | Colab                                                                                                                                                                                               | Kaggle                                                                                                                                                                                                   | Gradient                                                                                                                                                                               | Studio Lab                                                                                                                                                                                                   |
|:--------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Fine-tuning and Guidance                                | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit2/01_finetuning_and_guidance.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit2/01_finetuning_and_guidance.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/unit2/01_finetuning_and_guidance.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/unit2/01_finetuning_and_guidance.ipynb)              |
| Class-conditioned Diffusion Model Example                               | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit2/02_class_conditioned_diffusion_model_example.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit2/02_class_conditioned_diffusion_model_example.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/unit2/02_class_conditioned_diffusion_model_example.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/unit2/02_class_conditioned_diffusion_model_example.ipynb)              |

At this point, you know enough to get started with the accompanying notebooks! Open them in your platform of choice using the links above. Fine-tuning is quite computationally intensive, so if you're using Kaggle or Google Colab make sure you set the runtime type to 'GPU' for the best results.

The bulk of the material is in _**Fine-tuning and Guidance**_, where we explore these two topics through worked examples. The notebook shows how you can fine-tune an existing model on new data, add guidance, and share the result as a Gradio demo. There is an accompanying script ([finetune_model.py](https://github.com/huggingface/diffusion-models-class/blob/main/unit2/finetune_model.py)) that makes it easy to experiment with different fine-tuning settings, and an [example space](https://huggingface.co/spaces/johnowhitaker/color-guided-wikiart-diffusion) that you can use as a template for sharing your own demo on 🤗 Spaces. 

In the _**Class-conditioned Diffusion Model Example**_, we show a brief worked example of creating a diffusion model conditioned on class labels using the MNIST dataset. The focus is on demonstrating the core idea as simply as possible: by giving the model extra information about what it is supposed to be denoising, we can later control what kinds of images are generated at inference time.

## Project Time

Following the examples in the _**Fine-tuning and Guidance**_ notebook, fine-tune your own model or pick an existing model and create a Gradio demo to showcase your new guidance skills. Don't forget to share your demo on Discord, Twitter etc so we can admire your work!

## Some Additional Resources

[Denoising Diffusion Implicit Models](https://arxiv.org/abs/2010.02502) - Introduced the DDIM sampling method (used by DDIMScheduler)
 
[GLIDE: Towards Photorealistic Image Generation and Editing with Text-Guided Diffusion Models](https://arxiv.org/abs/2112.10741) - Introduced methods for conditioning diffusion models on text

[eDiffi: Text-to-Image Diffusion Models with an Ensemble of Expert Denoisers](https://arxiv.org/abs/2211.01324) - Shows how many different kinds of conditioning can be used together to give even more control over the kinds of samples generated

Found more great resources? Let us know and we'll add them to this list.

### Introduction
https://huggingface.co/learn/diffusion-course/unit3/2.md

# Introduction

This notebook is going to cover the basics of how to use Stable Diffusion to create and modify images using existing pipelines. We'll also take a brief look at the key components within the pipeline, while leaving further exploration of them to the deep dive notebook. Specifically, we will cover:
- Generating images from text using the `StableDiffusionPipeline` and experimenting with the available arguments
- Seeing some of the key pipeline components in action
    - The VAE that makes this a 'latent diffusion model'
    - The tokenizer and text encoder that process the text prompt
    - The UNet itself
    - The scheduler, and exploring different schedulers
- Replicating the sampling loop with the pipeline components
- Editing existing images with the Img2Img pipeline
- Using inpainting and Depth2Img pipelines

❓If you have any questions, please post them on the `#diffusion-models-class` channel on the Hugging Face Discord server. If you haven't signed up yet, you can do so here: https://huggingface.co/join/discord

# Setup

```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"

img_height = 512
img_width = 512

init_image = download_image(img_url).resize((img_height, img_width))
mask_image = download_image(mask_url).resize((img_height, img_width))
```

```python
# Set device
device = (
    "mps"
    if torch.backends.mps.is_available()
    else "cuda"
    if torch.cuda.is_available()
    else "cpu"
)
```

# Generating Images from Text

Let's load a Stable Diffusion pipeline and see what it can do. There are multiple different versions of Stable Diffusion, with the latest at the time of writing being version 2.1. If you'd like to explore an older version, simply replace the model ID with the appropriate model (for example, you could try "CompVis/stable-diffusion-v1-4" or pick a model from the [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)
```

If you're running out of GPU memory, there are some things you can do to reduce the RAM usage:
- Load the FP16 version (not supported on all systems). With this you may also need to convert tensors to torch.float16 when experimenting with individual components of the pipeline:

  `pipe = StableDiffusionPipeline.from_pretrained(model_id, revision="fp16", torch_dtype=torch.float16).to(device)`

- Enable attention slicing. This reduces GPU memory usage at the cost of a small reduction in speed:

 `pipe.enable_attention_slicing()`
- Reduce the size of the images you're generating

Once the pipeline is loaded, we can generate an image based on a prompt with the following code:

```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]
```

**Exercise:** Spend some time playing with the cell above, using your own prompts and tweaking settings to see how they affect the output. Use a different random seed or remove the `generator` argument to get different results each time.

Key arguments to tweak:
- Width and height specify the size of the generated image. They must be divisible by **8** for the VAE to work (which we'll see in a future section).
- The number of steps influences the generation quality. The default (50) works well, but in some cases you can get away with as few as 20 steps which is handy for experimentation.
- The negative prompt is used during the classifier-free guidance process, and can be a useful way to add additional control. You can leave it out, but many users find it useful to list some undesirable descriptions in the negative prompt as shown above.
- The `guidance_scale` argument determines how strong the classifier-free guidance (CFG) is. Higher scales push the generated images to better match the prompt, but if the scale is too high the results can become over-saturated and unpleasant. 

If you're looking for prompt inspiration, the [Stable Diffusion Prompt Book](https://stability.ai/sdv2-prompt-book) is a good place to start.

You can see the effect of increasing the guidance scale in the following cell:

```python
>>> #@markdown comparing guidance scales:
>>> cfg_scales = [1.1, 8, 12] #@param
>>> prompt = "A collie with a pink hat" #@param
>>> fig, axs = plt.subplots(1, len(cfg_scales), figsize=(16, 5))
>>> for i, ax in enumerate(axs):
...   im = pipe(prompt, height=480, width=480,
...     guidance_scale=cfg_scales[i], num_inference_steps=35,
...     generator=torch.Generator(device=device).manual_seed(42)).images[0]
...   ax.imshow(im); ax.set_title(f'CFG Scale {cfg_scales[i]}');
```

Tweak the values above to try different scales and prompts. Interpretation is subjective of course, but to my eye anything in the 8-12 range produces better results than values below or above this range.

# Pipeline Components

The `StableDiffusionPipeline` we're using is a little more complex than the `DDPMPipeline` we've explored in the previous units. In addition to the UNet and the scheduler, there are a number of other components included in the pipeline:

```python
>>> print(list(pipe.components.keys())) # List components
```

['vae', 'text_encoder', 'tokenizer', 'unet', 'scheduler', 'safety_checker', 'feature_extractor', 'image_encoder']

To better understand how the pipeline works, let's briefly see each component in action individually and then put them all together to replicate the functionality of the pipeline for ourselves.

### The VAE

![vae_diagram.png](data:image/png;base64,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)

The VAE (variational autoencoder) is a type of model that can encode its input into a compressed representation and then decode this 'latent' representation back into something close to the original input. When generating images with Stable Diffusion, we first **generate the latents** by applying the diffusion process in the 'latent space' of the VAE, and then **decode them at the end** to view the resulting image.

Here is some code that takes an input image, encodes it to a latent representation and then decodes it again using the VAE:

```python
>>> # Create some fake data (a random image, range (-1, 1))
>>> images = torch.rand(1, 3, 512, 512).to(device) * 2 - 1 
>>> print("Input images shape:", images.shape)

>>> # Encode to latent space
>>> with torch.no_grad():
...   latents = 0.18215 * pipe.vae.encode(images).latent_dist.mean
>>> print("Encoded latents shape:", latents.shape)

>>> # Decode again
>>> with torch.no_grad():
...   decoded_images = pipe.vae.decode(latents / 0.18215).sample
>>> print("Decoded images shape:", decoded_images.shape)
```

Input images shape: torch.Size([1, 3, 512, 512])
Encoded latents shape: torch.Size([1, 4, 64, 64])
Decoded images shape: torch.Size([1, 3, 512, 512])

As you can see, the 512x512 image is compressed to a 64x64 latent representation (with four channels). This 8x reduction in each spatial dimension is the reason the specified width and height need to be multiples of 8.

Working with these information-rich 4x64x64 latents is more efficient than working with massive 512px images, allowing for faster diffusion models that take less resources to train and use. The VAE decoding process is not perfect, but it is good enough that the small quality tradeoff is generally worth it. 

NB: The code example above includes the scaling factor of 0.18215 required to match the processing used during SD's training. 

### The Tokenizer and Text Encoder

![text_encoder.png](data:image/png;base64,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)

The goal of the text encoder is to turn an input string (the prompt) into a numerical representation that can be fed to the UNet as conditioning. The text is first turned into a series of tokens using the pipeline's tokenizer. The text encoder has a vocabulary of about 50k tokens - any word isn't in this vocabulary is split into smaller sub-words. The tokens are then fed through the text encoder model itself - a transformer model that was originally trained as the text encoder for CLIP. The hope is that this pretrained transformer model has learnt rich representations of text that will be useful for the diffusion task too.

Let's test out this process by encoding an example prompt, first manually tokenizing and feeding it through the text encoder and then using the pipelines `encode_prompt` method to show the full process including padding/truncating the length to the maximum length of 77 tokens:

```python
>>> # Tokenizing and encoding an example prompt manually

>>> # Tokenize
>>> input_ids = pipe.tokenizer(["A painting of a flooble"])['input_ids']
>>> print("Input ID -> 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 -> 
320 -> a
3086 -> painting
539 -> of
320 -> a
4062 -> floo
1059 -> ble
49407 -> 
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, True, '')
text_embeddings.shape
```

These text embeddings (the so-called 'hidden states' of the last transformer block in the text encoder model) will be fed to the UNet as an additional argument to the `forward` method, which we'll see in the next section.

### The UNet

![unet.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAjEAAAEFCAYAAAASbLbSAAAAAXNSR0IArs4c6QAABVp0RVh0bXhmaWxlACUzQ214ZmlsZSUyMGhvc3QlM0QlMjJhcHAuZGlhZ3JhbXMubmV0JTIyJTIwbW9kaWZpZWQlM0QlMjIyMDIyLTEyLTE5VDA0JTNBMzMlM0E0Ny44NTVaJTIyJTIwYWdlbnQlM0QlMjI1LjAlMjAoWDExJTNCJTIwTGludXglMjB4ODZfNjQpJTIwQXBwbGVXZWJLaXQlMkY1MzcuMzYlMjAoS0hUTUwlMkMlMjBsaWtlJTIwR2Vja28pJTIwQ2hyb21lJTJGMTA3LjAuMC4wJTIwU2FmYXJpJTJGNTM3LjM2JTIyJTIwdmVyc2lvbiUzRCUyMjIwLjcuMiUyMiUyMGV0YWclM0QlMjJjWFZ5OHhoenR5WUJIc3NFeXZKbiUyMiUyMHR5cGUlM0QlMjJkZXZpY2UlMjIlM0UlM0NkaWFncmFtJTIwaWQlM0QlMjI0WTc4ZDVQQlQ1OTlxOC10cHpIeSUyMiUyMG5hbWUlM0QlMjJQYWdlLTElMjIlM0UzVmZianBzd0VQMmFTTzNEVnR4aEg1dExiMnBYcmJLcjdqNVZEcDZBVzRPUmNSTFNyJTJCOFFUSURDSnEyMDJUUjlzdWVNamNkenp0aG1aRSUyQlM0cTBrV2Z4SlVPQWp5NkRGeUo2T0xNc3lmQWViRXRsV2lPJTJGYkZSQkpSaXZJYklBNSUyQndrYU5EUzZZaFR5emtBbEJGY3M2NEtoU0ZNSVZRY2pVb3BOZDloUzhPNnFHWW1nQjh4RHd2dm9WMFpWckZIVHUyNGM3NEJGc1Y0NnNQektrWkI2c041SkhoTXFOaTNJbm8zc2lSUkNWYjJrbUFBdmsxZm5wWnIzNWhIdlBqQUpxZnFUQ1IlMkJLMTVzdnQlMkZmeiUyRk9IR3VucXZ0a0ZpR1ZlbSUyRmt5dXR2V09nV0lDdENta2lrVWtVc0puRFRxV1lwVlNLRDlyb05XTSUyQlNoRWhxQ0o0SGRRYXF2WkpDc2xFSXBWd3JVWEk1YmJlejElMkZaenlVeGl2THJlMXAwZlpPdDlxcWdpMGpmRFFKOVliRVNvWndZT2V1RmhPUkVhaERHV3E0UXBHRFNBQUR3b2tTT0ZGczNRMkVhTFZGJTJCM0VOSWRqUm5Qd0ZQenJLTmVFcnZaS0NRbjJEWkFHVXNqUWFXUjdINk1jTGliMm83TDNBVUhBdHclMkZlcjFqUXM1MldQNUliQ2tvOU56QlRNTTdKTDJBWUx1VXZYa25FJTJCRVZ6STNWeWJFZ2lXSWVLNWt1SUh0RHhlR01CaXVlZHBEUktqUGN4VVA3RjZncVBMUnA4YmUzdlRxc0s2dE9KV0FYckdpYWd3N1hPVXloTXEzcjhJeGZzOXhhZUM1ZVg2dURydU9SJTJCUXZGTkozZHUzZmNFZmtUakpzJTJCcjJXTEtpcE9zOG12ZTZtcmV0dnVhREFja0hKNU84OHklMkZkRHY0ejNnN0JSZFJLMEw4ZFdBSzVncXpQRyUyQmY0WklMTE9PeWRBZUVQSHZiT3laVHZYZmhoWDclMkJmanl2WVBhZUM2ekJiRXI2N21kMzJrbyUyQlA1NnpzN3JSdGp6T1FLSFFGVWtPZkclMkZ1NHZ2R0Exd3dNNkIxTTZvSSUyRnBQZHJ6N2VKOXpSNiUyRiUyRjJrdHdLM0wzaCUyRlFQQ21lekxGOTUlMkJhNWNVTDViNGtVQllxSnRMJTJGJTJCTzUxZ21lN2ZORnNmdnQydnRiUHN6MzdCUSUzRCUzRCUzQyUyRmRpYWdyYW0lM0UlM0MlMkZteGZpbGUlM0WsljKvAAAgAElEQVR4Xu2dCXhN19fGX5knGQRB1BRBIighVFpDUFU1VNXUqmqJVlutUmpqqzWUoqMOSktNpdqaU2NQMYSYEgkiJAgJiQwyR+J79vHJP1Hh5t5zknPufc/z5CHu3uus9Vvr9rzdZw+V7ty5cwe8SIAESIAESIAESEBjBCpRxGgsY3SXBEiABEiABEhAIkARw0IgARIgARIgARLQJAGKGE2mjU6TAAmQAAmQAAlQxLAGSIAESIAESIAENEmAIkaTaaPTJEACJEACJEACFDGsARIgARIgARIgAU0SoIjRZNroNAmQAAmQAAmQAEUMa4AESIAESIAESECTBChiNJk2Ok0CJEACJEACJEARwxogARIgARIgARLQJAGKGE2mjU6TAAmQAAmQAAlQxLAGSIAESIAESIAENEmAIkaTaaPTJEACJEACJEACFDGsARIgARIgARIgAU0SoIjRZNroNAmQAAmQAAmQAEUMa4AESIAESIAESECTBChiNJk2Ok0CJEACJEACJEARwxogARIgARIgARLQJAGKGE2mjU6TAAmQAAmQAAmUi4i5npKFI1GJiIxNQWJKJnLzCkhepQSsrczh5mIP73ouaOPlhuoudir1lG6RAAmQAAmYOgHFRcy64PM4FHkNPg1rol6tKqjqbA9rKwtT567a+HPzbiMpNROxV28i4vw1tPOuif6dG6rWXzpGAiRAAiRgugQUEzFpmXlYtCECTo52aN+iPoWLBmtMCJoDJy8iLT0LgX184GRvpcEo6DIJkAAJkICxElBMxHyx6hjc3VzQxqeOsbIzmbiORFxCfGIKPhjSymRiZqAkQAIkQALqJ6CIiBGvkG5m3kbnNp7qJ0APdSIQfCQaVewt+GpJJ1psRAIkQAIkUB4EZBcxYhLv3FVheLW3H18hlUcGy+ke4tXS0o2hmDDEl5N9y4k5b0MCJEACJPBwArKLmC0HLuLGrQL4P16f7I2MQMiJi6hW2Rw92zO3RpZahkMCJEACmiQgu4gRc2HaNKsH9+pOmgRCp0snEH89DUfCYzk3hkVCAiRAAiSgCgKyi5jxC//lqyRVpFZ+J+69Upr31lPyG6dFEiABEiABEigjAdlFzDtf7sGYIXzIlTEPmmn+zap/8e3YTprxl46SAAmQAAkYLwGKGOPNrSKRUcQogpVGSYAESIAE9CBAEaMHNFPuQhFjytln7CRAAiSgLgIUMerKh+q9oYhRfYroIAmQAAmYDAGKGJNJtTyBUsTIw5FWSIAESIAEDCdAEWM4Q5OyQBFjUulmsCRAAiSgagIUMapOj/qco4hRX07oEQmQAAmYKgGKGFPNvJ5xU8ToCY7dSIAESIAEZCdAESM7UuM2SBFj3PlldCRAAiSgJQIUMVrKlgp8pYhRQRLoAgmQAAmQgERAtSLmqzkfo027p+DfsateqTK0v643PRF2GBPHvIZtIad17fLAdl7u1jgcmQhHJ+cSn4cdDsH0ye9g465jWPL9fFw4fxYzFywy6F6GdKaIMYQe+5IACZAACchJQLUiZlDvDhg9dgo6dO6uV7yG9tf1puUpYtJSbyIvLw/VqtfQ1T3Z21HEyI6UBkmABEiABPQkoEoRs3LpD5g3YzLcarjjo1lfo61/J3w99xPs3bVVCtPD0wsfz/4GSTcSMfC5p7D8z13w8mmBCe+8CgsLSzRt0apE//YdupSKJzL8BGZ99D4yMtJRCZUw6t0P8cxzLyDiZBimjh8l3Uvc51Z6GoaPeg//bP4TVy5dRLPH22DGvB8hRMyYEQPRsnU7XLxwDvYOlTF9zvdo1KQpCgoKHui3k3MV7Nv9D+Z+OhEWlpZ43Lcd1iz/uWgkZtF3c/HHyl9Q2dEJjZr4IDLi+H9GYnwbuWLIsDdwNioc8ZdjMXjYKLz82ltSnIu/n4c1yxfD3sEBfk90xI6t6xF8NEbPEinZjSJGFow0QgIkQAIkIAMBVYoYEVfxkZTfFn+LiFPHMPvLxTA3N8fPC79A9JnTmPvtUqxdsRjLf1mIV0a8A9Huj60HYGNjW6J/aZyys7PwXKfH8eNv6+HZ2BspN5PQv0d7LF61CZkZGXjx2fbYsOuYJEgmjBmOC9FnsGbzfhQWFqBDy3pYvWEPUlNTMPC5J/HbnzvRtn1HbPprNb7/cha27juF5Uu+e6DfU2d8hQC/hlj6x3b4NG+FP1YuwZRxo3D0bBJOnzom/f3vHaFwdHTGxDHDcSby1H9ETIsGTpjy6XwMeHkE4q/EoXt7bxw5c10SVR9NGI11QQfg6OQi/X1/8HaKGBm+LDRBAiRAAiSgLgKaEDHDBz6D2AvnUdnRUaJXcPs2rG1s8de2w9Lv74wYgL07g7Bx9zHUa+Ap/Zsur5OOHTmIYf27oX7DRkVZuZWWhg+mzUadeh4YM3IQdodGS599+flHyMrMwJTPFki/9+zYHDMX/Cz9fdoHb2DT7uNFNlrUd0TQ/ghMeT/wgX6/O+ETLJg9FRt2hkl9CgsL0ayuAw5GXMWPX3+O27fzMfnT+dJnx0IP4JNJbz9QxAih5F67rtROiJpdh8/h54XzYGVphXFTZkr/fi4qAqOG9qGIUdf3jt6QAAmQAAnIQEATIuaV/t3Qq99gvDjkNSlkMYIiBIVr1erIy8tF/x5PIPnGdUyd+RV69Oqvs4g5eng/3n/jZew7HluE8kbiNThXccXZyHCMG/1K0YRdIWJyc3Pw4cdz/yNiPpvyLv7851CRjZYNXbD9QBTGjR76QL/Fq6r5s6ZIwuTeJYTPvycuSSImPz+vSCydOn5Eeq11/8ReIVp2HjpbND/m3u9Lf/oalSpVwvips+6KmDOnMerl3hQxMnxZaIIESIAESEBdBFQrYl5+PgCvBr6Lrj36SK+Ptq5fixV/75bmnHzy4dtIS03Blz+uxGdT3oOY8Br49gS8OqA7/gg6II1OFO9fGvLMjFvo2q4xJk2fh94vDEHcxfPo170t1m7Zj+ysLJ1FjLiXGBURozd7dwXhy8+nYf2Oo6X6/enc7xHg54lFKzZKc2m2bliL90YNkV4niVdHE95+VXqd5FKlKqZ/+A7CjoToLGJiL0Rj0nsj8Oc/ByHm3gg+u7dvRvCR87JUHufEyIKRRkiABEiABGQgoFoR88sPC/Dt/M8wbeZX6N1vCObPnorg7VtgZmYmvf6ZtWARjh89hI8+GI3Ne05IS5PFhNhd/2zEqvV7sOznb4r69xs4rFRUYg7J55+MR0bGLdwpLMQb706SRk/EaImuIzFivoyYN5Oflye9Cvpo1jeoW78hbufnP9BvIS4OH9iLmdPGSqMmYpLwP5vWYXfoeSkOMZdm+ZKFcHCojOat/HDsyAGdRYxYuSRiX7X0J1jbWKNJ0xaIOBEmiSw5LooYOSjSBgmQAAmQgBwEVCti5AjOFG2ICdBHD/0rjWKJ69efvsLJsMP4atFqWXBQxMiCkUZIgARIgARkIGD0ImZn0Aas/u2nB6Lq1qMvBr0SKANG9ZgQr8jEhOLos6elUZ6a7nWkpeBuNd1lcZIiRhaMNEICJEACJCADAaMXMTIwooliBChiWA4kQAIkQAJqIUARo5ZMaMQPIWK+e7+zRrwt3c1OnTohODhY83EwABIgARIwZQIUMaacfT1iN5aRGPGq7c6dO3oQYBcSIAESIAG1EKCIUUsmNOIHRYxGEkU3SYAESMAECFDEmECS5QyRIkZOmrRFAiRAAiRgCAHNi5jZH49HQPde0rlF965pH7yJ2nXqYdQ7Ex/KRmzJ/2JP/xJtsrMyseCHFUhLS8HcTz8s+kzsIZOTk439Jy6heo1aj2QuzlDasG4FFq/aUtR2z86tmDdjErKzs+Hd7HHMWvCzdMij2E9m5rT3ceDf3VLbJt7N8OkX30ub1d27xKGTz3fzk85oEoddZtxKx3ujBuP7pX/Bysr6kf7I1YAiRi6StEMCJEACJGAoAU2LmCOH/pUOffx28VqJg9hxd/qkdxB2OASj35/ySBFzPzxxeva2zX/h19+DYG5hUeLj9wIHo4FnE4z54OOHMhfiQhxR8NeaZWjV5gksWX335O2byTfwbIfm+H3TPul8p/mzpkoHTorlz7/++CVC9u3Cj8v+lu778cS3pPkan33xg9RXHHcw7MWnceb0KazesFcSMeL6Y9UvuBx3Ee9P+szQOtC5P0WMzqjYkARIgARIQGECmhYxQ/t1wZvvTUb7Dl0kTJ9Pn4DGXj44dfwoatRyL5OIuXD+DF7qG4D1O478Z0+Vdat/xe+/LZJOsBanaD/s+nvtb4i7GCMJlU1/rSoSMRv/XCWdcP3zyk1S94RrV9DdvymOn0/ByWOh0nEKYtdfcf35+1Js3/I3flq+Qfp98tiRaOXXHgvnz5BGXu6JGHGGlDg2YevekyVGbZSsGYoYJenSNgmQAAmQQFkIaFbEpKYko33z2gi/eOs/oybTJ40ps4gZ+VIvtHniKekMpuKXEAoBbRrih2V/43Hftjqz/Wfzn/hj5ZIiEfPTt3MQfzkO4twkcYmRlsY1LXHkzPUSAkSMzgx87imMmzwT3Z/rJ9kQp23P/moxOrf2KCFihJ0RQ56Tjkno0/8lnX0zpCFFjCH02JcESIAESEBOApoVMeLMo7GjhjzwdOayipjos5EY+NyTCDl5GbZ29iX4rvz1e2zb8jd+W7ejTNzvFzE/fj0bV+Mv/0fEhJ1LlubFiCs25hxGD++PF4cMx/A3xkIcIfDJxLekgy9tbGwfKGLEAZGOzi4Y++GnZfJP38YUMfqSYz8SIAESIAG5CWhWxIhXMB+8PQzbD0T9h0lZRYyYn5J0PUEa7bj/EuJm8Cuj0HfA0DKxv1/EbFi3Ujqt+t4rosRr8ejRoRmEiBF7lvwbvB1Tx42SDrwUJ3eLS0z2Xf/HClhaWkq/i3k1jk4umPXlz+j6TO+iNkIEPWquTpmcf0hjihi5SNIOCZAACZCAoQQ0K2LSUm+iQ6v6OHr2BiwtrUpwuF/E5Ofn4eqVS9LJ0g+6BvT0x8ChI/HCoFdLfCxWKrXyrIIdB8+gdp36RZ89yp5oeL+ISU66Lk3sXbUhGB6eXlgwexquxV/CF98tk14XiYnDv6wJQsNGXqXm9EGvk94c9jx69h2I554fZGgt6NSfIkYnTGxEAiRAAiRQDgQ0K2IEG7FiRyyjvjex9x6v+0VMVMRJ9Onqi6grOf+ZPyP6tG5cFUv/2A6f5q1KIBergQb36Yhj0Tel0ZJ716PsPUjEiH/buysIX8yYhNycHElQzVu4DM4urhjU6ymcPH6kxFLpps1bYtX6PSX8uV/EiFVLAX6e2Lb/NBwqO5ZDuQAUMeWCmTchARIgARLQgYCmRYxYYi2WJ4sVO4+6Jr034oGvix7Vr7TP5banjx9i0u+luIsYN3mGPt316kMRoxc2diIBEiABElCAgKZFjOAxY+pYaQ5JO/9OpeIRr57EROCOXXrIglBue/o4JfajGTNyoCTgxKTf8rooYsqLNO9DAiRAAiTwKAKaFzGPCpCfy0uAIkZenrRGAiRAAiSgPwGKGP3ZmWRPihj1pL0gvwDrf9iF65eS1eMUPTEKAtXruKLvm11gbvnwzT2NIlgGoWkCFDGaTl/5O08RU/7MH3bH9Qt3orZnTVSv7aoux+iNpgkc2X4Krbv7oK7Xo8+J03SgdF7zBChiNJ/C8g2AIqZ8eT/qbkd3RCAlIR2NfRs8qik/JwGdCcScugQrWwv49ym5YlNnA2xIAuVEgCKmnEAby20oYtSVyYTYJASvPQz/53zV5Ri90TSBlOtpOHP0AgaOl2cxhKZh0HlVE6CIUXV61OccRYz6crJk6jp06OsHa7uSmz6qz1N6pCUCO1btx+AJPWHnWH6rH7XEh76qgwBFjDryoBkvKGLUl6qgX/bBuZoT3D3c1OccPdIsgeN7I+HdtgE8W9XTbAx03PgJUMQYf45ljZAiRlacshiLCInGpTPX4PNEI1ns0QgJCAJxUfHIy8tHl8HtCIQEVEtAdhEzfuG/eLW3H6ytLFQbNB3Tj0Bu3m0s3RiKeW89pZ8BFfUSx0jcuXNHRR7p70pKYjo2LQpGpxfa6m+EPUngPgIZqVkI2x2OoVPvHkjLiwTUSEB2EfPFqmNo06we3Ks7qTFe+mQAgfjraTgSHosPhmh/xYIxiRiR0uUzNsA3wAcOzvYGZJhdSaAkgT1/HkavwM5wcSufs9nInwTKSkB2EbPlwEXcuFUA/8f/d+pzWZ1ie3USCDlxEdUqm6Nne+3n1thEzK7Vh2BlZYm6Xu7qLB56pUkCEQfPoU6TmvDx99Sk/3Ta+AnILmKup2Rh7qowvlIystq59yppwhBfVHex03x0xiZioo/FIvLwBbTs6K353DAA9RCIj0lEyo00PPtaB/U4RU9IoBgB2UWMsL0u+DxuZt5G5zZU78ZSbcFHolHF3gL9Ozc0ipCMTcRkpWdj9dwt6DbkSaPID4NQB4Hc7Dzs+zsUr8/orw6H6AUJ3EdAEREj7iHmxri7uaCNTx1C1ziBIxGXEJ+YYhRzYe6lwthEjIhrzbwgNGndAC6cj6bxb5y63A/ZHIbOA9qiRr2q6nKM3pAAAMVETFpmHhZtiICTox3at6jP1UoaLDfxCunAyYtIS89CYB8fONkbz2ZqxihiQjYcQ152Pjya19VgtdFltRIQO/dWqemI1t181Ooi/TJhAoqJmHtMxaulQ5HX4NOwJurVqoKqzvYUNCouOCFcklIzEXv1JiLOX0M775pG8wqpOHZjFDGXoq4idFs4/J5uoeIKo2taI3D9SjKuRF9D37e6as11+msCBBQXMYKhmOx7JCoRkbEpSEzJRG5egQmg1WaI1lbmcHOxh3c9F7TxcjOKSbwPyoQxipiC/AIsmrQWPYZ1hJm5mTYLkF6rjkBhQSGClu1F4OwBMLc0V51/dMi0CZSLiDFtxIxejQSMUcQIzusX7kRtz5qoXttVjdjpk0YJhG4/iTbdm6GuVy2NRkC3jZUARYyxZpZxPZSAsYqYozsicPNaGpq09mAFkIBsBGJOxcHK1hL+fbS/0aVsUGhIFQQoYlSRBjpR3gSMVcQkxCYheM1h+PfyLW+kvJ8RE0i5noYzR2MwcPyzRhwlQ9MiAYoYLWaNPhtMwFhFjACzZOo6dOjrB2s741lNZnDCacBgAjtW7sfgiT1h52hrsC0aIAG5CFDEyEWSdjRFwJhFzNZf9sGlmhPcPdw0lRM6q24Cx/dEwrtdA3i2qqduR+mdSRGgiDGpdDPYewSMWcREhETjUtQ1+LRvxISTgGwE4qLikZeXjy6D28lmk4ZIwFACFDGGEmR/TRIwZhGTkpiOTYuC0emFtprMDZ1WJ4GM1CyE7Q7H0Kl91OkgvTJJAhQxJpl2Bm3MIkZkd/mMDfAN8IGDsz2TTQKyEdjz52H0CuwMFzdH2WzSEAkYQoAixhB67KtZAsYuYnavPgRLK0vU9XLXbI7ouPoIRBw4hzpeNeHjz8N91Zcd0/SIIsY0827yURu7iIk+FovIQxfQspO3yeeaAOQjEB+TiJQbaXj2tQ7yGaUlEjCAAEWMAfDYVbsEjF3EZKVnY/WcLej20pPaTRI9Vx2B3Kw87Fsfitdn9Fedb3TINAlQxJhm3k0+amMXMSLBa+ZtlXbudanuZPL5JgD5CIRsCkPngW1Ro15V+YzSEgnoSYAiRk9w7KZtAqYgYkI2HENuVj4atqir7WTRe1UREDv3utZ0gm83H1X5RWdMkwBFjGnm3eSjNgURcynqKkK3hcPv6RYmn28CkI/A9SvJuBJ9DX3f6iqfUVoiAT0JUMToCY7dtE3AFERMQX4BFk1aix7DOsLM3EzbCaP3qiFQWFCIoGV7ETh7AMwtzVXjFx0xTQIUMaaZd5OP2hREjEjy+oU7UduzJqrXdjX5nBOAfARCt5+EX/dmqONVSz6jtEQCehCgiNEDGrton4CpiJiwnRFIvpomTfDlRQJyETh/Mg7Wdpbw79NKLpO0QwJ6EaCI0QsbO2mdgKmImITYJASvOQz/Xr5aTxn9VxGBlOtpEBN8B45/VkVe0RVTJEARY4pZZ8wwFREjUr1k6jp06OsHazsrZp4EZCOwY+V+DJ7YE3aOtrLZpCESKCsB1YuYd77cU9aY2P4+At+O7UQm9xEwJRET9Ms+OFdzgruHG+uABGQjcHxPJLzbNYBnq3qy2VS7IT6PDM+Q3M8jTYiYMUOeMpyciVr4ZtW/kLtojAGlKYmYiJBoiOXWPu0bG0PqGINKCMRFxSM/Px8Bg9qpxCPl3RAihs8j/Tkr8TyiiNE/H5roqUTRaCLwRzhpSiImJTEdm37ajU79TedhYww1qvYYMlIzEbY7AkOn9lG7q7L5RxFjGEolnkcUMYblRPW9lSga1Qetg4OmJGIEjuUzNsA3wAcOzvY60GETEtCNwJ51h9BrVABc3Bx166DxVhQxhiVQiecRRYxhOVF9byWKRvVB6+CgMYqYkSNH4tSpU1i4cCFat25dgsLu3w/B0tISdb3cdaDDJiSgG4GIA2elvWJ8/D1166DxVhQxhiVQiecRRYxhOVF9byWKRvVB6+CgMYqYFStWIDAwUFp51bVrV0ybNq1IzEQfi0XkoRi07NRUBzpsQgK6EYiPSUTqjTT0eK2Dbh003ooixrAEKvE8oogxLCeq761E0ag+aB0cNEYRI8Ju3Lgxzp07JxGwtbVFt27dJDHj3agpVs/Zgm4vPakDHTYhAd0I5GblYd/6ULw+o79uHTTeiiLGsAQq8TyiiDEsJ6rvrUTRqD5oHRwUIuaTTz7RoaW2mojXSVu3bkVOTk6R40LMNGjQANOGzUWTNh5wqe6kraDoraoJhGwKQ+eBbVGjXlVV+ymHcxQxhlFU4nlEEWNYTlTfW4miUX3QOjg4ffp0HVppr0l4eDi2bNnyQBHzw2dLkZ9TgIYt6movMHqsWgJi517XWk7w7eqjWh/lcowixjCSSjyPKGIMy4nqeytRNKoP2oQdLO11kpjoK/aKCd0WDr+nW5gwIYYuN4HrV5JxJfoa+r7VVW7TqrNHEWNYSpR4HlHEGJYT1fdWomhUH7SJOigm9ooVSuJV2b25MMVXKRXkF2DRpLXoMawjzMzNTJQSw5abQGFBIYKW7UXg7AEwtzSX27yq7FHEGJYOJZ5HFDGG5UT1vZUoGtUHbaIOjhgxAuJ10oOWWN9Dsn7hTtT2rInqtV1NlBLDVoJA6PaT8OveTFpubcwXRYxh2VXieUQRY1hOVN9biaJRfdB0sFQCYTtPI/lqKpq09iAlEpCNwPmTcbCxt0T73q1ks6lGQxQxhmVFiecRRYxhOVF9byWKRvVB08FSCSTEJiF4zWH49/IlJRKQjUDK9TScOXoBA8f3kM2mGg1RxBiWFSWeRxQxhuVE9b2VKBrVB00HH0pgydR16NDXD9Z2ViRFArIR2LFyPwZP7Ak7R1vZbKrNEEWMYRlR4nlEEWNYTlTfW4miUX3QdPChBIJ+2Qfnak5w93AjKRKQjcDxPafh3c4Dnq3qyWZTbYYoYgzLiBLPI4oYw3Ki+t5KFI3qg6aDDyUQERKNuKiraNa+MUmRgGwE4qLikZ+fj4BBxntaOkWMYeWixPOIIsawnKi+txJFo/qg6eBDCaQkpmPTT7vRqb/xPmxYAuVPICM1E2G7IzB0ap/yv3k53ZEixjDQSjyPKGIMy4nqeytRNKoPmg4+ksDyGRvgG9AMDs52j2zLBiSgK4E96w6h16gAuLg56tpFU+0oYgxLlxLPI4oYw3Ki+t5KFI3qg6aDjySw+/dDsLS0RF0v90e2ZQMS0JVA+IGzqOtVCz7+nrp20VQ7ihjD0qXE84gixrCcqL63EkWj+qDp4CMJRB+LReShGLTs1PSRbdmABHQlEB+TiNSkNPQY3kHXLppqRxFjWLqUeB5RxBiWE9X3VqJoVB80HXwkgaz0bKyeswXdXnrykW3ZgAR0JZCblYd960Px+oz+unbRVDuKGMPSpcTziCLGsJyovrcSRaP6oOmgTgTWzAtCk9YN4FLdSaf2bEQCuhAI2RSGzgPboka9qro011QbNYuYiJNheG/UEOw8dFa1TJV4HlHEqDbd8jimRNHI4xmtVDSBAxuPIyczDw1b1K1oV3h/IyJw5kgMXN2d4dvV+F5VqlnE5Obm4HrCVTxWt4Fqq0mJ5xFFjGrTLY9jShSNPJ7RSkUTEHvFHNkWDr+nW1S0K7y/ERG4fiUZV6Kvoe9bXY0oqruhlJeIWfL9fJw6fgRCmKSlpcDSwhJffLcMbjXdcezIQXz+yXhkZWVK//7uxOno1PVZFB+JOXfmNKaNH4X8vDwU3inE0NffxguDXkVBQQG+nvsJ9u7aKsXj4emFj2d/AyfnKuWSKyWeRxQx5ZK6iruJEkVTcdHwznISKMgvwKJJa9FjWEeYmZvJaZq2TJhAYUEhgpbtReDsATC3NDcqEuUpYn5f/jM2BR+HjY0tJr03AtXcamLkW+PR3d8b3yxeg9Ztn8SF82cwqFdHrN2yHxm30oteJ00YMxzNH2+Nl197C/FX4vDV5x9JIui3xd8i4tQxzP5yMczNzfHzwi8QfeY05n67tFzypMTziCKmXFJXcTdRomgqLhreWW4C6xfuRG3Pmqhe21Vu07RnwgRCt5+EX/dmqONVy6golKeIiT4bic+/XiLxEyMzl+IuoEev/pgzfQL+3nGkiOvbr7+I9k91QfOWbYpEzM6gDZg0diTaPxWAJ54KQPfn+sGlSlUMH/gMYi+cR2XHu/v4FNy+DWsbW/y17XC55EmJ5xFFTLmkruJuokTRVFw0vLPcBMJ2nkZSfCq82njIbZr2TJjA+ZNxsLG3QvveLY2KQnmKmLjYGHw69/siESN+796zH+bPnIy/tocWcX3rtf5o274jWrVpX2Ji783kG9i/ZwdC9u7E/j3bsXnPCbwbOBi9+g3Gi1cLWs4AACAASURBVENek/pnZ2chKzMDrlWrl0uelHgeUcSUS+oq7iZKFE3FRcM7y00gITYJwWsOw7+Xr9ymac+ECaRcT8OZsAsYOK6HUVGoaBEzfsosPN3eC9/98of0Oik25hxe6PEEVm/ch7zcnCIRM2bEQHTo8gz6Dx4uzavp2q4xflj2Nw7+uwtb16/Fir93w96hMj758G2kpabgyx9XlkuelHgemZyIkWsZWtjhEHw04U1s2Xvqocn/as7HaNPuKfh31G+S2507dzCsfzf8vGozrK1tylxoShRNmZ1gB1UTWDJ1HTo87wdrWytV+0nntEVgx8r9GDyxJ+wcbbXl+EO8rWgRI0Zmjh7eL71Sys7KRCUzM7z53mQ82/vFkhN7oyIwdfwo5ORkw8zMDJ269sR7E6fjdn4+5s+eiuDtW6R/r9+wEWYtWMSJvUpWqNxFI9cyNF1FzKDeHTB67BR06NxdL0zinaVXbRuEx2VQxOhFkJ0eRSDo131wruoEdw+3RzXl5ySgM4Fje06jaTsPeLaqp3MftTeU+3mk9njl9k+J/6nW9EiMEsvQ+g0chu5PNsXHs74pGj2Z8n4gGnn5YNjIMUU5LS5ibqWnYdoHbyL+cixSbibDpYorvvppFfbsCsK8GZPhVsMdH836Gm39O5W6vM23kSuGDHsDZ6PCJTuDh42SZpZPHjsS61b/Kk3aWrJ6CxZ/vwDBOzZLS+vEbPU53/wiTdgq7VKiaOQubNqrWAIRIdGIi7yKZv6NK9YR3t2oCMRFxSM/Px8Bg4zntHSKGMNKVInnkeZFjBLL0JYu+hrHjxzE1z//jsyMW+jSthG2H4iCo5PzA0XMn78vxdnIcEz+dL70+cQxr6G6W02MmzITxUdiHra8rUUDJ0z5dD4GvDxCWhLXvb03jpy5Disr66KRmBuJ1zCg55P493gczC0s8P2XM9Hs8TZ4qvPTFDGGfbdMundKYjo2LdqNTi8Yz8PGpBOqkuAzUjMRtjsCQ6f2UYlHhrtBEWMYQ4qY+/iJkRgllqGlp6UiwK+hJFz+2fQnwk8cxeyvFpe4+/2vk8Ta+5Nhh3Ap9gL27AySRnHE6EtxEfOw5W1CxGzddwrute/unip+33X4HFxcXItEjIW5BYb07SRtctSh8zPo2LUH/J54+EFrShSNYWXM3moksHzGBvgGNIODs50a3aNPGiWw589D6BUYABe3u0t6tX5RxBiWQSWeR5ofiVFiGZp4PTN1/Bvw8GyCTX+txieffye9zil+FRcxi7+fhw3rVuLl4aPRsJE3gndsQWZmhrQTYnER80r/bqUubxOiRZx5Ua16jSIRI36vUqVqiTkxYqLvyWOh0izzDetW4bnnB+LtcdM4EmPYd8vke+/+/RAsLS1R18vd5FkQgHwEwkPOoq53Lfj4e8pntAItUcQYBp8i5gEjMQ8SMYYuQ/Np3gpnTp/Cm6/2g7OzS4mNhe65UFzEvPx8AHr2HSjNYxGvn4b264JmLdtg+pyFEJ+9GvguuvboI+2OWNryttJETNVqbmhSywpHztyQNjuaPHYE1mzeD1tbO6z4ZSH+Dd6On5ZvoIgx7Ltl8r2jj8Ui8lAMWnYyvvNuTD65FQggPiYRqUlp6DH84SPGFehimW5NEVMmXP9pTBGjo4gxdBnavdv07dZammwr5qncfxUXMUJIzJz2PpycnaWJbF5NW+DK5Vgs+2M7fvlhAb6d/xmmzfwKvfsNKXV5W2kiRozMiM2MDu0PxrqgA/h77Qr8s/lPONg7wMbODp/O/QENG3lRxBj23TKZ3vPnz0dgYCAqV65cIuas9GysnrMF3V56UvMstu36B/O++Rw7NuwpEcvId4ajTSs/BA5/E936dEL9eg2w6OtfitrEXDyPPoN7IuLQWWRmZcK7TUNYWf132fm2v4Mx84vp2Hfgrv28vDxYWFjCzKyS9PvBnUdR1bWa5jnKEUBuVh72rQ/F6zP6y2FOcRulfT/u3VhtIsbL3RqHIxNxKTbmkSdYizbffDEd8xb+VmI5tuJQi92AIqYcaYuEv/x8F2w7ECmNemj1UqJotMqCfgO2trbSIXDjxo3D5MmTS4iZtfOD0Ni3AVyqO2kala4iJvbSRXz84Wd4eeArUrwPEjFH955EtUfsZto2oCW+nrMQ7dq01zQ3pZwP2RSGzgPboka90ldRKnXvstp92PdD2FKriLG2sXnkCdYH9u3Cl59Pwx9bD0gb4FXEiddKPI80PSemrAWqa3txyuea5T9LWz6L10BavpQoGi3zMHXfv/76a3z44YcoLCxEpUqVMHbs2CIxc2DjceRk5qFhi7uTy7V66Spi+vcZgG9++gobVm9BwwaeFDEKJTzqSAyqujvDt6v6X1U+7PthiIgRm6xOeGe4NGp+B3eQdCMRUz77EmLqwk/fzoEY2RcHMTZt0QpfL/q91K049u3+B3M/nQgLS0s87ttOek7dPxKTn5+Hzz+ZANFWjBD6te+ASZ98geefbotrVy9LJ16PGD2uaORG7EX2+fQJ0hEF5uZm0orXKZ8tgENlR5S29Ye+paLE84giRt9saKSfEkWjkdDpZikEXF1dcfPmTelT8brknpgZ9uIIROw7D7+nW2iana4i5rOpsxB24ig2BW3Ext+34nL8pf+8TnJwqCzxuXc1qNsAG9cEleDDkZiHl8v1K8m4cv4a+o7Wb9fy8i7G0r4fYuRy8uIwjBnyVJldEiLmxZ7+2LjrGDwbeyP04D6I/cfECthF383FmuWLsTn4uCROfv9t0QNPmp464ytp1ezSP7ZL4uePlUswZdwoHD2bVOJ1kph7Kc5LWrRiI8zNLfDO6y/iuX6D4excpWgkpvjO9T98NQsnwg5LRxmI9h9NGC0dDClW5Ja29YetnX2ZGYgOSjyPKGL0SoV2Oomi+e79ztpxmJ5WCAGxMqlf3/548clX0bKDNyysLCrEDzluuiN4G+Z8OQs7N+4tYe610a+gfbsnMeKVQGlOjBAxfr7tMOT1AfBq7C29Vrp/TgxfJxmekdt5txG88QDGzB6OrJwsww1WgAXx/ejduzdq+r+tt4iZMi4QG3aGFXkvRjn+3h6KoE3rEHMuCnO/XSp9VtpWHO9O+AQLZk8tsiFGU5vVdcDBiKslRIzo3/fFoejT/6USpIq/TiouYsS2HSNGj0fA089J7c9FRWDYi09Ldkvb+kMsONHnoojRh5qJ91GiaEwcqebDr1q1KpKTk6U4jHEkJuzEEYhJvMf+jSiRq2f7d8PrQwPxQp8Xi0SMmMeSkJiAZ/oF4O1R7+Gr7+eXmNhLEWN4uWttJKa074ehIzGT3x8pjcSIS2yV0aK+I4L+Dcfm9WuQcDVe2pJDXKVtxSGEx/xZU4psiLbCxr8nLpUQMSOGPIfeLwyRfsR143qC9Kd4XXVvTkxxETOo11MYNeZDdO7WU2onNm4Vq2qPnL0hiZgHbf1xbyuQslaHEs8jjsSUNQsaa69E0WgMAd0tRkC88580aZI0uddY58SI1ULtuvhixLBASbSIa8u2TZg0/QPs2XoANd1qlhAx4vNtO4Pw9gdvSOeTFV+dRBFj+NdHa3NiSvt+CBL6TuwVoqF/jyewdkuItOeY2OX91x+/xOY9J6U5McVFTGlbcYg5mgF+ntJropat22HrhrXSvJb7XycJuyH7duLHZeulAyLfeKUvOnV7VtrDbOa0sZIIKi5iFi6YgVPHj0ivk8Qcmo8nvoX01BR8tWg1RYzh5a9/0chxb2OwQRFjDFmULwZTWJ0kaJ06fRIzv/gU4ZGncKewEI0beWHCux+ifdu7S8jvvU4qvqJo8vQJ2Bi0oYSIsbWxLTEnRvSd+9kC9Co24Z9zYh5en1ydBEk0vDHseTR/vLU0alLZyRkz5/+EBg2b/EfEPOyk6cMH9kpCRPwPiJiA+8+mddgder7ESIzoP/ezDxGydwfu3IG0e/yk6fOQlnoTA3vd3a9nwffLiyb25uXlYu6nH0K8brpdcBvNWvhKu807OVehiJHjP736Kl+RSLFZ3RffLYWzi2uRK2I/F3HA4vdL/3qke+IogRlT3oU44NHeoTI+/3qJVHTFL6XtCaUtjlCv10C/HS8pYh6ZZpNqYAr7xJhUQlUeLPeJuZsgIWLGjX4F20JOqzxjyrqnxPPIaF8niSEycWDj0NffLsrK1o1/4NNJY9CqzROPFDHi/KSn23vhm8VrpPOJ1q5YjL/W/obfN+4rV3uxF6IxaewIrN5QcpKirqWmRNHoem+20w4B7tirnVxpyVPu2EsRU7xelXgeGaWIybiVju7+3tgWEimtdRdXTHSUtE6/38BXpOVnjxqJEWchiXOTFq/aLPUXa+9jL5yXlseVtz0xU1zMHn/YadWl/YdNiaLR0n9E6atuBHh2km6c2KpsBHh2Utl4GXtrJZ5HRilitm/5G78t/hYr/t4t1URWZgZe7tdFWsJ26ngodgZteKSIERveiddOuTk5OB1+HO6P1YVYpy9ETHnbExO9YmOiMXPBojLXuBJFU2Yn2EH1BHiKtepTpEkHeYq1JtOmmNNKPI+MUsSI2d4Xos9izjd3z0V5d+QgdHmmt7Tk7K81y3QSMfNnTpE2Hfrtz51o0rS59Drpp2/nYndodLnbE/sILPv5mxKvsnStMiWKRtd7s502CKQkpmPTot3o9EI7bThMLzVBICM1E2G7IzB0qrZ3PS8OW985mppIWDk4qcTzyChFjNgB8VLsBcyY9yOSk66jS9tGsPv/HQZzcrKRl5uLZi1bP3SeyfIl32H39s34dc0/UmrFxkJNH7PF5j0n8MIzT5SrPTFy9OtPX2Hl+uAyl5kSRVNmJ9hB1QQiQqIRF3kVzfwbq9pPOqctAnFR8dKBuAGDjEccU8QYVoNKPI+MUsSIh/5vS77Db+t2/If4/SMxYiMgseGXWE5W/BKvkoRYWb1xD+p7NIZ4RSWWre04eKbEkkul7QmfhIC5cP4sPvvihzJXkBJFU2Yn2EHVBIJ+3Qfnqk5w99BvF05VB0fnKozAsT2n0bSdBzxb1aswH+S+MUWMYUSVeB4ZpYjJzs5CQJuG0k6DYml08et+0TH61X7wbOKDsR9++p/siAOx5s+cjOzsbDhUrowZ836SXi2Vpz1xr9cG9ZAm9rbv0KXMFaRE0ZTZCXZQNYElU9ehw/N+sLa1UrWfdE5bBHas3I/BE3vCztFWW44/xFt9RQy3/LgLVYnnkVGKGAHru/mfSSuTXg1896FfoONHDyH6TAQGvDxCli+a3PZiY85h0vsjucRaluzQyP0EEmKTELzmMPx7+RIOCchGIOV6Gs6EXcDAcT1ks6kGQ/qKGG75QRFT5voVuxC+Oex5zFv4G1yqVC21v3j1JEY47OwdynyPB3WQ2957gYMxZsLH/9lkT1dnlVC+ut6b7dRPIGznaSTFp8KrjYf6naWHmiFw/mQcbOyt0L53S834rIuj+ogYbvnxP7JKPI+MdiRGl4I0hTZKFI0pcDOVGNcv3InanjVRvfb/drU2ldgZp3IEQrefRJvuzVDXq5ZyN6kAy/qIGG75QRGj19HnFVDfqrwlRYwq06IKpwryC7Bo0lr0GNYRZuZmqvCJTmifQGFBIYKW7UXg7AEwtzTXfkDFItBHxHDLD4oYihgD/jNAEWMAPCPvGhd1FUe2hcPv6RZGHinDK08C168k40r0NfR9q2t53rZc7qWPiOGWHxQxFDEGfD0pYgyAZ+RdQzYeR25mHhq2qGvkkTK88iRw5kgMXN2d4du1aXnetlzupY+I4ZYfFDEUMQZ8PSliDIBn5F3XzAtCk9YN4FLdycgjZXjlSSBkUxg6D2yLGvVKX1BRnv7IeS99RAy3/KCIoYgx4FtIEWMAPCPumpWejdVztqDbS08acZQMrbwJ5GblYd/6ULw+o39537pc7qePiBGOccuPu+lR4nnE1UnlUvoVdxMliqbiouGd5SIQfSwWkYdi0LKT8Q35y8WIdspOID4mEalJaegxvEPZO2ugh74ihlt+UMRooLzV6SJFjDrzUtFe7f79ECwtLVHXy72iXeH9jYhA+IGz0rJqH39PI4rqf6HoK2KMEoYeQSnxPOJIjB6J0FIXJYpGS/HT1wcTWD5jA3wDmsHB2Y6ISEA2AnvWHUKvUQFwcXOUzaaaDFHEGJYNJZ5HFDGG5UT1vZUoGtUHTQcfSiAlMR2bftqNTv2N53RhprziCWSkZiJsdwSGTu1T8c4o5AFFjGFglXgeUcQYlhPV91aiaFQfNB18KIGIkGiIPWKatW9MUiQgG4G4qHjk5+cjYJDximOKGMPKRYnnEUWMYTlRfW8likb1QdPBhxII+mUfnKs5wd3DjaRIQDYCx/echnc7D3i2qiebTbUZoogxLCNKPI8oYgzLiep7K1E0qg+aDj6UwJKp69DheT9Y21qRFAnIRmDHyv0YPLEn7BxtZbOpNkMUMYZlRInnEUWMYTlRfW8likb1QdPBUgkkxCYheM1h+PfyJSUSkI1AyvU0nDl6AQPH95DNphoNUcQYlhUlnkcUMYblRPW9lSga1QdNB0slELbzNJKvpqJJaw9SIgHZCJw/GQdre0v4924lm001GqKIMSwrSjyPKGIMy4nqeytRNKoP2kQdHDlyJE6dOoWFCxeidevWD6SwfuFO1Pasieq1XU2UEsNWgkDo9pNo072ZtEeMMV8UMYZlV4nnEUWMYTlRfW8likb1QZuogytWrEBgYCAqVaqErl27Ytq0aSXETEF+ARZNWosewzrCzNzMRCkxbLkJFBYUImjZXgTOHgBzS3O5zavKHkWMYelQ4nlEEWNYTlTfW4miUX3QJuxg48aNce7cOYmAra0tunXrViRmxLLqI9vC4fd0CxMmxNDlJnD9SjKuRF9D37e6ym1adfYoYgxLiRLPI4oYw3Ki+t5KFI3qg9bBwenTp+vQSntNxOukrVu3Iicnp8h5IWYaNGiAHz5bivycAjRsUVd7gdFj1RI4czQGrrWc4NvVR7U+yuUYRYxhJJV4HlHEGJYT1fdWomhUH7QODopXLp988okOLbXVJDw8HFu2bHmgiJk2bC6atPGAS3UnbQVFb1VNIGRTGDoPbIsa9aqq2k85nKOIMYyiEs8jihjDcqL63koUjeqD1sFBIWLu3LmjQ0ttNSntdZJ3o6ZYPWcLur30pLYCoreqJpCblYd960Px+oz+qvZTLucoYgwjqcTziCLGsJyovrcSRaP6oHVw0BhFjJjYK1YoidiKz4UROKKPxSLyUAxadmqqAx02IQHdCMTHJCL1Rhp6vNZBtw4ab0URY1gClXgeUcQYlhPV91aiaFQftA4OGqOIGTFiBMTrpActsd69+hAsrSxR18tdBzpsQgK6EYg4cBZ1vGrBx99Ttw4ab0URY1gClXgeUcQYlhPV91aiaFQftA4OGqOIeVjYy2dsgG9AMzg42+lAh01IQDcCe9YdQq9RAXBxc9Stg8ZbUcQYlkAlnkcUMYblRPW9lSga1Qetg4OmJGJSEtOx6afd6NTfeE8X1iHlbCIzgYzULITtDsfQqX1ktqxecxQxhuVGiecRRYxhOVF9byWKRvVB6+CgKYmYiJBoXIq6Cp/2jXUgwyYkoBuBuKh45OflI2Cw6YhjihjdaqO0Vko8jzQhYgzDxt7fju1ECPcRMCURE/TLPjhXc4K7hxvrgARkI3B8TyS82zWAZ6t6stlUuyEhYngZRkDu55HqRYxhuNibBB5MwJREzJKp69Chrx+s7axYDiQgG4EdK/dj8MSesHO0lc0mDZFAWQlQxJSVGNsbBQFTETEJsUkIXnMY/r18jSJvDEIdBFKup0Hs1Dtw/LPqcIhemCwBihiTTb1pB24qIiZsZwSSr6ahSWsP0044o5eVwPmTcbC2s4R/n1ay2qUxEigrAYqYshJje6MgYCoiZv3CnajtWRPVa7saRd4YhDoIhG4/iTbdm6GuVy11OEQvTJYARYzJpt60AzcFEVOQX4BFk9aix7COMDM3M+2EM3rZCBQWFCJo2V4Ezh4Ac0tz2ezSEAnoQ4AiRh9q7KN5AqYgYuKiruLItnD4Pd1C8/liAOohcP1KMq5EX0Pft7qqxyl6YrIEKGJMNvWmHbgpiJiQDceQm5WPhi3qmnayGb2sBMSEXteaTvDt5iOrXRojAX0IUMToQ419NE/AFETMmnlbpQm9LtWdNJ8vBqAeAiGbwtB5YFvUqFdVPU7RE5MlQBFjsqk37cCNXcRkpWdj9Zwt6PbSk6adaEYvK4Hc7Dzs+zsUr8/oL6tdGiMBfQlQxOhLjv00TcDYRUz0sVhEHrqAlp28NZ0nOq8uAvExiUi5kYZnX+ugLsfojckSoIgx2dSbduDGLmJ2rz4ESytL1PVyN+1EM3pZCUQcOIc6XjXh4+8pq10aIwF9CVDE6EuO/TRNwNhFzPIZG+Ab4AMHZ3tN54nOq4vAnj8Po1dgZ7i4OarLMXpjsgQoYkw29aYduDGLmJTEdGxaFIxOL7Q17SQzelkJZKRmIWx3OIZO7SOrXRojAUMIUMQYQo99NUvAmEVMREg0LkVdg0/7RprNDx1XH4G4qHjk5eWjy+B26nOOHpksAYoYk029aQduzCJm6y/74FLNCe4ebqadZEYvK4HjeyPh3bYBPFvVk9UujZGAIQQoYgyhx76aJWDMImbJ1HXo0NcP1nZWms0PHVcfgR0r92PwxJ6wc7RVn3P0yGQJUMSYbOpNO3BjFTEJsUkIXnsY/s/5mnaCGb2sBFKup0Hs1Dtw/LOy2qUxEjCUAEWMoQTZX5MEjFXEHN0RgZvX0qSdenmRgFwEYk7FwcrGEv59W8llknZIQBYCFDGyYKQRrREwVhGzfuFO1Pasieq1XbWWEvqrYgKh20+iTfdmqOtVS8Ve0jVTJGCyIiYtIxdpmXm4lZWHjKx8ZGTn41Z2PrJybiMrNx/ZubeRm1eA3PwC5OUXIv92AW4XFKKg8I70U1h4B3fu3CmqGfFQNDOrBPP//7EwN4OlhTmsLM1gbWkOaytz2FpbwM7aEnY2FqhsawkH8WNnicp2VnCyt4KTg7Up1mCFxGyMIqYgvwCLJq1Fj2EdYWZuViFceVPjI1BYUIigZXsROHsAzC3NjS9ARqRpAkYrYoQIuZGaXewnBzfTs5FyKxdCwFhZmsPBzgr2Nlaws7GEjY0VrK0sYGNlCRsrC+nvoo0QIuLHwsIMQpiYm5lJYqW0S4ibgsJCSfDcvn1X/IifvPwC5ObdRo70k3/37zl5yMrJR2aOEFJ5UhshZFwqW6OKoy2qOdugmrP48+6PEEG85CFgjCImLuoqjmwLh9/TLeSBRCskAOD6lWRcib6Gvm91JQ8SUB0BoxAxCTezEH8jA1duZOJqUgYSkrMkoeLqbAuXyrZwqmyLyvY2cHKwgaO9DSrbW0M8xNR2iZGdW5m5SM/MQVpGDm6JP28J4ZWN5NRsSeDUcLVDraoOqF3NHu7VHFCjip3awtCEP8YoYkI2HENedj48mtfVRA7opDYInAm7gCo1HNG6m482HKaXJkVAcyJGjGRcvJqOC9fScfFaOi4n3pJGSqpXcUBVZ3u4OttLfzo62BhdItMzcpCUmonk1Ezpz+s3M6RRnsfcKqN+TUc0qOmI+rUcpZEkXg8nYIwiZs28IDRp3QAu1Z2YfhKQjUDI5jB0HtAWNepVlc0mDZGAXAQ0IWLOX0nFmUupOHc5BRevpuExNyfUrOYIN1dH1KhaGbbWlnLx0Jyd7Nx8JCTdQmJyOq7dEKIuDfVrOaHRYy5oUscZDWs7ay6m8nDY2ERMVno2Vs/dgm5DniwPfLyHiRDIzc7Dvr9D8fqM/iYSMcPUGgFVipj824WIuJiM8JhkRMXehL2dFerUcEZtNxc8VoMP5UcV2eWEVFxJTMGlhFRkZuXBq14VNPNwhU99V1hacMKn4GdsIib6WCwiD19Ay47ejyoPfk4COhOIj0lEyo00PPtaB537sCEJlCcBVYmY0xeTcfTsDZw6fwO1qjmivrsr6rtXgYMdV+3oWxQZWbm4GH8TF+OTcfVGOpo3rIbWjauhaX3TXoJrbCJm1+pDsLKyRF0vd31Lhf1I4D8EIg6eQ50mNeHj70k6JKBKAhUuYlIzcnEwIgGHIxOkFUGedaujUd1qJv2KSKlKEa+ezsXdQHTcdWl1VFvvGnjCpwacTXBpt7GJmOUzNsA3wAcOzvZKlQ/tmiCBPX8eRq/AznBxczTB6BmyFghUmIi5mpSJPcfjcTDiKlo0qgmvBjWkybm8yoeAmBQcdSEBJ89dwxM+tdCppTtqVTWdB6AxiZiUxHRsWhSMTi+0LZ/i4V1MgkBGahbCdodj6NQ+JhEvg9QmgXIXMUlp2dgeehlhZxPh6+WO5o3dYW3J1TQVVT65+bdx6mw8wqLi4dvYDU/7PYaqTsZ/wJsxiZiIkGhcOnMNPk80qqgy4n2NkEBcVDzy8vLRZXA7I4yOIRkLgXIVMUGH4rDtcCxae9dG66Z1YM5dRVVTRwUFhTh6+hKORl5B97b10KOdce81YkwiJuiXfXCu5gR3DzfV1BMd0T6B43sj4d22ATxb1dN+MIzAaAmUi4iJS0jHH8ExsLa2xBMt6kubzvFSJwGxyd7BkxeRm5uPFzt7oG4N43wXbkwiZsnUdejQ1w/WdlbqLCp6pUkCO1btx+AJPWHnaPwjs5pMEJ2WCCguYg6EX8Pvu86ii58nvD1qELtGCETGJGBXaDQGdWmM9s1qasRr3d00FhGTEJuE4LWH4f+cr+7BsyUJPIJAyvU0nDl6AQPH9yArElA1AUVFzD+HL+FA+FV09/fipF1Vl8GDnROTf7eFRMG/WS10b1tHgxGU7rKxiJijOyKQkpCOxr4NjCo/DKZiCcScugQrWwv492lVsY7w7iTwCAKKiZidR6/gQMQ19O7kA3tbDnNrtRIzs/OwcU8E2vvURNfWWCCCLQAACwZJREFUtbUaxn/8NhYRs37hTtT2rInqtU173x+jKUyVBHJk+ym07u6Dul61VOIR3SCBBxNQRMRExt7E0q1RGND9cc5/MYLKE/Nk1m47gVef9YJ3vSpGEJFx7NhbkF+A9T/swvVLyUaREwahHgLV67ii75tdYG5prh6n6AkJPICAIiJm5m9H4OtdBx6PqefAsK/mfIw27Z6Cf8euWPL9fFw4fxYzFyxSrCjEidTD+nfDz6s2w9pa+xOZYy4nISzyEqa80kYxZuVp2FhGYsqTGe9FAiRAAmojILuIOXj6Gg5H3kDPDk1VFeug3h0weuwUdOjcHWmpN5GXl4dq1ZWbaFxw+za8atsgPC7DKESMSOaWfafR1rsanmiq/Ym+FDGq+nrSGRIgARLQi4DsIua7P0/Bo64bGqpoFGbl0h8wb8ZkuNVwx0ezvkZUxImikRjfRq4YNDQQZyJPIjHhKoa+9haOHt6Pq1cuoaCwAIuWb4SjkzMiw09g1kfvIyMjHZVQCaPe/RDPPPcCMjNu4YN3XkX85VjpUMFWbfyle0weOxLrVv+K5i3bYMnqLYi/fOmB/SNOhmHCO8PRsJEX7uAOkm4kYspnX8Knufom1J2/nISYuES8/UJzvYpNTZ0oYtSUDfpCAiRAAvoRkF3ETPw+BC8956u6s4+Kj8QUf53UooETJn40B0NefQN//r4Un04ag52Hz0mjNKNf7YeOXXqgd/+X8Fynx/Hjb+vh2dgbKTeT0L9HeyxetQnHjhzEnp1b8e3itcjPz8OUcaPw/qTPUK1ajaKRmMLCwlL7Z2Zk4MWe/ti465hkO/TgPkx5PxDbD0RJokhNV05uPlZsDsOc0f5qcksvXyhi9MLGTiRAAiSgKgKyi5hDUUlwreKiqiCFMw8TMUH/hqOWex0c2LcLn0//QBIU4po+aQxq1HJHm3YdpPkt9Rv+b1v3W2lp+GDabPi08MVLzwegQcPGaP9UAJ7u+TzqezRG8ddJp08dL7V/nXoemDIuEBt2hhUxE6NDf28PhfhMbdfevfswcmCA2twqsz+dOnVCcHBwmfuxAwmQAAmQgHoIyC5iJv4Qgpd6amskZuehs9LIixAx82ZMwl/bQ0uIGF8/f7z/xsvYdzy2KHM3Eq/BuYorLC2tkJubg0P7g3FwfzA2/LECC35YAb8nOhSNxISfOFpq/7OR4Zj8/sgi4SQmBLeo7wghrNwfU9d238Y0EqOeryA9IQESIAES0JeA7CLmu79OwaOOuubECDgvPx+AVwPfRdcefUqsThKvkx4lYl4ePhpd2zXGpOnz0PuFIYi7eB79urfF2i37EbJ3pzRf5vOvl0g5eGfEALT0bYfhb4xFk1pWOHLmBszNzUvtn52Vhf49nsDaLSHS/BnxSuvXH7/E5j0n9c2pYv2kOTGXEvF2P+3PiVEMEg2TAAmQAAmUGwHZRYzY4C40Sn2rk375YQG+nf8Zps38CinJSUUTe3URMaPemYgTYYfx+SfjkZFxC3cKC/HGu5PQq99gZNxKx4fvvY6Yc2dgY2MjvQKa9eXPsHeojLde6y+N0KwLOoC01NQH9hcTe98Y9jyaP94al2JjUNnJGTPn/4QGDZuUWxHoeiOxOsmvSTWjPIZAVwZsRwIkQAIkoB4CsosYEZrYJ6aVdx1VrVBSD/KSnggRM270K9gWclqtLkp+iVGYY0a0T4yqYdM5EiABEiABnQgoImJOX7yJZUHcsVeXDGhBxNzbsXfYs15oaiQ79uqSG7YhARIgARJQNwFFRIwIeVfYFYSE8+wkdaf/0d7dOzvJv1lNdPE1nrOTHh05W5AACZAACaidgGIiRgTOU6zVnv6H+3fvFOv2zWrhGSM7xVrbmaH3JEACJEACgoCiIkbcQEz0/X3nWQT4eaKph3Lb/DOd8hI4HZOA3aHRGNS1sXSCNS8SIAESIAESUBsBxUWMCDguIR1/BMfA2toST7Soz5Ot1VYFxfwR818OnryI3Nx8vNjZA3VrOKrYW7pGAiRAAiRgygTKRcTcA/zPoTj8czgWrb1ro3XTOjA3NzNl9qqKvaCgEEdPX8LRyCt4pm09PNOurqr8ozMkQAIkQAIkcD+BchUx4uZJadnYFnoZx84mwtfLHc0bu8Pa0oKZqSACufm3cepsPMKi4tGqsRu6+z2Gqk62FeQNb0sCJEACJEACuhModxFzz7WrSZnYcyIeB8OvokWjmvBqUAPVqzjo7jlbGkRATNqNupCAk+eu4YlmtdDpcXfUqmpvkE12JgESIAESIIHyJFBhIuZekKkZuTgQkYDQyARYW1mgUd3q8KxbTXWnYJdnUpS6V3ZuPqLjbuBc3HXk5t2Gn3cNtPepAWcHa6VuSbskQAIkQAIkoBiBChcxxSM7fTEZR8/ewKnzN1CrmiPqu7uivnsVONjxIatvBWRk5eJC/E3Exifj6o10NG9YDa0bV0PT+q76mmQ/EiABEiABElAFAVWJmHtE8m8XIuJiMk7FJONM7E042FmhTg1nuLu54LEazqoAp2YnLiekIj4xBZcSUpGRlYcm9aqguYcrfOq7wtKCk6nVnDv6RgIkQAIkoDsBVYqY+90/fyUVZy+l4uzlFFy8mobH3JxQo5ojarg6okbVyib96km8IkpIuoWE5HQk3EjH5cQ01K/lhMaPuaBxHWc0rE3Rp/vXgS1JgARIgAS0REATIqY40Jy827h4NR0XrqXj4rV0XEm8BQsLc2lScFUXe7g62aOqsz0cHWy0lAedfE3PyEFSaiaS0zKRnJKJxJsZuH27ALXdKqN+TUc0qOmI+rUcYWPF1V46AWUjEiABEiABTRPQnIh5EO2Em1mIv5GB+BuZiE/KQEJyFtIycuHqbAuXyrZwFD/2NtIme+LPyvbWqFSpkuoSd+fOHdzKzEV6Zg7EpnNCtKRnZCPlVjaSU7Ph5GCNGq52cK/qAPdq9nCv5oAaVexUFwcdIgESIAESIIHyIGAUIuZBoLJzb+NGanaxnxzcTBeCIFcSOFaW5tJcG3tbK9jZWMHG2lIawbC2uvenhdTG0uLuj4WFGSzMzWBuZgYzs9IFUGHhHRQUFuJ2QSFu3y5E/u0C6Scvv0BaESRGknLz8qU/c3LzkJWTD3HIopi7ItoIoeJS2RpVHG1Qzdm2xI+tNUdYyuNLwXuQAAmQAAlog4DRiphH4RdCJi0zD7eyhIDIR0b23Z/MnNvIys2HEEG5eQXIzRcC5K4YEcKkQBIpdyDEihg5uXeJkR0hbsz//0cIHiF+rCzNYG1pDmsrcwgRYmdtCXsbCzjYWt79sbNEZTsrONlbSQKGFwmQAAmQAAmQgG4ETFbE6Ian9FaSiAEkISMEjBibedgIjaH3Y38SIAESIAESIIGSBChiWBEkQAIkQAIkQAKaJEARo8m00WkSIAESIAESIAGKGNYACZAACZAACZCAJglQxGgybXSaBEiABEiABEiAIoY1QAIkQAIkQAIkoEkCFDGaTBudJgESIAESIAESoIhhDZAACZAACZAACWiSAEWMJtNGp0mABEiABEiABChiWAMkQAIkQAIkQAKaJEARo8m00WkSIAESIAESIAGKGNYACZAACZAACZCAJglQxGgybXSaBEiABEiABEiAIoY1QAIkQAIkQAIkoEkCFDGaTBudJgESIAESIAESoIhhDZAACZAACZAACWiSAEWMJtNGp0mABEiABEiABChiWAMkQAIkQAIkQAKaJEARo8m00WkSIAESIAESIAGKGNYACZAACZAACZCAJgn8H2uWjx1sO5DOAAAAAElFTkSuQmCC)

The UNet takes a noisy input and predicts the noise, just like the UNets we've seen in previous units. Unlike those previous examples, the input is not an image but is instead a latent representation of an image. And in addition to the timestep conditioning, this UNet also takes in the text embeddings of the prompt as an additional input. Here it is making predictions on some dummy data:

```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])

### The Scheduler

The scheduler stores the noise schedule and manages updating the noisy sample based on the model predictions. The default scheduler is a `PNDMScheduler`, but you can use others (such as `LMSDiscreteScheduler`) as long as they are initialized with the same configuration.

We can plot the noise schedule to see the noise level (based on $\bar{\alpha}$) over time:

```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();
```

If you want to try out a different scheduler, you can swap in a new one as follows:

```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.30.3",
  "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,
  "timestep_spacing": "linspace",
  "trained_betas": null,
  "use_karras_sigmas": false
}

You can read more on using different schedulers [here](https://huggingface.co/docs/diffusers/using-diffusers/schedulers).

### A DIY Sampling Loop

Now that we've seen all these components in action, we can put them together to replicate the functionality of the pipeline:

```python
>>> guidance_scale = 8 #@param
>>> num_inference_steps = 30 #@param
>>> prompt = "Beautiful picture of a wave breaking" #@param
>>> negative_prompt = "zoomed in, blurry, oversaturated, warped" #@param

>>> # Encode the prompt
>>> text_embeddings = pipe._encode_prompt(prompt, device, 1, True, negative_prompt)

>>> # Create our random starting point
>>> latents = torch.randn((1, 4, 64, 64), device=device, generator=generator)
>>> latents *= pipe.scheduler.init_noise_sigma

>>> # Prepare the scheduler
>>> pipe.scheduler.set_timesteps(num_inference_steps, device=device)

>>> # Loop through the sampling timesteps
>>> for i, t in enumerate(pipe.scheduler.timesteps):

...   # Expand the latents if we are doing classifier free guidance
...   latent_model_input = torch.cat([latents] * 2)

...   # Apply any scaling required by the scheduler
...   latent_model_input = pipe.scheduler.scale_model_input(latent_model_input, t)

...   # Predict the noise residual with the UNet
...   with torch.no_grad():
...     noise_pred = pipe.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample

...   # Perform guidance
...   noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
...   noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

...   # Compute the previous noisy sample x_t -> 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]
```

In most cases it will be easier to use the existing pipelines, but having this hackable sampling loop can be useful for understanding and modifying how each component works. If you'd like to see this code and all the different components explored and modified in depth, check out the 'Stable Diffusion Deep Dive' [notebook](https://github.com/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb) and [video](https://m.youtube.com/watch?v=0_BBRNYInx8) for a more thorough exploration.

# Additonal Pipelines

So what can we do besides just generating images from a prompt? Quite a lot! In this section we'll demonstrate a few cool pipelines to give you a taste of some of the other tasks that Stable Diffusion can be used for. Several of these require downloading new models, so if you're in a hurry you can skim through this section just looking at the existing outputs rather than downloading and running all of the models yourself.

## Img2Img

In the examples so far, we've generated images completely from scratch by starting from random latents and applying the full diffusion sampling loop. But we don't have to start from scratch. The Img2Img pipeline first encodes an existing image into a set of latents, then adds some noise to the latents and uses that as the starting point. The amount of noise added and the number of denoising steps applied determine the 'strength' of the img2img process. Adding just a small amount of noise (low strength) will result in very little change, while adding the maximum amount of noise and running the full denoising process will give an image that hardly resembles the input apart from some similarities on overall structure.

To better understand the img2img process, let’s manually implement the pipeline. This approach will help clarify how latents are encoded, noise is added, and diffusion is applied. After manually constructing the pipeline, we’ll see how the diffusers library provides a ready-to-use StableDiffusionImg2ImgPipeline for simplicity and efficiency.

Here’s how you can manually implement the img2img pipeline:

### A DIY Img2Img Loop

```python
import numpy as np

# Encode init_image
init_image_tensor = torch.from_numpy(np.array(init_image).transpose(2, 0, 1)).float() / 255.0 # 0~255 => 0~1
init_image_tensor = 2.0 * init_image_tensor - 1.0 # 0~1 => -1~1
init_image_tensor = init_image_tensor.unsqueeze(0).to(device) # add batch dim.

with torch.no_grad():
    init_image_latents = pipe.vae.encode(init_image_tensor).latent_dist.sample() * pipe.vae.config.scaling_factor
```

```python
>>> guidance_scale = 7.5 #@param
>>> num_inference_steps = 30 #@param
>>> strength = 0.6
>>> prompt = "An oil painting of a man on a bench" #@param

>>> # Encode the prompt
>>> text_embeddings = pipe._encode_prompt(prompt, device, 1, True, '')

>>> # Prepare the scheduler
>>> pipe.scheduler.set_timesteps(num_inference_steps, device=device)

>>> # Prepare latent variables
>>> # We don't use all timesteps in the noise scheduler.
>>> # Calculate a subset of timesteps based on `strength` to apply to the initial image.
>>> init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
>>> t_start = max(num_inference_steps - init_timestep, 0)
>>> timesteps = pipe.scheduler.timesteps[t_start:]
>>> # The first timestep of the new timesteps will be the starting point for adding noise to the initial image.
>>> latent_timestep = timesteps[:1]

>>> # Add noise to init_image_latents at the noise level specified by latent_timestep.
>>> noise = torch.randn((1, 4, 64, 64), device=device, 
...                     generator=torch.Generator(device=device).manual_seed(42))
>>> latents = pipe.scheduler.add_noise(init_image_latents, noise, latent_timestep)

>>> # Loop through the sampling timesteps
>>> for i, t in enumerate(timesteps):

...   # Expand the latents if we are doing classifier free guidance
...   latent_model_input = torch.cat([latents] * 2)

...   # Apply any scaling required by the scheduler
...   latent_model_input = pipe.scheduler.scale_model_input(latent_model_input, t)

...   # Predict the noise residual with the UNet
...   with torch.no_grad():
...     noise_pred = pipe.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample

...   # Perform guidance
...   noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
...   noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

...   # Compute the previous noisy sample x_t -> x_t-1
...   latents = pipe.scheduler.step(noise_pred, t, latents).prev_sample

>>> # Decode latents
>>> latents_norm = latents / pipe.vae.config.scaling_factor

>>> with torch.no_grad():
...     result_image = pipe.vae.decode(latents_norm).sample

>>> result_image = (result_image / 2 + 0.5).clamp(0, 1).squeeze()
>>> result_image = (result_image.permute(1, 2, 0) * 255).to(torch.uint8).cpu().numpy()
>>> result_image = Image.fromarray(result_image)

>>> # View the result
>>> fig, axs = plt.subplots(1, 2, figsize=(12, 5))
>>> axs[0].imshow(init_image);axs[0].set_title('Input Image')
>>> axs[1].imshow(result_image);axs[1].set_title('Result');
```

Now that we've manually implemented the img2img process, let’s see how to achieve the same results more efficiently using the StableDiffusionImg2ImgPipeline provided by the diffusers library. 

This pipeline requires no special models, so as long as the model ID is the same as our text-to-image example above, no new files will need to be downloaded.

### Img2Img Pipeline

```python
# Loading an Img2Img pipeline
model_id = "stabilityai/stable-diffusion-2-1-base"
img2img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id).to(device)
```

In the 'Setup' section we loaded an example `init_image` to use for this demo, but you can replace it with your own image if you'd prefer. Here's the pipeline in  action:

```python
>>> # Apply Img2Img
>>> result_image = img2img_pipe(
...     prompt="An oil painting of a man on a bench",
...     image=init_image, # The starting image
...     strength=0.6, # 0 for no change, 1.0 for max strength
... ).images[0]

>>> # View the result
>>> fig, axs = plt.subplots(1, 2, figsize=(12, 5))
>>> axs[0].imshow(init_image);axs[0].set_title('Input Image')
>>> axs[1].imshow(result_image);axs[1].set_title('Result');
```

**Exercise:** Experiment with this pipeline. Try your own images, or play with different strengths and prompts. You can use many of the same arguments as the text-to-image pipeline, so feel free to try different sizes, number of steps etc.

## In-Painting

What if we wanted to keep some of the input image unchanged but generate something new in other parts? This is called 'inpainting'. While it can be done with the same model as the previous demos (via the `StableDiffusionInpaintPipelineLegacy`), we can get better results by using a custom fine-tuned version of Stable Diffusion that takes a masked image and the mask itself as additional conditioning. The mask image should be the same shape as the input image, with white in the areas to be replaces and black in the areas to be kept unchanged. 

To gain a deeper understanding of the inpainting process, let’s manually implement the logic behind the StableDiffusionInpaintPipelineLegacy. This approach will clarify how inpainting works at a lower level and provide insight into how Stable Diffusion processes inputs. Once we’ve completed this, we’ll explore the fine-tuned pipeline for comparison. Here’s how you can manually implement the inpainting pipeline and apply it to the example image and mask loaded in the 'Setup' section:

![inpainting from_scratch](https://raw.githubusercontent.com/metamath1/diffusion-models-class/unit3/implement_img2img_inpaint/unit3/inpaint_from_scratch.png)

### A DIY Inpainting Loop

```python
>>> # Resize mask image
>>> mask_image_latent_size = mask_image.resize((64,64))
>>> mask_image_latent_size = torch.tensor( (np.array(mask_image_latent_size)[...,0] > 5).astype(np.float32) )
>>> plt.imshow(mask_image_latent_size.numpy(), cmap='gray')

>>> mask_image_latent_size = mask_image_latent_size.to(device)
>>> mask_image_latent_size.shape
```

Write the denoising loop again.

```python
>>> guidance_scale = 8 #@param
>>> num_inference_steps = 30 #@param
>>> prompt = "A small robot, high resolution, sitting on a park bench"
>>> negative_prompt = "zoomed in, blurry, oversaturated, warped"
>>> generator = torch.Generator(device=device).manual_seed(42)

>>> # Encode the prompt
>>> text_embeddings = pipe._encode_prompt(prompt, device, 1, True, negative_prompt)

>>> # Create our random starting point
>>> latents = torch.randn((1, 4, 64, 64), device=device, generator=generator)
>>> latents *= pipe.scheduler.init_noise_sigma

>>> # Prepare the scheduler
>>> pipe.scheduler.set_timesteps(num_inference_steps, device=device)

>>> for i, t in enumerate(pipe.scheduler.timesteps):
...     # Expand the latents if we are doing classifier free guidance
...     latent_model_input = torch.cat([latents] * 2)
    
...     # Apply any scaling required by the scheduler
...     latent_model_input = pipe.scheduler.scale_model_input(latent_model_input, t)

...     # Predict the noise residual with the UNet
...     with torch.no_grad():
...         noise_pred = pipe.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample

...     # Perform guidance
...     noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
...     noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

...     # Compute the previous noisy sample x_t -> x_t-1
...     latents = pipe.scheduler.step(noise_pred, t, latents, return_dict=False)[0]

...     # Perform inpainting to fill in the masked areas
...     if i >> # Decode latents
>>> latents_norm = latents / pipe.vae.config.scaling_factor

>>> with torch.no_grad():
...     inpainted_image = pipe.vae.decode(latents_norm).sample

>>> inpainted_image = (inpainted_image / 2 + 0.5).clamp(0, 1).squeeze()
>>> inpainted_image = (inpainted_image.permute(1, 2, 0) * 255).to(torch.uint8).cpu().numpy()
>>> inpainted_image = Image.fromarray(inpainted_image)

>>> inpainted_image
```

### Inpainting Pipeline

Now that we’ve manually implemented the inpainting logic, let’s see how to use a fine-tuned pipeline designed specifically for inpainting tasks. Here’s how we load such a pipeline and apply it to the example image and mask loaded in the 'Setup' section:

![inpainting from_scratch](https://raw.githubusercontent.com/huggingface/diffusion-models-class/main/unit3/inpaint_w_border.jpg)

```python
# Load the inpainting pipeline (requires a suitable inpainting model)
# pipe = StableDiffusionInpaintPipeline.from_pretrained("runwayml/stable-diffusion-inpainting")

# "runwayml/stable-diffusion-inpainting" is no longer available.
# Therefore, we are using the "stabilityai/stable-diffusion-2-inpainting" model instead.
pipe = StableDiffusionInpaintPipeline.from_pretrained("stabilityai/stable-diffusion-2-inpainting")
pipe = pipe.to(device)
```

```python
>>> # Inpaint with a prompt for what we want the result to look like
>>> prompt = "A small robot, high resolution, sitting on a park bench"
>>> image = pipe(prompt=prompt, image=init_image, mask_image=mask_image).images[0]

>>> # View the result
>>> fig, axs = plt.subplots(1, 3, figsize=(16, 5))
>>> axs[0].imshow(init_image);axs[0].set_title('Input Image')
>>> axs[1].imshow(mask_image);axs[1].set_title('Mask')
>>> axs[2].imshow(image);axs[2].set_title('Result');
```

This can be especially powerful when combined with another model to automatically generate masks. For example, [this demo space](https://huggingface.co/spaces/nielsr/text-based-inpainting) uses a model called CLIPSeg to mask out an object to be replaced based on a text description.

### Aside: Managing Your Model Cache

Exploring different pipelines and model variants can fill up your disk space. You can see which models are currently downloaded with:

```python
>>> !ls ~/.cache/huggingface/hub/ # List the contents of the cache directory
```

models--CompVis--stable-diffusion-v1-4
models--ddpm-bedroom-256
models--google--ddpm-bedroom-256
models--google--ddpm-celebahq-256
models--runwayml--stable-diffusion-inpainting
models--stabilityai--stable-diffusion-2-1-base

Check out [the docs on caching](https://huggingface.co/docs/huggingface_hub/main/en/how-to-cache) to see how to view and manage your cache effectively. 

## Depth2Image

![depth to image examples](https://camo.githubusercontent.com/50c14634d9ff835abd36693cccbdb12fc153e56226414186012641ab75b70b6f/68747470733a2f2f68756767696e67666163652e636f2f73746162696c69747961692f737461626c652d646966667573696f6e2d322d64657074682f7265736f6c76652f6d61696e2f646570746832696d6167652e706e67)
_Input image, depth image and generated examples (image source: StabilityAI)_

Img2Img is great, but sometimes we want to create a new image with the composition of the original but completely different colours or textures. It can be difficult to find an Img2Img strength that preserves what we'd like of the layout without also keeping the input colors. 

Time for another fine-tuned model! This one takes in depth information as additional conditioning when generating. The pipeline uses a depth estimation model to create a depth map, which is then fed to the fine-tuned UNet when generating images to (hopefully) preserve the depth and structure of the initial image while filling in completely new content.

```python
# Load the Depth2Img pipeline (requires a suitable model)
pipe = StableDiffusionDepth2ImgPipeline.from_pretrained("stabilityai/stable-diffusion-2-depth")
pipe = pipe.to(device)
```

```python
>>> # Inpaint with a prompt for what we want the result to look like
>>> prompt = "An oil painting of a man on a bench"
>>> image = pipe(prompt=prompt, image=init_image).images[0]

>>> # View the result
>>> fig, axs = plt.subplots(1, 2, figsize=(16, 5))
>>> axs[0].imshow(init_image);axs[0].set_title('Input Image')
>>> axs[1].imshow(image);axs[1].set_title('Result');
```

Note how the output compares to the img2img example - here there is much more color variation, but the overall structure is still faithful to the original. This is not ideal in this case since the man has been given some extremely weird anatomy to match the dog shape, but in some cases this is extraordinarily useful. For an example of the 'killer app' for this approach, check out [this tweet](https://twitter.com/CarsonKatri/status/1600248599254007810?s=20&t=BlzSK26sfqi2336SN0gKpQ) showing the depth model being used to texture a 3D scene!

# Where Next?

Hopefully, this has given you a taste of the many things that Stable Diffusion can do! Once you get tired of playing with the examples in this notebook, check out the **DreamBooth hackathon** notebook to see how to fine-tune your own version of Stable Diffusion which can be used with the text-to-image or img2img pipelines we've seen here.

If you're curious to dig deeper into how the different components work, then check out the **Stable Diffusion Deep Dive** notebook which goes into much more detail and shows some additional tricks we can do.

Be sure to share your creations with us and the community!

### Unit 3: Stable Diffusion
https://huggingface.co/learn/diffusion-course/unit3/1.md

# Unit 3: Stable Diffusion

Welcome to Unit 3 of the Hugging Face Diffusion Models Course! In this unit you will meet a powerful diffusion model called Stable Diffusion (SD) and explore what it can do.

## Start this Unit 🚀

Here are the steps for this unit:

- Make sure you've [signed up for this course](https://huggingface.us17.list-manage.com/subscribe?u=7f57e683fa28b51bfc493d048&id=ef963b4162) so that you can be notified when new material is released.
- Read through the material below for an overview of the key ideas of this unit.
- Check out the [_**Stable Diffusion Introduction**_ notebook](#hands-on-notebook) to see SD applied in practice to some common use-cases.
- Use the _**Dreambooth**_ notebook in the [**hackathon** folder](https://github.com/huggingface/diffusion-models-class/tree/main/hackathon) to fine-tune your own custom Stable Diffusion model and share it with the community for a chance to win some prizes and swag.
- (Optional) Check out the [_**Stable Diffusion Deep Dive video**_](https://www.youtube.com/watch?app=desktop&v=0_BBRNYInx8) and the accompanying [_**notebook**_](https://github.com/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb) for a deeper exploration of the different components and how they can be adapted for different effects. This material was created for the new FastAI course, ['Stable Diffusion from the Foundations'](https://www.fast.ai/posts/part2-2022.html) - the whole course has been released, making this a great supplement to this class for anyone curious about building these kinds of models completely from scratch. 

📢 Don't forget to join the [Discord](https://huggingface.co/join/discord), where you can discuss the material and share what you've made in the `#diffusion-models-class` channel.

## Introduction

![SD example images](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/diffusion-course/sd_demo_images.jpg)
_Example images generated using Stable Diffusion_

Stable Diffusion is a powerful text-conditioned latent diffusion model. Don't worry, we'll explain those words shortly! Its ability to create amazing images from text descriptions has made it an internet sensation. In this unit, we're going to explore how SD works and see what other tricks it can do.
 
## Latent Diffusion

As image size grows, so does the computational power required to work with those images. This is especially pronounced in an operation called self-attention, where the amount of operations grows quadratically with the number of inputs. A 128px square image has 4x as many pixels as a 64px square image, and so requires 16x (i.e. 42) the memory and compute in a self-attention layer. This is a problem for anyone who'd like to generate high-resolution images!

![latent diffusion diagram](https://github.com/CompVis/latent-diffusion/raw/main/assets/modelfigure.png)
_Diagram from the [Latent Diffusion paper](http://arxiv.org/abs/2112.10752)_

Latent diffusion helps to mitigate this issue by using a separate model called a Variational Auto-Encoder (VAE) to **compress** images to a smaller spatial dimension. The rationale behind this is that images tend to contain a large amount of redundant information - given enough training data, a VAE can hopefully learn to produce a much smaller representation of an input image and then reconstruct the image based on this small **latent** representation with a high degree of fidelity. The VAE used in SD takes in 3-channel images and produces a 4-channel latent representation with a reduction factor of 8 for each spatial dimension. That is, a 512px square input image will be compressed down to a 4x64x64 latent.

By applying the diffusion process on these **latent representations** rather than on full-resolution images, we can get many of the benefits that would come from using smaller images (lower memory usage, fewer layers needed in the UNet, faster generation times...) and still decode the result back to a high-resolution image once we're ready to view the final result. This innovation dramatically lowers the cost to train and run these models. 

## Text Conditioning

In Unit 2 we showed how feeding additional information to the UNet allows us to have some additional control over the types of images generated. We call this conditioning. Given a noisy version of an image, the model is tasked with predicting the denoised version **based on additional clues** such as a class label or, in the case of Stable Diffusion, a text description of the image. At inference time, we can feed in the description of an image we'd like to see and some pure noise as a starting point, and the model does its best to 'denoise' the random input into something that matches the caption. 

![text encoder diagram](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/diffusion-course/text_encoder_noborder.png)
_Diagram showing the text encoding process which transforms the input prompt into a set of text embeddings (the encoder_hidden_states) which can then be fed in as conditioning to the UNet._

For this to work, we need to create a numeric representation of the text that captures relevant information about what it describes. To do this, SD leverages a pre-trained transformer model based on something called CLIP. CLIP's text encoder was designed to process image captions into a form that could be used to compare images and text, so it is well suited to the task of creating useful representations from image descriptions. An input prompt is first tokenized (based on a large vocabulary where each word or sub-word is assigned a specific token) and then fed through the CLIP text encoder, producing a 768-dimensional (in the case of SD 1.X) or 1024-dimensional (SD 2.X) vector for each token. To keep things consistent prompts are always padded/truncated to be 77 tokens long, and so the final representation which we use as conditioning is a tensor of shape 77x1024 per prompt.

![conditioning diagram](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/diffusion-course/sd_unet_color.png)

OK, so how do we actually feed this conditioning information into the UNet for it to use as it makes predictions? The answer is something called cross-attention. Scattered throughout the UNet are cross-attention layers. Each spatial location in the UNet can 'attend' to different tokens in the text conditioning, bringing in relevant information from the prompt. The diagram above shows how this text conditioning (as well as timestep-based conditioning) is fed in at different points. As you can see, at every level the UNet has ample opportunity to make use of this conditioning!

## Classifier-free Guidance

It turns out that even with all of the effort put into making the text conditioning as useful as possible, the model still tends to default to relying mostly on the noisy input image rather than the prompt when making its predictions. In a way, this makes sense - many captions are only loosely related to their associated images and so the model learns not to rely too heavily on the descriptions! However, this is undesirable when it comes time to generate new images - if the model doesn't follow the prompt then we may get images out that don't relate to our description at all.

![CFG scale demo grid](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/diffusion-course/cfg_example_0_1_2_10.jpeg)
_Images generated from the prompt "An oil painting of a collie in a top hat" with CFG scale 0, 1, 2 and 10 (left to right)_

To fix this, we use a trick called Classifier-Free Guidance (CGF). During training, text conditioning is sometimes kept blank, forcing the model to learn to denoise images with no text information whatsoever (unconditional generation). Then at inference time, we make two separate predictions: one with the text prompt as conditioning and one without. We can then use the difference between these two predictions to create a final combined prediction that pushes **even further** in the direction indicated by the text-conditioned prediction according to some scaling factor (the guidance scale), hopefully resulting in an image that better matches the prompt. The image above shows the outputs for a prompt at different guidance scales - as you can see, higher values result in images that better match the description.

## Other Types of Conditioning: Super-Resolution, Inpainting and Depth-to-Image

It is possible to create versions of Stable Diffusion that take in additional kinds of conditioning. For example, the [Depth-to-Image model](https://huggingface.co/stabilityai/stable-diffusion-2-depth) has extra input channels that take in-depth information about the image being denoised, and at inference time we can feed in the depth map of a target image (estimated using a separate model) to hopefully generate an image with a similar overall structure. 

![depth to image example](https://huggingface.co/stabilityai/stable-diffusion-2-depth/resolve/main/depth2image.png)
_Depth-conditioned SD is able to generate different images with the same overall structure (example from StabilityAI)_

In a similar manner, we can feed in a low-resolution image as the conditioning and have the model generate the high-resolution version ([as used by the Stable Diffusion Upscaler](https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler)). Finally, we can feed in a mask showing a region of the image to be re-generated as part of the 'in-painting' task, where the non-mask regions need to stay intact while new content is generated for the masked area. 

## Fine-Tuning with DreamBooth

![dreambooth diagram](https://dreambooth.github.io/DreamBooth_files/teaser_static.jpg)
_Image from the [dreambooth project page](https://dreambooth.github.io/) based on the Imagen model_

DreamBooth is a technique for fine-tuning a text-to-image model to 'teach' it a new concept, such as a specific object or style. The technique was originally developed for Google's Imagen model but was quickly adapted to [work for stable diffusion](https://huggingface.co/docs/diffusers/training/dreambooth). Results can be extremely impressive (if you've seen anyone with an AI profile picture on social media recently the odds are high it came from a dreambooth-based service) but the technique is also sensitive to the settings used, so check out our notebook and [this great investigation into the different training parameters](https://huggingface.co/blog/dreambooth) for some tips on getting it working as well as possible.

## Hands-On Notebook

| Chapter                                     | Colab                                                                                                                                                                                               | Kaggle                                                                                                                                                                                                   | Gradient                                                                                                                                                                               | Studio Lab                                                                                                                                                                                                   |
|:--------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Stable Diffusion Introduction                                | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit3/01_stable_diffusion_introduction.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit3/01_stable_diffusion_introduction.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/unit3/01_stable_diffusion_introduction.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/unit3/01_stable_diffusion_introduction.ipynb)              |
| DreamBooth Hackathon Notebook                      | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb)              |
| Stable Diffusion Deep Dive                               | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb )              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb )              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb )              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/fastai/diffusion-nbs/blob/master/Stable%20Diffusion%20Deep%20Dive.ipynb )              |

At this point, you know enough to get started with the accompanying notebooks! Open them in your platform of choice using the links above. DreamBooth requires quite a lot of compute power, so if you're using Kaggle or Google Colab make sure you set the runtime type to 'GPU' for the best results. 

The 'Stable Diffusion Introduction' notebook is a short introduction to stable diffusion with the 🤗 Diffusers library, stepping through some basic usage examples using pipelines to generate and modify images.

In the DreamBooth Hackathon Notebook (in the [hackathon folder](https://github.com/huggingface/diffusion-models-class/tree/main/hackathon)) we show how you can fine-tune SD on your own images to create a custom version of the model covering a new style or concept.

Finally, the 'Stable Diffusion Deep Dive' notebook and video break down every step in a typical generation pipeline, suggesting some novel ways to modify each stage for additional creative control. 

## Project Time

Follow the instructions in the **DreamBooth** notebook to train your own model for one of the specified categories. Make sure you include the example outputs in your submission so that we can choose the best models in each category! See the [hackathon info](https://github.com/huggingface/diffusion-models-class/tree/main/hackathon) for details on prizes, GPU credits and more.

## Some Additional Resources

- [High-Resolution Image Synthesis with Latent Diffusion Models](http://arxiv.org/abs/2112.10752) - The paper that introduced the approach behind Stable Diffusion.

- [CLIP](https://openai.com/blog/clip/) - CLIP learns to connect text with images and the CLIP text encoder is used to transform a text prompt into the rich numerical representation used by SD. See also, [this article on OpenCLIP](https://wandb.ai/johnowhitaker/openclip-benchmarking/reports/Exploring-OpenCLIP--VmlldzoyOTIzNzIz) for some background on recent open-source CLIP variants (one of which is used for SD version 2).

- [GLIDE: Towards Photorealistic Image Generation and Editing with Text-Guided Diffusion Models](https://arxiv.org/abs/2112.10741) an early paper demonstrating text conditioning and CFG.

Found more great resources? Let us know and we'll add them to this list.

### Diffusion for Audio
https://huggingface.co/learn/diffusion-course/unit4/3.md

# Diffusion for Audio

In this notebook, we're going to take a brief look at generating audio with diffusion models.

## What you will learn:
- How audio is represented in a computer
- Methods to convert between raw audio data and spectrograms
- How to prepare a dataloader with a custom collate function to convert audio slices into spectrograms
- Fine-tuning an existing audio diffusion model on a specific genre of music
- Uploading your custom pipeline to the Hugging Face hub

Caveat: This is mostly for educational purposes - no guarantees our model will sound good 😉.

Let's get started!

## Setup and Imports

```python
%pip install -q datasets diffusers torchaudio accelerate
```

```python
import torch, random
import numpy as np
import torch.nn.functional as F
from tqdm.auto import tqdm
from IPython.display import Audio
from matplotlib import pyplot as plt
from diffusers import DiffusionPipeline
from torchaudio import transforms as AT
from torchvision import transforms as IT
```

## Sampling from a Pre-Trained Audio Pipeline

Let's begin by following the [Audio Diffusion docs](https://huggingface.co/docs/diffusers/api/pipelines/audio_diffusion) to load a pre-existing audio diffusion model pipeline:

```python
# Load a pre-trained audio diffusion pipeline
device = "mps" if torch.backends.mps.is_available() else "cuda" if torch.cuda.is_available() else "cpu"
pipe = DiffusionPipeline.from_pretrained("teticio/audio-diffusion-instrumental-hiphop-256").to(device)
```

As with the pipelines we've used in previous units, we can create samples by calling the pipeline like so:

```python
>>> # Sample from the pipeline and display the outputs
>>> output = pipe()
>>> display(output.images[0])
>>> display(Audio(output.audios[0], rate=pipe.mel.get_sample_rate()))
```

Here, the `rate` argument specifies the _sampling rate_ for the audio; we'll take a deeper look at this later. You'll also notice there are multiple things returned by the pipeline. What's going on here? Let's take a closer look at both outputs.

The first is an array of data, representing the generated audio:

```python
# The audio array
output.audios[0].shape
```

The second looks like a greyscale image:

```python
# The output image (spectrogram)
output.images[0].size
```

This gives us a hint at how this pipeline works. The audio is not directly generated with diffusion - instead, the pipeline has the same kind of 2D UNet as the unconditional image generation pipelines we saw in [Unit 1](https://github.com/huggingface/diffusion-models-class/tree/main/unit1) that is used to generate the spectrogram, which is then post-processed into the final audio.

The pipe has an extra component that handles these conversions, which we can access via `pipe.mel`:

```python
pipe.mel
```

## From Audio to Image and Back Again

An audio 'waveform' encodes the raw audio samples over time - this could be the electrical signal received from a microphone, for example. Working with this 'Time Domain' representation can be tricky, so it is a common practice to convert it into some other form, commonly something called a spectrogram. A spectrogram shows the intensity of different frequencies (y axis) vs time (x axis):

```python
>>> # Calculate and show a spectrogram for our generated audio sample using torchaudio
>>> spec_transform = AT.Spectrogram(power=2)
>>> spectrogram = spec_transform(torch.tensor(output.audios[0]))
>>> print(spectrogram.min(), spectrogram.max())
>>> log_spectrogram = spectrogram.log()
>>> plt.imshow(log_spectrogram[0], cmap='gray');
```

tensor(0.) tensor(6.0842)

The spectrogram we just made has values between 0.0000000000001 and 1, with most being close to the low end of that range. This is not ideal for visualization or modelling - in fact we had to take the log of these values to get a greyscale plot that showed any detail. For this reason, we typically use a special kind of spectrogram called a Mel spectrogram, which is designed to capture the kinds of information which are important for human hearing by applying some transforms to the different frequency components of the signal. 

![torchaudio docs diagram](https://download.pytorch.org/torchaudio/tutorial-assets/torchaudio_feature_extractions.png)
_Some audio transforms from the [torchaudio docs](https://pytorch.org/audio/stable/transforms.html)_

Luckily for us, we don't even need to worry too much about these transforms - the pipeline's `mel` functionality handles these details for us. Using this, we can convert a spectrogram image to audio like so:

```python
a = pipe.mel.image_to_audio(output.images[0])
a.shape
```

And we can convert an array of audio data into a spectrogram images by first loading the raw audio data and then calling the `audio_slice_to_image()` function. Longer clips are automatically sliced into chunks of the correct length to produce a 256x256 spectrogram image:

```python
>>> pipe.mel.load_audio(raw_audio=a)
>>> im = pipe.mel.audio_slice_to_image(0)
>>> im
```

The audio is represented as a long array of numbers. To play this out loud we need one more key piece of information: the sample rate. How many samples (individual values) do we use to represent a single second of audio? 

We can see the sample rate used during training of this pipeline with:

```python
sample_rate_pipeline = pipe.mel.get_sample_rate()
sample_rate_pipeline
```

If we specify the sample rate incorrectly, we get audio that is sped up or slowed down:

```python
display(Audio(output.audios[0], rate=44100)) # 2x speed
```

## Fine-Tuning the pipeline

Now that we have a rough understanding of how the pipeline works, let's fine-tune it on some new audio data!

The dataset is a collection of audio clips in different genres, which we can load from the hub like so:

```python
from datasets import load_dataset
dataset = load_dataset('lewtun/music_genres', split='train')
dataset
```

You can use the code below to see the different genres in the dataset and how many samples are contained in each:

```python
>>> for g in list(set(dataset['genre'])):
...   print(g, sum(x==g for x in dataset['genre']))
```

Pop 945
Blues 58
Punk 2582
Old-Time / Historic 408
Experimental 1800
Folk 1214
Electronic 3071
Spoken 94
Classical 495
Country 142
Instrumental 1044
Chiptune / Glitch 1181
International 814
Ambient Electronic 796
Jazz 306
Soul-RnB 94
Hip-Hop 1757
Easy Listening 13
Rock 3095

The dataset has the audio as arrays:

```python
>>> audio_array = dataset[0]['audio']['array']
>>> sample_rate_dataset = dataset[0]['audio']['sampling_rate']
>>> print('Audio array shape:', audio_array.shape)
>>> print('Sample rate:', sample_rate_dataset)
>>> display(Audio(audio_array, rate=sample_rate_dataset))
```

Audio array shape: (1323119,)
Sample rate: 44100

Note that the sample rate of this audio is higher - if we want to use the existing pipeline we'll need to 'resample' it to match. The clips are also longer than the ones the pipeline is set up for. Fortunately, when we load the audio using `pipe.mel` it automatically slices the clip into smaller sections:

```python
>>> a = dataset[0]['audio']['array'] # Get the audio array
>>> pipe.mel.load_audio(raw_audio=a) # Load it with pipe.mel
>>> pipe.mel.audio_slice_to_image(0) # View the first 'slice' as a spectrogram
```

We need to remember to adjust the sampling rate, since the data from this dataset has twice as many samples per second:

```python
sample_rate_dataset = dataset[0]['audio']['sampling_rate']
sample_rate_dataset
```

Here we use torchaudio's transforms (imported as AT) to do the resampling, the pipe's `mel` to turn audio into an image and torchvision's transforms (imported as IT) to turn images into tensors. This gives us a function that turns an audio clip into a spectrogram tensor that we can use for training:

```python
resampler = AT.Resample(sample_rate_dataset, sample_rate_pipeline, dtype=torch.float32)
to_t = IT.ToTensor()

def to_image(audio_array):
  audio_tensor = torch.tensor(audio_array).to(torch.float32)
  audio_tensor = resampler(audio_tensor)
  pipe.mel.load_audio(raw_audio=np.array(audio_tensor))
  num_slices = pipe.mel.get_number_of_slices()
  slice_idx = random.randint(0, num_slices-1) # Pic a random slice each time (excluding the last short slice)
  im = pipe.mel.audio_slice_to_image(slice_idx) 
  return im
```

We'll use our `to_image()` function as part of a custom collate function to turn our dataset into a dataloader we can use for training. The collate function defines how to transform a batch of examples from the dataset into the final batch of data ready for training. In this case we turn each audio sample into a spectrogram image and stack the resulting tensors together:

```python
>>> def collate_fn(examples):
...   # to image -> to tensor -> rescale to (-1, 1) -> stack into batch
...   audio_ims = [to_t(to_image(x['audio']['array']))*2-1 for x in examples]
...   return torch.stack(audio_ims)

>>> # Create a dataset with only the 'Chiptune / Glitch' genre of songs
>>> batch_size = 4 # 4 on colab, 12 on A100
>>> chosen_genre = 'Electronic' # >> indexes = [i for i, g in enumerate(dataset['genre']) if g == chosen_genre]
>>> filtered_dataset = dataset.select(indexes)
>>> dl = torch.utils.data.DataLoader(filtered_dataset.shuffle(), batch_size=batch_size, collate_fn=collate_fn, shuffle=True)
>>> batch = next(iter(dl))
>>> print(batch.shape)
```

torch.Size([4, 1, 256, 256])

**NB: You will need to use a lower batch size (e.g., 4) unless you have plenty of GPU vRAM available.**

## Training Loop

Here is a simple training loop that runs through the dataloader for a few epochs to fine-tune the pipeline's UNet. You can also skip this cell and load the pipeline with the code in the following cell.

```python
epochs = 3
lr = 1e-4

pipe.unet.train()
pipe.scheduler.set_timesteps(1000)
optimizer = torch.optim.AdamW(pipe.unet.parameters(), lr=lr)

for epoch in range(epochs):
    for step, batch in tqdm(enumerate(dl), total=len(dl)):
        
        # Prepare the input images
        clean_images = batch.to(device)
        bs = clean_images.shape[0]

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

        # Add noise to the clean images according to the noise magnitude at each timestep
        noise = torch.randn(clean_images.shape).to(clean_images.device)
        noisy_images = pipe.scheduler.add_noise(clean_images, noise, timesteps)

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

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

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

```python
# OR: Load the version I trained earlier
pipe = DiffusionPipeline.from_pretrained("johnowhitaker/Electronic_test").to(device)
```

```python
>>> output = pipe()
>>> display(output.images[0])
>>> display(Audio(output.audios[0], rate=22050))
```

```python
>>> # Make a longer sample by passing in a starting noise tensor with a different shape
>>> noise = torch.randn(1, 1, pipe.unet.sample_size[0], pipe.unet.sample_size[1]*4).to(device)
>>> output = pipe(noise=noise)
>>> display(output.images[0])
>>> display(Audio(output.audios[0], rate=22050))
```

Not the most amazing-sounding outputs, but it's a start :) Explore tweaking the learning rate and number of epochs, and share your best results on Discord so we can improve together!

Some things to consider:
- We're working with 256px square spectrogram images which limits our batch size. Can you recover audio of sufficient quality from a 128x128 spectrogram?
- In place of random image augmentation we're picking different slices of the audio clip each time, but could this be improved with some different kinds of augmentation when training for many epochs?
- How else might we use this to generate longer clips? Perhaps you could generate a 5s starting clip and then use inpainting-inspired ideas to continue to generate additional segments of audio that follow on from the initial clip...
- What is the equivalent of image-to-image in this spectrogram diffusion context?

## Push to Hub

Once you're happy with your model, you can save it and push it to the hub for others to enjoy:

```python
from huggingface_hub import get_full_repo_name, HfApi, create_repo, ModelCard
```

```python
# Pick a name for the model
model_name = "audio-diffusion-electronic"
hub_model_id = get_full_repo_name(model_name)
```

```python
# Save the pipeline locally
pipe.save_pretrained(model_name)
```

```python
>>> # Inspect the folder contents
>>> !ls {model_name}
```

mel  model_index.json  scheduler  unet

```python
# Create a repository
create_repo(hub_model_id)
```

```python
# Upload the files
api = HfApi()
api.upload_folder(
    folder_path=f"{model_name}/scheduler", path_in_repo="scheduler", repo_id=hub_model_id
)
api.upload_folder(
    folder_path=f"{model_name}/mel", path_in_repo="mel", repo_id=hub_model_id
)
api.upload_folder(folder_path=f"{model_name}/unet", path_in_repo="unet", 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,
)
```

```python
# Push a model card
content = f"""
---
license: mit
tags:
- pytorch
- diffusers
- unconditional-audio-generation
- diffusion-models-class
---

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

This model is a diffusion model for unconditional audio generation of music in the genre {chosen_genre}

## Usage

from IPython.display import Audio
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("{hub_model_id}")
output = pipe()
display(output.images[0])
display(Audio(output.audios[0], rate=pipe.mel.get_sample_rate()))

"""

card = ModelCard(content)
card.push_to_hub(hub_model_id)
```

## Conclusion

This notebook has hopefully given you a small taste of the potential of audio generation. Check out some of the references linked from the introduction to this unit to see some fancier methods and the astounding samples they can create!

### DDIM Inversion
https://huggingface.co/learn/diffusion-course/unit4/2.md

# DDIM Inversion

In this notebook we will explore **inversion**, see how it relates to sampling, and apply it to the task of editing images with Stable Diffusion.

## What You Will Learn

- How DDIM sampling works
- Deterministic vs Stochastic samplers
- The theory behind DDIM inversion
- Editing images with inversion

Let's get started!

## Setup

```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("mps" if torch.backends.mps.is_available() else "cuda" if torch.cuda.is_available() else "cpu")
```

## Loading an existing 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 Sampling

At a given time $t$, the noisy image $x_t$ is some mixture of the original image ($x_0$) and some noise ($\epsilon$). Here is the formula for $x_t$ from the DDIM paper, which we'll be referring to in this section:

$$ x_t = \sqrt{\alpha_t}x_0 + \sqrt{1-\alpha_t}\epsilon $$

$\epsilon$ is some gaussian noise with unit variance
$\alpha_t$ ('alpha') is the value which is confusingly called $\bar{\alpha}$ ('alpha_bar') in the DDPM paper (!!) and defined the noise scheduler. In Diffusers, the alpha scheduler is calculated and the values are stored in the `scheduler.alphas_cumprod`. Confusing I know! Let's plot these values, and remember that for the rest of this notebook we'll use DDIM's notation.

```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();
```

Initially (timestep 0, left side of the graph) we begin with a clean image and no noise. $\alpha_t = 1$. As we move to higher timesteps, we end up with almost all noise and $\alpha_t$ drops towards 0.

During sampling, we begin with pure noise at timestep 1000 and slowly move towards timestep 0. To calculate the next t in the sampling trajectory ($x_{t-1}$ since we're moving from high t to low t) we predict the noise ($\epsilon_\theta(x_t)$, which is the output of our model) and use this to calculate the predicted denoised image $x_0$. Then we use this prediction to move a small distance in the 'direction pointing to $x_t$'. Finally, we can add some additional noise scaled by $\sigma_t$. Here's the relevant section from the paper showing this in action:

![Screenshot from 2023-01-28 10-04-22.png](data:image/png;base64,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)

So, we have an equation for how to move from $x_t$ to $x_{t-1}$, with a controllable abount of noise. And today we're specifically interested in the case where we don't add any additional noise - giving us fully deterministic DDIM sampling. Let's see what this looks like in code:

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

See if you can match the code with the equation from the paper. Note that $\sigma$=0 since we're only interested in the no-extra-noise case, so we can leave out those bits of the equation.

## Inversion

The goal of inversion is to 'reverse' the sampling process. We want to end up with a noisy latent which, if used as the starting point for our usual sampling procedure, results in the original image being generated. 

Here we load an image as our initial image, but you can also generate one yourself to use instead.

```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
```

We're also going to use a prompt to do the inversion with classifier-free-guidance included, so enter a description of the image:

```python
input_image_prompt = "Photograph of a puppy on the grass"
```

Next, we need to turn this PIL image into a set of latents which we will use as the starting point for our inversion:

```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()
```

Alright, time for the fun bit. This function looks similar to the sampling function above, but we move through the timesteps in the opposite direction, starting at t=0 and moving towards higher and higher noise. And instead of updating our latents to be less noisy, we estimate the predicted noise and use it to UNDO an update step, moving them from t to 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 = 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)
```

Running it on the latent representation of our puppy pic, we get back a set of all the intermediate latents created during the inversion process:

```python
inverted_latents = invert(l, input_image_prompt, num_inference_steps=50)
inverted_latents.shape
```

We can view the final set of latents - these will hopefully be the noisy starting point for our new sampling attempts:

```python
>>> # Decode the final inverted latents
>>> with torch.no_grad():
...   im = pipe.decode_latents(inverted_latents[-1].unsqueeze(0))
>>> pipe.numpy_to_pil(im)[0]
```

You can pass these inverted latents to the pipeline using the normal __call__ method:

```python
>>> pipe(input_image_prompt, latents=inverted_latents[-1][None], num_inference_steps=50, guidance_scale=3.5).images[0]
```

But here we see our first problem: this is **not quite the image we started with**! This is because DDIM inversion relies on a critical assumption that the noise prediction at time t and at time t+1 will be the same - something that is not true when we only invert over 50 or 100 timesteps. We could use more timesteps to hopefully get a more accurate inversion, but we can also 'cheat' and start from, say, 20/50 steps through sampling with the corresponding intermediate latents we saved during inversion:

```python
>>> # The reason we want to be able to specify start step
>>> start_step = 20
>>> sample(input_image_prompt, start_latents=inverted_latents[-(start_step+1)][None], 
...        start_step=start_step, num_inference_steps=50)[0]
```

Pretty close to our input image! Why are we doing this? Well, the hope is that if we now sample with a new prompt we'll get an image that matches the original EXCEPT in places relevant to the new prompt. For ex, replacing 'puppy' with 'cat' we should see a cat with a near-identical lawn and backgorund:

```python
>>> # Sampling with a new prompt
>>> start_step = 10
>>> new_prompt = input_image_prompt.replace('puppy', 'cat')
>>> sample(new_prompt, start_latents=inverted_latents[-(start_step+1)][None], 
...        start_step=start_step, num_inference_steps=50)[0]
```

### Why not just use img2img?

Why bother inverting? Can't we just add noise to the input image and denoise with the new prompt? We can, but this will result in much more drastic changes everywhere (if we add lots of noise) or not enough changes anywhere (if we add less noise). Try it yourself:

```python
>>> start_step = 10
>>> num_inference_steps = 50
>>> pipe.scheduler.set_timesteps(num_inference_steps)
>>> noisy_l = pipe.scheduler.add_noise(l, torch.randn_like(l), pipe.scheduler.timesteps[start_step])
>>> sample(new_prompt, start_latents=noisy_l, start_step=start_step, num_inference_steps=num_inference_steps)[0]
```

Note the much-larger change to the lawn and background.

# Putting it all together

Let's wrap the code we've written so far into a simple function that takes an image and two prompts and performs an edit using inversion:

```python
def edit(input_image, input_image_prompt, edit_prompt, num_steps=100, start_step=30, guidance_scale=3.5):
    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()
    inverted_latents = invert(l, input_image_prompt, num_inference_steps=num_steps)
    final_im = sample(edit_prompt, start_latents=inverted_latents[-(start_step+1)][None], 
                      start_step=start_step, num_inference_steps=num_steps, guidance_scale=guidance_scale)[0]
    return final_im
```

And in action:

```python
>>> edit(input_image, 'A puppy on the grass', 'an old grey dog on the grass', num_steps=50, start_step=10)
```

```python
>>> edit(input_image, 'A puppy on the grass', 'A blue dog on the lawn', num_steps=50, start_step=12, guidance_scale=6)
```

```python
# Exercise: Try this on some more images! Explore the different parameters.
```

## More Steps = Better Performance

If you've having issues with less-accurate inversions, you can try using more steps (at the cost of longer running time). To test the inversion you can use our edit function with the same prompt:

```python
>>> # Inversion test with far more steps
>>> edit(input_image, 'A puppy on the grass', 'A puppy on the grass', num_steps=350, start_step=1)
```

Much better! And trying it for an edit:

```python
>>> edit(input_image, 'A photograph of a puppy', 'A photograph of a grey cat', num_steps=150, start_step=30, guidance_scale=5.5)
```

```python
>>> # source: https://www.pexels.com/photo/girl-taking-photo-1493111/
>>> face = load_image('https://images.pexels.com/photos/1493111/pexels-photo-1493111.jpeg', size=(512, 512))
>>> face
```

```python
>>> edit(face, 'A photograph of a face', 'A photograph of a face with sunglasses', num_steps=250, start_step=30, guidance_scale=3.5)
```

```python
>>> edit(face, 'A photograph of a face', 'Acrylic palette knife painting of a face, colorful', num_steps=250, start_step=65, guidance_scale=5.5)
```

# What Next?

Armed with the knowledge from this notebook, I recommend you investigate ['Null-text Inversion'](https://null-text-inversion.github.io/) which builds on DDIM by optimizing the null text (unconditional text prompt) during inversion for more accurate inversions and better edits.

### Unit 4: Going Further with Diffusion Models
https://huggingface.co/learn/diffusion-course/unit4/1.md

# Unit 4: Going Further with Diffusion Models

Welcome to Unit 4 of the Hugging Face Diffusion Models Course! In this unit, we will look at some of the many improvements and extensions to diffusion models appearing in the latest research. It will be less code-heavy than previous units have been and is designed to give you a jumping-off point for further research.

## Start this Unit 🚀

Here are the steps for this unit:

- Make sure you've [signed up for this course](https://huggingface.us17.list-manage.com/subscribe?u=7f57e683fa28b51bfc493d048&id=ef963b4162) so that you can be notified when additional units are added to the course.
- Read through the material below for an overview of the different topics covered in this unit.
- Dive deeper into any specific topics with the linked videos and resources.
- Explore the demo notebooks and then read the 'What Next' section for some project suggestions.

📢 Don't forget to join [Discord](https://huggingface.co/join/discord), where you can discuss the material and share what you've made in the `#diffusion-models-class` channel.

## Table of Contents

- [Unit 4: Going Further with Diffusion Models](#unit-4-going-further-with-diffusion-models)
  - [Start this Unit 🚀](#start-this-unit-rocket)
  - [Table of Contents](#table-of-contents)
  - [Faster Sampling via Distillation](#faster-sampling-via-distillation)
  - [Training Improvements](#training-improvements)
  - [More Control for Generation and Editing](#more-control-for-generation-and-editing)
  - [Video](#video)
  - [Audio](#audio)
  - [New Architectures and Approaches - Towards 'Iterative Refinement'](#new-architectures-and-approaches---towards-iterative-refinement)
  - [Hands-On Notebooks](#hands-on-notebooks)
  - [Where Next?](#where-next)

## Faster Sampling via Distillation

Progressive distillation is a technique for taking an existing diffusion model and using it to train a new version of the model that requires fewer steps for inference. The 'student' model is initialized from the weights of the 'teacher' model. During training, the teacher model performs two sampling steps and the student model tries to match the resulting prediction in a single step. This process can be repeated multiple times, with the previous iteration's student model becoming the teacher for the next stage. The result is a model that can produce decent samples in much fewer steps (typically 4 or 8) than the original teacher model. The core mechanism is illustrated in this diagram from the [paper that introduced the idea](http://arxiv.org/abs/2202.00512):

![image](https://user-images.githubusercontent.com/6575163/211016659-7dac24a5-37e2-45f9-aba8-0c573937e7fb.png)

_Progressive Distillation illustrated (from the [paper](http://arxiv.org/abs/2202.00512))_

The idea of using an existing model to 'teach' a new model can be extended to create guided models where the classifier-free guidance technique is used by the teacher model and the student model must learn to produce an equivalent output in a single step based on an additional input specifying the targeted guidance scale. This further reduces the number of model evaluations required to produce high-quality samples. [This video](https://www.youtube.com/watch?v=ZXuK6IRJlnk) gives an overview of the approach.

NB: A distilled version of Stable Diffusion can be used [here](https://huggingface.co/docs/diffusers/main/en/using-diffusers/distilled_sd).

Key references:
- [Progressive Distillation For Fast Sampling Of Diffusion Models](http://arxiv.org/abs/2202.00512)
- [On Distillation Of Guided Diffusion Models](http://arxiv.org/abs/2210.03142)

## Training Improvements

There have been several additional tricks developed to improve diffusion model training. In this section we've tried to capture the core ideas from recent papers. There is a constant stream of research coming out with additional improvements, so if you see a paper you feel should be added here please let us know!

![image](https://user-images.githubusercontent.com/6575163/211021220-e87ca296-cf15-4262-9359-7aeffeecbaae.png)
_Figure 2 from the [ERNIE-ViLG 2.0 paper](http://arxiv.org/abs/2210.15257)_

Key training improvements:
- Tuning the noise schedule, loss weighting and sampling trajectories for more efficient training. An excellent paper exploring some of these design choices is [Elucidating the Design Space of Diffusion-Based Generative Models](http://arxiv.org/abs/2206.00364) by Karras et al.
- Training on diverse aspect ratios, as described in [this video from the course launch event](https://www.youtube.com/watch?v=g6tIUrMvOec).
- Cascaded diffusion models, training one model at low resolution and then one or more super-res models. Used in DALLE-2, Imagen and more for high-resolution image generation.
- Better conditioning, incorporating rich text embeddings ([Imagen](https://arxiv.org/abs/2205.11487) uses a large language model called T5) or multiple types of conditioning ([eDiffi](http://arxiv.org/abs/2211.01324)).
- 'Knowledge Enhancement' - incorporating pre-trained image captioning and object detection models into the training process to create more informative captions and produce better performance ([ERNIE-ViLG 2.0](http://arxiv.org/abs/2210.15257)).
- 'Mixture of Denoising Experts' (MoDE) - training different variants of the model ('experts') for different noise levels as illustrated in the image above from the [ERNIE-ViLG 2.0 paper](http://arxiv.org/abs/2210.15257).

Key references:
- [Elucidating the Design Space of Diffusion-Based Generative Models](http://arxiv.org/abs/2206.00364)
- [eDiffi: Text-to-Image Diffusion Models with an Ensemble of Expert Denoisers](http://arxiv.org/abs/2211.01324)
- [ERNIE-ViLG 2.0: Improving Text-to-Image Diffusion Model with Knowledge-Enhanced Mixture-of-Denoising-Experts](http://arxiv.org/abs/2210.15257)
- [Imagen - Photorealistic Text-to-Image Diffusion Models with Deep Language Understanding](https://arxiv.org/abs/2205.11487) ([demo site](https://imagen.research.google/))

## More Control for Generation and Editing

In addition to training improvements, there have been several innovations in the sampling and inference phase, including many approaches that can add new capabilities to existing diffusion models.

![image](https://user-images.githubusercontent.com/6575163/212529129-3de41cf4-6f70-4607-8448-e9bbe9d190cf.png)
_Samples generated by 'paint-with-words' ([eDiffi](http://arxiv.org/abs/2211.01324))_

The video ['Editing Images with Diffusion Models'](https://www.youtube.com/watch?v=zcG7tG3xS3s) gives an overview of the different methods being used to edit existing images with diffusion models. The available techniques can be split into four main categories:

1) Add noise and then denoise with a new prompt. This is the idea behind the `img2img` pipeline, which has been modified and extended in various papers:
- [SDEdit](https://sde-image-editing.github.io/) and [MagicMix](https://magicmix.github.io/) build on this idea.
- DDIM inversion (TODO link tutorial) uses the model to 'reverse' the sampling trajectory rather than adding random noise, giving more control.
- [Null-text Inversion](https://null-text-inversion.github.io/) enhances the performance of this kind of approach dramatically by optimizing the unconditional text embeddings used for classifier-free guidance at each step, allowing for extremely high-quality text-based image editing.
2) Extending the ideas in (1) but with a mask to control where the effect is applied:
- [Blended Diffusion](https://omriavrahami.com/blended-diffusion-page/) introduces the basic idea.
- [This demo](https://huggingface.co/spaces/nielsr/text-based-inpainting) uses an existing segmentation model (CLIPSeg) to create the mask based on a text description.
- [DiffEdit](https://arxiv.org/abs/2210.11427) is an excellent paper that shows how the diffusion model itself can be used to generate an appropriate mask for editing the image based on text.
- [SmartBrush: Text and Shape Guided Object Inpainting with Diffusion Model](https://arxiv.org/abs/2212.05034) fine-tunes a diffusion model for more accurate mask-guided inpainting.
3) Cross-attention Control: using the cross-attention mechanism in diffusion models to control the spatial location of edits for more fine-grained control:
- [Prompt-to-Prompt Image Editing with Cross Attention Control](https://arxiv.org/abs/2208.01626) is the key paper that introduced this idea, and the technique has [since been applied to Stable Diffusion](https://wandb.ai/wandb/cross-attention-control/reports/Improving-Generative-Images-with-Instructions-Prompt-to-Prompt-Image-Editing-with-Cross-Attention-Control--VmlldzoyNjk2MDAy).
- This idea is also used for 'paint-with-words' ([eDiffi](http://arxiv.org/abs/2211.01324), shown above).
4) Fine-tune ('overfit') on a single image and then generate with the fine-tuned model. The following papers both published variants of this idea at roughly the same time:
- [Imagic: Text-Based Real Image Editing with Diffusion Models](https://arxiv.org/abs/2210.09276).
- [UniTune: Text-Driven Image Editing by Fine Tuning an Image Generation Model on a Single Image
](https://arxiv.org/abs/2210.09477).

The paper [InstructPix2Pix: Learning to Follow Image Editing Instructions](https://arxiv.org/abs/2211.09800) is notable in that it used some of the image editing techniques described above to build a synthetic dataset of image pairs alongside image edit instructions (generated with GPT3.5) to train a new model capable of editing images based on natural language instructions.

## Video

![image](https://user-images.githubusercontent.com/6575163/213657523-be40178a-4357-410b-89e3-a4cbd8528900.png)
_Still frames from [sample videos generated with Imagen Video](https://imagen.research.google/video/)_

A video can be represented as a sequence of images, and the core ideas of diffusion models can be applied to these sequences. Recent work has focused on finding appropriate architectures (such as '3D UNets' which operate on entire sequences) and on working efficiently with video data. Since high-frame-rate video involves a lot more data than still images, current approaches tend to first generate low-resolution and low-frame-rate video and then apply spatial and temporal super-resolution to produce the final high-quality video outputs.

Key references:
- [Video Diffusion Models](https://video-diffusion.github.io/)
- [IMAGEN VIDEO: HIGH DEFINITION VIDEO GENERATION WITH DIFFUSION MODELS](https://imagen.research.google/video/paper.pdf)

## Audio

![image](https://user-images.githubusercontent.com/6575163/213657272-a1b54017-216f-453b-9b28-97c6fef21f54.png)

_A spectrogram generated with Riffusion ([image source](https://www.riffusion.com/about))_

While there has been some work on generating audio directly using diffusion models (e.g. [DiffWave](https://arxiv.org/abs/2009.09761)) the most successful approach so far has been to convert the audio signal into something called a spectrogram, which effectively 'encodes' the audio as a 2D "image" which can then be used to train the kinds of diffusion models we're used to using for image generation. The resulting generated spectrograms can then be converted into audio using existing methods. This approach is behind the recently-released Riffusion, which fine-tuned Stable Diffusion to generate spectrograms conditioned on text - [try it out here](https://www.riffusion.com/).

The field of audio generation is moving extremely quickly. Over the past week (at the time of writing) there have been at least 5 new advances announced, which are marked with a star in the list below:

Key references:
- [DiffWave: A Versatile Diffusion Model for Audio Synthesis](https://arxiv.org/abs/2009.09761)
- ['Riffusion'](https://www.riffusion.com/about) (and [code](https://github.com/riffusion/riffusion))
- *[MusicLM](https://google-research.github.io/seanet/musiclm/examples/) by Google generates consistent audio from text and can be conditioned with hummed or whistled melodies.
- *[RAVE2](https://github.com/acids-ircam/RAVE) - A new version of a Variational Auto-Encoder that will be useful for latent diffusion on audio tasks. This is used in the soon-to-be-announced *[AudioLDM](https://twitter.com/LiuHaohe/status/1619119637660327936?s=20&t=jMkPWBFuAH19HI9m5Sklmg) model.
- *[Noise2Music](https://noise2music.github.io/) - A diffusion model trained to produce high-quality 30-second clips of audio based on text descriptions.
- *[Make-An-Audio: Text-To-Audio Generation with Prompt-Enhanced Diffusion Models](https://text-to-audio.github.io/) - A diffusion model trained to generate diverse sounds based on text.
- *[Moûsai: Text-to-Music Generation with Long-Context Latent Diffusion](https://arxiv.org/abs/2301.11757)

## New Architectures and Approaches - Towards 'Iterative Refinement'

![image](https://user-images.githubusercontent.com/6575163/213731066-0fbe38a7-233f-42be-99fc-38cea889c86b.png)

_Figure 1 from the [Cold Diffusion](http://arxiv.org/abs/2208.09392) paper_

We are slowly moving beyond the original narrow definition of "diffusion" models and towards a more general class of models that perform **iterative refinement**, where some form of corruption (like the addition of gaussian noise in the forward diffusion process) is gradually reversed to generate samples. The 'Cold Diffusion' paper demonstrated that many other types of corruption can be iteratively 'undone' to generate images (examples shown above), and recent transformer-based approaches have demonstrated the effectiveness of token replacement or masking as a noising strategy.

![image](https://user-images.githubusercontent.com/6575163/213731351-7fd6c98c-6ba6-4bd9-a898-230002fc334f.png)

_Pipeline from [MaskGIT](http://arxiv.org/abs/2202.04200)_

The UNet architecture at the heart of many current diffusion models is also being replaced with different alternatives, most notably various transformer-based architectures. In [Scalable Diffusion Models with Transformers (DiT)](https://www.wpeebles.com/DiT) a transformer is used in place of the UNet for a fairly standard diffusion model approach, with excellent results. [Recurrent Interface Networks](https://arxiv.org/pdf/2212.11972.pdf) applies a novel transformer-based architecture and training strategy in pursuit of additional efficiency. [MaskGIT](http://arxiv.org/abs/2202.04200) and [MUSE](http://arxiv.org/abs/2301.00704) use transformer models to work with tokenized representations of images, although the [Paella](https://arxiv.org/abs/2211.07292v1) model demonstrates that a UNet can also be applied successfully to these token-based regimes too.

With each new paper, more efficient approaches are being developed, and it may be some time before we see what peak performance looks like on these kinds of iterative refinement tasks. There is much more still to explore!

Key references

- [Cold Diffusion: Inverting Arbitrary Image Transforms Without Noise](http://arxiv.org/abs/2208.09392)
- [Scalable Diffusion Models with Transformers (DiT)](https://www.wpeebles.com/DiT)
- [MaskGIT: Masked Generative Image Transformer](http://arxiv.org/abs/2202.04200)
- [Muse: Text-To-Image Generation via Masked Generative Transformers](http://arxiv.org/abs/2301.00704)
- [Fast Text-Conditional Discrete Denoising on Vector-Quantized Latent Spaces (Paella)](https://arxiv.org/abs/2211.07292v1)
- [Recurrent Interface Networks](https://arxiv.org/pdf/2212.11972.pdf) - A promising new architecture that does well at generating high-resolution images without relying on latent diffusion or super-resolution. See also, [simple diffusion: End-to-end diffusion for high-resolution images](https://arxiv.org/abs/2301.11093) which highlights the importance of the noise schedule for training at higher resolutions.

## Hands-On Notebooks

| Chapter                                     | Colab                                                                                                                                                                                               | Kaggle                                                                                                                                                                                                   | Gradient                                                                                                                                                                               | Studio Lab                                                                                                                                                                                                   |
|:--------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| DDIM Inversion                                | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit4/01_ddim_inversion.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit4/01_ddim_inversion.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/unit4/01_ddim_inversion.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/unit4/01_ddim_inversion.ipynb)              |
| Diffusion for Audio                                | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit4/02_diffusion_for_audio.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit4/02_diffusion_for_audio.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/unit4/02_diffusion_for_audio.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/unit4/02_diffusion_for_audio.ipynb)              |

We've covered a LOT of different ideas in this unit, many of which deserve much more detailed follow-on lessons in the future. For now, you can choose two of the many topics via the hands-on notebooks we've prepared.
- **DDIM Inversion** shows how a technique called inversion can be used to edit images using existing diffusion models.
- **Diffusion for Audio** introduces the idea of spectrograms and shows a minimal example of fine-tuning an audio diffusion model on a specific genre of music.

## Where Next?

This is the final unit of this course for now, which means that what comes next is up to you! Remember that you can always ask questions and chat about your projects on the Hugging Face [Discord](https://huggingface.co/join/discord). We look forward to seeing what you create 🤗.

### DreamBooth Hackathon 🏆
https://huggingface.co/learn/diffusion-course/hackathon/dreambooth.md

# DreamBooth Hackathon 🏆

Welcome to the DreamBooth Hackathon! In this competition, you'll **personalise a Stable Diffusion model by fine-tuning it on a handful of your own images.** To do so, we'll use a technique called [_DreamBooth_](https://arxiv.org/abs/2208.12242), which allows one to implant a subject (e.g. your pet or favourite dish) into the output domain of the model such that it can be synthesized with a _unique identifier_ in the prompt.

Let's dive in!

## Prerequisites

Before diving into this notebook, you should read the:

* [Unit 3 README](https://github.com/huggingface/diffusion-models-class/blob/main/unit3/README.md) that contains a deep dive into Stable Diffusion
* DreamBooth [blog post](https://dreambooth.github.io/) to get a sense of what's possible with this technique
* Hugging Face [blog post](https://huggingface.co/blog/dreambooth) on best practices for fine-tuning Stable Diffusion with DreamBooth

🚨 **Note:** the code in **this notebook requires at least 14GB of GPU vRAM** and is a simplified version of the [official training script](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth) provided in 🤗 Diffusers. It produces decent models for most applications, but we recommend experimenting with the advanced features like class preservation loss & fine-tuning the text encoder if you have at least 24GB vRAM available. Check out the 🤗 Diffusers [docs](https://huggingface.co/docs/diffusers/training/dreambooth) for more details.

## What is DreamBooth?

DreamBooth is a technique to teach new concepts to Stable Diffusion using a specialized form of fine-tuning. If you're on Twitter or Reddit, you may have seen people using this technique to create (often hilarious) avatars of themselves. For example, here's what [Andrej Karpathy](https://karpathy.ai/) would look like as a cowboy (you may need to run the cell to see the output):

```python
%%html
Stableboost auto-suggests a few hundred prompts by default but you can generate additional variations for any one prompt that seems to be giving fun/interesting results, or adjust it in any way: pic.twitter.com/qWmadiXftP&mdash; Andrej Karpathy (@karpathy) December 7, 2022 
```

The way DreamBooth works is as follows:

* Collect around 10-20 input images of a subject (e.g., your dog) and define a unique identifier [V] that refers to the subject. This identifier is usually some made up word like `flffydog` which is implanted in different text prompts at inference time to place the subject in different contexts.
* Fine-tune the diffusion model by providing the images together with a text prompt like "A photo of a [V] dog" that contains the unique identifier and class name (i.e., "dog" in this example).
* (Optionally) Apply a special _class-specific prior preservation loss_, which leverages the semantic prior that the model has on the class and encourages it to generate diverse instances belong to the subject's class by injecting the class name in the text prompt. In practice, this step is only really needed for human faces and can be skipped for the themes we'll be exploring in this hackathon.

An overview of the DreamBooth technique is shown in the image below:

![](https://dreambooth.github.io/DreamBooth_files/high_level.png)

### What can DreamBooth do?

Besides putting your subject in interesting locations, DreamBooth can be used for _**text-guided view synthesis**_, where the subject is viewed from different viewpoints as shown in the example below:

![](https://dreambooth.github.io/DreamBooth_files/novel_views.png)

DreamBooth can also be used to modify properties of the subject, such as colour or mixing up animal species!

![](https://dreambooth.github.io/DreamBooth_files/property_modification.png)

Now that we've seen some of the cool things DreamBooth can do, let's start training our own models!

## Step 1: Setup

If you're running this notebook on Google Colab or Kaggle, run the cell below to install the required libraries:

```python
%pip install -qqU diffusers transformers bitsandbytes accelerate ftfy datasets
```

If you're running on Kaggle, you'll need to install the latest PyTorch version to work with 🤗 Accelerate:

```python
# Uncomment and run if using Kaggle's notebooks. You may need to restart the notebook afterwards
# %pip install -U torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116
```

To be able to push your model to the Hub and make it appear on the [DreamBooth Leaderboard](https://huggingface.co/spaces/dreambooth-hackathon/leaderboard), there are a few more steps to follow. First you have to create an [access token](https://huggingface.co/docs/hub/security-tokens) with _**write access**_ from your Hugging Face account and then execute the following cell and input your token:

```python
from huggingface_hub import notebook_login

notebook_login()
```

The final step is to install Git LFS:

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

## Step 2: Pick a theme

This competition is composed of 5 _themes_, where each theme will collect models belong to the following categories:

* **Animal 🐨:** Use this theme to generate images of your pet or favourite animal hanging out in the Acropolis, swimming, or flying in space.
* **Science 🔬:** Use this theme to generate cool synthetic images of galaxies, proteins, or any domain of the natural and medical sciences.
* **Food 🍔:** Use this theme to tune Stable Diffusion on your favourite dish or cuisine.
* **Landscape 🏔:** Use this theme to generate beautiful landscapes of your faourite mountain, lake, or garden.
* **Wildcard 🔥:** Use this theme to go wild and create Stable Diffusion models for any category of your choosing!

We'll be **giving out prizes to the top 3 most liked models per theme**, and you're encouraged to submit as many models as you want! Run the cell below to create a dropdown widget where you can select the theme you wish to submit to:

```python
import ipywidgets as widgets

theme = "animal"
drop_down = widgets.Dropdown(
    options=["animal", "science", "food", "landscape", "wildcard"],
    description="Pick a theme",
    disabled=False,
)

def dropdown_handler(change):
    global theme
    theme = change.new

drop_down.observe(dropdown_handler, names="value")
display(drop_down)
```

```python
>>> print(f"You've selected the {theme} theme!")
```

You've selected the animal theme!

## Step 3: Create an image dataset and upload it to the Hub

Once you've picked a theme, the next step is to **create a dataset of images for that theme** and upload it to the Hugging Face Hub:

* You'll need around **10-20 images of the subject** that you wish to implant in the model. These can be photos you've taken or downloaded from platforms like [Unsplash](https://unsplash.com/). Alternatively, you can take a look at any of the [image datasets](https://huggingface.co/datasets?task_categories=task_categories:image-classification&sort=downloads) on the Hugging Face Hub for inspiration.
* For best results, we recommend using images of your subject from **different angles and perspectives**.

Once you've collected your images in a folder, you can upload them to the Hub by using the UI to drag and drop your images. See [this guide](https://huggingface.co/docs/datasets/upload_dataset#upload-with-the-hub-ui) for more details, or watch the video below:

```python
>>> from IPython.display import YouTubeVideo

>>> YouTubeVideo("HaN6qCr_Afc")
```

Alternatively, you can load your dataset locally using the `imagefolder` feature of 🤗 Datasets and then push it to the Hub:

```python
from datasets import load_dataset

dataset = load_dataset("imagefolder", data_dir="your_folder_of_images")
# Push to Hub
dataset.push_to_hub("dreambooth-hackathon-images")
dataset = dataset['train']
```

Once you've created your dataset, you can download it by using the `load_dataset()` function as follows:

```python
from datasets import load_dataset

dataset_id = "lewtun/corgi"  # CHANGE THIS TO YOUR {hub_username}/{dataset_id}
dataset = load_dataset(dataset_id, split="train")
dataset
```

Now that we have our dataset, let's define a helper function to view a few of the images:

```python
>>> from PIL import Image

>>> def image_grid(imgs, rows, cols):
...     assert len(imgs) == rows * cols
...     w, h = imgs[0].size
...     grid = Image.new("RGB", size=(cols * w, rows * h))
...     grid_w, grid_h = grid.size
...     for i, img in enumerate(imgs):
...         grid.paste(img, box=(i % cols * w, i // cols * h))
...     return grid

>>> num_samples = 4
>>> image_grid(dataset["image"][:num_samples], rows=1, cols=num_samples)
```

If this looks good, you can move onto the next step - creating a PyTorch dataset for training with DreamBooth.

## Step 3: Create a training dataset

To create a training set for our images we need a few components:

* An _instance prompt_ that is used to prime the model at the start of training. In most cases, using "a photo of [identifier] [class noun]" works quite well, e.g., "a photo of ccorgi dog" for our cute Corgi pictures. 
    * **Note:** it is recommended that you pick a unique / made up word like `ccorgi` to describe your subject. This will ensure a common word in the model's vocabulary isn't overwritten.
* A _tokenizer_ to convert the instance prompt into input IDs that can be fed to the text encoder of Stable Diffusion.
* A set of _image transforms_, notably resizing the images to a common shape and normalizing the pixel values to a common mean and standard distribution.

With this in mind, let's start by defining the instance prompt:

```python
>>> name_of_your_concept = "ccorgi"  # CHANGE THIS ACCORDING TO YOUR SUBJECT
>>> type_of_thing = "dog"  # CHANGE THIS ACCORDING TO YOUR SUBJECT
>>> instance_prompt = f"a photo of {name_of_your_concept} {type_of_thing}"
>>> print(f"Instance prompt: {instance_prompt}")
```

Instance prompt: a photo of ccorgi dog

Next, we need to create a PyTorch `Dataset` object that implements the `__len__` and `__getitem__` dunder methods:

```python
from torch.utils.data import Dataset
from torchvision import transforms

class DreamBoothDataset(Dataset):
    def __init__(self, dataset, instance_prompt, tokenizer, size=512):
        self.dataset = dataset
        self.instance_prompt = instance_prompt
        self.tokenizer = tokenizer
        self.size = size
        self.transforms = transforms.Compose(
            [
                transforms.Resize(size),
                transforms.CenterCrop(size),
                transforms.ToTensor(),
                transforms.Normalize([0.5], [0.5]),
            ]
        )

    def __len__(self):
        return len(self.dataset)

    def __getitem__(self, index):
        example = {}
        image = self.dataset[index]["image"]
        example["instance_images"] = self.transforms(image)
        example["instance_prompt_ids"] = self.tokenizer(
            self.instance_prompt,
            padding="do_not_pad",
            truncation=True,
            max_length=self.tokenizer.model_max_length,
        ).input_ids
        return example
```

Great, let's now check this works by loading the CLIP tokenizer associated with the text encoder of the original Stable Diffusion model, and then creating the training dataset:

```python
from transformers import CLIPTokenizer

# The Stable Diffusion checkpoint we'll fine-tune
model_id = "CompVis/stable-diffusion-v1-4"
tokenizer = CLIPTokenizer.from_pretrained(
    model_id,
    subfolder="tokenizer",
)

train_dataset = DreamBoothDataset(dataset, instance_prompt, tokenizer)
train_dataset[0]
```

## Step 4: Define a data collator

Now that we have a training dataset, the next thing we need is to define a _data collator_. A data collator is a function that collects elements in a batch of data and applies some logic to form a single tensor we can provide to the model. If you'd to learn more, you can check out this video from the [Hugging Face Course](hf.co/course):

```python
>>> YouTubeVideo("-RPeakdlHYo")
```

For DreamBooth, our data collator need to provide the model with the input IDs from the tokenizer and the pixel values from the images as a stacked tensor. The function below does the trick:

```python
import torch

def collate_fn(examples):
    input_ids = [example["instance_prompt_ids"] for example in examples]
    pixel_values = [example["instance_images"] for example in examples]
    pixel_values = torch.stack(pixel_values)
    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()

    input_ids = tokenizer.pad(
        {"input_ids": input_ids}, padding=True, return_tensors="pt"
    ).input_ids

    batch = {
        "input_ids": input_ids,
        "pixel_values": pixel_values,
    }
    return batch
```

## Step 5: Load the components of the Stable Diffusion pipeline

We nearly have all the pieces ready for training! As you saw in the Unit 3 notebook on Stable Diffusion, the pipeline is composed of several models:

* A text encoder that converts the prompts into text embeddings. Here we're using CLIP since it's the encoder used to train Stable Diffusion v1-4.
* A VAE or variational autoencoder that converts the images to compressed representations (i.e., latents) and decompresses them at inference time.
* A UNet that applies the denoising operation on the latent of the VAE.

We can load all these components using the 🤗 Diffusers and 🤗 Transformers libraries as follows:

```python
from diffusers import AutoencoderKL, UNet2DConditionModel
from transformers import CLIPFeatureExtractor, CLIPTextModel

text_encoder = CLIPTextModel.from_pretrained(model_id, subfolder="text_encoder")
vae = AutoencoderKL.from_pretrained(model_id, subfolder="vae")
unet = UNet2DConditionModel.from_pretrained(model_id, subfolder="unet")
feature_extractor = CLIPFeatureExtractor.from_pretrained("openai/clip-vit-base-patch32")
```

## Step 6: Fine-tune the model

Now comes the fun part - training our model with DreamBooth! As shown in the [Hugging Face's blog post](https://huggingface.co/blog/dreambooth), the most essential hyperparameters to tweak are the learning rate and number of training steps.

In general, you'll get better results with a lower learning rate at the expense of needing to increase the number of training steps. The values below are a good starting point, but you may need to adjust them according to your dataset: 

```python
learning_rate = 2e-06
max_train_steps = 400
```

Next, let's wrap the other hyperparameters we need in a `Namespace` object to make it easier to configure the training run:

```python
from argparse import Namespace

args = Namespace(
    pretrained_model_name_or_path=model_id,
    resolution=512, # Reduce this if you want to save some memory
    train_dataset=train_dataset,
    instance_prompt=instance_prompt,
    learning_rate=learning_rate,
    max_train_steps=max_train_steps,
    train_batch_size=1,
    gradient_accumulation_steps=1, # Increase this if you want to lower memory usage
    max_grad_norm=1.0,
    gradient_checkpointing=True,  # Set this to True to lower the memory usage
    use_8bit_adam=True,  # Use 8bit optimizer from bitsandbytes
    seed=3434554,
    sample_batch_size=2,
    output_dir="my-dreambooth",  # Where to save the pipeline
)
```

The final step is to define a `training_function()` function that wraps the training logic and can be passed to 🤗 Accelerate to handle training on 1 or more GPUs. If this is the first time you're using 🤗 Accelerate, check out this video to get a quick overview of what it can do:

```python
>>> YouTubeVideo("s7dy8QRgjJ0")
```

The details should look familiar to what we saw in Units 1 & 2 when we trained our own diffusion models from scratch:

```python
import math

import torch.nn.functional as F
from accelerate import Accelerator
from accelerate.utils import set_seed
from diffusers import DDPMScheduler, PNDMScheduler, StableDiffusionPipeline
from diffusers.pipelines.stable_diffusion import StableDiffusionSafetyChecker
from torch.utils.data import DataLoader
from tqdm.auto import tqdm

def training_function(text_encoder, vae, unet):

    accelerator = Accelerator(
        gradient_accumulation_steps=args.gradient_accumulation_steps,
    )

    set_seed(args.seed)

    if args.gradient_checkpointing:
        unet.enable_gradient_checkpointing()

    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs
    if args.use_8bit_adam:
        import bitsandbytes as bnb
        optimizer_class = bnb.optim.AdamW8bit
    else:
        optimizer_class = torch.optim.AdamW

    optimizer = optimizer_class(
        unet.parameters(),  # Only optimize unet
        lr=args.learning_rate,
    )

    noise_scheduler = DDPMScheduler(
        beta_start=0.00085,
        beta_end=0.012,
        beta_schedule="scaled_linear",
        num_train_timesteps=1000,
    )

    train_dataloader = DataLoader(
        args.train_dataset,
        batch_size=args.train_batch_size,
        shuffle=True,
        collate_fn=collate_fn,
    )

    unet, optimizer, train_dataloader = accelerator.prepare(
        unet, optimizer, train_dataloader
    )

    # Move text_encode and vae to gpu
    text_encoder.to(accelerator.device)
    vae.to(accelerator.device)

    # We need to recalculate our total training steps as the size of the training dataloader may have changed
    num_update_steps_per_epoch = math.ceil(
        len(train_dataloader) / args.gradient_accumulation_steps
    )
    num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)

    # Train!
    total_batch_size = (
        args.train_batch_size
        * accelerator.num_processes
        * args.gradient_accumulation_steps
    )
    # Only show the progress bar once on each machine
    progress_bar = tqdm(
        range(args.max_train_steps), disable=not accelerator.is_local_main_process
    )
    progress_bar.set_description("Steps")
    global_step = 0

    for epoch in range(num_train_epochs):
        unet.train()
        for step, batch in enumerate(train_dataloader):
            with accelerator.accumulate(unet):
                # Convert images to latent space
                with torch.no_grad():
                    latents = vae.encode(batch["pixel_values"]).latent_dist.sample()
                    latents = latents * 0.18215

                # Sample noise that we'll add to the latents
                noise = torch.randn(latents.shape).to(latents.device)
                bsz = latents.shape[0]
                # Sample a random timestep for each image
                timesteps = torch.randint(
                    0,
                    noise_scheduler.config.num_train_timesteps,
                    (bsz,),
                    device=latents.device,
                ).long()

                # Add noise to the latents according to the noise magnitude at each timestep
                # (this is the forward diffusion process)
                noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)

                # Get the text embedding for conditioning
                with torch.no_grad():
                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]

                # Predict the noise residual
                noise_pred = unet(
                    noisy_latents, timesteps, encoder_hidden_states
                ).sample
                loss = (
                    F.mse_loss(noise_pred, noise, reduction="none")
                    .mean([1, 2, 3])
                    .mean()
                )

                accelerator.backward(loss)
                if accelerator.sync_gradients:
                    accelerator.clip_grad_norm_(unet.parameters(), args.max_grad_norm)
                optimizer.step()
                optimizer.zero_grad()

            # Checks if the accelerator has performed an optimization step behind the scenes
            if accelerator.sync_gradients:
                progress_bar.update(1)
                global_step += 1

            logs = {"loss": loss.detach().item()}
            progress_bar.set_postfix(**logs)

            if global_step >= args.max_train_steps:
                break

        accelerator.wait_for_everyone()

    # Create the pipeline using the trained modules and save it
    if accelerator.is_main_process:
        print(f"Loading pipeline and saving to {args.output_dir}...")
        scheduler = PNDMScheduler(
            beta_start=0.00085,
            beta_end=0.012,
            beta_schedule="scaled_linear",
            skip_prk_steps=True,
            steps_offset=1,
        )
        pipeline = StableDiffusionPipeline(
            text_encoder=text_encoder,
            vae=vae,
            unet=accelerator.unwrap_model(unet),
            tokenizer=tokenizer,
            scheduler=scheduler,
            safety_checker=StableDiffusionSafetyChecker.from_pretrained(
                "CompVis/stable-diffusion-safety-checker"
            ),
            feature_extractor=feature_extractor,
        )
        pipeline.save_pretrained(args.output_dir)
```

Now that we have the function defined, let's train it! Depending on the size of your dataset and type of GPU, this can take anywhere from 5 minutes to 1 hour to run:

```python
>>> from accelerate import notebook_launcher

>>> num_of_gpus = 1  # CHANGE THIS TO MATCH THE NUMBER OF GPUS YOU HAVE
>>> notebook_launcher(
...     training_function, args=(text_encoder, vae, unet), num_processes=num_of_gpus
... )
```

Launching training on one GPU.

If you're running on a single GPU, you can free up some memory for the next section by copying the code below into a new cell and running it. For multi-GPU machines, 🤗 Accelerate doesn't allow _any_ cell to directly access the GPU with `torch.cuda`, so we don't recommend using this trick in those cases:

```python
with torch.no_grad():
    torch.cuda.empty_cache()
```

## Step 7: Run inference and inspect generations

Now that we've trained the model, let's generate some images with it to see how it fares! First we'll load the pipeline from the output directory we save the model to:

```python
pipe = StableDiffusionPipeline.from_pretrained(
    args.output_dir,
    torch_dtype=torch.float16,
).to("cuda")
```

Next, let's generate a few images. The `prompt` variable will later be used to set the default on the Hugging Face Hub widget, so experiment a bit to find a good one. You might also want to try creating elaborate prompts with [CLIP Interrogator](https://huggingface.co/spaces/pharma/CLIP-Interrogator):

```python
>>> # Pick a funny prompt here and it will be used as the widget's default 
>>> # when we push to the Hub in the next section
>>> prompt = f"a photo of {name_of_your_concept} {type_of_thing} in the Acropolis"

>>> # Tune the guidance to control how closely the generations follow the prompt
>>> # Values between 7-11 usually work best
>>> guidance_scale = 7

>>> num_cols = 2
>>> all_images = []
>>> for _ in range(num_cols):
...     images = pipe(prompt, guidance_scale=guidance_scale).images
...     all_images.extend(images)

>>> image_grid(all_images, 1, num_cols)
```

## Step 8: Push your model to the Hub

If you're happy with you model, the final step is to push it to the Hub and view it on the [DreamBooth Leaderboard](https://huggingface.co/spaces/dreambooth-hackathon/leaderboard)!

First, you'll need to define a name for your model repo. By default, we use the unique identifier and class name, but feel free to change this if you want: 

```python
# Create a name for your model on the Hub. No spaces allowed.
model_name = f"{name_of_your_concept}-{type_of_thing}"
```

Next, add a brief description on the type of model you've trained or any other information you'd like to share:

```python
# Describe the theme and model you've trained
description = f"""
This is a Stable Diffusion model fine-tuned on `{type_of_thing}` images for the {theme} theme.
"""
```

Finally, run the cell below to create a repo on the Hub and push all our files with a nice model card to boot:

```python
>>> # 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
>>> hub_model_id = get_full_repo_name(model_name)
>>> create_repo(hub_model_id)
>>> api = HfApi()
>>> api.upload_folder(folder_path=args.output_dir, path_in_repo="", repo_id=hub_model_id)

>>> content = f"""
... ---
... license: creativeml-openrail-m
... tags:
... - pytorch
... - diffusers
... - stable-diffusion
... - text-to-image
... - diffusion-models-class
... - dreambooth-hackathon
... - {theme}
... widget:
... - text: {prompt}
... ---

... # DreamBooth model for the {name_of_your_concept} concept trained by {api.whoami()["name"]} on the {dataset_id} dataset.

... This is a Stable Diffusion model fine-tuned on the {name_of_your_concept} concept with DreamBooth. It can be used by modifying the `instance_prompt`: **{instance_prompt}**

... This model was created as part of the DreamBooth Hackathon 🔥. Visit the [organisation page](https://huggingface.co/dreambooth-hackathon) for instructions on how to take part!

... ## Description

... {description}

... ## Usage

... ```python
... from diffusers import StableDiffusionPipeline

... pipeline = StableDiffusionPipeline.from_pretrained('{hub_model_id}')
... image = pipeline().images[0]
... image
... ```
... """

>>> card = ModelCard(content)
>>> hub_url = card.push_to_hub(hub_model_id)
>>> print(f"Upload successful! Model can be found here: {hub_url}")
>>> print(
...     f"View your submission on the public leaderboard here: https://huggingface.co/spaces/dreambooth-hackathon/leaderboard"
... )
```

Upload successful! Model can be found here: https://huggingface.co/lewtun/test-dogs/blob/main/README.md
View your submission on the public leaderboard here: https://huggingface.co/spaces/dreambooth-hackathon/leaderboard

## Step 9: Celebrate 🥳

Congratulations, you've trained your very first DreamBooth model! You can train as many models as you want for the competition - the important thing is that **the most liked models will win prizes** so don't forget to share your creation far and wide to get the most votes!

### DreamBooth Hackathon 🏆
https://huggingface.co/learn/diffusion-course/hackathon/introduction.md

# DreamBooth Hackathon 🏆

📣 **The hackathon is now over and the winners have been announced on Discord. You are still welcome to train models and submit them to the leaderboard, but we won't be offering prizes or certificates at this point in time.**

Welcome to the DreamBooth Hackathon! This is a community event where you'll **personalise a Stable Diffusion model by fine-tuning it on a handful of your own images.** To do so, you'll use a powerful technique called [_DreamBooth_](https://arxiv.org/abs/2208.12242), which allows one to implant a subject (e.g. your pet or favourite dish) into the output domain of the model such that it can be synthesized with a _unique identifier_ in the prompt.

This competition is composed of 5 _themes_, where each theme will collect models belong to the following categories:

* **Animal 🐨:** Use this theme to generate images of your pet or favourite animal hanging out in the Acropolis, swimming, or flying in space.
* **Science 🔬:** Use this theme to generate cool synthetic images of galaxies, proteins, or any domain of the natural and medical sciences.
* **Food 🍔:** Use this theme to tune Stable Diffusion on your favourite dish or cuisine.
* **Landscape 🏔:** Use this theme to generate beautiful landscapes of your favourite mountain, lake, or garden.
* **Wildcard 🔥:** Use this theme to go wild and create Stable Diffusion models for any category of your choosing!

We'll be **giving out prizes to the top 3 most liked models per theme**, and you're encouraged to submit as many models as you want! 

## Getting started

Follow the steps below to take part in this event:

1. Join the [Hugging Face Discord server](https://huggingface.co/join/discord) and check out the `#dreambooth-hackathon` channel to stay up to date with the event.
2. Launch and run the [DreamBooth notebook](https://github.com/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb) to train your models by clicking on one of the links below. Make sure you select the GPU runtime in each platform to ensure your models train fast!

| Notebook                                     | Colab                                                                                                                                                                                               | Kaggle                                                                                                                                                                                                   | Gradient                                                                                                                                                                               | Studio Lab                                                                                                                                                                                                   |
|:--------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| DreamBooth Training                              | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb)              |

**Note 👋:** The DreamBooth notebook uses the [`CompVis/stable-diffusion-v1-4`](https://huggingface.co/CompVis/stable-diffusion-v1-4) checkpoint as the Stable Diffusion model to fine-tune. However, you are totally free to use any Stable Diffusion checkpoint that you want - you'll just have to adjust the code to load the appropriate components and the safety checker (if it exists). Some interesting models to fine-tune include:

* [`runwayml/stable-diffusion-v1-5`](https://huggingface.co/runwayml/stable-diffusion-v1-5)
* [`prompthero/openjourney`](https://huggingface.co/prompthero/openjourney)
* [`stabilityai/stable-diffusion-2`](https://huggingface.co/stabilityai/stable-diffusion-2)
* [`hakurei/waifu-diffusion`](https://huggingface.co/hakurei/waifu-diffusion)
* [`stabilityai/stable-diffusion-2-1`](https://huggingface.co/stabilityai/stable-diffusion-2-1)
* [`nitrosocke/elden-ring-diffusion`](https://huggingface.co/nitrosocke/elden-ring-diffusion)

## Evaluation & Leaderboard

To be in the running for the prizes, push one or more DreamBooth models to the Hub with the `dreambooth-hackathon` tag in the model card ([example](https://huggingface.co/lewtun/ccorgi-dog/blob/main/README.md#L9)). This is created automatically by the [DreamBooth notebook](https://github.com/huggingface/diffusion-models-class/blob/main/hackathon/dreambooth.ipynb), but you'll need to add it if you're running your own scripts.

Models are evaluated according to the number of likes they have and you can track your model's ranking on the hackathon's leaderboard:

* [DreamBooth Leaderboard](https://huggingface.co/spaces/dreambooth-hackathon/leaderboard)

## Timeline

* **December 21, 2022** - Start date
* **December 31, 2022** - Colab Pro registration deadline
* **January 22, 2023** - Final submissions deadline (closing of the leaderboard)
* **January 23-27, 2023** - Announce winners of each theme

All deadlines are at 11:59 PM UTC on the corresponding day unless otherwise noted.

## Prizes

We will be awarding 3 prizes per theme, where **winners are determined by the models with the most likes** on the leaderboard:

**1st place winner**

* [Hugging Face Pro subscription](https://huggingface.co/pricing) for 1 year or a $100 voucher for the [Hugging Face merch store](https://store.huggingface.co/)

**2nd place winner**

* A copy of the [_NLP with Transformers_](https://transformersbook.com/) book or a $50 voucher for the [Hugging Face merch store](https://store.huggingface.co/)

**3rd place winner**

* [Hugging Face Pro subscription](https://huggingface.co/pricing) for 1 month or a $15 voucher for the [Hugging Face merch store](https://store.huggingface.co/)

We will also provide a **certificate of completion** to all the participants that submit at least 1 DreamBooth model to the hackathon 🔥.

## Compute

Google Colab will be sponsoring this event by providing fee Colab Pro credits to 100 participants (selected randomly). We'll be giving out the credits in January 2023, and you have until December 31 to register. To register for these credits, please fill out [this form](https://docs.google.com/forms/d/e/1FAIpQLSeE_js5bxq_a_nFTglbZbQqjd6KNDD9r4YRg42kDFGSb5aoYQ/viewform).

![](https://lh3.googleusercontent.com/-l6dUgmPOKMM/X7w3nNn3OpI/AAAAAAAALAg/74fTRiPqikMURTD_Dn4PzAVADey2_6lLwCNcBGAsYHQ/s400/colab-logo-128x128.png)

## FAQ

### What data is allowed for fine-tuning?

You can use any images that belong to you or for which a permissive license allows for. If you'd like to submit a model trained on faces (e.g. as a Wildcard submission), we recommend using your own likeness. Ideally, use your own data where you can - we'd love to see your pets or favorite local landscape features, and we suspect the likes and prizes will tend to go to those who do something nice and personal 😁.

### Are other fine-tuning techniques like Textual Inversion allowed?

Absolutely! Although this hackathon is focused on DreamBooth, you're welcome (and encouraged) to experiment with other fine-tuning techniques. This also means you can use whatever frameworks, code, or services that help you make delightful models for the community to enjoy 🥰.

### Diffusion Models from Scratch
https://huggingface.co/learn/diffusion-course/unit1/3.md

# Diffusion Models from Scratch

Sometimes it is helpful to consider the simplest possible version of something to better understand how it works. We're going to try that in this notebook, beginning with a 'toy' diffusion model to see how the different pieces work, and then examining how they differ from a more complex implementation. 

We will look at 
- The corruption process (adding noise to data)
- What a UNet is, and how to implement an extremely minimal one from scratch
- Diffusion model training
- Sampling theory

Then we'll compare our versions with the diffusers DDPM implementation, exploring
- Improvements over our mini UNet
- The DDPM noise schedule
- Differences in training objective
- Timestep conditioning
- Sampling approaches

This notebook is fairly in-depth, and can safely be skipped if you're not excited about a from-scratch deep dive! 

It is also worth noting that most of the code here is for illustrative purposes, and I wouldn't recommend directly adopting any of it for your own work (unless you're just trying improve on the examples shown here for learning purposes). 

## Setup and Imports:

```python
>>> %pip install -q diffusers
```

[K     |████████████████████████████████| 255 kB 16.0 MB/s 
[K     |████████████████████████████████| 163 kB 53.9 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

>>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
>>> print(f'Using device: {device}')
```

Using device: cuda

## The Data

Here we're going to test things with a very small dataset: mnist. If you'd like to give the model a slightly harder challenge without changing anything else, torchvision.datasets.FashionMNIST should work as a drop-in replacement. 

```python
>>> dataset = torchvision.datasets.MNIST(root="mnist/", train=True, download=True, transform=torchvision.transforms.ToTensor())
```

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

```python
train_dataloader = DataLoader(dataset, batch_size=8, shuffle=True)
```

```python
>>> x, y = next(iter(train_dataloader))
>>> print('Input shape:', x.shape)
>>> print('Labels:', y)
>>> plt.imshow(torchvision.utils.make_grid(x)[0], cmap='Greys');
```

Input shape: torch.Size([8, 1, 28, 28])
Labels: tensor([1, 9, 7, 3, 5, 2, 1, 4])

Each image is a greyscale 28px by 28px drawing of a digit, with values ranging from 0 to 1.

## The Corruption Process

Pretend you haven't read any diffusion model papers, but you know the process involves adding noise. How would you do it?

We probably want an easy way to control the amount of corruption. So what if we take in a parameter for the `amount` of noise to add, and then we do:

`noise = torch.rand_like(x)` 

`noisy_x =  (1-amount)*x + amount*noise`

If amount = 0, we get back the input without any changes. If amount gets up to 1, we get back noise with no trace of the input x. By mixing the input with noise this way, we keep the output in the same range (0 to 1).

We can implement this fairly easily (just watch the shapes so you don't get burnt by broadcasting rules): 

```python
def corrupt(x, amount):
  """Corrupt the input `x` by mixing it with noise according to `amount`"""
  noise = torch.rand_like(x)
  amount = amount.view(-1, 1, 1, 1) # Sort shape so broadcasting works
  return x*(1-amount) + noise*amount
```

And looking at the results visually to see that it works as expected:

```python
>>> # Plotting the input data
>>> fig, axs = plt.subplots(2, 1, figsize=(12, 5))
>>> axs[0].set_title('Input data')
>>> axs[0].imshow(torchvision.utils.make_grid(x)[0], cmap='Greys')

>>> # Adding noise
>>> amount = torch.linspace(0, 1, x.shape[0]) # Left to right -> more corruption
>>> noised_x = corrupt(x, amount)

>>> # Plotting the noised version
>>> axs[1].set_title('Corrupted data (-- amount increases -->)')
>>> axs[1].imshow(torchvision.utils.make_grid(noised_x)[0], cmap='Greys');
```

As noise amount approaches one, our data begins to look like pure random noise. But for most noise amounts, you can guess the digit fairly well. Do you think this is optimal?

## The Model

We'd like a model that takes in a 28px noisy images and outputs a prediction of the same shape. A popular choice here is an architecture called a UNet. [Originally invented for segmentation tasks in medical imagery](https://arxiv.org/abs/1505.04597), a UNet consists of a 'constricting path' through which data is compressed down and an 'expanding path' through which it expands back up to the original dimension (similar to an autoencoder) but also features skip connections that allow for information and gradients to flow across at different levels. 

Some UNets feature complex blocks at each stage, but for this toy demo we'll build a minimal example that takes in a one-channel image and passes it through three convolutional layers on the down path (the down_layers in the diagram and code) and three on the up path, with skip connections between the down and up layers. We'll use max pooling for downsampling and `nn.Upsample` for upsampling rather than relying on learnable layers like more complex UNets. Here is the rough architecture showing the number of channels in the output of each layer:

![unet_diag.png](data:image/png;base64,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)

This is what that looks like in code:

```python
class BasicUNet(nn.Module):
    """A minimal UNet implementation."""
    def __init__(self, in_channels=1, out_channels=1):
        super().__init__()
        self.down_layers = torch.nn.ModuleList([ 
            nn.Conv2d(in_channels, 32, kernel_size=5, padding=2),
            nn.Conv2d(32, 64, kernel_size=5, padding=2),
            nn.Conv2d(64, 64, kernel_size=5, padding=2),
        ])
        self.up_layers = torch.nn.ModuleList([
            nn.Conv2d(64, 64, kernel_size=5, padding=2),
            nn.Conv2d(64, 32, kernel_size=5, padding=2),
            nn.Conv2d(32, out_channels, kernel_size=5, padding=2), 
        ])
        self.act = nn.SiLU() # The activation function
        self.downscale = nn.MaxPool2d(2)
        self.upscale = nn.Upsample(scale_factor=2)

    def forward(self, x):
        h = []
        for i, l in enumerate(self.down_layers):
            x = self.act(l(x)) # Through the layer and the activation function
            if i  0: # For all except the first up layer
              x = self.upscale(x) # Upscale
              x += h.pop() # Fetching stored output (skip connection)
            x = self.act(l(x)) # Through the layer and the activation function
            
        return x
```

We can verify that the output shape is the same as the input, as we expect:

```python
net = BasicUNet()
x = torch.rand(8, 1, 28, 28)
net(x).shape
```

This network has just over 300,000 parameters:

```python
sum([p.numel() for p in net.parameters()])
```

You can explore changing the number of channels in each layer or swapping in different architectures if you want.

## Training the network

So what should the model do, exactly? Again, there are various takes on this but for this demo let's pick a simple framing: given a corrupted input noisy_x the model should output its best guess for what the original x looks like. We will compare this to the actual value via the mean squared error.

We can now have a go at training the network. 
- Get a batch of data
- Corrupt it by random amounts
- Feed it through the model
- Compare the model predictions with the clean images to calculate our loss
- Update the model's parameters accordingly.

Feel free to modify this and see if you can get it working better!

```python
>>> # Dataloader (you can mess with batch size)
>>> batch_size = 128
>>> train_dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

>>> # How many runs through the data should we do?
>>> n_epochs = 3

>>> # Create the network
>>> net = BasicUNet()
>>> net.to(device)

>>> # Our loss function
>>> loss_fn = nn.MSELoss()

>>> # The optimizer
>>> opt = torch.optim.Adam(net.parameters(), lr=1e-3) 

>>> # Keeping a record of the losses for later viewing
>>> losses = []

>>> # The training loop
>>> for epoch in range(n_epochs):

...     for x, y in train_dataloader:

...         # Get some data and prepare the corrupted version
...         x = x.to(device) # Data on the GPU
...         noise_amount = torch.rand(x.shape[0]).to(device) # Pick random noise amounts
...         noisy_x = corrupt(x, noise_amount) # Create our noisy x

...         # Get the model prediction
...         pred = net(noisy_x)

...         # Calculate the loss
...         loss = loss_fn(pred, x) # How close is the output to the true 'clean' x?

...         # Backprop and update the params:
...         opt.zero_grad()
...         loss.backward()
...         opt.step()

...         # Store the loss for later
...         losses.append(loss.item())

...     # Print our the average of the loss values for this epoch:
...     avg_loss = sum(losses[-len(train_dataloader):])/len(train_dataloader)
...     print(f'Finished epoch {epoch}. Average loss for this epoch: {avg_loss:05f}')

>>> # View the loss curve
>>> plt.plot(losses)
>>> plt.ylim(0, 0.1);
```

Finished epoch 0. Average loss for this epoch: 0.026736
Finished epoch 1. Average loss for this epoch: 0.020692
Finished epoch 2. Average loss for this epoch: 0.018887

We can try to see what the model predictions look like by grabbing a batch of data, corrupting it by different amounts and then seeing the models predictions:

```python
>>> #@markdown Visualizing model predictions on noisy inputs:

>>> # Fetch some data
>>> x, y = next(iter(train_dataloader))
>>> x = x[:8] # Only using the first 8 for easy plotting

>>> # Corrupt with a range of amounts
>>> amount = torch.linspace(0, 1, x.shape[0]) # Left to right -> more corruption
>>> noised_x = corrupt(x, amount)

>>> # Get the model predictions
>>> with torch.no_grad():
...   preds = net(noised_x.to(device)).detach().cpu()

>>> # Plot
>>> fig, axs = plt.subplots(3, 1, figsize=(12, 7))
>>> axs[0].set_title('Input data')
>>> axs[0].imshow(torchvision.utils.make_grid(x)[0].clip(0, 1), cmap='Greys')
>>> axs[1].set_title('Corrupted data')
>>> axs[1].imshow(torchvision.utils.make_grid(noised_x)[0].clip(0, 1), cmap='Greys')
>>> axs[2].set_title('Network Predictions')
>>> axs[2].imshow(torchvision.utils.make_grid(preds)[0].clip(0, 1), cmap='Greys');
```

You can see that for the lower amounts the predictions are pretty good! But as the level gets very high there is less for the model to work with, and by the time we get to amount=1 it outputs a blurry mess close to the mean of the dataset to try and hedge its bets on what the output might look like...

## Sampling

If our predictions at high noise levels aren't very good, how do we generate images?

Well, what if we start from random noise, look at the model predictions but then only move a small amount towards that prediction - say, 20% of the way there. Now we have a very noisy image in which there is perhaps a hint of structure, which we can feed into the model to get a new prediction. The hope is that this new prediction is slightly better than the first one (since our starting point is slightly less noisy) and so we can take another small step with this new, better prediction.

Repeat a few times and (if all goes well) we get an image out! Here is that process illustrated over just 5 steps, visualizing the model input (left) and the predicted denoised images (right) at each stage. Note that even though the model predicts the denoised image even at step 1, we only move x part of the way there. Over a few steps the structures appear and are refined, until we get our final outputs.

```python
>>> #@markdown Sampling strategy: Break the process into 5 steps and move 1/5'th of the way there each time:
>>> n_steps = 5
>>> x = torch.rand(8, 1, 28, 28).to(device) # Start from random
>>> step_history = [x.detach().cpu()]
>>> pred_output_history = []

>>> for i in range(n_steps):
...     with torch.no_grad(): # No need to track gradients during inference
...         pred = net(x) # Predict the denoised x0
...     pred_output_history.append(pred.detach().cpu()) # Store model output for plotting
...     mix_factor = 1/(n_steps - i) # How much we move towards the prediction
...     x = x*(1-mix_factor) + pred*mix_factor # Move part of the way there
...     step_history.append(x.detach().cpu()) # Store step for plotting

>>> fig, axs = plt.subplots(n_steps, 2, figsize=(9, 4), sharex=True)
>>> axs[0,0].set_title('x (model input)')
>>> axs[0,1].set_title('model prediction')
>>> for i in range(n_steps):
...     axs[i, 0].imshow(torchvision.utils.make_grid(step_history[i])[0].clip(0, 1), cmap='Greys')
...     axs[i, 1].imshow(torchvision.utils.make_grid(pred_output_history[i])[0].clip(0, 1), cmap='Greys')
```

We can split the process up into more steps, and hope for better images that way:

```python
>>> #@markdown Showing more results, using 40 sampling steps
>>> n_steps = 40
>>> x = torch.rand(64, 1, 28, 28).to(device)
>>> for i in range(n_steps):
...   noise_amount = torch.ones((x.shape[0], )).to(device) * (1-(i/n_steps)) # Starting high going low
...   with torch.no_grad():
...     pred = net(x)
...   mix_factor = 1/(n_steps - i)
...   x = x*(1-mix_factor) + pred*mix_factor
>>> fig, ax = plt.subplots(1, 1, figsize=(12, 12))
>>> ax.imshow(torchvision.utils.make_grid(x.detach().cpu(), nrow=8)[0].clip(0, 1), cmap='Greys')
```

Not great, but there are some recognizable digits there! You can experiment with training for longer (say, 10 or 20 epochs) and tweaking model config, learning rate, optimizer and so on. Also, don't forget that fashionMNIST is a one-line replacement if you want a slightly harder dataset to try.

## Comparison To DDPM

In this section we'll take a look at how our toy implementation differs from the approach used in the other notebook ([Introduction to Diffusers](https://github.com/huggingface/diffusion-models-class/blob/main/unit1/01_introduction_to_diffusers.ipynb)), which is based on the DDPM paper.

We'll see that

*   The diffusers `UNet2DModel` is a bit more advanced than our BasicUNet
*   The corruption process in handled differently
*   The training objective is different, involving predicting the noise rather than the denoised image
*   The model is conditioned on the amount of noise present via timestep conditioning, where t is passed as an additional argument to the forward method.
*   There are a number of different sampling strategies available, which should work better than our simplistic version above.

There have been a number of improvements suggested since the DDPM paper came out, but this example is hopefully instructive as to the different available design decisions. Once you've read through this, you may enjoy diving into the paper ['Elucidating the Design Space of Diffusion-Based Generative Models'](https://arxiv.org/abs/2206.00364) which explores all of these components in some detail and makes new recommendations for how to get the best performance. 

If all of this is too technical or intimidating, don't worry! Feel free to skip the rest of this notebook or save it for a rainy day. 

### The UNet

The diffusers UNet2DModel model has a number of improvements over our basic UNet above:

*   GroupNorm applies group normalization to the inputs of each block
*   Dropout layers for smoother training
*   Multiple resnet layers per block (if layers_per_block isn't set to 1)
*   Attention (usually used only at lower resolution blocks)
*   Conditioning on the timestep. 
*   Downsampling and upsampling blocks with learnable parameters

Let's create and inspect a UNet2DModel:

```python
>>> model = UNet2DModel(
...     sample_size=28,           # the target image resolution
...     in_channels=1,            # the number of input channels, 3 for RGB images
...     out_channels=1,           # the number of output channels
...     layers_per_block=2,       # how many ResNet layers to use per UNet block
...     block_out_channels=(32, 64, 64), # Roughly matching our basic unet example
...     down_block_types=( 
...         "DownBlock2D",        # a regular ResNet downsampling block
...         "AttnDownBlock2D",    # a ResNet downsampling block with spatial self-attention
...         "AttnDownBlock2D",
...     ), 
...     up_block_types=(
...         "AttnUpBlock2D", 
...         "AttnUpBlock2D",      # a ResNet upsampling block with spatial self-attention
...         "UpBlock2D",          # a regular ResNet upsampling block
...       ),
... )
>>> print(model)
```

UNet2DModel(
  (conv_in): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (time_proj): Timesteps()
  (time_embedding): TimestepEmbedding(
    (linear_1): Linear(in_features=32, out_features=128, bias=True)
    (act): SiLU()
    (linear_2): Linear(in_features=128, out_features=128, bias=True)
  )
  (down_blocks): ModuleList(
    (0): DownBlock2D(
      (resnets): ModuleList(
        (0): ResnetBlock2D(
          (norm1): GroupNorm(32, 32, eps=1e-05, affine=True)
          (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=32, bias=True)
          (norm2): GroupNorm(32, 32, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
        )
        (1): ResnetBlock2D(
          (norm1): GroupNorm(32, 32, eps=1e-05, affine=True)
          (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=32, bias=True)
          (norm2): GroupNorm(32, 32, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
        )
      )
      (downsamplers): ModuleList(
        (0): Downsample2D(
          (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
        )
      )
    )
    (1): AttnDownBlock2D(
      (attentions): ModuleList(
        (0): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
        (1): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
      )
      (resnets): ModuleList(
        (0): ResnetBlock2D(
          (norm1): GroupNorm(32, 32, eps=1e-05, affine=True)
          (conv1): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (1): ResnetBlock2D(
          (norm1): GroupNorm(32, 64, eps=1e-05, affine=True)
          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
        )
      )
      (downsamplers): ModuleList(
        (0): Downsample2D(
          (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
        )
      )
    )
    (2): AttnDownBlock2D(
      (attentions): ModuleList(
        (0): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
        (1): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
      )
      (resnets): ModuleList(
        (0): ResnetBlock2D(
          (norm1): GroupNorm(32, 64, eps=1e-05, affine=True)
          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
        )
        (1): ResnetBlock2D(
          (norm1): GroupNorm(32, 64, eps=1e-05, affine=True)
          (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
        )
      )
    )
  )
  (up_blocks): ModuleList(
    (0): AttnUpBlock2D(
      (attentions): ModuleList(
        (0): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
        (1): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
        (2): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
      )
      (resnets): ModuleList(
        (0): ResnetBlock2D(
          (norm1): GroupNorm(32, 128, eps=1e-05, affine=True)
          (conv1): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (1): ResnetBlock2D(
          (norm1): GroupNorm(32, 128, eps=1e-05, affine=True)
          (conv1): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (2): ResnetBlock2D(
          (norm1): GroupNorm(32, 128, eps=1e-05, affine=True)
          (conv1): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))
        )
      )
      (upsamplers): ModuleList(
        (0): Upsample2D(
          (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        )
      )
    )
    (1): AttnUpBlock2D(
      (attentions): ModuleList(
        (0): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
        (1): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
        (2): AttentionBlock(
          (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
          (query): Linear(in_features=64, out_features=64, bias=True)
          (key): Linear(in_features=64, out_features=64, bias=True)
          (value): Linear(in_features=64, out_features=64, bias=True)
          (proj_attn): Linear(in_features=64, out_features=64, bias=True)
        )
      )
      (resnets): ModuleList(
        (0): ResnetBlock2D(
          (norm1): GroupNorm(32, 128, eps=1e-05, affine=True)
          (conv1): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (1): ResnetBlock2D(
          (norm1): GroupNorm(32, 128, eps=1e-05, affine=True)
          (conv1): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))
        )
        (2): ResnetBlock2D(
          (norm1): GroupNorm(32, 96, eps=1e-05, affine=True)
          (conv1): Conv2d(96, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
          (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(96, 64, kernel_size=(1, 1), stride=(1, 1))
        )
      )
      (upsamplers): ModuleList(
        (0): Upsample2D(
          (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        )
      )
    )
    (2): UpBlock2D(
      (resnets): ModuleList(
        (0): ResnetBlock2D(
          (norm1): GroupNorm(32, 96, eps=1e-05, affine=True)
          (conv1): Conv2d(96, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=32, bias=True)
          (norm2): GroupNorm(32, 32, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(96, 32, kernel_size=(1, 1), stride=(1, 1))
        )
        (1): ResnetBlock2D(
          (norm1): GroupNorm(32, 64, eps=1e-05, affine=True)
          (conv1): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=32, bias=True)
          (norm2): GroupNorm(32, 32, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))
        )
        (2): ResnetBlock2D(
          (norm1): GroupNorm(32, 64, eps=1e-05, affine=True)
          (conv1): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (time_emb_proj): Linear(in_features=128, out_features=32, bias=True)
          (norm2): GroupNorm(32, 32, eps=1e-05, affine=True)
          (dropout): Dropout(p=0.0, inplace=False)
          (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (nonlinearity): SiLU()
          (conv_shortcut): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))
        )
      )
    )
  )
  (mid_block): UNetMidBlock2D(
    (attentions): ModuleList(
      (0): AttentionBlock(
        (group_norm): GroupNorm(32, 64, eps=1e-05, affine=True)
        (query): Linear(in_features=64, out_features=64, bias=True)
        (key): Linear(in_features=64, out_features=64, bias=True)
        (value): Linear(in_features=64, out_features=64, bias=True)
        (proj_attn): Linear(in_features=64, out_features=64, bias=True)
      )
    )
    (resnets): ModuleList(
      (0): ResnetBlock2D(
        (norm1): GroupNorm(32, 64, eps=1e-05, affine=True)
        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
        (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
        (dropout): Dropout(p=0.0, inplace=False)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (nonlinearity): SiLU()
      )
      (1): ResnetBlock2D(
        (norm1): GroupNorm(32, 64, eps=1e-05, affine=True)
        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (time_emb_proj): Linear(in_features=128, out_features=64, bias=True)
        (norm2): GroupNorm(32, 64, eps=1e-05, affine=True)
        (dropout): Dropout(p=0.0, inplace=False)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (nonlinearity): SiLU()
      )
    )
  )
  (conv_norm_out): GroupNorm(32, 32, eps=1e-05, affine=True)
  (conv_act): SiLU()
  (conv_out): Conv2d(32, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)

As you can see, a little more going on! It also has significantly more parameters than our BasicUNet:

```python
sum([p.numel() for p in model.parameters()]) # 1.7M vs the ~309k parameters of the BasicUNet
```

We can replicate the training shown above using this model in place of our original one. We need to pass both x and timestep to the model (here I always pass t=0 to show that it works without this timestep conditioning and to keep the sampling code easy, but you can also try feeding in `(amount*1000)` to get a timestep equivalent from the corruption amount). Lines changed are shown with `#>> #@markdown Trying UNet2DModel instead of BasicUNet:

>>> # Dataloader (you can mess with batch size)
>>> batch_size = 128
>>> train_dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

>>> # How many runs through the data should we do?
>>> n_epochs = 3

>>> # Create the network
>>> net = UNet2DModel(
...     sample_size=28,  # the target image resolution
...     in_channels=1,  # the number of input channels, 3 for RGB images
...     out_channels=1,  # the number of output channels
...     layers_per_block=2,  # how many ResNet layers to use per UNet block
...     block_out_channels=(32, 64, 64),  # Roughly matching our basic unet example
...     down_block_types=( 
...         "DownBlock2D",  # a regular ResNet downsampling block
...         "AttnDownBlock2D",  # a ResNet downsampling block with spatial self-attention
...         "AttnDownBlock2D",
...     ), 
...     up_block_types=(
...         "AttnUpBlock2D", 
...         "AttnUpBlock2D",  # a ResNet upsampling block with spatial self-attention
...         "UpBlock2D",   # a regular ResNet upsampling block
...       ),
... ) #>> net.to(device)

>>> # Our loss finction
>>> loss_fn = nn.MSELoss()

>>> # The optimizer
>>> opt = torch.optim.Adam(net.parameters(), lr=1e-3) 

>>> # Keeping a record of the losses for later viewing
>>> losses = []

>>> # The training loop
>>> for epoch in range(n_epochs):

...     for x, y in train_dataloader:

...         # Get some data and prepare the corrupted version
...         x = x.to(device) # Data on the GPU
...         noise_amount = torch.rand(x.shape[0]).to(device) # Pick random noise amounts
...         noisy_x = corrupt(x, noise_amount) # Create our noisy x

...         # Get the model prediction
...         pred = net(noisy_x, 0).sample #>> # Plot losses and some samples
>>> fig, axs = plt.subplots(1, 2, figsize=(12, 5))

>>> # Losses
>>> axs[0].plot(losses)
>>> axs[0].set_ylim(0, 0.1)
>>> axs[0].set_title('Loss over time')

>>> # Samples
>>> n_steps = 40
>>> x = torch.rand(64, 1, 28, 28).to(device)
>>> for i in range(n_steps):
...   noise_amount = torch.ones((x.shape[0], )).to(device) * (1-(i/n_steps)) # Starting high going low
...   with torch.no_grad():
...     pred = net(x, 0).sample
...   mix_factor = 1/(n_steps - i)
...   x = x*(1-mix_factor) + pred*mix_factor

>>> axs[1].imshow(torchvision.utils.make_grid(x.detach().cpu(), nrow=8)[0].clip(0, 1), cmap='Greys')
>>> axs[1].set_title('Generated Samples');
```

Finished epoch 0. Average loss for this epoch: 0.018925
Finished epoch 1. Average loss for this epoch: 0.012785
Finished epoch 2. Average loss for this epoch: 0.011694

This looks quite a bit better than our first set of results! You can explore tweaking the unet configuration or training for longer to get even better performance. 

### The Corruption Process

The DDPM paper describes a corruption process that adds a small amount of noise for every 'timestep'. Given $x_{t-1}$ for some timestep, we can get the next (slightly more noisy) version $x_t$ with:

$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})$

That is, we take $x_{t-1}$, scale it by $\sqrt{1 - \beta_t}$ and add noise scaled by $\beta_t$. This $\beta$ is defined for every t according to some schedule, and determines how much noise is added per timestep. Now, we don't necessarily want to do this operation 500 times to get $x_{500}$ so we have another formula to get $x_t$ for any t given $x_0$: 

$\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$

The maths notation always looks scary! Luckily the scheduler handles all that for us (uncomment the next cell to check out the code). We can plot $\sqrt{\bar{\alpha}_t}$ (labelled as `sqrt_alpha_prod`) and $\sqrt{(1 - \bar{\alpha}_t)}$ (labelled as `sqrt_one_minus_alpha_prod`) to view how the input (x) and the noise are scaled and mixed across different timesteps:

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

Initially, the noisy x is mostly x (sqrt_alpha_prod ~= 1) but over time the contribution of x drops and the noise component increases. Unlike our linear mix of x and noise according to `amount`, this one gets noisy relatively quickly. We can visualize this on some data:

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

Another dynamic at play: the DDPM version adds noise drawn from a Gaussian distribution (mean 0, s.d. 1 from torch.randn) rather than the uniform noise between 0 and 1 (from torch.rand) we used in our original `corrupt` function. In general, it makes sense to normalize the training data as well. In the other notebook, you'll see `Normalize(0.5, 0.5)` in the list of transforms, which maps the image data form (0, 1) to (-1, 1) and is 'good enough' for our purposes. We didn't do that for this notebook, but the visualization cell above adds it in for more accurate scaling and visualization.

### Training Objective

In our toy example, we had the model try to predict the denoised image. In DDPM and many other diffusion model implementations, the model predicts the noise used in the corruption process (before scaling, so unit variance noise). In code, it looks something like:

```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
```

You may think that predicting the noise (from which we can derive what the denoised image looks like) is equivalent to just predicting the denoised image directly. So why favour one over the other - is it just for mathematical convenience?

It turns out there's another subtlety here. We compute the loss across different (randomly chosen) timesteps during training. These different objectives will lead to different 'implicit weighting' of these losses, where predicting the noise puts more weight on lower noise levels. You can pick more complex objectives to change this 'implicit loss weighting'. Or perhaps you choose a noise schedule that will result in more examples at a higher noise level. Perhaps you have the model predict a 'velocity' v which we define as being a combination of both the image and the noise dependent on the noise level (see 'PROGRESSIVE DISTILLATION FOR FAST SAMPLING OF DIFFUSION MODELS'). Perhaps you have the model predict the noise but then scale the loss by some factor dependent on the amount of noise based on a bit of theory (see 'Perception Prioritized Training of Diffusion Models') or based on experiments trying to see what noise levels are most informative to the model (see 'Elucidating the Design Space of Diffusion-Based Generative Models'). TL;DR: choosing the objective has an effect on model performance, and research in ongoing into what the 'best' option is.

At the moment, predicting the noise (epsilon or eps you'll see in some places) is the favoured approach but over time we will likely see other objectives supported in the library and used in different situations. 

### Timestep Conditioning

The UNet2DModel takes in both x and timestep. The latter is turned into an embedding and fed into the model in a number of places. 

The theory behind this is that by giving the model information about what the noise level is, it can better perform its task. While it is possible to train a model without this timestep conditioning, it does seem to help performance in some cases and most implementations include it, at least in the current literature. 

### Sampling

Given a model that estimates the noise present in a noisy input (or predicts the denoised version), how do we produce new images?

We could feed in pure noise, and hope that the model predicts a good image as the denoised version in one step. However, as we saw in the experiments above, this doesn't usually work well. So, instead, we take a number of smaller steps based on the model prediction, iteratively removing a little bit of the noise at a time.

Exactly how we take these steps depends on the sampling method used. We won't go into the theory too deeply, but some key design questions are:
- How large of a step should you take? In other words, what 'noise schedule' should you follow?
- Do you use only the model's current prediction to inform the update step (like DDPM, DDIM and many others)? Do you evaluate the model several times to estimate higher-order gradients for a larger, more accurate step (higher-order methods and some discrete ODE solvers)? Or do you keep a history of past predictions to try and better inform the current update step (linear multi-step and ancestral samplers)? 
- Do you add in additional noise (sometimes called churn) to add more stochasticity (randomness) to the sampling process, or do you keep it completely deterministic? Many samplers control this with a parameter (such as 'eta' for DDIM samplers) so that the user can choose.

Research on sampling methods for diffusion models is rapidly evolving, and more and more methods for finding good solutions in fewer steps are being proposed. The brave and curious might find it interesting to browse through the code of the different implementations available in the diffusers library [here](https://github.com/huggingface/diffusers/tree/main/src/diffusers/schedulers) or check out the [docs](https://huggingface.co/docs/diffusers/api/schedulers/overview) which often link to the relevant papers.

## Conclusions

Hopefully this has been a helpful way to look at diffusion models from a slightly different angle. 

This notebook was written for this Hugging Face course by Jonathan Whitaker, and overlaps with a [version included in his own course](https://johnowhitaker.github.io/tglcourse/dm1.html), 'The Generative Landscape'. Check that out if you'd like to see this basic example extended with noise and class conditioning. Questions or bugs can be communicated through GitHub issues or via Discord. You are also welcome to reach out via Twitter [@johnowhitaker](https://twitter.com/johnowhitaker).

### Introduction to 🤗 Diffusers
https://huggingface.co/learn/diffusion-course/unit1/2.md

# Introduction to 🤗 Diffusers

![diffusers_library](https://github.com/huggingface/diffusers/raw/main/docs/source/en/imgs/diffusers_library.jpg)

In this notebook, you'll train your first diffusion model to **generate images of cute butterflies 🦋.** Along the way, you'll learn about the core components of the 🤗 Diffusers library, which will provide a good foundation for the more advanced applications that we'll cover later in the course.

Let's dive in!

## What You Will Learn

In this notebook you will:

- See a powerful custom diffusion model pipeline in action (with information on how to make your own version)
- Create your own mini pipeline by:
  - Recapping the core ideas behind diffusion models
  - Loading in data from the Hub for training
  - Exploring how we add noise to this data with a scheduler
  - Creating and training the UNet model
  - Putting the pieces together into a working pipeline
- Edit and run a script for initializing longer training runs, that will handle
  - Multi-GPU training via 🤗 Accelerate
  - Experiment logging to track critical stats
  - Uploading the final model to the Hugging Face Hub

❓If you have any questions, please post them on the `#diffusion-models-class` channel on the Hugging Face Discord server. If you haven't signed up yet, you can do so here: https://huggingface.co/join/discord

## Prerequisites

Before diving into the notebook, you should:

* 📖 Read the Unit 1 materials
* 🤗 Create an account on the Hugging Face Hub. If you haven't done so yet, you can do so here: https://huggingface.co/join

## Step 1: Setup

Run the following cell to install the diffusers library as well as a few other requirements:

```python
%pip install -qq -U diffusers datasets transformers accelerate ftfy pyarrow==9.0.0
```

Next, head over to https://huggingface.co/settings/tokens and create an access token with write permission if you don't already have one:

![Screenshot from 2022-11-10 12-23-34.png](data:image/png;base64,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)

You can login with this token using the command line (`huggingface-cli login`) or by running the following cell:

```python
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

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

Then you need to install Git-LFS to upload your model checkpoints:

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

Finally, let's import the libraries we'll be using and define a few convenience functions which we'll use later in the notebook:

```python
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")
```

OK, we're all set!

## Dreambooth: A Sneak Peak at What's to Come

If you've looked at AI-related social media at all in the past few months, you've heard about Stable Diffusion. It's a powerful text-conditioned latent diffusion model (don't worry, we'll learn what all that means). But it has a flaw: it doesn't know what you or I look like unless we're famous enough to have our images plastered around the internet. 

Dreambooth let's us create our own model variant with some extra knowledge of a specific face, object or style. The Corridor Crew made an excellent video using this to tell stories with consistent characters, which is a great example of what this technique can do:

```python
>>> from IPython.display import YouTubeVideo

>>> YouTubeVideo("W4Mcuh38wyM")
```

Here's an example using [a model](https://huggingface.co/sd-dreambooth-library/mr-potato-head) trained on 5 photos of a popular children's toy called "Mr Potato Head".

First, we load the pipeline. This will download model weights etc. from the Hub. Since this will download several gigabytes of data for a one-line demo, you are welcome to skip this cell and simply admire the example output!

```python
from diffusers import StableDiffusionPipeline

# Check out https://huggingface.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
)
```

Once the pipeline has finished loading, we can generate images with:

```python
>>> 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
```

**Exercise:** Try it yourself with different prompts. The `sks` token represents a unique identifier for the novel concept in this case - what happens if you leave that out? You can also experiment with changing the number of sampling steps (how low can you go?) and the `guidance_scale`, which determines how much the model will try to match the prompt.

There's a lot going on in that magical pipeline! By the end of the course you'll know how it all works. For now, let's take a look at how we can train a diffusion model from scratch.

## MVP (Minimum Viable Pipeline)

The core API of 🤗 Diffusers is divided into three main components:
1. **Pipelines**: high-level classes designed to rapidly generate samples from popular trained diffusion models in a user-friendly fashion.
2. **Models**: popular architectures for training new diffusion models, *e.g.* [UNet](https://arxiv.org/abs/1505.04597).
3. **Schedulers**: various techniques for generating images from noise during *inference* as well as to generate noisy images for *training*.

Pipelines are great for end-users, but if you're here for this course we assume you want to know what is going on under the hood! So, over the rest of this notebook we're going to build our own pipeline capable of generating small butterfly pictures. Here's the final result in action:

```python
>>> 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)
```

Not as impressive as the DreamBooth example perhaps, but then we're training from scratch with ~0.0001% of the data used to train Stable Diffusion. Speaking of training, recall from the introduction to this unit that training a diffusion model looks something like this:

1.   Load in some images from the training data
2.   Add noise, in different amounts. 
3.   Feed the noisy versions of the inputs into the model
4.   Evaluate how well the model does at denoising these inputs
5.   Use this information to update the model weights, and repeat

We'll explore these steps one by one in the next few sections until we have a complete training loop working, and then we'll explore how to sample from the trained model and how to package everything up into a pipeline for easy sharing. Let's begin with the data...

## Step 2: Download a training dataset

For this example, we'll use a dataset of images from the Hugging Face Hub. Specifically, [this collection of 1000 butterfly pictures](https://huggingface.co/datasets/huggan/smithsonian_butterflies_subset). This is a very small dataset, so we've also included commented out lines for a few larger options. If you'd prefer to use your own collection of images, you can also use the commented-out code example to load in pictures from a folder instead.

```python
import torchvision
from datasets import load_dataset
from torchvision import transforms

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

# Or load images from a local folder
# dataset = load_dataset("imagefolder", data_dir="path/to/folder")

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

We can grab a batch of images and view some of them like so:

```python
>>> 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])

We're sticking to a small dataset with 32 pixel images to keep training times manageable in this notebook.

## Step 3: Define the Scheduler

Our plan for training is to take these input images and add noise to them, then feed the noisy images to the model. And during inference, we will use the model predictions to iteratively remove noise. In `diffusers`,  these processes are both handled by the **scheduler**. 

The noise schedule determines how much noise is added at different timesteps. Here's how we might create a scheduler using the default settings for 'DDPM' training and sampling (based on the paper ["Denoising Diffusion Probabilistic Models"](https://arxiv.org/abs/2006.11239)):

```python
from diffusers import DDPMScheduler

noise_scheduler = DDPMScheduler(num_train_timesteps=1000)
```

The DDPM paper describes a corruption process that adds a small amount of noise for every 'timestep'. Given $x_{t-1}$ for some timestep, we can get the next (slightly more noisy) version $x_t$ with:

$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})$

That is, we take $x_{t-1}$, scale it by $\sqrt{1 - \beta_t}$ and add noise scaled by $\beta_t$. This $\beta$ is defined for every t according to some schedule, and determines how much noise is added per timestep. Now, we don't necessarily want to do this operation 500 times to get $x_{500}$ so we have another formula to get $x_t$ for any t given $x_0$: 

$\begin{aligned}
q(\mathbf{x}_t \vert \mathbf{x}_0) &= \mathcal{N}(\mathbf{x}_t; \sqrt{\bar{\alpha}_t} \mathbf{x}_0, {(1 - \bar{\alpha}_t)} \mathbf{I})
\end{aligned}$ where $\bar{\alpha}_t = \prod_{i=1}^T \alpha_i$ and $\alpha_i = 1-\beta_i$

The maths notation always looks scary! Luckily the scheduler handles all that for us. We can plot $\sqrt{\bar{\alpha}_t}$ (labelled as `sqrt_alpha_prod`) and $\sqrt{(1 - \bar{\alpha}_t)}$ (labelled as `sqrt_one_minus_alpha_prod`) to view how the input (x) and the noise are scaled and mixed across different timesteps:

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

**Exercise:** You can explore how this plot changes with different settings for beta_start, beta_end and beta_schedule by swapping in one of the commented-out options here:

```python
# 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')
```

Whichever scheduler you've chosen, we can now use it to add noise in different amounts using the `noise_scheduler.add_noise` function like so:

```python
>>> 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])

Again, explore the effect of using different noise schedules and parameters here. [This video](https://www.youtube.com/watch?v=fbLgFrlTnGU) does a great job explaining some of the maths above in more detail, and is a great introduction to some of these concepts.

## Step 4: Define the Model

Now we come to the core component: the model itself. 

Most diffusion models use architectures that are some variant of a [U-net](https://arxiv.org/abs/1505.04597) and that's what we'll use here.

![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/unet-model.png)

In a nutshell:
- the model has the input image go through several blocks of ResNet layers, each of which halves the image size by 2
- then through the same number of blocks that upsample it again.
- there are skip connections linking the features on the downsample path to the corresponding layers in the upsample path.

A key feature of this model is that it predicts images of the same size as the input, which is exactly what we need here.

Diffusers provides us a handy `UNet2DModel` class which creates the desired architecture in PyTorch.

Let's create a U-net for our desired image size. 
Note that `down_block_types` correspond to the downsampling blocks (green on the diagram above), and `up_block_types` are the upsampling blocks (red on the diagram):

```python
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);
```

When dealing with higher-resolution inputs you may want to use more down and up-blocks, and keep the attention layers only at the lowest resolution (bottom) layers to reduce memory usage. We'll talk later about how you might experiment to find the best settings for your use-case.

We can check that passing in a batch of data and some random timesteps produces an output the same shape as the input data:

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

In the next section we'll see how to train this model.

## Step 5: Create a Training Loop

Time to train! Below is a typical optimization loop in PyTorch, where we run through the data batch by batch and update the parameters of our model each step using an optimizer - in this case the AdamW optimizer with a learning rate of 0.0004. 

For each batch of data, we
- Sample some random timesteps
- Noise the data accordingly
- Feed the noisy data through the model
- Compare the model predictions with the target (i.e. the noise in this case) using mean squared error as our loss function
- Update the model parameters via `loss.backward()` and `optimizer.step()`

During this process we also log the losses over time for later plotting.

NB: This code takes nearly 10 minutes to run - feel free to skip these two cells and use the pretrained model if you are in a hurry. Alternatively, you can explore how reducing the number of channels in each layer via the model definition above can speed things up.

The [official diffusers training example](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/training_example.ipynb) trains a larger model on this dataset at higher resolution, and is a good reference for what a less minimal training loop looks like:

```python
>>> # 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

Plotting the loss, we see that the model rapidly improves initially and then continues to get better at a slower rate (which is more obvious if we use a log scale as shown on the right):

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

As an alternative to running the training code above, you can use the model from the pipeline like so:

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

## Step 6: Generate Images

How do we get images with this model?

### Option 1: Creating a pipeline:

```python
from diffusers import DDPMPipeline

image_pipe = DDPMPipeline(unet=model, scheduler=noise_scheduler)
```

```python
>>> pipeline_output = image_pipe()
>>> pipeline_output.images[0]
```

We can save a pipeline to a local folder like so:

```python
image_pipe.save_pretrained("my_pipeline")
```

Inspecting the folder contents:

```python
>>> !ls my_pipeline/
```

model_index.json  scheduler  unet

The `scheduler` and `unet` subfolders contain everything needed to re-create those components. For example, inside the `unet` folder you'll find the model weights (`diffusion_pytorch_model.bin`) alongside a config file which specifies the UNet architecture. 

```python
>>> !ls my_pipeline/unet/
```

config.json  diffusion_pytorch_model.bin

Together, these files contain everything needed to recreate the pipeline. You can manually upload them to the hub to share the pipeline with others, or check out the code to do this via the API in the next section.

### Option 2: Writing a Sampling Loop

If you inspect the forward method of the pipeline you'll be able to see what is happening when we run `image_pipe()`:

```python
# ??image_pipe.forward
```

We begin with random noise, and run through the scheduler timesteps from most to least noisy, removing a small amount of noise each step based on the model prediction:

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

The `noise_scheduler.step()` function does the maths required to update `sample` appropriately. There are a number of sampling methods - in the next unit we'll see how we can swap in a different sampler to speed up image generation with existing models, and talk more about the theory behind sampling from diffusion models.

## Step 7: Push your model to the Hub

In the example above we saved our pipeline to a local folder. To push our model to the Hub, we will need to model repository to push our files to. We'll determine the repository name from the model ID we want to give our model (feel free to replace the `model_name` with your own choice; it just needs to contain your username, which is what the function `get_full_repo_name()` does):

```python
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
```

Next, create a model repository on the 🤗 Hub and push our model:

```python
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,
)
```

The last thing to do is create a nice model card so that our butterfly generator can easily be found on the Hub (feel free to expand and edit the description!):

```python
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)
```

Now that the model is on the Hub, you can download it from anywhere by using the `from_pretrained()` method of the `DDPMPipeline` as follows"

```python
>>> from diffusers import DDPMPipeline

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

Great it works!

# Scaling up with 🤗 Accelerate

This notebook was made for learning purposes, and as such I tried to keep the code as minimal and clean as possible. Because of this, we omitted some of the things you might want if you were to try training a larger model on much more data, such as multi-GPU support, logging of progress and example images, gradient checkpointing to support larger batch sizes, automatic uploading of models and so on. Thankfully most of these features are available in the example training script [here](https://github.com/huggingface/diffusers/raw/main/examples/unconditional_image_generation/train_unconditional.py).

You can download the file like so:

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

Open up the file and you'll see where the model is defined and what settings are available. I ran the script with the following command:

```python
# 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
```

```python
!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"
```

As before, let's push the model to the Hub and create a nice model card (and feel free to edit it as you wish!):

```python
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)
```

About 45 minutes later, this is the result:

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

**Exercise:** See if you can find training/model settings that give good results in as little time as possible, and share your findings with the community. Dig around in the script to see if you can understand the code, and ask for clarification on anything that looks confusing.

# Avenues for Further Exploration

Hopefully this has given you a taste of what you can do with the 🤗 Diffusers library! Some possible next steps:

- Try training an unconditional diffusion model on a new dataset - bonus points if you [create one yourself](https://huggingface.co/docs/datasets/image_dataset). You can find some great image datasets for this task in the [HugGan organization](https://huggingface.co/huggan) on the Hub. Just make sure you downsample them if you don't want to wait a very long time for the model to train!
- Try out DreamBooth to create your own customized Stable Diffusion pipeline using either [this Space](https://huggingface.co/spaces/multimodalart/dreambooth-training) or [this notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/sd_dreambooth_training.ipynb)
- Modify the training script to explore different UNet hyperparameters (number of layers, channels etc), different noise schedules etc.
- Check out the [Diffusion Models from Scratch](https://github.com/huggingface/diffusion-models-class/blob/main/unit1/02_diffusion_models_from_scratch.ipynb) notebook for a different take on the core ideas we've covered in this unit

Good luck, and stay tuned for Unit 2!

### Unit 1: An Introduction to Diffusion Models
https://huggingface.co/learn/diffusion-course/unit1/1.md

# Unit 1: An Introduction to Diffusion Models

Welcome to Unit 1 of the Hugging Face Diffusion Models Course! In this unit, you will learn the basics of how diffusion 
models work and how to create your own using the 🤗 Diffusers library.

## Start this Unit 🚀

Here are the steps for this unit:

- Make sure you've [signed up for this course](https://huggingface.us17.list-manage.com/subscribe?u=7f57e683fa28b51bfc493d048&id=ef963b4162) so that you can be notified when new material is released.
- Read through the introductory material below as well as any of the additional resources that sound interesting.
- Check out the _**Introduction to Diffusers**_  notebook below to put theory into practice with the 🤗 Diffusers library.
- Train and share your own diffusion model using the notebook or the linked training script.
- (Optional) Dive deeper with the _**Diffusion Models from Scratch**_ notebook if you're interested in seeing a minimal from-scratch implementation and exploring the different design decisions involved.
- (Optional) Check out [this video](https://www.youtube.com/watch?v=09o5cv6u76c) for an informal run-through the material for this unit. 

📢 Don't forget to join the [Discord](https://huggingface.co/join/discord), where you can discuss the material and share what you've made in the `#diffusion-models-class` channel.
 
## What Are Diffusion Models?

Diffusion models are a relatively recent addition to a group of algorithms known as 'generative models'. The goal of generative modeling is to learn to **generate** data, such as images or audio, given a number of training examples. A good generative model will create a **diverse** set of outputs that resemble the training data without being exact copies. How do diffusion models achieve this? Let's focus on the image generation case for illustrative purposes.

    
    
     Figure from DDPM paper (https://arxiv.org/abs/2006.11239). 

The secret to diffusion models' success is the iterative nature of the diffusion process. Generation begins with random noise, but this is gradually refined over a number of steps until an output image emerges. At each step, the model estimates how we could go from the current input to a completely denoised version. However, since we only make a small change at every step, any errors in this estimate at the early stages (where predicting the final output is extremely difficult) can be corrected in later updates. 

Training the model is relatively straightforward compared to some other types of generative model. We repeatedly
1) Load in some images from the training data
2) Add noise, in different amounts. Remember, we want the model to do a good job estimating how to 'fix' (denoise) both extremely noisy images and images that are close to perfect.
3) Feed the noisy versions of the inputs into the model
4) Evaluate how well the model does at denoising these inputs
5) Use this information to update the model weights

To generate new images with a trained model, we begin with a completely random input and repeatedly feed it through the model, updating it each time by a small amount based on the model prediction. As we'll see, there are a number of sampling methods that try to streamline this process so that we can generate good images with as few steps as possible.

We will show each of these steps in detail in the hands-on notebooks here in unit 1. In unit 2, we will look at how this process can be modified to add additional control over the model outputs through extra conditioning (such as a class label) or with techniques such as guidance. And units 3 and 4 will explore an extremely powerful diffusion model called Stable Diffusion, which can generate images given text descriptions.  

## Hands-On Notebooks

At this point, you know enough to get started with the accompanying notebooks! The two notebooks here come at the same idea in different ways. 
 
| Chapter                                     | Colab                                                                                                                                                                                               | Kaggle                                                                                                                                                                                                   | Gradient                                                                                                                                                                               | Studio Lab                                                                                                                                                                                                   |
|:--------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Introduction to Diffusers                                | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit1/01_introduction_to_diffusers.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit1/01_introduction_to_diffusers.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/unit1/01_introduction_to_diffusers.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/unit1/01_introduction_to_diffusers.ipynb)              |
| Diffusion Models from Scratch                                | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/diffusion-models-class/blob/main/unit1/02_diffusion_models_from_scratch.ipynb)              | [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/huggingface/diffusion-models-class/blob/main/unit1/02_diffusion_models_from_scratch.ipynb)              | [![Gradient](https://assets.paperspace.io/img/gradient-badge.svg)](https://console.paperspace.com/github/huggingface/diffusion-models-class/blob/main/unit1/02_diffusion_models_from_scratch.ipynb)              | [![Open In SageMaker Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/huggingface/diffusion-models-class/blob/main/unit1/02_diffusion_models_from_scratch.ipynb)              |

In _**Introduction to Diffusers**_, we show the different steps described above using building blocks from the diffusers library. You'll quickly see how to create, train and sample your own diffusion models on whatever data you choose. By the end of the notebook, you'll be able to read and modify the example training script to train diffusion models and share them with the world! This notebook also introduces the main exercise associated with this unit, where we will collectively attempt to figure out good 'training recipes' for diffusion models at different scales - see the next section for more info.

In _**Diffusion Models from Scratch**_, we show those same steps (adding noise to data, creating a model, training and sampling) but implemented from scratch in PyTorch as simply as possible. Then we compare this 'toy example' with the diffusers version, noting how the two differ and where improvements have been made. The goal here is to gain familiarity with the different components and the design decisions that go into them so that when you look at a new implementation you can quickly identify the key ideas.

## Project Time

Now that you've got the basics down, have a go at training one or more diffusion models! Some suggestions are included at the end of the _**Introduction to Diffusers**_ notebook. Make sure to share your results, training recipes and findings with the community so that we can collectively figure out the best ways to train these models.

## Some Additional Resources
 
[The Annotated Diffusion Model](https://huggingface.co/blog/annotated-diffusion) is a very in-depth walk-through of the code and theory behind DDPMs with 
 maths and code showing all the different components. It also links to a number of papers for further reading.
 
Hugging Face documentation on [Unconditional Image-Generation](https://huggingface.co/docs/diffusers/training/unconditional_training) for some examples of how to train diffusion models using the official training example script, including code showing how to create your own dataset. 

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

Found more great resources? Let us know and we'll add them to this list.

### Hugging Face Diffusion Models Course
https://huggingface.co/learn/diffusion-course/unit0/1.md

# Hugging Face Diffusion Models Course

In this free course, you will:
- 👩‍🎓 Study the theory behind diffusion models
- 🧨 Learn how to generate images and audio with the popular 🤗 Diffusers library
- 🏋️‍♂️ Train your own diffusion models from scratch
- 📻 Fine-tune existing diffusion models on new datasets
- 🗺 Explore conditional generation and guidance
- 🧑‍🔬 Create your own custom diffusion model pipelines

## Prerequisites
This course requires a good level in Python and a grounding in deep learning and Pytorch.
If it's not the case yet, you can check these free resources:
- Python: https://www.udacity.com/course/introduction-to-python--ud1110
- Intro to Deep Learning with PyTorch: https://www.udacity.com/course/deep-learning-pytorch--ud188
- PyTorch in 60min: https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html

To upload your models to the Hugging Face Hub, you'll need an account. You can create one for free at the following address: [https://huggingface.co/join](https://huggingface.co/join).

	
## What is the syllabus?

The course consists in four units. Each unit is made up of a theory section, which also lists resources/papers, and two *notebooks*. More specifically, we have:
- Unit 1: Introduction to diffusion models  
Introduction to 🤗 Diffusers and implementation from 0
- Unit 2: Finetuning and guidance  
Finetuning a diffusion model on new data and adding guidance.
- Unit 3: Stable Diffusion  
Exploring a powerful text-conditioned latent diffusion model
- Unit 4: Doing more with diffusion  
Advanced techniques for going further with diffusion

## Who are we?

About the authors:

[**Jonathan Whitaker**](https://huggingface.co/johnowhitaker) is a Data Scientist/AI Researcher doing R&D with [answer.ai](https://www.answer.ai/). He likes teaching and making courses. His current focus is on generative AI, flitting between several modalities. You can find more info at: [johnowhitaker.dev](https://johnowhitaker.dev/).

[**Lewis Tunstall**](https://huggingface.co/lewtun) is a machine learning engineer at Hugging Face, focused on developing open-source tools and making them accessible to the wider community. He is also a co-author of the O’Reilly book [Natural Language Processing with Transformers](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/).

## FAQ

Here are some answers to frequently asked questions:

- **Does taking this course lead to a certification?**
Currently we do not have any certification for this course. However, we are working on a certification program for the Hugging Face ecosystem -- stay tuned!

- **How much time should I spend on this course?**
Each chapter in this course is designed to be completed in 1 week, with approximately 6-8 hours of work per week. However, you can take as much time as you need to complete the course.

- **Where can I ask a question if I have one?**
If you have a question about any section of the course, just click on the "*Ask a question*" banner at the top of the page to be automatically redirected to the right section of the [Hugging Face Discord](https://discord.com/invite/JfAtkvEtRb) to ask your question in the channel `#diffusion-models-class`.

- **Where can I get the code for the course?**
For each section, click on the banner at the top of the page to run the code:

- **How can I contribute to the course?**
There are many ways to contribute to the course! If you find a typo or a bug, please open an issue on the [`diffusion-models-class`](https://github.com/huggingface/diffusion-models-class) repo. 
If you would like to help translate the course into your native language, check out the instructions [here](https://github.com/huggingface/diffusion-models-class#translating-the-course-into-your-language).

- **Can I reuse this course?**
Of course! The course is released under the permissive [Apache 2 license](https://www.apache.org/licenses/LICENSE-2.0.html). This means that you must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use. If you would like to cite the course, please use the following BibTeX:

```
@misc{huggingfacecourse,
  author = {Hugging Face},
  title = {The Hugging Face Diffusion Models Course, 2022},
  howpublished = "\url{https://huggingface.co/course}",
  year = {2022},
  note = "[Online; accessed ]"
}
```

## Let's get started!

Are you ready to get started? Then go to the first unit to start the course.
