# Callback

Callbacks adalah objek yang dapat menyesuaikan perilaku loop pelatihan di [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer) PyTorch, yang dapat memeriksa status loop pelatihan (untuk pelaporan kemajuan, pencatatan log di TensorBoard atau platform ML lainnya...) dan mengambil keputusan (seperti early stopping).

Callback adalah potongan kode "hanya-baca"; selain objek [TrainerControl](/docs/transformers/main/id/main_classes/callback#transformers.TrainerControl) yang dikembalikan, callback tidak dapat mengubah apa pun di dalam loop pelatihan. Untuk kustomisasi yang memerlukan perubahan pada loop pelatihan, Anda harus membuat subclass dari [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer) dan menimpa metode yang Anda butuhkan (lihat [trainer](trainer) untuk contoh).

Secara default, `TrainingArguments.report_to` diatur ke `"none"`.

Kelas utama yang mengimplementasikan callback adalah [TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback). Kelas ini menerima [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) yang digunakan untuk menginstansiasi [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer), dapat mengakses status internal Trainer tersebut melalui [TrainerState](/docs/transformers/main/id/main_classes/callback#transformers.TrainerState), dan dapat melakukan beberapa tindakan pada loop pelatihan melalui [TrainerControl](/docs/transformers/main/id/main_classes/callback#transformers.TrainerControl).

## Callback yang Tersedia[[transformers.integrations.CometCallback]]

Berikut adalah daftar [TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang tersedia di pustaka:

#### transformers.integrations.CometCallback[[transformers.integrations.CometCallback]]

```python
transformers.integrations.CometCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1133)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mengirim log ke [Comet ML](https://www.comet.com/site/).

#### setup[[transformers.integrations.CometCallback.setup]]

```python
setup(args, state, model)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1147)

Atur integrasi Comet opsional.

Lingkungan:
- **COMET_MODE** (`str`, *opsional*, default `get_or_create`): Mengontrol apakah akan membuat dan mencatat ke eksperimen Comet baru atau menambahkan ke eksperimen yang sudah ada. Nilai yang diterima adalah:
  * `get_or_create`: Menentukan secara otomatis berdasarkan apakah `COMET_EXPERIMENT_KEY` telah diset dan apakah Experiment dengan kunci tersebut sudah ada atau belum.
  * `create`: Selalu buat Eksperimen Comet baru.
  * `get`: Selalu coba untuk menambahkan ke Eksperimen Comet yang Sudah Ada. Memerlukan `COMET_EXPERIMENT_KEY` untuk disetel.
- **COMET_START_ONLINE** (`bool`, *opsional*): Apakah akan membuat Experiment secara online atau offline.
- **COMET_PROJECT_NAME** (`str`, *opsional*): Nama proyek Comet untuk eksperimen.
- **COMET_LOG_ASSETS** (`str`, *opsional*, default `TRUE`): Menentukan apakah aset pelatihan (checkpoint, dll.) akan dicatat ke Comet. Nilainya bisa `TRUE` atau `FALSE`.

Untuk sejumlah item yang dapat dikonfigurasi di lingkungan, lihat [di sini](https://www.comet.com/docs/v2/guides/experiment-management/configure-sdk/#explore-comet-configuration-options).

#### transformers.DefaultFlowCallback[[transformers.DefaultFlowCallback]]

```python
transformers.DefaultFlowCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L563)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang menangani alur default dari loop pelatihan untuk log, evaluasi, dan checkpoint.

#### transformers.PrinterCallback[[transformers.PrinterCallback]]

```python
transformers.PrinterCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L698)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) polos yang hanya mencetak log.

#### transformers.ProgressCallback[[transformers.ProgressCallback]]

```python
transformers.ProgressCallback(max_str_len: int = 100)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L624)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang menampilkan progres pelatihan atau evaluasi. Anda dapat memodifikasi `max_str_len` untuk mengontrol seberapa panjang string dipangkas saat pencatatan log.

#### transformers.EarlyStoppingCallback[[transformers.EarlyStoppingCallback]]

```python
transformers.EarlyStoppingCallback(early_stopping_patience: int = 1, early_stopping_threshold: float | None = 0.0)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L711)

**Parameter:**

early_stopping_patience (`int`) : Digunakan bersama `metric_for_best_model` untuk menghentikan pelatihan ketika metrik yang ditentukan memburuk selama `early_stopping_patience` pemanggilan evaluasi.

