Konfigurasi

Autentikasi

Anda harus terautentikasi dengan hf auth login untuk menjalankan Jobs, dan menggunakan token dengan izin untuk memulai dan mengelola Jobs.

Sebagai alternatif, berikan token Hugging Face secara manual dengan --token di CLI, atau argumen token di Python.

Menyampaikan argumen

Gunakan -- untuk memisahkan opsi Jobs dari perintah atau skrip Anda beserta argumennya. Opsi setelah --, seperti --help atau --timeout, diteruskan apa adanya dan tidak diinterpretasikan oleh Jobs. Hal ini berlaku untuk Jobs UV dan Docker.

hf jobs uv run --flavor t4-small -- script.py --early-stopping-patience 3
               └─ Jobs option ┘    └─ script + arguments ─────────────┘

UV Jobs

Tentukan skrip UV atau perintah python yang akan dijalankan seperti yang Anda lakukan dengan UV:

>>> hf jobs uv run train.py

>>> hf jobs uv run python -c 'print("Hello from the cloud!")'

Perintah hf jobs uv run menerima argumen UV seperti --with dan --python. Argumen --with memungkinkan Anda menentukan dependensi python, dan --python memungkinkan Anda memilih versi python yang akan digunakan:

>>> hf jobs uv run --with trl train.py
>>> hf jobs uv run --python 3.12 train.py

Sebagai contoh, berikan argumen ke perintah menggunakan --:

>>> hf jobs uv run --with trl-jobs -- trl-jobs sft --model_name Qwen/Qwen3-0.6B --dataset_name trl-lib/Capybara

Temukan daftar semua argumen dalam dokumentasi CLI dan dokumentasi Perintah UV.

Secara default, UV Jobs berjalan dengan image Docker ghcr.io/astral-sh/uv:python3.12-bookworm, tetapi Anda dapat menggunakan image lain selama image tersebut memiliki UV yang terinstal, dengan menggunakan --image <docker-image>.

Lihat Menggunakan gambar Docker untuk memilih gambar dan memahami bagaimana lingkungannya berinteraksi dengan dependensi UV.

Definisikan konfigurasi peluncuran dalam skrip

Skrip yang hanya berjalan dengan benar pada runtime tertentu (image, varian GPU, atau interpreter sistem tertentu) dapat membawa konfigurasi tersebut bersamanya, dalam tabel opsional [tool.hf-jobs] di header PEP 723-nya:

# /// 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 kemudian meluncurkan pada image dan hardware tersebut. uv run biasa mengabaikan tabel, karena tabel [tool.*] merupakan bagian dari PEP 723 dan tool melewatkan tabel yang bukan miliknya.

Kunci yang didukung, semuanya opsional: image, flavor, python, timeout, name, namespace, env, secrets, labels, volumes, network_group dan network_aliases. Mereka dipetakan ke flag dengan nama yang sama. Nilai dari skrip adalah nilai default: flag eksplisit selalu menang, dan env, secrets, labels serta volumes digabungkan per entri, sehingga -e dan -v menambah apa yang dideklarasikan oleh skrip. Kunci yang tidak dikenal adalah kesalahan, dan secrets hanya mencantumkan nama: nilainya berasal dari lingkungan dari siapa pun yang menjalankan skrip, dan secret yang tidak disetel secara lokal juga merupakan kesalahan.

Gunakan --dry-run untuk mencetak konfigurasi yang telah diselesaikan tanpa mengirimkannya; nilai yang berasal dari skrip ditandai (from script). Lihat panduan CLI hf untuk aturan penggabungan lengkap.

Tabel ini hanya dibaca oleh CLI hf. run_uv_job() dan create_scheduled_uv_job() mengabaikannya, jadi berikan image=, flavor=, … secara eksplisit dari Python.

Docker Jobs

Tentukan gambar Docker dan perintah yang akan dijalankan seperti yang Anda lakukan dengan docker:

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

Di sini, --help mencapai Python alih-alih menampilkan bantuan Jobs:

>>> hf jobs run --flavor cpu-basic python:3.12 -- python --help

Temukan daftar semua argumen dalam dokumentasi CLI.

Lihat Menggunakan image Docker untuk contoh penggunaan image yang sudah ada dan image yang dibangun oleh Docker Spaces.

Variabel lingkungan dan Secrets

Variabel lingkungan bawaan

