# Texto para imagem

> [!WARNING]
> O script de texto para imagem é experimental, e é fácil sofrer overfitting e encontrar problemas como o esquecimento catastrófico. Tente explorar diferentes hiperparâmetros para obter os melhores resultados no seu conjunto de dados.

Modelos de texto para imagem, como o Stable Diffusion, são condicionados para gerar imagens a partir de um prompt de texto.

Treinar um modelo pode ser exigente para o seu hardware, mas, se você ativar `gradient_checkpointing` e `mixed_precision`, é possível treinar um modelo em uma única GPU de 24GB. Se você estiver treinando com tamanhos de lote maiores ou quiser treinar mais rápido, é melhor usar GPUs com mais de 30GB de memória. Você pode reduzir a sua pegada de memória ativando a atenção eficiente em memória com [xFormers](../optimization/attention_backends).

Este guia explorará o script de treinamento [train_text_to_image.py](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image.py) para ajudá-lo a se familiarizar com ele e como você pode adaptá-lo para o seu próprio caso de uso.

Antes de executar o script, certifique-se de instalar a biblioteca a partir do código-fonte:

```bash
git clone https://github.com/huggingface/diffusers
cd diffusers
pip install .
```

Em seguida, navegue até a pasta de exemplo que contém o script de treinamento e instale as dependências necessárias para o script que você está usando:

```bash
cd examples/text_to_image
pip install -r requirements.txt
```