early_stopping_threshold(`float`, *opsional*) : Digunakan bersama TrainingArguments `metric_for_best_model` dan `early_stopping_patience` untuk menentukan seberapa besar metrik yang ditentukan harus membaik agar kondisi early stopping terpenuhi. `

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang menangani penghentian dini.

Callback ini bergantung pada argumen [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) *load_best_model_at_end* untuk mengatur best_metric di [TrainerState](/docs/transformers/main/id/main_classes/callback#transformers.TrainerState). Perhatikan bahwa jika argumen [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) *save_steps* berbeda dari *eval_steps*, early stopping tidak akan terjadi hingga langkah penyimpanan berikutnya.

#### transformers.integrations.TensorBoardCallback[[transformers.integrations.TensorBoardCallback]]

```python
transformers.integrations.TensorBoardCallback(tb_writer = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L577)

**Parameter:**

tb_writer (`SummaryWriter`, *opsional*) : Writer yang akan digunakan. Akan menginstansiasi satu jika tidak disetel.

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mengirim log ke [TensorBoard](https://www.tensorflow.org/tensorboard).

Lingkungan:
- **TENSORBOARD_LOGGING_DIR** (`str`, *opsional*, default `None`): Direktori logging untuk mencatat hasil. Nilai default adalah os.path.join(args.output_dir, default_logdir())

#### transformers.integrations.TrackioCallback[[transformers.integrations.TrackioCallback]]

```python
transformers.integrations.TrackioCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L935)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mencatat metrik ke Trackio.

#### setup[[transformers.integrations.TrackioCallback.setup]]

```python
setup(args, state, model, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L969)

Setel integrasi Trackio opsional.

Untuk menyesuaikan setup, Anda juga dapat mengatur `project`, `trackio_space_id`, `trackio_bucket_id`, `trackio_static_space_id`, dan `hub_private_repo` di [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments).

#### transformers.integrations.WandbCallback[[transformers.integrations.WandbCallback]]

```python
transformers.integrations.WandbCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L695)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mencatat metrik, media, dan checkpoint model ke [Weight and Biases](https://www.wandb.com/).

#### setup[[transformers.integrations.WandbCallback.setup]]

```python
setup(args, state, model, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L711)

Atur integrasi Weights & Biases (*wandb*) opsional.

Anda dapat membuat subclass dan menimpa metode ini untuk menyesuaikan setup jika diperlukan. Temukan informasi lebih lanjut [di sini](https://docs.wandb.ai/guides/integrations/huggingface). Anda juga dapat menimpa variabel lingkungan berikut:

Lingkungan:
- **WANDB_LOG_MODEL** (`str`, *opsional*, default `"false"`): Apakah model dan checkpoint akan dicatat selama pelatihan. Nilainya dapat berupa `"end"`, `"checkpoint"`, atau `"false"`. Jika diatur ke `"end"`, model akan diunggah di akhir pelatihan. Jika diatur ke `"checkpoint"`, checkpoint akan diunggah setiap `args.save_steps`. Jika diatur ke `"false"`, model tidak akan diunggah. Gunakan bersama `load_best_model_at_end()` untuk mengunggah model terbaik.
- **WANDB_WATCH** (`str`, *opsional* dengan nilai default `"false"`): Dapat berupa `"gradients"`, `"all"`, `"parameters"`, atau `"false"`. Atur ke `"all"` untuk mencatat gradien dan parameter.
- **WANDB_PROJECT** (`str`, *opsional*, default `"huggingface"`): Atur ini ke string kustom untuk menyimpan hasil di proyek yang berbeda.

#### transformers.integrations.MLflowCallback[[transformers.integrations.MLflowCallback]]

```python
transformers.integrations.MLflowCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1286)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mengirim log ke [MLflow](https://www.mlflow.org/). Dapat dinonaktifkan dengan mengatur variabel lingkungan `DISABLE_MLFLOW_INTEGRATION = TRUE`.

#### setup[[transformers.integrations.MLflowCallback.setup]]

```python
setup(args, state, model)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1305)

Setel integrasi MLflow opsional.

Lingkungan:
- **HF_MLFLOW_LOG_ARTIFACTS** (`str`, *opsional*): Apakah akan menggunakan fasilitas `.log_artifact()` MLflow untuk mencatat artefak. Hal ini hanya masuk akal jika pencatatan dilakukan ke server jarak jauh, misalnya s3 atau GCS. Jika disetel ke `True` atau *1*, setiap checkpoint yang disimpan pada setiap penyimpanan di `output_dir` dari [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) akan disalin ke penyimpanan artefak lokal atau jarak jauh. Penggunaannya tanpa penyimpanan jarak jauh hanya akan menyalin file ke lokasi artefak Anda.
- **MLFLOW_TRACKING_URI** (`str`, *opsional*): Menentukan apakah run disimpan di path tertentu atau server remote. Secara default tidak diset, yang berarti pengisian tracking URI dilewati sepenuhnya.
- **MLFLOW_EXPERIMENT_NAME** (`str`, *opsional*, defaultnya `None`): Apakah akan menggunakan experiment_name MLflow di mana run akan diluncurkan. Defaultnya adalah `None` yang akan menunjuk ke eksperimen `Default` di MLflow. Jika tidak, ini adalah nama eksperimen yang akan diaktifkan, dengan pembedaan huruf besar dan kecil. Jika eksperimen dengan nama ini tidak ada, eksperimen baru dengan nama ini akan dibuat.
- **MLFLOW_TAGS** (`str`, *opsional*): String dump dari dictionary pasangan key/value yang akan ditambahkan ke run MLflow sebagai tag. Contoh: `os.environ['MLFLOW_TAGS']='{"release.candidate": "RC1", "release.version": "2.2.0"}'`.
- **MLFLOW_NESTED_RUN** (`str`, *opsional*): Apakah akan menggunakan nested runs MLflow. Jika diatur ke `True` atau *1*, akan membuat nested run di dalam run saat ini.
- **MLFLOW_RUN_ID** (`str`, *opsional*): Memungkinkan untuk menempel kembali ke run yang sudah ada, yang berguna saat melanjutkan pelatihan dari checkpoint. Ketika variabel lingkungan `MLFLOW_RUN_ID` diset, `start_run` akan mencoba melanjutkan run dengan run ID yang ditentukan dan parameter lainnya diabaikan.
- **MLFLOW_FLATTEN_PARAMS** (`str`, *opsional*, default `False`): Apakah akan meratakan kamus parameter sebelum pencatatan.
- **MLFLOW_MAX_LOG_PARAMS** (`int`, *opsional*): Menetapkan jumlah maksimum parameter yang dicatat dalam run.

#### transformers.integrations.AzureMLCallback[[transformers.integrations.AzureMLCallback]]

```python
transformers.integrations.AzureMLCallback(azureml_run = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1263)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mengirim log ke [AzureML](https://pypi.org/project/azureml-sdk/).

#### transformers.integrations.CodeCarbonCallback[[transformers.integrations.CodeCarbonCallback]]

```python
transformers.integrations.CodeCarbonCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1809)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang melacak emisi CO2 dari pelatihan.