Sama seperti variabel lingkungan bawaan di Spaces, Jobs secara otomatis menyediakan variabel lingkungan berikut di dalam container:

Anda dapat menggunakan variabel-variabel ini untuk melacak output, menyesuaikan kode Anda dengan sumber daya yang tersedia, atau merujuk pada pekerjaan saat ini secara programatik:

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

Variabel lingkungan yang didefinisikan pengguna

Anda dapat meneruskan variabel lingkungan ke pekerjaan Anda menggunakan

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

Gunakan --secrets HF_TOKEN untuk meneruskan token Hugging Face lokal Anda secara implisit. Dengan sintaks ini, secret diambil dari variabel lingkungan. Untuk HF_TOKEN, file token yang terletak di folder home Hugging Face dapat dibaca jika variabel lingkungan tidak disetel.

Volume

Pasang repositori Hugging Face (model, dataset), Storage Buckets, atau direktori lokal sebagai volume di dalam kontainer tugas Anda menggunakan -v atau --volume. Sumber Hub menggunakan skema URL hf://: hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]; direktori lokal diteruskan langsung sebagai sumber.

Karena file yang dimuat diambil secara malas (lazy), proses mounting memungkinkan Job bekerja dengan dataset yang jauh lebih besar daripada disk lokalnya. Lihat Memproses Dataset Besar untuk mounting, streaming, dan pemrosesan data besar pada Jobs.

Jenis volume:

Lalu gunakan volume yang dipasang sebagai direktori lokal di dalam kontainer:

# 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

Beberapa volume dapat dipasang dengan mengulang flag -v:

>>> hf jobs run -v hf://datasets/username/my-dataset:/data -v hf://buckets/username/my-bucket:/output \
...     python:3.12 python script.py

Model dan dataset selalu dipasang sebagai hanya-baca. Bucket penyimpanan bersifat baca-tulis secara default, yang berguna untuk menyimpan output, checkpoint, atau hasil antara. Gunakan :ro untuk memasang bucket dalam mode hanya-baca:

>>> hf jobs run -v hf://buckets/username/my-bucket:/mnt:ro python:3.12 ls /mnt

Direktori lokal

Menyampaikan direktori lokal sebagai sumber akan menyinkronkannya ke Storage Bucket jobs-artifacts privat Anda (dibuat secara otomatis) sebelum Job dimulai, lalu memount-nya di dalam container. Direktori lokal secara default dimount read-only; gunakan :rw untuk menulis output:

>>> hf jobs uv run -v ./pdfs:/input -v ./md-out:/output:rw ocr.py

Sinkronisasi ulang direktori yang sama hanya mengunggah file baru atau yang telah dimodifikasi. Untuk mengambil file yang ditulis oleh Job ke volume baca-tulis, sinkronkan kembali folder bucket-nya setelah Job selesai — CLI akan mencetak perintah hf buckets sync yang tepat saat Job dimulai. Job terjadwal juga berfungsi: direktori disinkronkan sekali saat jadwal dibuat, dan setiap pemicu memuat folder yang sama. Di Python, gunakan sync_job_volume.

Di Python, gunakan kelas 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"),
    ],
)

Volume mounting membutuhkan huggingface_hub >= 1.8.0. Lihat dokumentasi klien Python dan panduan instalasi untuk detail lebih lanjut.

Rasa perangkat keras

Jalankan tugas pada GPU atau TPU dengan argumen flavor. Misalnya, untuk menjalankan tugas PyTorch pada 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()}')"

Menjalankan ini akan menampilkan output berikut!

This code ran with the following GPU: NVIDIA A10G

Berikut adalah contoh lain untuk menjalankan skrip fine-tuning seperti 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 ...

Untuk panduan komprehensif tentang menjalankan tugas pelatihan model dengan TRL pada infrastruktur Hugging Face, lihat dokumentasi Pelatihan TRL Jobs. Dokumentasi ini mencakup resep fine-tuning, pemilihan perangkat keras, dan praktik terbaik untuk melatih model secara efisien.