> [!TIP]
> 🤗 Accelerate é uma biblioteca para ajudar você a treinar em múltiplos GPUs/TPUs ou com precisão mista. Ela configura automaticamente seu ambiente de treinamento com base no seu hardware e ambiente. Dê uma olhada no [Quick tour](https://huggingface.co/docs/accelerate/quicktour) do 🤗 Accelerate para saber mais.

Inicialize um ambiente do 🤗 Accelerate:

```bash
accelerate config
```

Para configurar um ambiente padrão do 🤗 Accelerate sem escolher nenhuma configuração:

```bash
accelerate config default
```

Ou, se o seu ambiente não suporta um shell interativo, como um notebook, você pode usar:

```py
from accelerate.utils import write_basic_config

write_basic_config()
```

Por fim, se você deseja treinar um modelo em seu próprio conjunto de dados, consulte o guia [Criar um conjunto de dados para treinamento](create_dataset) para aprender a criar um conjunto de dados que funcione com o script de treinamento.

## Parâmetros do script

> [!TIP]
> As seções a seguir destacam partes do script de treinamento que são importantes para entender como modificá-lo, mas não cobrem todos os aspectos do script em detalhes. Se você tiver interesse em aprender mais, sinta-se à vontade para ler o [script](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image.py) e nos informar caso tenha alguma dúvida ou preocupação.

O script de treinamento fornece muitos parâmetros para ajudar você a personalizar sua execução de treinamento. Todos os parâmetros e suas descrições estão encontrados na função [`parse_args()`](https://github.com/huggingface/diffusers/blob/8959c5b9dec1c94d6ba482c94a58d2215c5fd026/examples/text_to_image/train_text_to_image.py#L193). Esta função fornece valores padrão para cada parâmetro, como o tamanho do lote de treinamento e a taxa de aprendizado, mas você também pode definir seus próprios valores no comando de treinamento, se desejar.

Por exemplo, para acelerar o treinamento com precisão mista usando o formato fp16, adicione o parâmetro `--mixed_precision` ao comando de treinamento:

```bash
accelerate launch train_text_to_image.py \
  --mixed_precision="fp16"
```

Alguns parâmetros básicos e importantes incluem:

- `--pretrained_model_name_or_path`: o nome do modelo no Hub ou um caminho local para o modelo pré-treinado
- `--dataset_name`: o nome do conjunto de dados no Hub ou um caminho local para o conjunto de dados em que o treinamento será realizado
- `--image_column`: o nome da coluna de imagens no conjunto de dados para treinamento
- `--caption_column`: o nome da coluna de texto no conjunto de dados para treinamento
- `--output_dir`: onde salvar o modelo treinado
- `--push_to_hub`: se o modelo treinado deve ser enviado para o Hub
- `--checkpointing_steps`: frequência de salvamento de um checkpoint durante o treinamento do modelo; isso é útil caso, por algum motivo, o treinamento seja interrompido, pois você pode continuar o treinamento a partir desse checkpoint adicionando `--resume_from_checkpoint` ao seu comando de treinamento

### Ponderação Min-SNR

A estratégia de ponderação [Min-SNR](https://huggingface.co/papers/2303.09556) pode ajudar no treinamento ao reequilibrar a perda para alcançar uma convergência mais rápida. O script de treinamento suporta a previsão de `epsilon` (ruído) ou `v_prediction`, mas o Min-SNR é compatível com ambos os tipos de previsão. Essa estratégia de ponderação é suportada apenas pelo PyTorch.

Adicione o parâmetro `--snr_gamma` e defina-o com o valor recomendado de 5.0:

```bash
accelerate launch train_text_to_image.py \
  --snr_gamma=5.0
```

Você pode comparar as superfícies de perda para diferentes valores de `snr_gamma` neste relatório do [Weights and Biases](https://wandb.ai/sayakpaul/text2image-finetune-minsnr). Para conjuntos de dados menores, os efeitos do Min-SNR podem não ser tão evidentes em comparação com conjuntos de dados maiores.

## Script de treinamento

O código de pré-processamento do conjunto de dados e o loop de treinamento estão na função [`main()`](https://github.com/huggingface/diffusers/blob/8959c5b9dec1c94d6ba482c94a58d2215c5fd026/examples/text_to_image/train_text_to_image.py#L490). Se você precisar adaptar o script de treinamento, é aqui que você precisará fazer suas alterações.

O script `train_text_to_image` começa [carregando um scheduler](https://github.com/huggingface/diffusers/blob/8959c5b9dec1c94d6ba482c94a58d2215c5fd026/examples/text_to_image/train_text_to_image.py#L543) e um tokenizer. Você pode escolher usar um scheduler diferente aqui, se desejar:

```py
noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
tokenizer = CLIPTokenizer.from_pretrained(
    args.pretrained_model_name_or_path, subfolder="tokenizer", revision=args.revision
)
```

Em seguida, o script [carrega o modelo UNet](https://github.com/huggingface/diffusers/blob/8959c5b9dec1c94d6ba482c94a58d2215c5fd026/examples/text_to_image/train_text_to_image.py#L619):

```py
load_model = UNet2DConditionModel.from_pretrained(input_dir, subfolder="unet")
model.register_to_config(**load_model.config)

model.load_state_dict(load_model.state_dict())
```

Em seguida, as colunas de texto e imagem do conjunto de dados precisam ser pré-processadas. A função [`tokenize_captions`](https://github.com/huggingface/diffusers/blob/8959c5b9dec1c94d6ba482c94a58d2215c5fd026/examples/text_to_image/train_text_to_image.py#L724) trata a tokenização das entradas, e a função [`train_transforms`](https://github.com/huggingface/diffusers/blob/8959c5b9dec1c94d6ba482c94a58d2215c5fd026/examples/text_to_image/train_text_to_image.py#L742) especifica o tipo de transformações a serem aplicadas à imagem. Ambas as funções são agrupadas em `preprocess_train`:

```py
def preprocess_train(examples):
    images = [image.convert("RGB") for image in examples[image_column]]
    examples["pixel_values"] = [train_transforms(image) for image in images]
    examples["input_ids"] = tokenize_captions(examples)
    return examples
```

Por fim, o [training loop](https://github.com/huggingface/diffusers/blob/8959c5b9dec1c94d6ba482c94a58d2215c5fd026/examples/text_to_image/train_text_to_image.py#L878) cuida de tudo o mais. Ele codifica as imagens no espaço latente, adiciona ruído aos latentes, calcula os embeddings de texto para condicionar, atualiza os parâmetros do modelo e salva e envia o modelo para o Hub. Se você quiser aprender mais sobre como o training loop funciona, confira o tutorial [Understanding pipelines, models and schedulers](../using-diffusers/write_own_pipeline), que detalha o padrão básico do processo de remoção de ruído.

## Inicie o script

Depois de fazer todas as alterações ou se você estiver satisfeito com a configuração padrão, está pronto para executar o script de treinamento! 🚀

Vamos treinar no conjunto de dados [Naruto BLIP captions](https://huggingface.co/datasets/lambdalabs/naruto-blip-captions) para gerar seus próprios personagens de Naruto. Defina as variáveis de ambiente `MODEL_NAME` e `dataset_name` para o modelo e o conjunto de dados (seja do Hub ou um caminho local). Se você estiver treinando em mais de uma GPU, adicione o parâmetro `--multi_gpu` ao comando `accelerate launch`.

> [!TIP]
> Para treinar em um conjunto de dados local, defina as variáveis de ambiente `TRAIN_DIR` e `OUTPUT_DIR` com o caminho do conjunto de dados e o local onde o modelo será salvo.

```bash
export MODEL_NAME="stable-diffusion-v1-5/stable-diffusion-v1-5"
export dataset_name="lambdalabs/naruto-blip-captions"

accelerate launch --mixed_precision="fp16"  train_text_to_image.py \
  --pretrained_model_name_or_path=$MODEL_NAME \
  --dataset_name=$dataset_name \
  --use_ema \
  --resolution=512 --center_crop --random_flip \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --gradient_checkpointing \
  --max_train_steps=15000 \
  --learning_rate=1e-05 \
  --max_grad_norm=1 \
  --enable_xformers_memory_efficient_attention \
  --lr_scheduler="constant" --lr_warmup_steps=0 \
  --output_dir="sd-naruto-model" \
  --push_to_hub
```

Quando o treinamento estiver concluído, você pode usar o seu modelo recém-treinado para inferência:

```py
from diffusers import StableDiffusionPipeline
import torch

pipeline = StableDiffusionPipeline.from_pretrained("path/to/saved_model", dtype=torch.float16, use_safetensors=True).to("cuda")  # or "mps", "xpu", "cpu"

image = pipeline(prompt="yoda").images[0]
image.save("yoda-naruto.png")
```

## Próximas etapas

Parabéns por treinar seu próprio modelo de texto para imagem! Para saber mais sobre como usar seu novo modelo, os seguintes guias podem ser úteis:

- Aprenda como [carregar pesos LoRA](../tutorials/using_peft_for_inference) para inferência se você treinou seu modelo com LoRA.
- Saiba mais sobre como certos parâmetros, como a escala de orientação, ou técnicas, como o ponderamento de prompts, podem ajudar você a controlar a inferência no guia de tarefas de [Texto para imagem](../using-diffusers/conditional_image_generation).