Yapılandırma

Kimlik Doğrulama

Jobs'ı çalıştırmak için hf auth login ile kimlik doğrulamanız gerekir ve Jobs'ı başlatma ve yönetme iznine sahip bir jeton kullanmalısınız.

Alternatif olarak, bir Hugging Face jetonunu CLI'de --token ile veya Python'da token argümanı ile manuel olarak geçebilirsiniz.

Argümanların geçirilmesi

-- işareti, Jobs seçeneklerini komutunuz veya betiğiniz ile argümanlarından ayırmak için kullanılır. -- işaretinden sonraki --help veya --timeout gibi seçenekler, Jobs tarafından yorumlanmak yerine olduğu gibi iletilir. Bu durum hem UV hem de Docker Jobs için geçerlidir.

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

UV İşleri

UV ile yapacağınız gibi, çalıştırılacak UV betiğini veya python komutunu belirtin:

>>> hf jobs uv run train.py

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

hf jobs uv run komutu, --with ve --python gibi bir UV argümanı kabul eder. --with argümanı Python bağımlılıklarını belirtmenizi sağlar, --python ise kullanılacak Python sürümünü seçmenizi sağlar:

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

Örneğin, -- kullanarak bir komuta argümanlar geçirin:

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

CLI belgeleri ve UV Komutları belgeleri içindeki tüm argümanların listesini bulun.

Varsayılan olarak UV Jobs, ghcr.io/astral-sh/uv:python3.12-bookworm Docker görüntüsüyle çalışır ancak UV yüklü olduğu sürece --image <docker-image> kullanarak başka bir görüntü de kullanabilirsiniz.

Bir görüntü seçmek ve ortamının UV bağımlılıklarıyla nasıl etkileşime girdiğini anlamak için Docker görüntülerini kullanma bölümüne bakın.

Betik içinde başlatma yapılandırmasını tanımlayın

Belirli bir çalışma zamanında (belirli bir görüntü, GPU türü veya sistem yorumlayıcısı) yalnızca doğru çalışan bir betik, bu yapılandırmayı PEP 723 başlığında isteğe bağlı [tool.hf-jobs] tablosuyla birlikte taşıyabilir:

# /// 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 ardından bu görüntü ve donanım üzerinde başlatılır. Sadece uv run tabloyu yok sayar, çünkü [tool.*] tabloları PEP 723’ün bir parçasıdır ve araçlar sahip olmadıkları tabloları atlar.

Desteklenen anahtarlar, tümü isteğe bağlıdır: image, flavor, python, timeout, name, namespace, env, secrets, labels, volumes, network_group ve network_aliases. Bunlar, aynı adlı bayraklara eşlenir. Betikten gelen değerler varsayılanlardır: açıkça belirtilen bir bayrak her zaman önceliklidir ve env, secrets, labels ile volumes girdi girdi birleştirilir; bu nedenle -e ve -v, betiğin bildirdiği değerlere eklenir. Bilinmeyen bir anahtar hata olarak değerlendirilir ve secrets yalnızca adları listeler: değerler, betiği çalıştıran kişinin ortamından gelir ve yerel olarak ayarlanmamış bir gizli değer de hata olarak ele alınır.

Çözümlemeyi göndermeden çözümlenmiş yapılandırmayı yazdırmak için --dry-run kullanın; betikten gelen değerler (from script) olarak işaretlenir. Tam birleştirme kuralları için hf CLI kılavuzuna bakın.

Tablo yalnızca hf CLI tarafından okunur. run_uv_job() ve create_scheduled_uv_job() bunu yoksayar, bu nedenle image=, flavor=, … değerlerini Python'dan açıkça iletin.

Docker İşleri

Docker'da olduğu gibi Docker görüntüsünü ve çalıştırılacak komutu belirtin:

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

Burada, --help komutu Jobs yardımını göstermek yerine Python'a iletilir:

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

Tüm argümanların listesini CLI belgelerinde bulabilirsiniz.

Mevcut görüntülerin ve Docker Spaces tarafından oluşturulan görüntülerin kullanımına dair örnekler için Docker görüntülerini kullanma başlığını inceleyin.

Ortam değişkenleri ve Gizli Bilgiler

Yerleşik ortam değişkenleri

Spaces'teki yerleşik ortam değişkenleri gibi, Jobs, konteynerin içinde aşağıdaki ortam değişkenlerini otomatik olarak sağlar:

