# Empleos en Hugging Face

[Hugging Face Jobs](https://huggingface.co/docs/hub/jobs) se ejecuta en GPUs de Hugging Face, por lo que no necesitas configurar una máquina y la ejecución continúa aunque cierres tu terminal. Los scripts de entrenamiento de Diffusers se ejecutan en Jobs directamente desde su URL de GitHub, sin necesidad de clonar el repositorio ni instalar nada localmente.

Antes de comenzar, siga el [Inicio rápido de Jobs](https://huggingface.co/docs/hub/jobs-quickstart) para instalar la CLI `hf`, iniciar sesión y añadir créditos a su cuenta.

## Entrena un LoRA en Jobs

El siguiente comando entrena un LoRA para [FLUX.2-klein-4B](https://huggingface.co/black-forest-labs/FLUX.2-klein-4B) con las cinco fotos de perros en [diffusers/dog-example](https://huggingface.co/datasets/diffusers/dog-example). Se ejecuta en una sola A10G y sube el LoRA a tu espacio de nombres en el Hub.

```bash
# 20 steps is a test run. For a real run, raise --max_train_steps
# (the FLUX.2 README uses 500) and --timeout to match.
hf jobs uv run --flavor a10g-small --timeout 30m -s HF_TOKEN -- \
  https://raw.githubusercontent.com/huggingface/diffusers/main/examples/dreambooth/train_dreambooth_lora_flux2_klein.py \
  --pretrained_model_name_or_path black-forest-labs/FLUX.2-klein-4B \
  --dataset_name diffusers/dog-example \
  --instance_prompt "a photo of sks dog" \
  --resolution 512 --mixed_precision bf16 --guidance_scale 1 \
  --gradient_checkpointing --cache_latents \
  --optimizer adamW --use_8bit_adam --learning_rate 1e-4 \
  --max_train_steps 20 --seed 0 \
  --output_dir /tmp/out \
  --push_to_hub --hub_model_id your-username/klein-dog-lora
```

`uv` instala las dependencias listadas en la cabecera `# /// script` del script, incluyendo Diffusers desde `main`. Los Jobs no reciben un token de Hugging Face de forma predeterminada, por lo que `-s HF_TOKEN` lo reenvía para permitir que el script suba el LoRA. El disco del Job se descarta cuando el Job termina, y todo lo que no se suba se pierde. Las guías de [DreamBooth](./dreambooth) y [LoRA](./lora) explican los argumentos de entrenamiento.

## Gestión de un trabajo

Los registros de entrenamiento se imprimen en tu terminal mientras el Job se ejecuta. Cerrar la terminal o presionar `Ctrl+C` no detiene el entrenamiento, porque el Job se ejecuta en las máquinas de Hugging Face. Para iniciar una ejecución larga sin ocupar tu terminal, agrega `-d` antes de `--`. El comando imprime el ID del Job y regresa.

Use el ID del trabajo para volver a conectar con los registros, verificar la memoria y el uso de la GPU mientras el modelo se entrena, o detener una ejecución.

```bash
hf jobs logs -f <job_id>
hf jobs stats <job_id>
hf jobs cancel <job_id>
```

Si la ejecución falla, `hf jobs inspect <job_id>` muestra el mensaje de error. Consulta [Manage Jobs](https://huggingface.co/docs/hub/jobs-manage) para ver los demás comandos.

## Entrenar con tus propias imágenes

Para entrenar con tus imágenes, monta su carpeta en el Job con `-v` y pasa la ruta de montaje a `--instance_data_dir` en lugar de `--dataset_name`. Jobs sube la carpeta a un bucket privado antes de que comience el Job y la monta en solo lectura. Subir la misma carpeta de nuevo solo envía los archivos nuevos o modificados.

```bash
hf jobs uv run --flavor a10g-small --timeout 30m -s HF_TOKEN \
  -v ./my-dog:/data -- \
  https://raw.githubusercontent.com/huggingface/diffusers/main/examples/dreambooth/train_dreambooth_lora_flux2_klein.py \
  --pretrained_model_name_or_path black-forest-labs/FLUX.2-klein-4B \
  --instance_data_dir /data \
  --instance_prompt "a photo of sks dog" \
  --resolution 512 --mixed_precision bf16 --guidance_scale 1 \
  --gradient_checkpointing --cache_latents \
  --optimizer adamW --use_8bit_adam --learning_rate 1e-4 \
  --max_train_steps 20 --seed 0 \
  --output_dir /tmp/out \
  --push_to_hub --hub_model_id your-username/klein-dog-lora
```

El script abre todos los archivos de `--instance_data_dir` como imágenes, por lo que debe mantener solo imágenes en la carpeta. Un archivo oculto como `.DS_Store` hace que la ejecución falle. Consulte [Directorios locales](https://huggingface.co/docs/hub/jobs-configuration#local-directories) para obtener más información sobre el montaje de una carpeta.

Con `--with_prior_preservation`, el script genera imágenes de clase en `--class_data_dir` antes de que comience el entrenamiento. Indícale una ruta donde el Job pueda escribir. Para reutilizar las imágenes de clase en ejecuciones posteriores, colócalas en un montaje de bucket de lectura y escritura, como el de [Guardar puntos de control para ejecuciones largas](#save-checkpoints-for-long-runs).

## Entrenar en FP8

Los scripts de DreamBooth LoRA para FLUX.2, Z-Image, Ideogram 4 y Krea 2 aceptan `--do_fp8_training` para entrenar en FP8 con [torchao](https://github.com/pytorch/ao), lo que reduce el uso de memoria. La cabecera de ningún script incluye torchao, por lo que hay que añadir `--with torchao` antes de `--`. El FP8 también requiere una GPU con capacidad de cálculo 8.9 o superior, como una L4 (`l4x1`) o una L40S (`l40sx1`). La A10G (8.6) y la A100 (8.0) no la admiten.

## Ejecutar un script sin una cabecera de dependencias

Solo los scripts en [examples/dreambooth](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth) y [examples/advanced_diffusion_training](https://github.com/huggingface/diffusers/tree/main/examples/advanced_diffusion_training) declaran sus dependencias en un bloque `# /// script` al inicio del archivo. Algunos scripts de esas carpetas, como `train_dreambooth_lora_sdxl.py`, no lo tienen.

Para un script sin encabezado, pasa cada dependencia con `--with`. Instala Diffusers desde el código fuente, porque los scripts de entrenamiento requieren la versión de desarrollo. Las demás dependencias provienen del archivo `requirements.txt` del script y de sus importaciones.

```bash
hf jobs uv run --flavor a10g-small --timeout 30m -s HF_TOKEN \
  --with "diffusers @ git+https://github.com/huggingface/diffusers.git" \
  --with torch --with torchvision --with accelerate --with transformers \
  --with peft --with datasets --with bitsandbytes \
  --with ftfy --with tensorboard --with Jinja2 -- \
  https://raw.githubusercontent.com/huggingface/diffusers/main/examples/dreambooth/train_dreambooth_lora_sdxl.py \
  --pretrained_model_name_or_path stabilityai/stable-diffusion-xl-base-1.0 \
  --pretrained_vae_model_name_or_path madebyollin/sdxl-vae-fp16-fix \
  --dataset_name diffusers/dog-example \
  --instance_prompt "a photo of sks dog" \
  --resolution 1024 --mixed_precision fp16 \
  --gradient_checkpointing --use_8bit_adam --learning_rate 1e-4 \
  --max_train_steps 20 --seed 0 \
  --output_dir /tmp/out \
  --push_to_hub --hub_model_id your-username/sdxl-dog-lora
```

## Guardar puntos de control para ejecuciones largas

Una ejecución que tarda horas puede agotar el tiempo de espera o fallar antes de terminar. Para conservar su progreso, monte un [Storage Bucket](https://huggingface.co/docs/hub/storage-buckets) en el Job con `-v` y apunte `--output_dir` hacia él. Cree el bucket primero con `hf buckets create`.

El script guarda una carpeta `checkpoint-<step>` en `--output_dir` cada `--checkpointing_steps` pasos (500 por defecto), de modo que los checkpoints se almacenan en el bucket a medida que avanza el entrenamiento. `--checkpoints_total_limit` limita cuántos se conservan. `--resume_from_checkpoint latest` retoma desde el checkpoint más reciente en `--output_dir` y comienza desde cero si no existe ninguno, por lo que el mismo comando funciona tanto para la primera ejecución como para cada reinicio.

```bash
hf jobs uv run --flavor a10g-small --timeout 8h -s HF_TOKEN \
  -v hf://buckets/your-username/checkpoints:/ckpt -- \
  https://raw.githubusercontent.com/huggingface/diffusers/main/examples/dreambooth/train_dreambooth_lora_flux2_klein.py \
  --pretrained_model_name_or_path black-forest-labs/FLUX.2-klein-4B \
  --dataset_name diffusers/dog-example \
  --instance_prompt "a photo of sks dog" \
  --resolution 1024 --mixed_precision bf16 --guidance_scale 1 \
  --gradient_checkpointing --cache_latents \
  --optimizer adamW --use_8bit_adam --learning_rate 1e-4 \
  --max_train_steps 5000 --seed 0 \
  --checkpointing_steps 500 --checkpoints_total_limit 3 \
  --resume_from_checkpoint latest \
  --output_dir /ckpt/klein-dog
```

Cuando termina el entrenamiento, el LoRA se guarda en el bucket como `pytorch_lora_weights.safetensors`. Consulta [Volumes](https://huggingface.co/docs/hub/jobs-configuration#volumes) para las opciones de montaje.

> [!NOTE]
> No añadas `--push_to_hub` cuando `--output_dir` contenga puntos de control. La carga solo omite las carpetas `step_*` y `epoch_*`, por lo que las carpetas `checkpoint-<step>` se suben al repositorio del modelo junto con el LoRA. En su lugar, sube tú mismo `pytorch_lora_weights.safetensors` a un repositorio de modelos.

## Próximos pasos

- Lee [Train Models on Jobs](https://huggingface.co/docs/hub/jobs-training) en la documentación de Hub para conocer las comprobaciones que debes realizar antes de un trabajo largo y cómo leer uno que ha fallado.
- Carga tu LoRA entrenado para inferencia con la guía de [LoRA](../tutorials/using_peft_for_inference).
- Consulte los [archivos README de DreamBooth](https://github.com/huggingface/diffusers/tree/main/examples/dreambooth) para conocer los comandos y las opciones de memoria específicos de cada modelo.