#### transformers.integrations.ClearMLCallback[[transformers.integrations.ClearMLCallback]]

```python
transformers.integrations.ClearMLCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1843)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mengirim log ke [ClearML](https://clear.ml/).

Lingkungan:
- **CLEARML_PROJECT** (`str`, *opsional*, default `HuggingFace Transformers`): Nama proyek ClearML.
- **CLEARML_TASK** (`str`, *opsional*, default `Trainer`): Nama task ClearML.
- **CLEARML_LOG_MODEL** (`bool`, *opsional*, default `False`): Apakah model akan dicatat sebagai artefak selama pelatihan.

#### transformers.integrations.DagsHubCallback[[transformers.integrations.DagsHubCallback]]

```python
transformers.integrations.DagsHubCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1467)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mencatat ke [DagsHub](https://dagshub.com/). Mengembangkan `MLflowCallback`

#### setup[[transformers.integrations.DagsHubCallback.setup]]

```python
setup(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1481)

Setel integrasi Logging DagsHub.

Lingkungan:
- **HF_DAGSHUB_LOG_ARTIFAKS** (`str`, *opsional*): Apakah akan menyimpan artefak data dan model untuk eksperimen. Default ke `False`.

#### transformers.integrations.FlyteCallback[[transformers.integrations.FlyteCallback]]

```python
transformers.integrations.FlyteCallback(save_log_history: bool = True, sync_checkpoints: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2094)

**Parameter:**

save_log_history (`bool`, *opsional*, defaultnya `True`) : Jika diatur ke True, log pelatihan disimpan sebagai Flyte Deck.

sync_checkpoints (`bool`, *opsional*, default `True`) : Jika diset ke True, checkpoint akan disinkronkan dengan Flyte dan dapat digunakan untuk melanjutkan pelatihan jika terjadi gangguan.

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mengirim log ke [Flyte](https://flyte.org/). CATATAN: Callback ini hanya berfungsi di dalam tugas Flyte.

Contoh:

```python
# Note: This example skips over some setup steps for brevity.
from flytekit import current_context, task

@task
def train_hf_transformer():
    cp = current_context().checkpoint
    trainer = Trainer(..., callbacks=[FlyteCallback()])
    output = trainer.train(resume_from_checkpoint=cp.restore())
```

#### transformers.integrations.KubeflowCallback[[transformers.integrations.KubeflowCallback]]

```python
transformers.integrations.KubeflowCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2436)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang melaporkan kemajuan pelatihan ke [Kubeflow Trainer](https://github.com/kubeflow/trainer).

Callback ini didaftarkan secara otomatis saat pelatihan dilakukan di dalam Kubeflow TrainJob dengan feature gate `TrainJobRuntimeStatus` diaktifkan. Kubeflow controller menyuntikkan variabel lingkungan yang diperlukan ke dalam pod pelatihan.

**Variabel Lingkungan (disuntikkan oleh controller):**

- `KUBEFLOW_TRAINER_SERVER_URL`: endpoint HTTPS untuk pembaruan status
- `KUBEFLOW_TRAINER_SERVER_CA_CERT`: Path ke sertifikat CA untuk verifikasi TLS
- `KUBEFLOW_TRAINER_SERVER_TOKEN`: Path ke token service account untuk autentikasi

**Informasi yang Dilaporkan:**

- Persentase kemajuan (0-100%)
- Perkiraan waktu tersisa (detik)
- Metrik pelatihan (loss, learning_rate, dll.)

**Fitur:**

- Pembatasan otomatis (maksimal 1 pembaruan per 5 detik) untuk menghindari beban berlebih pada pengontrol
- Penyimpanan sementara token (5 menit) untuk meminimalkan I/O file
- Hanya rank 0 yang melaporkan kemajuan dalam pelatihan terdistribusi
- Gagal secara diam-diam - masalah jaringan tidak akan mengganggu pelatihan

Dapat dinonaktifkan dengan mengatur variabel lingkungan `DISABLE_KUBEFLOW_INTEGRATION=TRUE`.

#### transformers.integrations.DVCLiveCallback[[transformers.integrations.DVCLiveCallback]]

```python
transformers.integrations.DVCLiveCallback(live: typing.Any | None = None, log_model: typing.Union[typing.Literal['all'], bool, NoneType] = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2157)

**Parameter:**

live (`dvclive.Live`, *opsional*, default `None`) : Instance Live opsional. Jika None, instance baru akan dibuat menggunakan **kwargs.

log_model (Union[Literal["all"], bool], *opsional*, defaultnya `None`) : Apakah akan menggunakan `dvclive.Live.log_artifact()` untuk mencatat checkpoint yang dibuat oleh [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer). Jika diatur ke `True`, checkpoint akhir dicatat di akhir pelatihan. Jika diatur ke `"all"`, seluruh `output_dir` dari [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) dicatat pada setiap checkpoint.

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mengirim log ke [DVCLive](https://www.dvc.org/doc/dvclive).

Gunakan variabel lingkungan di bawah ini di `setup` untuk mengonfigurasi integrasi. Untuk menyesuaikan callback ini di luar variabel lingkungan tersebut, lihat [di sini](https://dvc.org/doc/dvclive/ml-frameworks/huggingface).

#### setup[[transformers.integrations.DVCLiveCallback.setup]]

```python
setup(args, state, model)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2198)

Atur integrasi DVCLive opsional. Untuk menyesuaikan callback ini di luar variabel lingkungan di bawah, lihat [di sini](https://dvc.org/doc/dvclive/ml-frameworks/huggingface).

Lingkungan:
- **HF_DVCLIVE_LOG_MODEL** (`str`, *opsional*): Apakah akan menggunakan `dvclive.Live.log_artifact()` untuk mencatat checkpoint yang dibuat oleh [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer). Jika diatur ke `True` atau *1*, checkpoint akhir akan dicatat di akhir pelatihan. Jika diatur ke `all`, seluruh `output_dir` dari [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) akan dicatat pada setiap checkpoint.

#### transformers.integrations.SwanLabCallback[[transformers.integrations.SwanLabCallback]]

```python
transformers.integrations.SwanLabCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2262)

[TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) yang mencatat metrik, media, dan checkpoint model ke [SwanLab](https://swanlab.cn/).

#### setup[[transformers.integrations.SwanLabCallback.setup]]

```python
setup(args, state, model, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2276)

Siapkan integrasi SwanLab (*swanlab*) opsional.

Anda dapat membuat subclass dan menimpa metode ini untuk menyesuaikan setup jika diperlukan. Temukan informasi lebih lanjut [di sini](https://docs.swanlab.cn/guide_cloud/integration/integration-huggingface-transformers.html).

Anda juga dapat menimpa variabel lingkungan berikut. Temukan informasi lebih lanjut tentang variabel lingkungan [di sini](https://docs.swanlab.cn/en/api/environment-variable.html#environment-variables)

Lingkungan:
- **SWANLAB_API_KEY** (`str`, *opsional*, default `None`): Cloud API Key. Saat login, variabel lingkungan ini diperiksa terlebih dahulu. Jika tidak ada, sistem memeriksa apakah pengguna sudah login. Jika belum, proses login akan dimulai.

  - Jika string diteruskan ke antarmuka login, variabel lingkungan ini diabaikan.
  - Jika pengguna sudah masuk, variabel lingkungan ini memiliki prioritas lebih tinggi daripada informasi login yang disimpan secara lokal.

- **SWANLAB_PROJECT** (`str`, *opsional*, default `None`): Atur ini ke string kustom untuk menyimpan hasil ke proyek yang berbeda. Jika tidak ditentukan, nama direktori berjalan saat ini akan digunakan.

- **SWANLAB_LOG_DIR** (`str`, *opsional*, default `swanlog`): Variabel lingkungan ini menentukan jalur penyimpanan untuk file log saat dijalankan dalam mode lokal. Secara default, log disimpan dalam folder bernama swanlog di bawah direktori kerja.

- **SWANLAB_MODE** (`Literal["local", "cloud", "disabled"]`, *opsional*, default `cloud`): mode parsing SwanLab, yang melibatkan callback yang didaftarkan oleh operator. Saat ini, terdapat tiga mode: local, cloud, dan disabled. Catatan: Case-sensitive. Temukan informasi lebih lanjut [di sini](https://docs.swanlab.cn/en/api/py-init.html#swanlab-init)

- **SWANLAB_LOG_MODEL** (`str`, *opsional*, default `None`): SwanLab saat ini tidak mendukung fungsi mode simpan. Fitur ini akan tersedia pada rilis mendatang

- **SWANLAB_WEB_HOST** (`str`, *opsional*, default `None`): Alamat web untuk lingkungan cloud SwanLab pada versi privat (gratis)

- **SWANLAB_API_HOST** (`str`, *opsional*, default `None`): alamat API untuk lingkungan cloud SwanLab versi privat (gratis)

- **SWANLAB_RUN_ID** (`str`, *opsional*, default `None`): ID eksperimen untuk melanjutkan run sebelumnya. Gunakan bersama `SWANLAB_RESUME` untuk melanjutkan eksperimen yang sudah ada.

- **SWANLAB_RESUME** (`str`, *opsional*, default `None`): Mode resume (`"must"`, `"allow"`, `"never"`). Defaultnya `"allow"` ketika `resume_from_checkpoint` digunakan.

## TrainerCallback[[transformers.TrainerCallback]]

#### transformers.TrainerCallback[[transformers.TrainerCallback]]

```python
transformers.TrainerCallback()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L295)

**Parameter:**

args ([TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments)) : Argumen pelatihan yang digunakan untuk menginstansiasi [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer).

state ([TrainerState](/docs/transformers/main/id/main_classes/callback#transformers.TrainerState)) : Status terkini dari [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer).

control ([TrainerControl](/docs/transformers/main/id/main_classes/callback#transformers.TrainerControl)) : Objek yang dikembalikan ke [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer) dan dapat digunakan untuk membuat beberapa keputusan.

model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel) atau `torch.nn.Module`) : Model yang sedang dilatih.

processing_class ([`PreTrainedTokenizer` atau `BaseImageProcessor` atau `ProcessorMixin` atau `FeatureExtractionMixin`]) : Kelas pemrosesan yang digunakan untuk mengkodekan data. Bisa berupa tokenizer, processor, image processor, atau feature extractor.

optimizer (`torch.optim.Optimizer`) : Optimizer yang digunakan untuk langkah pelatihan.

lr_scheduler (`torch.optim.lr_scheduler.LambdaLR`) : Scheduler yang digunakan untuk mengatur learning rate.

train_dataloader (`torch.utils.data.DataLoader`, *opsional*) : Dataloader saat ini yang digunakan untuk pelatihan.

eval_dataloader (`torch.utils.data.DataLoader`, *opsional*) : Dataloader saat ini yang digunakan untuk evaluasi.

metrics (`dict[str, float]`) : Metrik yang dihitung oleh fase evaluasi terakhir. Metrik ini hanya dapat diakses pada event `on_evaluate`.

logs  (`dict[str, float]`) : Nilai yang akan dicatat.  Nilai ini hanya dapat diakses pada event `on_log`.

Kelas untuk objek yang akan memeriksa status loop pelatihan pada beberapa event dan mengambil beberapa keputusan. Pada masing-masing event tersebut, argumen berikut tersedia:

Objek `control` adalah satu-satunya yang dapat diubah oleh callback, di mana peristiwa yang mengubahnya harus mengembalikan versi yang telah dimodifikasi.

Argumen `args`, `state`, dan `control` adalah argumen posisional untuk semua event, sedangkan yang lainnya dikelompokkan dalam `kwargs`. Anda dapat mengurai argumen yang Anda butuhkan dalam tanda tangan event dengan menggunakan argumen tersebut. Sebagai contoh, lihat kode [PrinterCallback](/docs/transformers/main/id/main_classes/callback#transformers.PrinterCallback) sederhana.

Contoh:

```python
class PrinterCallback(TrainerCallback):
    def on_log(self, args, state, control, logs=None, **kwargs):
        _ = logs.pop("total_flos", None)
        if state.is_local_process_zero:
            print(logs)
```

#### on_epoch_begin[[transformers.TrainerCallback.on_epoch_begin]]

```python
on_epoch_begin(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L361)

Event yang dipanggil di awal epoch.

#### on_epoch_end[[transformers.TrainerCallback.on_epoch_end]]

```python
on_epoch_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L366)

Event yang dipanggil di akhir epoch.

#### on_evaluate[[transformers.TrainerCallback.on_evaluate]]

```python
on_evaluate(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L398)

Event yang dipanggil setelah fase evaluasi.

#### on_init_end[[transformers.TrainerCallback.on_init_end]]

```python
on_init_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L346)

Event yang dipanggil di akhir inisialisasi [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer).

#### on_log[[transformers.TrainerCallback.on_log]]

```python
on_log(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L413)

Event yang dipanggil setelah pencatatan log terakhir.

#### on_optimizer_step[[transformers.TrainerCallback.on_optimizer_step]]

```python
on_optimizer_step(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L382)

Event yang dipanggil setelah langkah optimizer tetapi sebelum gradien di-nol-kan. Berguna untuk memantau gradien.

#### on_pre_optimizer_step[[transformers.TrainerCallback.on_pre_optimizer_step]]

```python
on_pre_optimizer_step(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L377)

Event yang dipanggil sebelum langkah optimizer tetapi setelah pemangkasan gradien. Berguna untuk memantau gradien.

#### on_predict[[transformers.TrainerCallback.on_predict]]

```python
on_predict(args: TrainingArguments, state: TrainerState, control: TrainerControl, metrics, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L403)

Event yang dipanggil setelah prediksi berhasil.

#### on_prediction_step[[transformers.TrainerCallback.on_prediction_step]]

```python
on_prediction_step(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L418)

Event yang dipanggil setelah langkah prediksi.

#### on_push_begin[[transformers.TrainerCallback.on_push_begin]]

```python
on_push_begin(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L423)

Event yang dipanggil sebelum mendorong model ke hub, di awal Trainer.push_to_hub dan Trainer._push_from_checkpoint.

#### on_save[[transformers.TrainerCallback.on_save]]

```python
on_save(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L408)

Event yang dipanggil setelah penyimpanan checkpoint.

#### on_step_begin[[transformers.TrainerCallback.on_step_begin]]

```python
on_step_begin(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L371)

Event yang dipanggil di awal langkah pelatihan. Jika menggunakan akumulasi gradien, satu langkah pelatihan mungkin memerlukan beberapa input.

#### on_step_end[[transformers.TrainerCallback.on_step_end]]

```python
on_step_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L392)

Event yang dipanggil di akhir langkah pelatihan. Jika menggunakan akumulasi gradien, satu langkah pelatihan mungkin memerlukan beberapa input.

#### on_substep_end[[transformers.TrainerCallback.on_substep_end]]

```python
on_substep_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L387)

Event yang dipanggil di akhir substep selama akumulasi gradien.

#### on_train_begin[[transformers.TrainerCallback.on_train_begin]]

```python
on_train_begin(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L351)

Event yang dipanggil di awal pelatihan.

#### on_train_end[[transformers.TrainerCallback.on_train_end]]

```python
on_train_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L356)

Event yang dipanggil di akhir pelatihan.

Berikut adalah contoh cara mendaftarkan callback kustom dengan [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer) PyTorch:

```python
class MyCallback(TrainerCallback):
    "A callback that prints a message at the beginning of training"

    def on_train_begin(self, args, state, control, **kwargs):
        print("Starting training")

trainer = Trainer(
    model,
    args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    callbacks=[MyCallback],  # We can either pass the callback class this way or an instance of it (MyCallback())
)
```

Cara lain untuk mendaftarkan callback adalah dengan memanggil `trainer.add_callback()` sebagai berikut:

```python
trainer = Trainer(...)
trainer.add_callback(MyCallback)
# Alternatively, we can pass an instance of the callback class
trainer.add_callback(MyCallback())
```

## TrainerState[[transformers.TrainerState]]

#### transformers.TrainerState[[transformers.TrainerState]]

```python
transformers.TrainerState(epoch: float = 0, global_step: int = 0, max_steps: int = 0, logging_steps: int = 500, eval_steps: int = 500, save_steps: int = 500, train_batch_size: int | None = None, num_train_epochs: int = 0, num_input_tokens_seen: int = 0, total_flos: float = 0, log_history: list = None, best_metric: float | None = None, best_global_step: int | None = None, best_model_checkpoint: str | None = None, is_local_process_zero: bool = True, is_world_process_zero: bool = True, is_hyper_param_search: bool = False, trial_name: str | None = None, trial_params: dict[str, str | float | int | bool] | None = None, stateful_callbacks: list['TrainerCallback'] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L35)

**Parameter:**

epoch (`float`, *opsional*) : Hanya diset selama pelatihan, akan merepresentasikan epoch saat pelatihan berlangsung (bagian desimalnya adalah persentase epoch saat ini yang telah selesai).

global_step (`int`, *opsional*, default 0) : Selama pelatihan, mewakili jumlah langkah pembaruan yang telah diselesaikan.

max_steps (`int`, *opsional*, default 0) : Jumlah langkah pembaruan yang dilakukan selama pelatihan saat ini.

logging_steps (`int`, *opsional*, default 500) : Catat setiap X langkah pembaruan

eval_steps (`int`, *opsional*) : Jalankan evaluasi setiap X langkah.

save_steps (`int`, *opsional*, default 500) : Simpan checkpoint setiap X langkah pembaruan.

train_batch_size (`int`, *opsional*) : Ukuran batch untuk dataloader pelatihan. Hanya diperlukan ketika `auto_find_batch_size` telah digunakan.

num_input_tokens_seen (`int`, *opsional*, default 0) : Saat melacak token input, jumlah token yang dilihat selama pelatihan (jumlah token input, bukan jumlah token prediksi).

total_flos (`float`, *opsional*, default 0) : Total jumlah operasi floating point yang dilakukan oleh model sejak awal pelatihan (disimpan sebagai float untuk menghindari overflow).

log_history (`list[dict[str, float]]`, *opsional*) : Daftar log yang dilakukan sejak awal pelatihan.

best_metric (`float`, *opsional*) : Saat melacak model terbaik, nilai metrik terbaik yang ditemukan sejauh ini.

best_global_step (`int`, *opsional*) : Saat melacak model terbaik, langkah di mana metrik terbaik ditemukan. Digunakan untuk mengatur `best_model_checkpoint`.

best_model_checkpoint (`str`, *opsional*) : Saat melacak model terbaik, nilai dari nama checkpoint untuk model terbaik yang ditemukan sejauh ini.

is_local_process_zero (`bool`, *opsional*, default `True`) : Apakah proses ini merupakan proses utama lokal (misalnya, pada satu mesin jika pelatihan dilakukan secara terdistribusi di beberapa mesin).

is_world_process_zero (`bool`, *opsional*, default `True`) : Apakah proses ini merupakan proses utama global (saat pelatihan dilakukan secara terdistribusi di beberapa mesin, nilai ini hanya akan menjadi `True` untuk satu proses).

is_hyper_param_search (`bool`, *opsional*, defaultnya `False`) : Apakah kita sedang dalam proses pencarian hiperparameter menggunakan Trainer.hyperparameter_search. Hal ini akan memengaruhi cara data dicatat di TensorBoard.

stateful_callbacks (`list[StatefulTrainerCallback]`, *opsional*) : Callbacks yang terpasang pada `Trainer` dan seharusnya memiliki state yang disimpan atau dipulihkan. Callbacks yang relevan harus mengimplementasikan fungsi `state` dan `from_state`.

Kelas yang berisi status internal [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer) yang akan disimpan bersama model dan optimizer saat checkpointing, lalu diteruskan ke [TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback).

Dalam seluruh kelas ini, satu langkah harus dipahami sebagai satu langkah pembaruan. Saat menggunakan akumulasi gradien, satu langkah pembaruan mungkin memerlukan beberapa jalur maju dan mundur: jika Anda menggunakan `gradient_accumulation_steps=n`, maka satu langkah pembaruan memerlukan pemrosesan *n* batch.

#### compute_steps[[transformers.TrainerState.compute_steps]]

```python
compute_steps(args, max_steps)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L156)

Menghitung dan menyimpan nilai absolut untuk langkah logging, eval, dan save berdasarkan apakah nilainya berupa proporsi atau tidak.

#### init_training_references[[transformers.TrainerState.init_training_references]]

```python
init_training_references(trainer, max_steps, num_train_epochs, trial)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L169)

Menyimpan referensi pelatihan awal yang diperlukan di `self`

#### load_from_json[[transformers.TrainerState.load_from_json]]

```python
load_from_json(json_path: str)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L149)