Bu değişkenleri çıktıları izlemek, kodunuzu mevcut kaynaklara uyarlamak veya mevcut işi programatik olarak referans almak için kullanabilirsiniz:

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

Kullanıcı tanımlı ortam değişkenleri

İşinize ortam değişkenlerini şu şekilde iletebilirsiniz

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

Yerel Hugging Face tokeninizi örtük olarak iletmek için --secrets HF_TOKEN kullanın. Bu sözdizimiyle gizli değer, ortam değişkeninden alınır. HF_TOKEN için, ortam değişkeni ayarlanmamışsa Hugging Face ana klasöründeki token dosyasını okuyabilir.

Hacimler

Hugging Face depolarını (modeller, veri kümeleri), Storage Buckets veya yerel dizinleri, -v veya --volume kullanarak iş konteynerinizde hacim olarak bağlayın. Hub kaynakları hf:// URL şemasını kullanır: hf://[TYPE/]SOURCE:/MOUNT_PATH[:ro]; yerel bir dizin doğrudan kaynak olarak geçirilir.

Yüklü dosyalar tembel (lazy) olarak getirildiğinden, yükleme (mounting) bir Job'ın yerel diskinden çok daha büyük veri kümeleriyle çalışmasını sağlar. Yükleme, akış (streaming) ve Job'larda büyük verileri işleme hakkında Büyük Veri Kümelerini İşleme bölümüne bakın.

Hacim türleri:

Ardından, konteyner içinde bağlı birimi yerel bir dizin olarak kullanın:

# 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

Birden çok hacim, -v bayrağını tekrarlayarak bağlanabilir:

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

Modeller ve veri setleri her zaman sadece okunur olarak bağlanır. Depolama varlıkları varsayılan olarak okuma-yazma modundadır; bu, çıktıları, denetim noktalarını veya ara sonuçları kaydetmek için kullanışlıdır. Bir varlığı salt okunur modda bağlamak için :ro kullanın:

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

Yerel dizinler

Yerel bir dizini kaynak olarak iletme, İş başlatılmadan önce onu özel jobs-artifacts Depolama Kova (otomatik olarak oluşturulur) ile senkronize eder ve ardından konteynerde bağlar. Yerel dizinler varsayılan olarak sadece okunur olarak bağlanır; çıktıları yazmak için :rw kullanın:

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

Aynı dizinin yeniden senkronize edilmesi yalnızca yeni veya değiştirilmiş dosyaları yükler. Bir Job'un okuma-yazma birimine yazdığı dosyaları almak için, Job tamamlandığında varil klasörünü geri senkronize edin — CLI, Job başladığında tam hf buckets sync komutunu görüntüler. Zamanlanmış işler de çalışır: dizin, zamanlama oluşturulduğunda bir kez senkronize edilir ve her tetikleme aynı klasörü bağlar. Python'da sync_job_volume kullanın.

Python'da Volume sınıfını kullanın:

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

Hacim bağlama işlemi için huggingface_hub >= 1.8.0 gereklidir. Daha fazla ayrıntı için Python istemcisi belgelerini ve kurulum kılavuzunu inceleyin.

Donanım türü

İşleri flavor argümanını kullanarak GPU veya TPU üzerinde çalıştırın. Örneğin, bir PyTorch işini A10G GPU üzerinde çalıştırmak için:

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

Bunu çalıştırdığınızda aşağıdaki çıktı görüntülenir!

This code ran with the following GPU: NVIDIA A10G

trl/scripts/sft.py gibi bir ince ayar betiğini çalıştırmak için bir başka örnek:

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

Hugging Face altyapısında TRL ile model eğitim işlerini çalıştırmaya dair kapsamlı yönergeler için TRL Jobs Eğitim belgelerini inceleyin. Bu belgeler, ince ayar tarifleri, donanım seçimi ve modelleri verimli bir şekilde eğitmek için en iyi uygulamaları kapsamaktadır.

hf jobs hardware komutunu kullanarak kullanılabilir --flavor seçeneklerinin listesini görüntüleyin (varsayılan cpu-basic’tir):

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

Portları Aç

Görevler, --expose <port> (CLI) veya expose=[<port>] (Python API) kullanarak genel görevler vekili aracılığıyla konteyner portlarını açabilir. Her açılan port, https://<job_id>--<port>.hf.jobs adresinden erişilebilir ve görevin ad alanına read erişimine sahip bir HF jetonu gerektirir:

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

