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.

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:

>>> hf jobs uv run train.py

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

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

>>> 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 y la documentación de los comandos de UV.

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 <docker-image>.

Consulte Uso de imágenes de Docker 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:

# /// 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 para conocer todas las reglas de fusión.

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:

>>> hf jobs run ubuntu echo "Hello from the cloud!"

Aquí, --help llega a Python en lugar de mostrar la ayuda de Jobs:

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

Consulte Uso de imágenes de Docker 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, los Jobs proporcionan automáticamente las siguientes variables de entorno dentro del contenedor:

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:

# 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

# Pass environment variables
>>> hf jobs uv run -e FOO=foo -e BAR=bar python -c 'import os; print(os.environ["FOO"], os.environ["BAR"])'

# 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"])'

# 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"])'

# 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"])'

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

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 para obtener información sobre el montaje, la transmisión y el procesamiento de grandes volúmenes de datos en Jobs.

Tipos de volumen:

Luego, use el volumen montado como un directorio local dentro del contenedor:

# 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:

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

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

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

En Python, usa la clase Volume:

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"),
    ],
)

El montaje de volúmenes requiere huggingface_hub >= 1.8.0. Consulte la documentación del cliente de Python y la guía de instalación 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:

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

>>> hf jobs uv run --with trl --flavor a10g-small -s HF_TOKEN -- sft.py --model_name_or_path Qwen/Qwen2-0.5B ...

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. 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):

>>> 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 <port> (CLI) o expose=[<port>] (API de Python). Cada puerto expuesto es accesible en https://<job_id>--<port>.hf.jobs y requiere un token de HF con acceso de read al espacio de nombres del trabajo:

curl -H "Authorization: Bearer $HF_TOKEN" https://<job_id>--<port>.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 <port> (CLI) o expose_public=[<port>] (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.

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 para obtener más detalles.

CLI

# 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

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

# Expose port 8000 (requires an HF token)
>>> hf jobs expose <job_id> 8000

# Expose port 8000 (requires an HF token) and port 9000 publicly
>>> hf jobs expose <job_id> 8000 --public 9000

# Close all exposed ports
>>> hf jobs expose <job_id> --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 <job_id>.

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.

SSH está disponible en hf jobs run y hf jobs uv run. No se admite para trabajos programados.

CLI

# 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):

>>> hf jobs ssh 6a2bd1f1871c005b5352ad31 --dry-run
ssh 6a2bd1f1871c005b5352ad31@ssh.hf.jobs

>>> hf jobs ssh 6a2bd1f1871c005b5352ad31 -i ~/.ssh/id_ed25519

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 <job_id>, o directamente con ssh <job_id>@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 <job_id> --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:

# 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 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:

# 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 <name> (CLI) o network_group="<name>" (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}<alias> a los miembros que reclamaron un alias con --network-alias <alias> (CLI) o network_aliases=[<alias>] (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

# 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

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

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

>>> hf jobs uv run --timeout 2h --with torch --flavor a10g-large train.py

Otros ejemplos:

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

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 <n> (CLI) o attempts=<n> (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:

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

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

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

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.

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:

# Replace the labels on a Job
hf jobs labels <job_id> --label env=prod --label team=ml

# Name an existing Job (keeps its other labels)
hf jobs labels <job_id> --name daily-report

# Remove all labels from a Job
hf jobs labels <job_id> --clear