# Configuración ## Autenticación Debes estar autenticado con `hf auth login` para ejecutar Jobs, y usar un token con el permiso para iniciar y gestionar Jobs. Alternativamente, pase un token de Hugging Face manualmente con `--token` en la CLI, o el argumento `token` en Python. ## Pasar argumentos Use `--` para separar las opciones de Jobs de su comando o script y sus argumentos. Las opciones posteriores a `--`, como `--help` o `--timeout`, se transmiten tal cual en lugar de ser interpretadas por Jobs. Esto se aplica tanto a los Jobs de UV como a los de Docker. ```text hf jobs uv run --flavor t4-small -- script.py --early-stopping-patience 3 └─ Jobs option ┘ └─ script + arguments ─────────────┘ ``` ## UV Jobs Especifique el script de UV o el comando de python que desea ejecutar, tal como lo haría con UV: ```bash >>> hf jobs uv run train.py ``` ```bash >>> hf jobs uv run python -c 'print("Hello from the cloud!")' ``` El comando `hf jobs uv run` acepta un argumento de UV como `--with` y `--python`. El argumento `--with` permite especificar dependencias de python, y `--python` permite elegir la versión de python a utilizar: ```bash >>> hf jobs uv run --with trl train.py >>> hf jobs uv run --python 3.12 train.py ``` Por ejemplo, pase argumentos a un comando usando `--`: ```bash >>> hf jobs uv run --with trl-jobs -- trl-jobs sft --model_name Qwen/Qwen3-0.6B --dataset_name trl-lib/Capybara ``` Encuentra la lista de todos los argumentos en la [documentación de la CLI](https://huggingface.co/docs/huggingface_hub/package_reference/cli#hf-jobs-uv-run) y la [documentación de los comandos de UV](https://docs.astral.sh/uv/reference/cli/#uv-run). Por defecto, los UV Jobs se ejecutan con la imagen de Docker `ghcr.io/astral-sh/uv:python3.12-bookworm`, pero puedes usar otra imagen siempre que tenga UV instalado, utilizando `--image `. Consulte [Uso de imágenes de Docker](./jobs-images#use-an-image-with-uv) para elegir una imagen y comprender cómo su entorno interactúa con las dependencias de UV. ### Defina la configuración de lanzamiento en el script Un script que solo se ejecuta correctamente en un entorno de ejecución específico (una imagen, un tipo de GPU o un intérprete de sistema dado) puede llevar esa configuración consigo mismo, en una tabla opcional `[tool.hf-jobs]` de su encabezado PEP 723: ```python # /// script # requires-python = ">=3.11" # dependencies = ["vllm", "datasets"] # # [tool.hf-jobs] # image = "vllm/vllm-openai:unlimited-ocr" # flavor = "l4x1" # python = "/usr/bin/python3" # secrets = ["HF_TOKEN"] # /// ``` `hf jobs uv run ocr.py` luego se lanza en esa imagen y ese hardware. Un simple `uv run` ignora la tabla, ya que las tablas `[tool.*]` forman parte de PEP 723 y las herramientas omiten las que no les pertenecen. Claves admitidas, todas opcionales: `image`, `flavor`, `python`, `timeout`, `name`, `namespace`, `env`, `secrets`, `labels`, `volumes`, `network_group` y `network_aliases`. Se corresponden con las banderas del mismo nombre. Los valores del script son valores predeterminados: una bandera explícita siempre tiene prioridad, y `env`, `secrets`, `labels` y `volumes` se combinan entrada por entrada, de modo que `-e` y `-v` se añaden a lo que declara el script. Una clave desconocida es un error, y `secrets` solo lista nombres: los valores provienen del entorno de quien ejecuta el script, y un secreto que no está definido localmente también es un error. Use `--dry-run` para imprimir la configuración resuelta sin enviarla; los valores que provienen del script se marcan como `(from script)`. Consulte la [guía de la CLI `hf`](https://huggingface.co/docs/huggingface_hub/guides/cli#ship-the-launch-config-with-the-script) para conocer todas las reglas de fusión. > [!WARNING] > La tabla solo la lee la CLI `hf`. `run_uv_job()` y `create_scheduled_uv_job()` la ignoran, por lo que debe pasar `image=`, `flavor=`, ... explícitamente desde Python. ## Docker Jobs Especifique la imagen de Docker y el comando para ejecutarlo, tal como lo haría con docker: ```bash >>> hf jobs run ubuntu echo "Hello from the cloud!" ``` Aquí, `--help` llega a Python en lugar de mostrar la ayuda de Jobs: ```bash >>> hf jobs run --flavor cpu-basic python:3.12 -- python --help ``` Encuentra la lista de todos los argumentos en la [documentación de la CLI](https://huggingface.co/docs/huggingface_hub/package_reference/cli#hf-jobs-run). Consulte [Uso de imágenes de Docker](./jobs-images) para ver ejemplos con imágenes existentes e imágenes creadas por Docker Spaces. ## Variables de entorno y Secrets ### Variables de entorno integradas De manera similar a las [variables de entorno integradas en Spaces](./spaces-overview#built-in-environment-variables), los Jobs proporcionan automáticamente las siguientes variables de entorno dentro del contenedor: | Variable | Descripción | |----------|-------------| | `JOB_ID` | El identificador único del trabajo actual (p. ej., `699d874f1aad19adb8aaeadc`). Este es el mismo ID que se muestra en la interfaz de usuario y en la URL del trabajo. | | `ACCELERATOR` | El tipo de acelerador disponible (p. ej., `t4-medium`, `a10g-small`, `a100x4`), o `none` para trabajos solo de CPU. | | `CPU_CORES` | El número de núcleos de CPU asignados al trabajo. | | `MEMORY` | La cantidad de memoria asignada al trabajo (p. ej., `8Gi`). | | `HF_NETWORK_GROUP_HOSTNAME` | Resolución del nombre de host para cada trabajo en el [grupo de red](#network-groups) del trabajo. Solo se establece cuando el trabajo declara uno. | | `HF_NETWORK_GROUP_PREFIX` | Prefijo que se antepone a un alias para obtener el nombre de host de los miembros del grupo que lo reclaman (p. ej., `${HF_NETWORK_GROUP_PREFIX}master`). Solo se establece cuando el trabajo declara un grupo de red. | Puede utilizar estas variables para hacer un seguimiento de las salidas, adaptar su código a los recursos disponibles o hacer referencia al trabajo actual de forma programática: ```bash # Access job environment information >>> hf jobs run python:3.12 python -c "import os; print(f'Job: {os.environ.get(\"JOB_ID\")}, CPU: {os.environ.get(\"CPU_CORES\")}, Mem: {os.environ.get(\"MEMORY\")}')" ``` ### Variables de entorno definidas por el usuario Puedes pasar variables de entorno a tu trabajo usando ```bash # Pass environment variables >>> hf jobs uv run -e FOO=foo -e BAR=bar python -c 'import os; print(os.environ["FOO"], os.environ["BAR"])' ``` ```bash # Pass an environment from a local .env file >>> hf jobs uv run --env-file .env python -c 'import os; print(os.environ["FOO"], os.environ["BAR"])' ``` ```bash # Pass secrets - they will be encrypted server side >>> hf jobs uv run -s MY_SECRET=psswrd python -c 'import os; print(os.environ["MY_SECRET"])' ``` ```bash # Pass secrets from a local .env.secrets file - they will be encrypted server side >>> hf jobs uv run --secrets-file .env.secrets python -c 'import os; print(os.environ["MY_SECRET"])' ``` > [!TIP] > Use `--secrets HF_TOKEN` para pasar su token local de Hugging Face de forma implícita. Con esta sintaxis, el secreto se recupera de la variable de entorno. En el caso de `HF_TOKEN`, puede leer el archivo de token ubicado en la carpeta de inicio de Hugging Face si la variable de entorno no está definida. ## Volúmenes Monta repositorios de Hugging Face (modelos, conjuntos de datos), [Storage Buckets](./storage-buckets) o directorios locales como volúmenes en el contenedor de tu trabajo usando `-v` o `--volume`. Las fuentes de Hub usan el esquema de URL `hf://`: `hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]`; un directorio local se pasa directamente como fuente. > [!TIP] > Dado que los archivos montados se obtienen de forma perezosa, el montaje permite que un Job trabaje con conjuntos de datos mucho más grandes que su disco local. Consulte [Procesar conjuntos de datos grandes](./jobs-large-datasets) para obtener información sobre el montaje, la transmisión y el procesamiento de grandes volúmenes de datos en Jobs. Tipos de volumen: | Tipo | Ejemplo | |------|---------| | Repositorio del modelo | `-v hf://openai/gpt-oss-120b:/model` | | Repositorio de datos | `-v hf://datasets/stanfordnlp/imdb:/data` | | Bucket de almacenamiento | `-v hf://buckets/username/my-bucket:/mnt` | | Subcarpeta | `-v hf://datasets/org/my-dataset/train:/data` | | Directorio local | `-v ./training-data:/data` | Luego, use el volumen montado como un directorio local dentro del contenedor: ```bash # Mount a dataset and query it with DuckDB >>> hf jobs run -v hf://datasets/stanfordnlp/imdb:/dataset \ ... duckdb/duckdb duckdb -c "SELECT * FROM '/dataset/**/*.parquet' LIMIT 5" # Mount a bucket to save training checkpoints >>> hf jobs uv run -v hf://buckets/username/my-bucket:/training-outputs \ ... sft.py --output-dir /training-outputs/training-v3-final ``` Se pueden montar varios volúmenes repitiendo la bandera `-v`: ```bash >>> hf jobs run -v hf://datasets/username/my-dataset:/data -v hf://buckets/username/my-bucket:/output \ ... python:3.12 python script.py ``` Los modelos y conjuntos de datos siempre se montan en modo **solo lectura**. Los cubos de almacenamiento son **lectura-escritura** de forma predeterminada, lo cual es útil para guardar salidas, puntos de control o resultados intermedios. Use `:ro` para montar un cubo en modo solo lectura: ```bash >>> hf jobs run -v hf://buckets/username/my-bucket:/mnt:ro python:3.12 ls /mnt ``` ### Directorios locales Al pasar un directorio local como origen, se sincroniza con tu [Storage Bucket](./storage-buckets) privado `jobs-artifacts` (creado automáticamente) antes de que comience el Job y luego se monta en el contenedor. Los directorios locales se montan de **solo lectura** de forma predeterminada; usa `:rw` para escribir salidas: ```bash >>> hf jobs uv run -v ./pdfs:/input -v ./md-out:/output:rw ocr.py ``` Volver a sincronizar el mismo directorio solo sube archivos nuevos o modificados. Para recuperar los archivos que un Job escribió en un volumen de lectura y escritura, sincronice de vuelta la carpeta de su bucket cuando el Job termine: la CLI imprime el comando exacto de `hf buckets sync` cuando el Job comienza. Los trabajos programados también funcionan: el directorio se sincroniza una vez cuando se crea la programación, y cada activación monta la misma carpeta. En Python, use [`sync_job_volume`](https://huggingface.co/docs/huggingface_hub/guides/jobs#mount-local-data). En Python, usa la clase [`Volume`](https://huggingface.co/docs/huggingface_hub/package_reference/jobs#huggingface_hub.Volume): ```python from huggingface_hub import Volume, run_job job = run_job( image="python:3.12", command=["python", "-c", "import os; print(os.listdir('/data'))"], volumes=[ Volume(type="dataset", source="username/my-dataset", mount_path="/data"), Volume(type="bucket", source="username/my-bucket", mount_path="/output"), ], ) ``` > [!NOTE] > El montaje de volúmenes requiere `huggingface_hub` >= 1.8.0. Consulte la [documentación del cliente de Python](https://huggingface.co/docs/huggingface_hub/guides/jobs#mount-a-volume) y la [guía de instalación](https://huggingface.co/docs/huggingface_hub/installation) para obtener más detalles. ## Tipo de hardware Ejecuta trabajos en GPUs o TPUs con el argumento `flavor`. Por ejemplo, para ejecutar un trabajo de PyTorch en una GPU A10G: ```bash >>> hf jobs uv run --with torch --flavor a10g-small python -c "import torch; print(f'This code ran with the following GPU: {torch.cuda.get_device_name()}')" ``` Al ejecutarlo, se mostrará la siguiente salida. ``` This code ran with the following GPU: NVIDIA A10G ``` Aquí hay otro ejemplo para ejecutar un script de ajuste fino como [trl/scripts/sft.py](https://github.com/huggingface/trl/blob/main/trl/scripts/sft.py): ```bash >>> hf jobs uv run --with trl --flavor a10g-small -s HF_TOKEN -- sft.py --model_name_or_path Qwen/Qwen2-0.5B ... ``` > [!TIP] > Para obtener una guía completa sobre la ejecución de trabajos de entrenamiento de modelos con TRL en la infraestructura de Hugging Face, consulte la [documentación de TRL Jobs Training](https://huggingface.co/docs/trl/main/en/jobs_training). Aborda recetas de ajuste fino, selección de hardware y mejores prácticas para entrenar modelos de manera eficiente. Vea la lista de opciones de `--flavor` disponibles usando el comando `hf jobs hardware` (el valor predeterminado es `cpu-basic`): ```bash >>> hf jobs hardware name pretty name cpu ram storage accelerator cost/min cost/hour cpu-basic CPU Basic 2 vCPU 16 GB 50 GB $0.0002 $0.01 cpu-upgrade CPU Upgrade 8 vCPU 32 GB 50 GB $0.0005 $0.03 cpu-performance CPU Performance 32 vCPU 256 GB 1024 GB $0.0317 $1.90 cpu-xl CPU XL 16 vCPU 124 GB 1000 GB $0.0167 $1.00 t4-small Nvidia T4 - small 4 vCPU 15 GB 50 GB 1x T4 (16 GB) $0.0067 $0.40 t4-medium Nvidia T4 - medium 8 vCPU 30 GB 100 GB 1x T4 (16 GB) $0.0100 $0.60 a10g-small Nvidia A10G - small 4 vCPU 15 GB 110 GB 1x A10G (24 GB) $0.0167 $1.00 a10g-large Nvidia A10G - large 12 vCPU 46 GB 200 GB 1x A10G (24 GB) $0.0250 $1.50 a10g-largex2 2x Nvidia A10G - large 24 vCPU 92 GB 1000 GB 2x A10G (48 GB) $0.0500 $3.00 a10g-largex4 4x Nvidia A10G - large 48 vCPU 184 GB 2000 GB 4x A10G (96 GB) $0.0833 $5.00 a100-large Nvidia A100 - large 12 vCPU 142 GB 1000 GB 1x A100 (80 GB) $0.0417 $2.50 a100x4 4x Nvidia A100 48 vCPU 568 GB 4000 GB 4x A100 (320 GB) $0.1667 $10.00 a100x8 8x Nvidia A100 96 vCPU 1136 GB 8000 GB 8x A100 (640 GB) $0.3333 $20.00 h200 Nvidia H200 23 vCPU 256 GB 3000 GB 1x H200 (141 GB) $0.0833 $5.00 h200x2 Nvidia H200 46 vCPU 512 GB 6000 GB 2x H200 (282 GB) $0.1667 $10.00 h200x4 Nvidia H200 92 vCPU 1024 GB 12000 GB 4x H200 (564 GB) $0.3333 $20.00 h200x8 Nvidia H200 184 vCPU 2048 GB 24000 GB 8x H200 (1128 GB) $0.6667 $40.00 rtx-pro-6000 Nvidia RTX PRO 6000 23 vCPU 256 GB 475 GB 1x RTX PRO 6000 (96 GB) $0.0458 $2.75 rtx-pro-6000x2 Nvidia RTX PRO 6000 46 vCPU 512 GB 950 GB 2x RTX PRO 6000 (192 GB) $0.0917 $5.50 rtx-pro-6000x4 Nvidia RTX PRO 6000 92 vCPU 1024 GB 1900 GB 4x RTX PRO 6000 (384 GB) $0.1833 $11.00 rtx-pro-6000x8 Nvidia RTX PRO 6000 184 vCPU 2048 GB 3800 GB 8x RTX PRO 6000 (768 GB) $0.3667 $22.00 l4x1 1x Nvidia L4 8 vCPU 30 GB 400 GB 1x L4 (24 GB) $0.0133 $0.80 l4x4 4x Nvidia L4 48 vCPU 186 GB 3200 GB 4x L4 (96 GB) $0.0633 $3.80 l40sx1 1x Nvidia L40S 8 vCPU 62 GB 380 GB 1x L40S (48 GB) $0.0300 $1.80 l40sx4 4x Nvidia L40S 48 vCPU 382 GB 3200 GB 4x L40S (192 GB) $0.1383 $8.30 l40sx8 8x Nvidia L40S 192 vCPU 1534 GB 6500 GB 8x L40S (384 GB) $0.3917 $23.50 ``` ## Exponer puertos Los trabajos pueden exponer puertos de contenedor a través del proxy público de trabajos mediante `--expose ` (CLI) o `expose=[]` (API de Python). Cada puerto expuesto es accesible en `https://--.hf.jobs` y requiere un token de HF con acceso de `read` al espacio de nombres del trabajo: ```bash curl -H "Authorization: Bearer $HF_TOKEN" https://--.hf.jobs/ ``` Esto funciona con `hf jobs run`, `hf jobs uv run` y sus variantes programadas. Repite la bandera para exponer varios puertos (`--expose 8000 --expose 8001`) o pasa varios puertos en la lista (`expose=[8000, 8001]`). Para hacer que un puerto sea accesible sin un token de HF, use `--expose-public ` (CLI) o `expose_public=[]` (API de Python) en su lugar. Cualquier persona que tenga la URL puede acceder al puerto, por lo que úselo solo para un servicio que sea seguro de compartir. Puede combinar ambas opciones: algunos puertos requieren un token de HF y otros son públicos. > [!NOTE] > Los puertos expuestos se facturan a una tarifa horaria fija y reducida, además del precio del hardware del trabajo, solo mientras el trabajo está en ejecución. Consulte la [página de precios](./jobs-pricing) para obtener más detalles. ### CLI ```bash # Expose a web server running on port 8000 >>> hf jobs run --expose 8000 python:3.12 python -m http.server 8000 ✓ Job started id: 6a2aa7cec4f53f9fc5aa4cff url: https://huggingface.co/jobs/Wauplin/6a2aa7cec4f53f9fc5aa4cff Hint: Exposed ports are reachable at (requires an HF token with read access to the job): https://6a2aa7cec4f53f9fc5aa4cff--8000.hf.jobs Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ... ``` ### Python ```python >>> from huggingface_hub import run_job >>> job = run_job(image="python:3.12", command=["python", "-m", "http.server", "8000"], expose=[8000]) >>> job.status.expose_urls ['https://6a2ab384c4f53f9fc5aa4d4f--8000.hf.jobs'] ``` ### Cambiar los puertos de un Job en ejecución Use `hf jobs expose` para cambiar los puertos expuestos, sin reiniciar el Job: ```bash # Expose port 8000 (requires an HF token) >>> hf jobs expose 8000 # Expose port 8000 (requires an HF token) and port 9000 publicly >>> hf jobs expose 8000 --public 9000 # Close all exposed ports >>> hf jobs expose --clear ``` El comando reemplaza la lista completa de puertos expuestos, por lo que un puerto que se omita quedará cerrado. En Python, use `update_job_expose`. ## SSH Puede abrir una sesión SSH interactiva en un Job en ejecución para depurar, inspeccionar o trabajar directamente dentro del contenedor. Habilítelo al crear el job con `--ssh` (CLI) o `ssh=True` (API de Python) y luego conéctese con `hf jobs ssh `. Solo se permite el acceso a los usuarios con permisos de escritura en el espacio de nombres del Job (es decir, el creador del Job o los miembros de la organización propietaria con permisos de escritura). La autenticación se realiza mediante claves públicas SSH registradas en [https://huggingface.co/settings/keys](https://huggingface.co/settings/keys). SSH está disponible en `hf jobs run` y `hf jobs uv run`. No se admite para trabajos programados. ### CLI ```bash # Start a job with SSH enabled >>> hf jobs run --ssh --detach --timeout 10m python:3.12 sleep infinity ✓ Job started id: 6a2bd1f1871c005b5352ad31 url: https://huggingface.co/jobs/Wauplin/6a2bd1f1871c005b5352ad31 Hint: Use `hf jobs ssh 6a2bd1f1871c005b5352ad31` to open an SSH session into the job. # Open an SSH session into the job >>> hf jobs ssh 6a2bd1f1871c005b5352ad31 ``` También puede imprimir el comando SSH sin ejecutarlo (`--dry-run`) o pasar un archivo de identidad específico (`-i`/`--identity-file`): ```bash >>> hf jobs ssh 6a2bd1f1871c005b5352ad31 --dry-run ssh 6a2bd1f1871c005b5352ad31@ssh.hf.jobs >>> hf jobs ssh 6a2bd1f1871c005b5352ad31 -i ~/.ssh/id_ed25519 ``` ### Python ```python >>> from huggingface_hub import run_job >>> job = run_job(image="python:3.12", command=["sleep", "infinity"], ssh=True) >>> job.status.ssh_url 'ssh://6a2bd1f1871c005b5352ad31@ssh.hf.jobs' ``` Luego, conéctate desde una terminal con `hf jobs ssh `, o directamente con `ssh @ssh.hf.jobs`. ### Redirección de puertos Dado que se trata de una conexión SSH regular, puedes usar las banderas `-L` y `-R` de SSH para reenviar puertos entre tu máquina y el Job. Conéctate directamente con `ssh` (usa `hf jobs ssh --dry-run` para obtener el destino exacto) y añade las banderas de reenvío. Use `-L` (reenvío local) para acceder a un servicio que se ejecuta dentro del Job desde su máquina. Por ejemplo, para llegar a un TensorBoard iniciado en un Job de entrenamiento: ```bash # Forward local port 6006 to the Job's TensorBoard on port 6006 >>> ssh -L 6006:localhost:6006 6a2bd1f1871c005b5352ad31@ssh.hf.jobs ``` Luego, abre [http://localhost:6006](http://localhost:6006) en tu navegador. Use `-R` (reenvío remoto) para permitir que el Job acceda a un servicio que se ejecuta en su máquina. Por ejemplo, para exponer una base de datos o API local al Job: ```bash # Make your local port 8080 reachable from inside the Job on port 8080 >>> ssh -R 8080:localhost:8080 6a2bd1f1871c005b5352ad31@ssh.hf.jobs ``` ## Grupos de red Los trabajos pueden unirse a un grupo de red usando `--network-group ` (CLI) o `network_group=""` (API de Python). Los trabajos en el mismo espacio de nombres y grupo de recursos que comparten un grupo pueden comunicarse entre sí en todos los puertos: `HF_NETWORK_GROUP_HOSTNAME` se resuelve a todos los miembros, y `${HF_NETWORK_GROUP_PREFIX}` a los miembros que reclamaron un alias con `--network-alias ` (CLI) o `network_aliases=[]` (API de Python). Esto funciona con `hf jobs run` y `hf jobs uv run`. Los miembros son resolubles antes de que estén listos, por lo que debe conectarse con reintentos. Los nombres de grupo y los alias son alfanuméricos en minúsculas y guiones, con un máximo de 46 y 34 caracteres respectivamente; los alias de un trabajo deben ser únicos. ### CLI ```bash # Start a server, reachable by the other members of the group as "master" >>> hf jobs run --detach --network-group train --network-alias master python:3.12 python -m http.server 8000 # Start a client in the same group >>> hf jobs run --detach --network-group train python:3.12 sh -c 'curl --retry 10 --retry-connrefused "http://${HF_NETWORK_GROUP_PREFIX}master:8000/"' ``` ### Python ```python >>> from huggingface_hub import run_job >>> server = run_job( ... image="python:3.12", ... command=["python", "-m", "http.server", "8000"], ... network_group="train", ... network_aliases=["master"], ... ) >>> client = run_job( ... image="python:3.12", ... command=["sh", "-c", 'curl --retry 10 --retry-connrefused "http://${HF_NETWORK_GROUP_PREFIX}master:8000/"'], ... network_group="train", ... ) ``` Los marcos de trabajo de entrenamiento multinodo pueden usar un alias como host de reunión, por ejemplo, `torchrun --master_addr "${HF_NETWORK_GROUP_PREFIX}master"`. ## Tiempo de espera Los trabajos tienen un tiempo de espera predeterminado (30 minutos), tras el cual se detienen automáticamente. Es importante tenerlo en cuenta al ejecutar tareas de larga duración, como el entrenamiento de modelos. Puede especificar un valor de tiempo de espera personalizado usando el parámetro `--timeout` al ejecutar un trabajo. El tiempo de espera se puede especificar de dos formas: 1. **Como un número** (interpretado como segundos): Usa `--timeout` y pasa el número en segundos (aquí 2 horas = 7200 segundos): ```bash >>> hf jobs uv run --timeout 7200 --with torch --flavor a10g-large train.py ``` 2. **Como una cadena con unidades de tiempo**: O use `--timeout` y utilice diferentes unidades de tiempo: ```bash >>> hf jobs uv run --timeout 2h --with torch --flavor a10g-large train.py ``` Otros ejemplos: ```bash --timeout 30m # 30 minutes --timeout 1.5h # 1.5 hours --timeout 1d # 1 day --timeout 3600s # 3600 seconds ``` Unidades de tiempo admitidas: - `s` - segundos - `m` - minutos - `h` - horas - `d` - días > [!WARNING] > Si no especificas un tiempo de espera, se aplicará un tiempo de espera predeterminado a tu trabajo. Para tareas de larga duración, como el entrenamiento de modelos que pueden llevar horas, asegúrate de establecer un tiempo de espera adecuado para evitar terminaciones inesperadas del trabajo. ## Reintentos Por defecto, un Job se ejecuta una sola vez. Utilice `--attempts ` (CLI) o `attempts=` (API de Python) para reintentar un Job que falla. El número incluye la primera ejecución, por lo que `--attempts 3` permite hasta dos reintentos: ```bash >>> hf jobs uv run --attempts 3 --flavor a10g-large train.py ``` Esto funciona con `hf jobs run`, `hf jobs uv run` y sus variantes programadas. Un reintento ejecuta el comando nuevamente desde el principio, bajo el mismo Job ID. Para que un reintento retome donde se detuvo el intento anterior, escribe checkpoints en un bucket montado y haz que tu script retome desde ellos. Consulta [After it ends](./jobs-training#after-it-ends) en Train Models on Jobs. ## Espacio de nombres Ejecuta Jobs en la cuenta de tu organización usando el argumento `--namespace`. Asegúrate de que has iniciado sesión con un token que tenga el permiso para iniciar y gestionar Jobs en la cuenta de tu organización. ```bash >>> hf jobs uv run --namespace my-org-name python -c "print('Running in an org account')" ``` Tenga en cuenta que puede pasar manualmente un token con el permiso adecuado: ```bash >>> hf jobs uv run --namespace my-org-name --token hf_xxx python -c "print('Running in an org account')" ``` ## Etiquetas Añade una o más etiquetas a un Job para agregar metadatos con `-l` o `--label`. Puedes usar dichos metadatos más adelante para filtrar Jobs en el sitio web o en la CLI. Añade etiquetas con `--label my-label` o etiquetas de clave-valor con `--label key=value`. Las claves y los valores pueden contener letras, dígitos, `-` y `_`. Por ejemplo: ```bash hf jobs uv run --label fine-tuning --label model=Qwen3-06B --label dataset=Capybara ... ``` Tenga en cuenta que usar la misma `key` varias veces provoca que el último `key=value` sobrescriba y descarte cualquier etiqueta anterior con `key`. ### Nombrar un trabajo Asigne un nombre a un Job para facilitar su búsqueda e identificación en la interfaz de usuario. El nombre se almacena como la etiqueta `name` y no tiene que ser único. En la interfaz de usuario, los Jobs se agrupan por nombre. ```bash hf jobs run --name daily-report python:3.12 python report.py ``` Si no pasas `--name`, el Job se nombra según su imagen de Docker o su script más un hash corto del comando, de modo que las reejecuciones del mismo comando comparten un nombre, mientras que los comandos diferentes obtienen nombres distintos (p. ej. `python-3-12-6b9d662c` para un Job que se ejecuta en `python:3.12`). ### Actualizar etiquetas Actualice las etiquetas de un Job existente con `hf jobs labels`. Si se pasa `--label`, se reemplazan todas las etiquetas existentes; si se pasa solo `--name`, se conservan: ```bash # Replace the labels on a Job hf jobs labels --label env=prod --label team=ml # Name an existing Job (keeps its other labels) hf jobs labels --name daily-report # Remove all labels from a Job hf jobs labels --clear ```