Lihat daftar opsi --flavor yang tersedia menggunakan perintah hf jobs hardware (default adalah 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

Buka Port

Jobs dapat mengekspos port container melalui proxy jobs publik menggunakan --expose <port> (CLI) atau expose=[<port>] (Python API). Setiap port yang diekspos dapat diakses di https://<job_id>--<port>.hf.jobs dan memerlukan token HF dengan akses read ke namespace job tersebut:

curl -H "Authorization: Bearer $HF_TOKEN" https://<job_id>--<port>.hf.jobs/

Ini berfungsi pada hf jobs run, hf jobs uv run, dan varian terjadwalnya. Ulangi flag untuk mengekspos beberapa port (--expose 8000 --expose 8001), atau berikan beberapa port dalam daftar (expose=[8000, 8001]).

Untuk membuat port dapat diakses tanpa token HF, gunakan --expose-public <port> (CLI) atau expose_public=[<port>] (Python API) sebagai gantinya. Siapa pun yang memiliki URL dapat mengakses port tersebut, jadi gunakan opsi ini hanya untuk layanan yang aman untuk dibagikan. Anda dapat menggabungkan kedua opsi: beberapa port kemudian memerlukan token HF dan yang lainnya bersifat publik.

Port yang diekspos dikenakan biaya tetap kecil per jam di atas harga hardware pekerjaan, hanya selama pekerjaan berjalan. Lihat halaman harga untuk detailnya.

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

Ubah port dari Job yang sedang berjalan

Gunakan hf jobs expose untuk mengubah port mana yang diekspos, tanpa perlu memulai ulang 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

Perintah ini menggantikan daftar lengkap port yang diekspos, sehingga port yang tidak Anda cantumkan akan ditutup. Di Python, gunakan update_job_expose.

SSH

Anda dapat membuka sesi SSH interaktif ke Job yang sedang berjalan untuk melakukan debug, inspeksi, atau bekerja langsung di dalam container. Aktifkan saat pembuatan job dengan --ssh (CLI) atau ssh=True (Python API), lalu hubungkan dengan hf jobs ssh <job_id>.

Hanya pengguna dengan akses Write ke namespace Job yang diizinkan (yaitu, pembuat Job, atau anggota organisasi pemilik dengan izin Write). Autentikasi dilakukan melalui kunci publik SSH yang terdaftar di https://huggingface.co/settings/keys.

SSH tersedia di hf jobs run dan hf jobs uv run. Tidak didukung untuk pekerjaan terjadwal.

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

Anda juga dapat mencetak perintah SSH tanpa menjalankannya (--dry-run), atau melewatkan file identitas tertentu (-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'

Lalu hubungkan dari terminal dengan hf jobs ssh <job_id>, atau langsung dengan ssh <job_id>@ssh.hf.jobs.

Port forwarding

Karena ini adalah koneksi SSH biasa, Anda dapat menggunakan flag -L dan -R SSH untuk meneruskan port antara mesin Anda dan Job. Hubungkan langsung dengan ssh (gunakan hf jobs ssh <job_id> --dry-run untuk mendapatkan tujuan yang tepat) dan tambahkan flag penerusan.

Gunakan -L (lokal forwarding) untuk mengakses layanan yang berjalan di dalam Job dari mesin Anda. Misalnya, untuk menjangkau TensorBoard yang dimulai di Job pelatihan:

# Forward local port 6006 to the Job's TensorBoard on port 6006
>>> ssh -L 6006:localhost:6006 6a2bd1f1871c005b5352ad31@ssh.hf.jobs

Lalu buka http://localhost:6006 di browser Anda.

Gunakan -R (remote forwarding) agar Job dapat mengakses layanan yang berjalan di mesin Anda. Misalnya, untuk mengekspos database atau API lokal ke Job:

# Make your local port 8080 reachable from inside the Job on port 8080
>>> ssh -R 8080:localhost:8080 6a2bd1f1871c005b5352ad31@ssh.hf.jobs

Grup jaringan

Jobs dapat bergabung ke grup jaringan menggunakan --network-group <name> (CLI) atau network_group="<name>" (Python API). Jobs dalam namespace dan resource group yang sama yang berbagi grup dapat saling menjangkau di setiap port: HF_NETWORK_GROUP_HOSTNAME teresolusi ke setiap anggota, dan ${HF_NETWORK_GROUP_PREFIX}<alias> ke anggota yang mengklaim alias dengan --network-alias <alias> (CLI) atau network_aliases=[<alias>] (Python API).

Ini berfungsi pada hf jobs run dan hf jobs uv run. Anggota dapat diresolusi sebelum siap, sehingga hubungkan dengan retry. Nama grup dan alias adalah alfanumerik kecil dan tanda hubung, maksimal 46 dan 34 karakter; alias sebuah job harus unik.

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

Framework pelatihan multi-node dapat menggunakan alias sebagai host rendezvous, misalnya torchrun --master_addr "${HF_NETWORK_GROUP_PREFIX}master".

Timeout

Jobs memiliki timeout default (30 menit), setelah itu mereka akan berhenti secara otomatis. Hal ini penting untuk diketahui saat menjalankan tugas jangka panjang seperti pelatihan model.

Anda dapat menentukan nilai timeout khusus menggunakan parameter --timeout saat menjalankan job. Timeout dapat ditentukan dengan dua cara:

1. Sebagai angka (diartikan sebagai detik):

Gunakan --timeout dan masukkan angka dalam detik (di sini 2 jam = 7200 detik):

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

2. Sebagai string dengan satuan waktu:

Atau gunakan --timeout dan gunakan satuan waktu yang berbeda:

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

Contoh lainnya:

--timeout 30m    # 30 minutes
--timeout 1.5h   # 1.5 hours
--timeout 1d     # 1 day
--timeout 3600s  # 3600 seconds

Satuan waktu yang didukung:

• s - detik
• m - menit
• h - jam
• d - hari

Jika Anda tidak menentukan timeout, timeout default akan diterapkan pada job Anda. Untuk tugas berdurasi panjang seperti pelatihan model yang mungkin memakan waktu berjam-jam, pastikan untuk mengatur timeout yang sesuai guna menghindari pengakhiran job yang tidak terduga.

Percobaan Ulang

Secara default, sebuah Job berjalan sekali. Gunakan --attempts <n> (CLI) atau attempts=<n> (Python API) untuk mengulang Job yang gagal. Jumlah ini mencakup eksekusi pertama, sehingga --attempts 3 memungkinkan hingga dua percobaan ulang:

>>> hf jobs uv run --attempts 3 --flavor a10g-large train.py

Ini berfungsi pada hf jobs run, hf jobs uv run, dan varian terjadwalnya.

Retry menjalankan ulang perintah dari awal, di bawah Job ID yang sama. Agar retry dapat melanjutkan dari titik di mana percobaan sebelumnya berhenti, tulis checkpoint ke bucket yang dimount dan pastikan skrip Anda melanjutkan dari checkpoint tersebut. Lihat Setelah selesai di Train Models on Jobs.

Namespace

Jalankan Jobs di bawah akun organisasi Anda menggunakan argumen --namespace. Pastikan Anda telah masuk dengan token yang memiliki izin untuk memulai dan mengelola Jobs di bawah akun organisasi Anda.

>>> hf jobs uv run --namespace my-org-name python -c "print('Running in an org account')"

Perhatikan bahwa Anda dapat meneruskan token dengan izin yang tepat secara manual:

>>> hf jobs uv run --namespace my-org-name --token hf_xxx python -c "print('Running in an org account')"

Label

Tambahkan satu atau lebih label ke Job untuk menambahkan beberapa metadata dengan -l atau --label. Anda dapat menggunakan metadata tersebut kemudian untuk memfilter Job di situs web atau di CLI.

Tambahkan label dengan --label my-label atau label key-value dengan --label key=value. Kunci dan nilai dapat berisi huruf, angka, - dan _. Sebagai contoh:

hf jobs uv run --label fine-tuning --label model=Qwen3-06B --label dataset=Capybara ...

Perhatikan bahwa penggunaan key yang sama beberapa kali menyebabkan key=value terakhir menimpa dan membuang label sebelumnya dengan key.

Beri Nama Pekerjaan

Beri nama Job agar lebih mudah ditemukan dan diidentifikasi di UI. Nama disimpan sebagai label name dan tidak harus unik. Di UI, Job akan dikelompokkan berdasarkan nama.

hf jobs run --name daily-report python:3.12 python report.py

Jika Anda tidak meneruskan --name, Job diberi nama berdasarkan image Docker atau skripnya ditambah hash pendek dari perintah, sehingga eksekusi ulang dari perintah yang sama berbagi nama yang sama, sementara perintah yang berbeda mendapatkan nama yang berbeda (misalnya python-3-12-6b9d662c untuk Job yang berjalan di python:3.12).

Perbarui label

Perbarui label pada Job yang sudah ada dengan hf jobs labels. Menjalankan --label akan mengganti semua label yang ada; menjalankan --name saja akan mempertahankannya:

# 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