Bu, hf jobs run, hf jobs uv run ve zamanlanmış varyantlarında çalışır. Birden fazla portu açmak için bayrağı tekrarlayın (--expose 8000 --expose 8001) veya listede birden fazla port geçirin (expose=[8000, 8001]).

Bir portu HF token gerektirmedene erişilebilir kılmak için bunun yerine --expose-public <port> (CLI) veya expose_public=[<port>] (Python API) kullanın. URL'ye sahip herkes portu erişebilir, bu nedenle yalnızca paylaşılması güvenli olan bir hizmet için kullanın. Her iki seçeneği birleştirebilirsiniz: bazı portlar HF token gerektirirken diğerleri herkese açıktır.

Açık portlar, yalnızca iş çalışırken, işin donanım fiyatının üzerine küçük bir sabit saatlik ücret olarak faturalandırılır. Ayrıntılar için fiyatlandırma sayfasına bakın.

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

Çalışan bir Job'un portlarını değiştirme

Job'u yeniden başlatmadan hangi portların açılacağını değiştirmek için hf jobs expose kullanın:

# 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

Komut, maruz bırakılan portların tam listesini değiştirir; bu nedenle listede yer almayan bir port kapatılır. Python'da update_job_expose kullanın.

SSH

Çalışan bir Job'a hata ayıklama, inceleme veya konteynerin içinde doğrudan çalışma amacıyla etkileşimli bir SSH oturumu açabilirsiniz. Bunu, iş oluşturulurken --ssh (CLI) veya ssh=True (Python API) ile etkinleştirin, ardından hf jobs ssh <job_id> komutuyla bağlanın.

Yalnızca İş'in ad alanına (namespace) Yazma erişimine sahip kullanıcılar (yani İş oluşturucusu veya Yazma izinlerine sahip sahip organizasyonun üyeleri) izin verilir. Kimlik doğrulama, https://huggingface.co/settings/keys adresinde kayıtlı SSH genel anahtarları (public key) aracılığıyla gerçekleştirilir.

SSH, hf jobs run ve hf jobs uv run komutlarında kullanılabilir. Zamanlanmış işler için desteklenmez.

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

