Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /main /es /training /kandinsky.md

mishig

8 days ago

preview code

download

raw

16.2 kB

# Kandinsky 2.2

> [!WARNING]
> Este script es experimental y es fácil sobreajustar y encontrarse con problemas como el olvido catastrófico. Pruebe explorar diferentes hiperparámetros para obtener los mejores resultados en su conjunto de datos.

Kandinsky 2.2 es un modelo de texto a imagen multilingüe capaz de generar imágenes más fotorrealistas. El modelo incluye un modelo de prior de imagen para crear embeddings de imagen a partir de prompts de texto, y un modelo decodificador que genera imágenes basándose en los embeddings del modelo de prior. Por eso, encontrarás dos scripts separados en Diffusers para Kandinsky 2.2, uno para entrenar el modelo de prior y otro para entrenar el modelo decodificador. Puedes entrenar ambos modelos por separado, pero para obtener los mejores resultados, debes entrenar tanto el modelo de prior como el modelo decodificador.

Dependiendo de tu GPU, es posible que necesites habilitar `gradient_checkpointing` (⚠️ no compatible con el modelo anterior), `mixed_precision` y `gradient_accumulation_steps` para ayudar a que el modelo quepa en la memoria y acelerar el entrenamiento. Puedes reducir aún más el uso de memoria habilitando la atención eficiente en memoria con [xFormers](../optimization/attention_backends) (la versión [v0.0.16](https://github.com/huggingface/diffusers/issues/2234#issuecomment-1416931212) falla en el entrenamiento en algunas GPUs, por lo que es posible que necesites instalar una versión de desarrollo en su lugar).

Esta guía explora los scripts [train_text_to_image_prior.py](https://github.com/huggingface/diffusers/blob/main/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py) y [train_text_to_image_decoder.py](https://github.com/huggingface/diffusers/blob/main/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py) para ayudarte a familiarizarte con ellos y con la forma de adaptarlos a tu caso de uso.

Antes de ejecutar los scripts, asegúrate de instalar la biblioteca desde el código fuente:

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

Luego, navegue a la carpeta de ejemplo que contiene el script de entrenamiento e instale las dependencias requeridas para el script que está utilizando:

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

> [!TIP]
> 🤗 Accelerate es una biblioteca para ayudarte a entrenar en varias GPUs/TPUs o con precisión mixta. Configura automáticamente tu configuración de entrenamiento en función de tu hardware y entorno. Echa un vistazo al [Quick tour](https://huggingface.co/docs/accelerate/quicktour) de 🤗 Accelerate para saber más.

Inicializa un entorno de 🤗 Accelerate:

```bash
accelerate config
```

Para configurar un entorno predeterminado de 🤗 Accelerate sin elegir ninguna configuración:

```bash
accelerate config default
```

O si su entorno no admite una shell interactiva, como un notebook, puede usar:

```py
from accelerate.utils import write_basic_config
write_basic_config()
```

Por último, si deseas entrenar un modelo con tu propio conjunto de datos, consulta la guía [Crear un conjunto de datos para el entrenamiento](create_dataset) para aprender a crear un conjunto de datos que funcione con el script de entrenamiento.

> [!TIP]
> Las siguientes secciones resaltan las partes de los scripts de entrenamiento que son importantes para entender cómo modificarlos, pero no abordan todos los aspectos de los scripts en detalle. Si te interesa aprender más, no dudes en leer los scripts y hacernos saber si tienes alguna pregunta o inquietud.

## Parámetros del script

Los scripts de entrenamiento ofrecen muchos parámetros para ayudarte a personalizar tu ejecución de entrenamiento. Todos los parámetros y sus descripciones se encuentran en la función [`parse_args()`](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L190). Los scripts de entrenamiento proporcionan valores predeterminados para cada parámetro, como el tamaño del lote de entrenamiento y la tasa de aprendizaje, pero también puedes establecer tus propios valores en el comando de entrenamiento si lo deseas.

Por ejemplo, para acelerar el entrenamiento con precisión mixta usando el formato fp16, añade el parámetro `--mixed_precision` al comando de entrenamiento:

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

La mayoría de los parámetros son idénticos a los de la guía de entrenamiento [Text-to-image](text2image#script-parameters), así que vamos directamente a un recorrido por los scripts de entrenamiento de Kandinsky.

### Ponderación Min-SNR

La estrategia de ponderación [Min-SNR](https://huggingface.co/papers/2303.09556) puede ayudar en el entrenamiento al reequilibrar la pérdida para lograr una convergencia más rápida. El script de entrenamiento admite la predicción de `epsilon` (ruido) o `v_prediction`, pero Min-SNR es compatible con ambos tipos de predicción. Esta estrategia de ponderación solo está soportada por PyTorch.

Agrega el parámetro `--snr_gamma` y establécelo en el valor recomendado de 5.0:

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

## Script de entrenamiento

El script de entrenamiento también es similar a la guía de entrenamiento de [Texto a imagen](text2image#training-script), pero se ha modificado para admitir el entrenamiento de los modelos prior y decoder. Esta guía se centra en el código que es único para los scripts de entrenamiento de Kandinsky 2.2.

La función [`main()`](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L441) contiene el código para preparar el conjunto de datos y entrenar el modelo.

Una de las principales diferencias que notará de inmediato es que el script de entrenamiento también carga un [CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor) - además de un scheduler y un tokenizer - para preprocesar las imágenes y un modelo [CLIPVisionModelWithProjection](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPVisionModelWithProjection) para codificar las imágenes:

```py
noise_scheduler = DDPMScheduler(beta_schedule="squaredcos_cap_v2", prediction_type="sample")
image_processor = CLIPImageProcessor.from_pretrained(
    args.pretrained_prior_model_name_or_path, subfolder="image_processor"
)
tokenizer = CLIPTokenizer.from_pretrained(args.pretrained_prior_model_name_or_path, subfolder="tokenizer")
with ContextManagers(deepspeed_zero_init_disabled_context_manager()):
    image_encoder = CLIPVisionModelWithProjection.from_pretrained(
        args.pretrained_prior_model_name_or_path, subfolder="image_encoder", dtype=weight_dtype
    ).eval()
    text_encoder = CLIPTextModelWithProjection.from_pretrained(
        args.pretrained_prior_model_name_or_path, subfolder="text_encoder", dtype=weight_dtype
    ).eval()
```

Kandinsky utiliza un [PriorTransformer](/docs/diffusers/main/es/api/models/prior_transformer#diffusers.PriorTransformer) para generar los embeddings de la imagen, por lo que querrás configurar el optimizador para aprender los parámetros del modo prior.

```py
prior = PriorTransformer.from_pretrained(args.pretrained_prior_model_name_or_path, subfolder="prior")
prior.train()
optimizer = optimizer_cls(
    prior.parameters(),
    lr=args.learning_rate,
    betas=(args.adam_beta1, args.adam_beta2),
    weight_decay=args.adam_weight_decay,
    eps=args.adam_epsilon,
)
```

A continuación, las descripciones de entrada se tokenizan y las imágenes se [preprocesan](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L632) mediante el [CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor):

```py
def preprocess_train(examples):
    images = [image.convert("RGB") for image in examples[image_column]]
    examples["clip_pixel_values"] = image_processor(images, return_tensors="pt").pixel_values
    examples["text_input_ids"], examples["text_mask"] = tokenize_captions(examples)
    return examples
```

Por último, el [bucle de entrenamiento](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L718) convierte las imágenes de entrada en latentes, añade ruido a los embeddings de las imágenes y realiza una predicción:

```py
model_pred = prior(
    noisy_latents,
    timestep=timesteps,
    proj_embedding=prompt_embeds,
    encoder_hidden_states=text_encoder_hidden_states,
    attention_mask=text_mask,
).predicted_image_embedding
```

Si quieres saber más sobre cómo funciona el bucle de entrenamiento, consulta el tutorial [Understanding pipelines, models and schedulers](../using-diffusers/write_own_pipeline), que desglosa el patrón básico del proceso de desruido.

La función [`main()`](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L440) contiene el código para preparar el conjunto de datos y entrenar el modelo.

A diferencia del modelo anterior, el decodificador inicializa un [VQModel](/docs/diffusers/main/es/api/models/vq#diffusers.VQModel) para decodificar los latentes en imágenes y utiliza un [UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel):

```py
with ContextManagers(deepspeed_zero_init_disabled_context_manager()):
    vae = VQModel.from_pretrained(
        args.pretrained_decoder_model_name_or_path, subfolder="movq", dtype=weight_dtype
    ).eval()
    image_encoder = CLIPVisionModelWithProjection.from_pretrained(
        args.pretrained_prior_model_name_or_path, subfolder="image_encoder", dtype=weight_dtype
    ).eval()
unet = UNet2DConditionModel.from_pretrained(args.pretrained_decoder_model_name_or_path, subfolder="unet")
```

A continuación, el script incluye varias transformaciones de imagen y una función de [preprocesamiento](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L622) para aplicar las transformaciones a las imágenes y devolver los valores de píxeles:

```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["clip_pixel_values"] = image_processor(images, return_tensors="pt").pixel_values
    return examples
```

Por último, el [bucle de entrenamiento](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L706) se encarga de convertir las imágenes en latentes, añadir ruido y predecir el residuo de ruido.

Si quieres saber más sobre cómo funciona el bucle de entrenamiento, consulta el tutorial [Understanding pipelines, models and schedulers](../using-diffusers/write_own_pipeline), que desglosa el patrón básico del proceso de desruido.

```py
model_pred = unet(noisy_latents, timesteps, None, added_cond_kwargs=added_cond_kwargs).sample[:, :4]
```

## Ejecutar el script

Una vez que hayas realizado todos tus cambios o estés conforme con la configuración predeterminada, ¡estás listo para lanzar el script de entrenamiento! 🚀

Entrenarás con el conjunto de datos [Naruto BLIP captions](https://huggingface.co/datasets/lambdalabs/naruto-blip-captions) para generar tus propios personajes de Naruto, pero también puedes crear y entrenar con tu propio conjunto de datos siguiendo la guía [Create a dataset for training](create_dataset). Establece la variable de entorno `DATASET_NAME` con el nombre del conjunto de datos en el Hub o, si estás entrenando con tus propios archivos, establece la variable de entorno `TRAIN_DIR` con la ruta a tu conjunto de datos.

Si estás entrenando en más de una GPU, añade el parámetro `--multi_gpu` al comando `accelerate launch`.

> [!TIP]
> Para monitorear el progreso del entrenamiento con Weights & Biases, añade el parámetro `--report_to=wandb` al comando de entrenamiento. También debes añadir `--validation_prompt` al comando de entrenamiento para llevar un registro de los resultados. Esto puede ser muy útil para depurar el modelo y ver resultados intermedios.

```bash
export DATASET_NAME="lambdalabs/naruto-blip-captions"
accelerate launch --mixed_precision="fp16"  train_text_to_image_prior.py \
  --dataset_name=$DATASET_NAME \
  --resolution=768 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --max_train_steps=15000 \
  --learning_rate=1e-05 \
  --max_grad_norm=1 \
  --checkpoints_total_limit=3 \
  --lr_scheduler="constant" \
  --lr_warmup_steps=0 \
  --validation_prompts="A robot naruto, 4k photo" \
  --report_to="wandb" \
  --push_to_hub \
  --output_dir="kandi2-prior-naruto-model"
```

```bash
export DATASET_NAME="lambdalabs/naruto-blip-captions"
accelerate launch --mixed_precision="fp16"  train_text_to_image_decoder.py \
  --dataset_name=$DATASET_NAME \
  --resolution=768 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --gradient_checkpointing \
  --max_train_steps=15000 \
  --learning_rate=1e-05 \
  --max_grad_norm=1 \
  --checkpoints_total_limit=3 \
  --lr_scheduler="constant" \
  --lr_warmup_steps=0 \
  --validation_prompts="A robot naruto, 4k photo" \
  --report_to="wandb" \
  --push_to_hub \
  --output_dir="kandi2-decoder-naruto-model"
```

Una vez finalizado el entrenamiento, ¡puedes usar tu modelo recién entrenado para inferencia!

```py
from diffusers import AutoPipelineForText2Image, DiffusionPipeline
import torch
prior_pipeline = DiffusionPipeline.from_pretrained(output_dir, dtype=torch.float16)
prior_components = {"prior_" + k: v for k,v in prior_pipeline.components.items()}
pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", **prior_components, dtype=torch.float16)
pipe.enable_model_cpu_offload()
prompt="A robot naruto, 4k photo"
image = pipeline(prompt=prompt, negative_prompt=negative_prompt).images[0]
```

> [!TIP]
> Puedes reemplazar `kandinsky-community/kandinsky-2-2-decoder` con tu propio checkpoint de decodificador entrenado.

```py
from diffusers import AutoPipelineForText2Image
import torch
pipeline = AutoPipelineForText2Image.from_pretrained("path/to/saved/model", dtype=torch.float16)
pipeline.enable_model_cpu_offload()
prompt="A robot naruto, 4k photo"
image = pipeline(prompt=prompt).images[0]
```

Para el modelo decodificador, también puedes realizar inferencia desde un punto de control guardado, lo cual puede ser útil para ver resultados intermedios. En este caso, carga el punto de control en el UNet:

```py
from diffusers import AutoPipelineForText2Image, UNet2DConditionModel
unet = UNet2DConditionModel.from_pretrained("path/to/saved/model" + "/checkpoint-<N>/unet")
pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", unet=unet, dtype=torch.float16)
pipeline.enable_model_cpu_offload()
image = pipeline(prompt="A robot naruto, 4k photo").images[0]
```

## Próximos pasos

¡Felicidades por entrenar un modelo Kandinsky 2.2! Para aprender más sobre cómo usar tu nuevo modelo, las siguientes guías pueden ser útiles:

- Lee la guía de [Kandinsky](../api/pipelines/kandinsky) para aprender a usarla para una variedad de tareas diferentes (texto a imagen, imagen a imagen, inpainting, interpolación) y cómo puede combinarse con un ControlNet.
- Consulta las guías de entrenamiento de [DreamBooth](dreambooth) y [LoRA](lora) para aprender a entrenar un modelo de Kandinsky personalizado con solo unas pocas imágenes de ejemplo. ¡Incluso se pueden combinar estas dos técnicas de entrenamiento!

Xet Storage Details

Size:: 16.2 kB
Xet hash:: 79c58555eb6d44f7465dd30e980403b845cc26fab26df9ccb58733af1e919940

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# Kandinsky 2.2

	> [!WARNING]
	> Este script es experimental y es fácil sobreajustar y encontrarse con problemas como el olvido catastrófico. Pruebe explorar diferentes hiperparámetros para obtener los mejores resultados en su conjunto de datos.

	Kandinsky 2.2 es un modelo de texto a imagen multilingüe capaz de generar imágenes más fotorrealistas. El modelo incluye un modelo de prior de imagen para crear embeddings de imagen a partir de prompts de texto, y un modelo decodificador que genera imágenes basándose en los embeddings del modelo de prior. Por eso, encontrarás dos scripts separados en Diffusers para Kandinsky 2.2, uno para entrenar el modelo de prior y otro para entrenar el modelo decodificador. Puedes entrenar ambos modelos por separado, pero para obtener los mejores resultados, debes entrenar tanto el modelo de prior como el modelo decodificador.

	Dependiendo de tu GPU, es posible que necesites habilitar `gradient_checkpointing` (⚠️ no compatible con el modelo anterior), `mixed_precision` y `gradient_accumulation_steps` para ayudar a que el modelo quepa en la memoria y acelerar el entrenamiento. Puedes reducir aún más el uso de memoria habilitando la atención eficiente en memoria con [xFormers](../optimization/attention_backends) (la versión [v0.0.16](https://github.com/huggingface/diffusers/issues/2234#issuecomment-1416931212) falla en el entrenamiento en algunas GPUs, por lo que es posible que necesites instalar una versión de desarrollo en su lugar).

	Esta guía explora los scripts [train_text_to_image_prior.py](https://github.com/huggingface/diffusers/blob/main/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py) y [train_text_to_image_decoder.py](https://github.com/huggingface/diffusers/blob/main/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py) para ayudarte a familiarizarte con ellos y con la forma de adaptarlos a tu caso de uso.

	Antes de ejecutar los scripts, asegúrate de instalar la biblioteca desde el código fuente:

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

	Luego, navegue a la carpeta de ejemplo que contiene el script de entrenamiento e instale las dependencias requeridas para el script que está utilizando:

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

	> [!TIP]
	> 🤗 Accelerate es una biblioteca para ayudarte a entrenar en varias GPUs/TPUs o con precisión mixta. Configura automáticamente tu configuración de entrenamiento en función de tu hardware y entorno. Echa un vistazo al [Quick tour](https://huggingface.co/docs/accelerate/quicktour) de 🤗 Accelerate para saber más.

	Inicializa un entorno de 🤗 Accelerate:

	```bash
	accelerate config
	```

	Para configurar un entorno predeterminado de 🤗 Accelerate sin elegir ninguna configuración:

	```bash
	accelerate config default
	```

	O si su entorno no admite una shell interactiva, como un notebook, puede usar:

	```py
	from accelerate.utils import write_basic_config

	write_basic_config()
	```

	Por último, si deseas entrenar un modelo con tu propio conjunto de datos, consulta la guía [Crear un conjunto de datos para el entrenamiento](create_dataset) para aprender a crear un conjunto de datos que funcione con el script de entrenamiento.

	> [!TIP]
	> Las siguientes secciones resaltan las partes de los scripts de entrenamiento que son importantes para entender cómo modificarlos, pero no abordan todos los aspectos de los scripts en detalle. Si te interesa aprender más, no dudes en leer los scripts y hacernos saber si tienes alguna pregunta o inquietud.

	## Parámetros del script

	Los scripts de entrenamiento ofrecen muchos parámetros para ayudarte a personalizar tu ejecución de entrenamiento. Todos los parámetros y sus descripciones se encuentran en la función [`parse_args()`](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L190). Los scripts de entrenamiento proporcionan valores predeterminados para cada parámetro, como el tamaño del lote de entrenamiento y la tasa de aprendizaje, pero también puedes establecer tus propios valores en el comando de entrenamiento si lo deseas.

	Por ejemplo, para acelerar el entrenamiento con precisión mixta usando el formato fp16, añade el parámetro `--mixed_precision` al comando de entrenamiento:

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

	La mayoría de los parámetros son idénticos a los de la guía de entrenamiento [Text-to-image](text2image#script-parameters), así que vamos directamente a un recorrido por los scripts de entrenamiento de Kandinsky.

	### Ponderación Min-SNR

	La estrategia de ponderación [Min-SNR](https://huggingface.co/papers/2303.09556) puede ayudar en el entrenamiento al reequilibrar la pérdida para lograr una convergencia más rápida. El script de entrenamiento admite la predicción de `epsilon` (ruido) o `v_prediction`, pero Min-SNR es compatible con ambos tipos de predicción. Esta estrategia de ponderación solo está soportada por PyTorch.

	Agrega el parámetro `--snr_gamma` y establécelo en el valor recomendado de 5.0:

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

	## Script de entrenamiento

	El script de entrenamiento también es similar a la guía de entrenamiento de [Texto a imagen](text2image#training-script), pero se ha modificado para admitir el entrenamiento de los modelos prior y decoder. Esta guía se centra en el código que es único para los scripts de entrenamiento de Kandinsky 2.2.

	La función [`main()`](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L441) contiene el código para preparar el conjunto de datos y entrenar el modelo.

	Una de las principales diferencias que notará de inmediato es que el script de entrenamiento también carga un [CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor) - además de un scheduler y un tokenizer - para preprocesar las imágenes y un modelo [CLIPVisionModelWithProjection](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPVisionModelWithProjection) para codificar las imágenes:

	```py
	noise_scheduler = DDPMScheduler(beta_schedule="squaredcos_cap_v2", prediction_type="sample")
	image_processor = CLIPImageProcessor.from_pretrained(
	args.pretrained_prior_model_name_or_path, subfolder="image_processor"
	)
	tokenizer = CLIPTokenizer.from_pretrained(args.pretrained_prior_model_name_or_path, subfolder="tokenizer")

	with ContextManagers(deepspeed_zero_init_disabled_context_manager()):
	image_encoder = CLIPVisionModelWithProjection.from_pretrained(
	args.pretrained_prior_model_name_or_path, subfolder="image_encoder", dtype=weight_dtype
	).eval()
	text_encoder = CLIPTextModelWithProjection.from_pretrained(
	args.pretrained_prior_model_name_or_path, subfolder="text_encoder", dtype=weight_dtype
	).eval()
	```

	Kandinsky utiliza un [PriorTransformer](/docs/diffusers/main/es/api/models/prior_transformer#diffusers.PriorTransformer) para generar los embeddings de la imagen, por lo que querrás configurar el optimizador para aprender los parámetros del modo prior.

	```py
	prior = PriorTransformer.from_pretrained(args.pretrained_prior_model_name_or_path, subfolder="prior")
	prior.train()
	optimizer = optimizer_cls(
	prior.parameters(),
	lr=args.learning_rate,
	betas=(args.adam_beta1, args.adam_beta2),
	weight_decay=args.adam_weight_decay,
	eps=args.adam_epsilon,
	)
	```

	A continuación, las descripciones de entrada se tokenizan y las imágenes se [preprocesan](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L632) mediante el [CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor):

	```py
	def preprocess_train(examples):
	images = [image.convert("RGB") for image in examples[image_column]]
	examples["clip_pixel_values"] = image_processor(images, return_tensors="pt").pixel_values
	examples["text_input_ids"], examples["text_mask"] = tokenize_captions(examples)
	return examples
	```

	Por último, el [bucle de entrenamiento](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L718) convierte las imágenes de entrada en latentes, añade ruido a los embeddings de las imágenes y realiza una predicción:

	```py
	model_pred = prior(
	noisy_latents,
	timestep=timesteps,
	proj_embedding=prompt_embeds,
	encoder_hidden_states=text_encoder_hidden_states,
	attention_mask=text_mask,
	).predicted_image_embedding
	```

	Si quieres saber más sobre cómo funciona el bucle de entrenamiento, consulta el tutorial [Understanding pipelines, models and schedulers](../using-diffusers/write_own_pipeline), que desglosa el patrón básico del proceso de desruido.

	La función [`main()`](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L440) contiene el código para preparar el conjunto de datos y entrenar el modelo.

	A diferencia del modelo anterior, el decodificador inicializa un [VQModel](/docs/diffusers/main/es/api/models/vq#diffusers.VQModel) para decodificar los latentes en imágenes y utiliza un [UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel):

	```py
	with ContextManagers(deepspeed_zero_init_disabled_context_manager()):
	vae = VQModel.from_pretrained(
	args.pretrained_decoder_model_name_or_path, subfolder="movq", dtype=weight_dtype
	).eval()
	image_encoder = CLIPVisionModelWithProjection.from_pretrained(
	args.pretrained_prior_model_name_or_path, subfolder="image_encoder", dtype=weight_dtype
	).eval()
	unet = UNet2DConditionModel.from_pretrained(args.pretrained_decoder_model_name_or_path, subfolder="unet")
	```

	A continuación, el script incluye varias transformaciones de imagen y una función de [preprocesamiento](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L622) para aplicar las transformaciones a las imágenes y devolver los valores de píxeles:

	```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["clip_pixel_values"] = image_processor(images, return_tensors="pt").pixel_values
	return examples
	```

	Por último, el [bucle de entrenamiento](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L706) se encarga de convertir las imágenes en latentes, añadir ruido y predecir el residuo de ruido.

	Si quieres saber más sobre cómo funciona el bucle de entrenamiento, consulta el tutorial [Understanding pipelines, models and schedulers](../using-diffusers/write_own_pipeline), que desglosa el patrón básico del proceso de desruido.

	```py
	model_pred = unet(noisy_latents, timesteps, None, added_cond_kwargs=added_cond_kwargs).sample[:, :4]
	```

	## Ejecutar el script

	Una vez que hayas realizado todos tus cambios o estés conforme con la configuración predeterminada, ¡estás listo para lanzar el script de entrenamiento! 🚀

	Entrenarás con el conjunto de datos [Naruto BLIP captions](https://huggingface.co/datasets/lambdalabs/naruto-blip-captions) para generar tus propios personajes de Naruto, pero también puedes crear y entrenar con tu propio conjunto de datos siguiendo la guía [Create a dataset for training](create_dataset). Establece la variable de entorno `DATASET_NAME` con el nombre del conjunto de datos en el Hub o, si estás entrenando con tus propios archivos, establece la variable de entorno `TRAIN_DIR` con la ruta a tu conjunto de datos.

	Si estás entrenando en más de una GPU, añade el parámetro `--multi_gpu` al comando `accelerate launch`.

	> [!TIP]
	> Para monitorear el progreso del entrenamiento con Weights & Biases, añade el parámetro `--report_to=wandb` al comando de entrenamiento. También debes añadir `--validation_prompt` al comando de entrenamiento para llevar un registro de los resultados. Esto puede ser muy útil para depurar el modelo y ver resultados intermedios.

	```bash
	export DATASET_NAME="lambdalabs/naruto-blip-captions"

	accelerate launch --mixed_precision="fp16" train_text_to_image_prior.py \
	--dataset_name=$DATASET_NAME \
	--resolution=768 \
	--train_batch_size=1 \
	--gradient_accumulation_steps=4 \
	--max_train_steps=15000 \
	--learning_rate=1e-05 \
	--max_grad_norm=1 \
	--checkpoints_total_limit=3 \
	--lr_scheduler="constant" \
	--lr_warmup_steps=0 \
	--validation_prompts="A robot naruto, 4k photo" \
	--report_to="wandb" \
	--push_to_hub \
	--output_dir="kandi2-prior-naruto-model"
	```

	```bash
	export DATASET_NAME="lambdalabs/naruto-blip-captions"

	accelerate launch --mixed_precision="fp16" train_text_to_image_decoder.py \
	--dataset_name=$DATASET_NAME \
	--resolution=768 \
	--train_batch_size=1 \
	--gradient_accumulation_steps=4 \
	--gradient_checkpointing \
	--max_train_steps=15000 \
	--learning_rate=1e-05 \
	--max_grad_norm=1 \
	--checkpoints_total_limit=3 \
	--lr_scheduler="constant" \
	--lr_warmup_steps=0 \
	--validation_prompts="A robot naruto, 4k photo" \
	--report_to="wandb" \
	--push_to_hub \
	--output_dir="kandi2-decoder-naruto-model"
	```

	Una vez finalizado el entrenamiento, ¡puedes usar tu modelo recién entrenado para inferencia!

	```py
	from diffusers import AutoPipelineForText2Image, DiffusionPipeline
	import torch

	prior_pipeline = DiffusionPipeline.from_pretrained(output_dir, dtype=torch.float16)
	prior_components = {"prior_" + k: v for k,v in prior_pipeline.components.items()}
	pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", **prior_components, dtype=torch.float16)

	pipe.enable_model_cpu_offload()
	prompt="A robot naruto, 4k photo"
	image = pipeline(prompt=prompt, negative_prompt=negative_prompt).images[0]
	```

	> [!TIP]
	> Puedes reemplazar `kandinsky-community/kandinsky-2-2-decoder` con tu propio checkpoint de decodificador entrenado.

	```py
	from diffusers import AutoPipelineForText2Image
	import torch

	pipeline = AutoPipelineForText2Image.from_pretrained("path/to/saved/model", dtype=torch.float16)
	pipeline.enable_model_cpu_offload()

	prompt="A robot naruto, 4k photo"
	image = pipeline(prompt=prompt).images[0]
	```

	Para el modelo decodificador, también puedes realizar inferencia desde un punto de control guardado, lo cual puede ser útil para ver resultados intermedios. En este caso, carga el punto de control en el UNet:

	```py
	from diffusers import AutoPipelineForText2Image, UNet2DConditionModel

	unet = UNet2DConditionModel.from_pretrained("path/to/saved/model" + "/checkpoint-<N>/unet")

	pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", unet=unet, dtype=torch.float16)
	pipeline.enable_model_cpu_offload()

	image = pipeline(prompt="A robot naruto, 4k photo").images[0]
	```

	## Próximos pasos

	¡Felicidades por entrenar un modelo Kandinsky 2.2! Para aprender más sobre cómo usar tu nuevo modelo, las siguientes guías pueden ser útiles:

	- Lee la guía de [Kandinsky](../api/pipelines/kandinsky) para aprender a usarla para una variedad de tareas diferentes (texto a imagen, imagen a imagen, inpainting, interpolación) y cómo puede combinarse con un ControlNet.
	- Consulta las guías de entrenamiento de [DreamBooth](dreambooth) y [LoRA](lora) para aprender a entrenar un modelo de Kandinsky personalizado con solo unas pocas imágenes de ejemplo. ¡Incluso se pueden combinar estas dos técnicas de entrenamiento!