Buat sebuah instance dari konten `json_path`.

#### save_to_json[[transformers.TrainerState.save_to_json]]

```python
save_to_json(json_path: str)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L143)

Simpan konten instance ini dalam format JSON di dalam `json_path`.

## TrainerControl[[transformers.TrainerControl]]

#### transformers.TrainerControl[[transformers.TrainerControl]]

```python
transformers.TrainerControl(should_training_stop: bool = False, should_epoch_stop: bool = False, should_save: bool = False, should_evaluate: bool = False, should_log: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L234)

**Parameter:**

should_training_stop (`bool`, *opsional*, default `False`) : Apakah pelatihan harus dihentikan. Jika `True`, variabel ini tidak akan direset menjadi `False`. Pelatihan akan langsung berhenti.

should_epoch_stop (`bool`, *opsional*, default `False`) : Apakah epoch saat ini harus diinterupsi. Jika `True`, variabel ini akan diset kembali ke `False` di awal epoch berikutnya.

should_save (`bool`, *opsional*, default `False`) : Apakah model harus disimpan pada langkah ini. Jika `True`, variabel ini akan diatur kembali menjadi `False` di awal langkah berikutnya.

should_evaluate (`bool`, *opsional*, default `False`) : Apakah model harus dievaluasi pada langkah ini. Jika `True`, variabel ini akan diset kembali menjadi `False` di awal langkah berikutnya.

should_log (`bool`, *opsional*, default `False`) : Apakah log harus dilaporkan pada langkah ini. Jika `True`, variabel ini akan diset kembali ke `False` di awal langkah berikutnya.

Kelas yang menangani alur kendali [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer). Kelas ini digunakan oleh [TrainerCallback](/docs/transformers/main/id/main_classes/callback#transformers.TrainerCallback) untuk mengaktifkan beberapa saklar dalam loop pelatihan.