Komutu çalıştırmadan SSH komutunu da yazdırabilirsiniz (--dry-run) veya belirli bir kimlik dosyası iletebilirsiniz (-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'

Ardından bir terminalden hf jobs ssh <job_id> ile bağlanın veya doğrudan ssh <job_id>@ssh.hf.jobs ile bağlanın.

Port yönlendirme

Bu normal bir SSH bağlantısı olduğu için, makineniz ile Job arasında port yönlendirmesi yapmak için SSH’nin -L ve -R bayraklarını kullanabilirsiniz. Doğrudan ssh ile bağlanın (tam hedefi almak için hf jobs ssh <job_id> --dry-run kullanın) ve yönlendirme bayraklarını ekleyin.

Makinenizden Job içinde çalışan bir servise erişmek için -L (yerel yönlendirme) kullanın. Örneğin, bir eğitim Job'ında başlatılan bir TensorBoard'a ulaşmak için:

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

Ardından tarayıcınızda http://localhost:6006 adresini açın.

İşin (Job) makinenizde çalışan bir servise erişebilmesi için -R (uzak yönlendirme) kullanın. Örneğin, yerel bir veritabanını veya API'yi İşe (Job) açmak için:

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

Ağ grupları

İşler, --network-group <name> (CLI) veya network_group="<name>" (Python API) kullanarak bir ağ grubuna katılabilir. Aynı namespace ve kaynak grubunda bir grubu paylaşan işler, her port üzerinden birbirine erişebilir: HF_NETWORK_GROUP_HOSTNAME tüm üyelere, ${HF_NETWORK_GROUP_PREFIX}<alias> ise --network-alias <alias> (CLI) veya network_aliases=[<alias>] (Python API) ile bir takma ad talep eden üyelere çözümlenir.

Bu, hf jobs run ve hf jobs uv run komutlarında çalışır. Üyeler hazır olmadan önce de çözümlenebilir, bu nedenle yeniden denemelerle bağlantı kurun. Grup adları ve takma adları küçük harfli alfanümerik karakterlerden ve tirelerden oluşur; en fazla 46 ve 34 karakter olabilir; bir işin takma adları benzersiz olmalıdır.

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

Çok düğümlü eğitim çerçeveleri, buluşma ana makinesi olarak bir takma ad kullanabilir, örneğin torchrun --master_addr "${HF_NETWORK_GROUP_PREFIX}master".

Zaman aşımı

İşlerin varsayılan bir zaman aşımı (30 dakika) vardır; bu süre dolduğunda işler otomatik olarak durdurulur. Model eğitimi gibi uzun süreli görevleri çalıştırırken bunu bilmek önemlidir.

Bir iş çalıştırırken --timeout parametresi kullanarak özel bir zaman aşımı değeri belirleyebilirsiniz. Zaman aşımı iki şekilde belirtilebilir:

1. Sayı olarak (saniye olarak yorumlanır):

--timeout kullanın ve saniye cinsinden sayıyı iletin (burada 2 saat = 7200 saniye):

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

2. Zaman birimleriyle bir dize olarak:

Veya --timeout parametresini farklı zaman birimleri ile kullanın:

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

Diğer örnekler:

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

Desteklenen zaman birimleri:

• s - saniye
• m - dakika
• h - saat
• d - günler

Zaman aşımı belirtmezseniz, işinize varsayılan bir zaman aşımı uygulanır. Saatler sürebilen model eğitimi gibi uzun süreli görevlerde, beklenmeyen iş sonlandırmalarını önlemek için uygun bir zaman aşımı ayarlamayı unutmayın.

Yeniden denemeler

Varsayılan olarak bir Job bir kez çalışır. Başarısız olan bir Job’u yeniden denemek için --attempts <n> (CLI) veya attempts=<n> (Python API) kullanın. Sayı ilk çalışmayı da içerdiğinden, --attempts 3 en fazla iki yeniden denemeye izin verir:

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

Bu, hf jobs run, hf jobs uv run ve zamanlanmış varyantlarında çalışır.

Retry, komutu aynı Job ID altında baştan tekrar çalıştırır. Bir retry'in önceki denemenin durduğu yerden devam etmesini sağlamak için checkpoint'leri bağlı bir kovaya (bucket) yazdırın ve script'inizden bunlardan devam etmesini sağlayın. Train Models on Jobs içindeki After it ends bölümüne bakın.

Ad Alanı

--namespace argümanını kullanarak işleri (Jobs) organizasyon hesabınız altında çalıştırın. Organizasyon hesabınız altında işleri başlatma ve yönetme iznine sahip bir token ile oturum açtığınızdan emin olun.

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

Doğru izinlere sahip bir belirteci manuel olarak geçebileceğinizi unutmayın:

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

Etiketler

-l veya --label ile bir İşe bir veya daha fazla etiket ekleyerek bazı meta veriler ekleyebilirsiniz. Bu tür meta verileri daha sonra web sitesinde veya CLI'da İşleri filtrelemek için kullanabilirsiniz.

Etiketleri --label my-label ile veya anahtar-değer etiketlerini --label key=value ile ekleyin. Anahtarlar ve değerler harfler, rakamlar, - ve _ içerebilir. Örneğin:

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

Aynı key'in birden fazla kez kullanılmasının, key ile etiketlenmiş önceki tüm değerleri geçersiz kılıp son key=value'nin uygulanmasına neden olduğunu unutmayın.

İş Adı Ver

Arayüzde bir Job'ı bulmayı ve tanımlamayı kolaylaştırmak için ona bir ad verin. Ad, name etiketi olarak saklanır ve benzersiz olmak zorunda değildir. Arayüzde Job'lar ada göre gruplandırılır.

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

--name parametresini iletmezseniz, Job, Docker görüntüsüne veya betiğine ve komutun kısa bir özetine (hash) göre adlandırılır; böylece aynı komutun yeniden çalıştırılmaları aynı adı paylaşırken farklı komutlar farklı adlar alır (ör. python:3.12 üzerinde çalışan bir Job için python-3-12-6b9d662c).

Etiketleri güncelle

Mevcut bir Job üzerindeki etiketleri hf jobs labels ile güncelleyin. --label parametresinin geçirilmesi tüm mevcut etiketlerin yerini alır; yalnızca --name parametresinin geçirilmesi ise etiketleri korur:

# 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