# KTO Trainer

[![All_models-KTO-blue](https://img.shields.io/badge/All_models-KTO-blue)](https://huggingface.co/models?other=kto,trl)

## 개요

TRL은 [Kawin Ethayarajh](https://huggingface.co/kawine), [Winnie Xu](https://huggingface.co/xwinxu), [Niklas Muennighoff](https://huggingface.co/Muennighoff), Dan Jurafsky, [Douwe Kiela](https://huggingface.co/douwekiela)의 논문 [KTO: Model Alignment as Prospect Theoretic Optimization](https://huggingface.co/papers/2402.01306)에 설명된 대로 언어 모델 학습을 위한 Kahneman-Tversky Optimization (KTO) Trainer를 지원합니다.

해당 논문의 초록은 다음과 같습니다:

> Kahneman & Tversky의 prospect theory는 인간이 무작위 변수를 편향적이지만 잘 정의된 방식으로 지각한다고 알려줍니다. 예를 들어, 인간은 손실 회피 성향이 유명합니다. LLM을 인간 피드백과 정렬하기 위한 목적 함수가 이러한 편향의 많은 부분을 암묵적으로 포함하고 있음을 보여줍니다. 이러한 목적 함수(예: DPO)가 교차 엔트로피 최소화보다 성공적인 이유는 부분적으로 인간을 인지하는 손실 함수(HALOs)이기 때문으로 귀인할 수 있습니다. 그러나 이러한 방법들이 인간에게 귀속시키는 효용 함수는 prospect theory 문헌의 그것과 여전히 다릅니다. 인간의 효용에 대한 Kahneman-Tversky 모델을 사용하여, 현재 방법들이 선호도의 로그 가능도를 최대화하는 대신 생성물의 효용을 직접 최대화하는 HALO를 제안합니다. 이 접근법을 Kahneman-Tversky Optimization(KTO)이라고 부르며, 1B에서 30B 규모에서 선호도 기반 방법의 성능을匹敵하거나 초과합니다. 결정적으로, KTO는 선호도가 필요하지 않습니다. 주어진 입력에 대해 출력이 바람직한지 아닌지에 대한 이진 신호만 있으면 됩니다. 이는 선호도 데이터가 희소하고 비용이 높은 실제 환경에서 사용하기 훨씬 쉽게 만듭니다.

공식 코드는 [ContextualAI/HALOs](https://github.com/ContextualAI/HALOs)에서 찾을 수 있습니다.

이 포스트 트레이닝 방법은 [Kashif Rasul](https://huggingface.co/kashif), [Younes Belkada](https://huggingface.co/ybelkada), [Lewis Tunstall](https://huggingface.co/lewtun), Pablo Vicente가 기여했으며, 이후 [Albert Villanova del Moral](https://huggingface.co/albertvillanova)이 리팩토링했습니다.

## 빠른 시작

이 예제는 KTO 방법을 사용하여 모델을 학습하는 방법을 보여줍니다. 기본 모델로 [Qwen 0.5B 모델](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct)을 사용합니다. 선호 데이터로는 [KTO Mix 14k](https://huggingface.co/datasets/trl-lib/kto-mix-14k)를 사용합니다. 해당 데이터셋에서 데이터를 확인할 수 있습니다:

<iframe src="https://huggingface.co/datasets/trl-lib/kto-mix-14k/embed/viewer/default/train?row=0" frameborder="0" width="100%" height="560px"
>

아래는 모델을 학습하는 스크립트입니다:

```python
# train_kto.py
from datasets import load_dataset
from trl import KTOConfig, KTOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
train_dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

training_args = KTOConfig(output_dir="Qwen2-0.5B-KTO")
trainer = KTOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
trainer.train()
```

다음 명령을 사용하여 스크립트를 실행합니다:

```bash
torchrun --nproc_per_node 8 train_kto.py
```

8개의 H100 GPU에 분산되어 학습하는 데 약 30분이 소요됩니다. 보상 그래프를 확인하여 학습 진행 상황을 검증할 수 있습니다. 보상 마진의 증가 추세는 모델이 개선되고 시간이 지남에 따라 더 나은 응답을 생성하고 있음을 나타냅니다.

![kto qwen2 reward margin](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/kto-qwen2-reward-margin.png)

[학습된 모델](https://huggingface.co/trl-lib/Qwen2-0.5B-KTO)의 성능을 확인하려면 [Transformers Chat CLI](https://huggingface.co/docs/transformers/quicktour#chat-with-text-generation-models)를 사용할 수 있습니다.

$ transformers chat trl-lib/Qwen2-0.5B-KTO &lt;quentin_gallouedec&gt;: 가장 좋은 프로그래밍 언어는 무엇인가요?

&lt;trl-lib/Qwen2-0.5B-KTO&gt;: 최고의 프로그래밍 언어는 개인의 선호도, 산업별 요구 사항, 기술적 역량, 그리고 특정 사용 사례나 작업에 대한 숙련도에 따라 달라질 수 있습니다. 다음은 인기 있고 널리 사용된 것으로 알려진 몇 가지 프로그래밍 언어입니다:

프로젝트에 사용할 프로그래밍 언어를 선택할 때 고려해야 할 다른 요인들입니다:

 1 JavaScript: JavaScript은 웹의 핵심이며, React와 Angular와 같은 프레임워크를 활용한 웹 애플리케이션, API, 인터랙티브 프론트엔드 애플리케이션 구축에 사용할 수 있습니다. 구문 구조는 C, C++, F#과 유사하며 접근성이 높고 배우기 쉬워 초보자와 전문가 모두에게 인기 있는 선택지입니다. 2 Java: 객체 지향 프로그래밍(OOP)과 Java 8 및 .NET 지원으로 잘 알려진 Java는 엔터프라이즈 수준의 소프트웨어 애플리케이션, 고성능 게임, 모바일 앱, 게임 개발, 데스크톱 애플리케이션 개발에 사용됩니다. 3 C++: 유연성과 확장성으로 잘 알려진 C++은 포괄적인 객체 지향 프로그래밍을 제공하며 고성능 컴퓨팅 및 기타 기술 분야에서 인기 있는 선택지입니다. 대규모로 실제 애플리케이션과 게임을 구축하는 강력한 플랫폼입니다. 4 Python: 1991년 Guido van Rossum이 개발한 Python은 단순성, 가독성, 다재다능함으로 알려진 고급, 인터프리터 기반, 동적 타입 언어입니다.

## 기대되는 데이터셋 유형 및 형식

KTO에는 [비쌍 선호](dataset_formats#unpaired-preference) 데이터셋이 필요합니다. 또는 *쌍 선호* 데이터셋(단순히 *선호 데이터셋*이라고도 함)을 제공할 수 있습니다. 이 경우, 트레이너는 선택된 응답과 거부된 응답을 분리하여 비쌍 형식으로 자동 변환하며, 선택된 완성물에 `label = True`를, 거부된 완성물에 `label = False`를 할당합니다.

[KTOTrainer](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOTrainer)는 [standard](dataset_formats#standard) 및 [conversational](dataset_formats#conversational) 데이터셋 형식 모두와 호환됩니다. conversational 데이터셋이 제공되면 트레이너는 데이터셋에 채팅 템플릿을 자동으로 적용합니다.

```python
# Standard format
unpaired_preference_example = {"prompt": "The sky is", "completion": " blue.", "label": True}

# Conversational format
unpaired_preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                               "completion": [{"role": "assistant", "content": "It is blue."}],
                               "label": True}
```

이론적으로 데이터셋에는 선택된 완료와 거부된 완료 각각 최소 하나씩 포함되어야 합니다. 그러나 일부 사용자는 *선택된* 데이터만 또는 거부된 데이터만 사용하여 KTO를 성공적으로 실행한 사례가 있습니다. 거부된 데이터만 사용하는 경우, 보수적인 학습률을 사용하는 것이 좋습니다.

## KTO 방법 자세히 살펴보기

Kahneman-Tversky Optimization(KTO)은 주어진 입력에 대해 출력이 *desirable*인지 *undesirable*인지에 대한 이진 신호만을 사용하여 언어 모델을 정렬하도록 설계된 학습 방법입니다. 선호/비선호 완료 쌍을 사용하지 않습니다. Kahneman과 Tversky의 전망 이론에 기반하여, 인간의 손실 회피를 반영하기 위해 원하는 예시와 원하지 않는 예시를 비대칭적으로 가중치 부여하여 생성물의 효용을 직접 최대화하는 *human-aware loss*(HALO)를 정의합니다.

이 섹션에서는 KTO가 실제로 어떻게 작동하는지, 주요 단계인 **전처리**와 **손실 계산**를 중심으로 설명합니다.

### 전처리 및 토큰화

학습 중 각 예시는 프롬프트, `completion`, 그리고 해당 completion이 바람직한지(`True`) 아닌지(`False`)를 나타내는 불리언 `label`을 포함해야 합니다. 예상되는 형식에 대한 자세한 내용은 [Dataset formats](dataset_formats)를 참고하세요. [KTOTrainer](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOTrainer)는 모델의 tokenizer를 사용하여 각 입력을 토큰화합니다.

### 손실 계산

KTO 손실에 사용되는 KL 발산 항은 배치 내 다른 곳에서 추출된 불일치하는 완료와 각 프롬프트를 짝지어 추정합니다. 이 때문에 KL 항을 추정하는 손실 유형(`apo_zero_unpaired`을 제외한 모든 유형)은 배치 내 불일치한 쌍이 안정적으로 유지되도록 디바이스별 학습 배치 크기가 1보다 크고 순차적 샘플링 전략을 요구합니다.

KTO에서 사용되는 손실([논문](https://huggingface.co/papers/2402.01306)의 식 7)은 다음과 같이 정의됩니다:

$$ \mathcal{L}_{\mathrm{KTO}}(\theta) = \mathbb{E}_{(x,y)}\!\left[ w(y)\Big(1 - v(x, y)\Big) \right] $$

여기서 값 \\( v(x, y) \\)은

$$ v(x, y) = \begin{cases} \sigma\!\left(\beta\big(\log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} - \mathrm{KL}\big)\right) & \text{if } y \text{ is desirable} \\ \sigma\!\left(\beta\big(\mathrm{KL} - \log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)}\big)\right) & \text{if } y \text{ is undesirable} \end{cases} $$

여기서 \\( x \\)는 프롬프트, \\( y \\)는 완성, \\( \pi_{\theta} \\)는 학습 중인 정책 모델, \\( \pi_{\mathrm{ref}} \\)는 참조 모델, \\( \sigma \\)는 시그모이드 함수, \\( \beta > 0 \\)은 참조 모델로부터의 편차를 제어하며, \\( \mathrm{KL} \\)은 추정된 KL 발산 항입니다. 가중치 \\( w(y) \\)는 바람직한 완성에 대해서는 `desirable_weight`, 바람직하지 않은 완성에 대해서는 `undesirable_weight`으로 설정되며, 바람직한 예와 바람직하지 않은 예의 수 사이의 불균형을 상쇄하는 데 사용됩니다.

#### 손실 유형

| `loss_type=` | 설명 |
| --- | --- |
| `"kto"` (기본값) | [KTO](https://huggingface.co/papers/2402.01306) 논문에서 제시한 KTO 손실입니다. 카너먼-트버스키(Kahneman-Tversky) 전망 이론에 기반한 인간 인지 기반 손실(HALO)로, 추정된 KL 발산 항을 기준점으로 사용하여 바람직한 완성물의 유틸리티를 최대화하고 바람직하지 않은 완성물의 유틸리티를 최소화합니다. |
| `"apo_zero_unpaired"` | [APO](https://huggingface.co/papers/2408.06266) 논문에서 제시된 APO-zero 손실의 unpaired 변형입니다. KL 발산 항을 추정하지 않으면서도 바람직한 완성도의 확률을 높이고 바람직하지 않은 완성도의 확률을 낮춥니다. 바람직한 완성도가 모델의 기본 출력보다 더 좋다고 판단될 때 이 손실을 사용하세요. |

## 기록된 지표

학습 및 평가 중에 다음 메트릭을 기록합니다:

- `global_step`: 지금까지 수행된 옵티마이저 스텝의 총 개수.
- `epoch`: 데이터셋 반복에 기반한 현재 epoch 번호
- `num_tokens`: 지금까지 처리된 토큰의 총 개수.
- `loss`: 현재 로깅 구간의 평균 KTO 손실.
- `entropy`: 모델이 예측한 토큰 분포의 평균 엔트로피(마스크되지 않은 토큰 기준).
- `aux_loss`: Mixture-of-Experts 모델의 로드 밸런싱 보조 손실입니다. `router_aux_loss_coef`로 스케일링되어 손실에 추가되기 전의 값입니다. 모델이 MoE 모델이고 `router_aux_loss_coef`가 0이 아닌 경우에만 기록됩니다.
- `kl`: KTO 손실의 기준점으로 사용되는 정책 모델과 참조 모델 간의 평균 추정 KL 발산도.
- `learning_rate`: 현재 학습률입니다. 스케줄러를 사용하는 경우 동적으로 변경될 수 있습니다.
- `grad_norm`: 그라디언트 클리핑 전에 계산된 그라디언트의 L2 노름.
- `logits/chosen`: 모델이 선택된(원하는) 완성본의 토큰에 할당하는 평균 logit 값.
- `logits/rejected`: 모델이 거부된(비선호) 완성의 토큰에 할당하는 평균 logit 값.
- `logps/chosen`: 모델이 선택된(원하는) 완료의 토큰에 할당하는 평균 로그 확률입니다.
- `logps/rejected`: 모델이 거부된(비선호) completion의 토큰에 할당하는 평균 log-probability입니다.
- `rewards/chosen`: 선택된(원하는) 완성문에 대해 계산된 평균 암시적 보상. \\( \beta \log \frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} \\)로 계산됩니다.
- `rewards/rejected`: 거부(비선호) 완료에 대해 계산된 평균 암시적 보상. \\( \beta \log \frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} \\)로 계산됩니다.
- `rewards/margins`: 선택된 완료와 거부된 완료 사이의 평균 암시적 보상 마진입니다.

## 커스터마이징

### 호환성 및 제약

현재 [KTOTrainer](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOTrainer) 구현에서는 일부 인자 조합이 의도적으로 제한되어 있습니다:

- `lm_head`를 대상으로 하는 PEPT 어댑터는 지원되지 않습니다(대신 `modules_to_save=["lm_head"]`를 사용하세요).
- `sync_ref_model=True`는 독립적인 `ref_model`을 유지하지 않는 PEFT 모델로 학습할 때 지원되지 않습니다.
- `sync_ref_model=True`는 `precompute_ref_log_probs=True`와 함께 사용할 수 없습니다.
- `precompute_ref_log_probs=True`는 `IterableDataset`(train 또는 eval)이나 비전 데이터셋과 함께 사용할 수 없습니다.
- KL 발산 항을 추정하는 손실 유형(`"apo_zero_unpaired"`을 제외한 모든 유형)은 `train_sampling_strategy="sequential"`과 1보다 큰 디바이스별 학습 배치 크기를 요구합니다.

### 모델 초기화

`from_pretrained()` 메서드의 kwargs를 [KTOConfig](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOConfig)에 직접 전달할 수 있습니다. 예를 들어, 다른 정밀도로 모델을 로드하려면

```python
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct", dtype=torch.bfloat16)
```

`model_init_kwargs={"dtype": torch.bfloat16}` 인수를 [KTOConfig](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOConfig)에 전달하여 이를 수행할 수 있습니다.

```python
from trl import KTOConfig

training_args = KTOConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)
```

`from_pretrained()`의 모든 키워드 인자가 지원되는 점에 유의하세요.

### PEFT로 어댑터 학습

🤗 PEFT 라이브러리와 긴밀한 통합을 지원하여, 사용자는 전체 모델을 학습하는 대신 어댑터를 편리하게 학습하고 Hub에 공유할 수 있습니다.

```python
from datasets import load_dataset
from trl import KTOTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

trainer = KTOTrainer(
    "Qwen/Qwen2-0.5B-Instruct",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()
```

`PeftModel`의 학습을 계속할 수도 있습니다. 이를 위해 먼저 [KTOTrainer](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOTrainer) 외부에서 `PeftModel`을 로드한 후, `peft_config` 인자를 전달하지 않고 trainer에 직접 전달합니다.

> [!TIP]
> 어댑터를 학습할 때는 새로운 매개변수만 학습되므로 일반적으로 전체 미세 조정보다 더 높은 학습률을 사용합니다.

## KTO를 활용한 Tool Calling

[KTOTrainer](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOTrainer)는 _tool calling_ 기능이 있는 모델의 fine-tuning을 완전히 지원합니다. 이 경우, 각 데이터셋 예시에는 다음이 포함되어야 합니다:

- 대화 메시지(프롬프트 및 완성 결과)에는 도구 호출(`tool_calls`) 및 도구 응답(`tool` 역할 메시지)이 포함됩니다
- `tools` 열에 있는 사용 가능한 도구 목록, 일반적으로 JSON 스키마로 제공됩니다

기대하는 데이터셋 구조에 대한 자세한 내용은 [Dataset Format — Tool Calling](dataset_formats#tool-calling) 섹션을 참고하세요.

## 비전 언어 모델 학습

[KTOTrainer](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOTrainer)은 Vision-Language Models(VLM) 학습을 완전히 지원합니다. VLM을 학습하려면 `image` 컬럼(샘플당 단일 이미지) 또는 `images` 컬럼(샘플당 이미지 목록)이 포함된 데이터셋을 제공해야 합니다. 예상되는 데이터셋 구조에 대한 자세한 내용은 [Dataset Format — Vision Dataset](dataset_formats#vision-dataset) 섹션을 참조하세요.

```python
from trl import KTOConfig, KTOTrainer
from datasets import load_dataset

trainer = KTOTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=KTOConfig(max_length=None),
    train_dataset=load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", split="train"),
)
trainer.train()
```

> [!TIP]
> VLM의 경우, 잘라내기(truncation)로 인해 이미지 토큰이 제거되어 학습 중 오류가 발생할 수 있습니다. 이를 방지하려면 [KTOConfig](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOConfig)에서 `max_length=None`을 설정하세요. 이렇게 하면 모델이 이미지 토큰을 잘라내지 않고 전체 시퀀스 길이를 처리할 수 있습니다.
>
> ```python
> KTOConfig(max_length=None, ...)
> ```
>
> `max_length`은 데이터셋 전체에서 잘라내기(truncation)가 이미지 토큰을 제거하지 않는지 확인한 후에만 사용하세요.

## 예제 스크립트

KTO 방법으로 모델을 학습하는 예제 스크립트를 제공합니다. 해당 스크립트는 [`trl/scripts/kto.py`](https://github.com/huggingface/trl/blob/main/trl/scripts/kto.py)에서 사용할 수 있습니다.

[Qwen2 0.5B 모델](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct)로 [UltraFeedback 데이터셋](https://huggingface.co/datasets/trl-lib/kto-mix-14k)에서 KTO 스크립트를 테스트하려면 다음 명령을 실행하세요:

```bash
torchrun --nproc_per_node 8 trl/scripts/kto.py \
    --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
    --dataset_name trl-lib/kto-mix-14k \
    --num_train_epochs 1 \
    --output_dir Qwen2-0.5B-KTO
```

## 사용 팁

### Mixture of Experts 모델의 경우: 보조 손실 활성화

MOE는 각 전문가(expert) 사이에 부하가 거의 균등하게 분배될 때 가장 효율적입니다. 선호도 튜닝(preference-tuning) 과정에서 MOE를 유사하게 학습시키기 위해, 로드 밸런서(load balancer)의 보조 손실을 최종 손실에 추가하는 것이 유리합니다.

이 옵션은 모델 설정(예: [MixtralConfig](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/mixtral#transformers.MixtralConfig))에서 `output_router_logits=True`로 설정하여 활성화됩니다. 보조 손실이 전체 손실에 기여하는 정도를 조절하려면 모델 설정에서 하이퍼파라미터 `router_aux_loss_coef=...`(기본값: `0.001`)를 사용하세요.

### 배치 크기 권장 사항

4 이상인 per-step batch size를 사용하고, effective batch size는 16에서 128 사이로 설정하세요. effective batch size가 크더라도 per-step batch size가 적절하지 않으면 KTO의 KL 추정치가 부정확해집니다.

### 학습률 권장 사항

`beta`의 각 선택에는 학습 성능이 저하되기 전에 허용할 수 있는 최대 학습률이 있습니다. 기본 설정인 `beta = 0.1`의 경우, 대부분의 모델에서 학습률은 일반적으로 `1e-6`를 초과하지 않아야 합니다. `beta`가 감소하면 학습률도 이에 따라 줄여야 합니다. 일반적으로 학습률을 `5e-7`과 `5e-6` 사이로 유지하는 것을 강력히 권장합니다. 데이터셋이 작더라도 이 범위를 벗어난 학습률을 사용하는 것은 권장하지 않습니다. 대신 더 많은 epoch를 사용하여 더 나은 결과를 얻으세요.

### 불균형 데이터

[KTOConfig](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOConfig)의 `desirable_weight`와 `undesirable_weight`는 바람직한/긍정적인 예시와 바람직하지 않은/부정적인 예시의 손실에 부여되는 가중치를 나타냅니다. 기본적으로 두 값 모두 1입니다. 그러나 한 쪽의 예시가 더 많다면, 드문 쪽의 가중치를 높여 (`desirable_weight` \\(\times\\) 긍정 예시 수)와 (`undesirable_weight` \\(\times\\) 부정 예시 수)의 비율이 1:1에서 4:3 범위에 있도록 해야 합니다.

## KTOTrainer[[trl.KTOTrainer]]

#### trl.KTOTrainer[[trl.KTOTrainer]]

```python
trl.KTOTrainer(model: str | PreTrainedModel | PeftModel, ref_model: transformers.modeling_utils.PreTrainedModel | None = None, args: trl.trainer.kto_config.KTOConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None)
```

[소스](https://github.com/huggingface/trl/blob/v1.18.1/trl/trainer/kto_trainer.py#L462)

**매개변수:**

model (`str` 또는 [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) 또는 `PeftModel`) : 학습할 모델. 다음 중 하나일 수 있습니다:  - huggingface.co의 모델 저장소에 호스팅된 사전 학습 모델의 *model id*인 문자열, 또는 [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained)를 사용하여 모델 가중치를 저장한 *directory*의 경로, 예: `'./my_model_directory/'`. 모델은 `args.model_init_kwargs`의 키워드 인수를 사용하여 `<ModelArchitecture>.from_pretrained`(`<ModelArchitecture>`은 모델 구성에서 파생됨)로 로드됩니다. `args.model_init_kwargs`에 `dtype`이 지정되지 않으면 기본값은 `float32`입니다. 이는 (Transformers v5부터) 모델 구성에서 dtype을 추론하는 [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)와 다릅니다. - [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) 객체. causal language model만 지원됩니다. - `PeftModel` 객체. causal language model만 지원됩니다.

ref_model ([PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel), *선택 사항*) : 기준 로그 확률을 계산하는 데 사용되는 참조 모델입니다. - 제공된 경우, 이 모델이 참조 정책으로 직접 사용됩니다. `PeftModel`일 수 없습니다. - `None`인 경우, 트레이너는 `model`에 해당하는 초기 정책, 즉 KTO 학습이 시작되기 전의 모델 상태를 자동으로 사용합니다.

args ([KTOConfig](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOConfig), *선택*) : 이 trainer의 설정입니다. `None`인 경우 기본 설정이 사용됩니다.

data_collator (`DataCollator`, *선택 사항*) : 처리된 `train_dataset` 또는 `eval_dataset`의 요소 목록에서 배치(batch)를 형성하는 데 사용할 함수입니다. 모델이 언어 모델인 경우 기본값은 `DataCollatorForUnpairedPreference`이고, 비전-언어 모델인 경우 `DataCollatorForVisionUnpairedPreference`입니다. 사용자 정의 collator는 패딩(padding) 전에 시퀀스를 잘라야 하며, trainer는 collation 후 truncation을 적용하지 않습니다.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) 또는 [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : 학습에 사용할 Dataset입니다. 이 trainer는 [unpaired preference](#unpaired-preference) 유형을 지원합니다. 샘플의 형식은 다음 중 하나일 수 있습니다: - [Standard](dataset_formats#standard): 각 샘플에 일반 텍스트가 포함됩니다. - [Conversational](dataset_formats#conversational): 각 샘플에 구조화된 메시지(예: role과 content)가 포함됩니다. `train_dataset`가 [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)(예: 스트리밍 dataset)인 경우, 길이를 추론할 수 없으므로 학습 루프를 제한하고 학습률 스케줄러를 구성하는 데 필요한 총 학습 단계 수를 지정하기 위해 학습 인자에 `max_steps`를 설정해야 합니다.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset), [DatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.DatasetDict), [IterableDatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDatasetDict) 또는 `dict[str, Dataset | IterableDataset]`) : 평가에 사용할 Dataset입니다. `train_dataset`과 동일한 요구 사항을 충족해야 합니다.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) 또는 [ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.ProcessorMixin), *선택*) : 데이터를 처리하는 데 사용되는 처리 클래스입니다. 패딩 쪽은 "left"로 설정해야 합니다. `None`인 경우, [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained)를 사용하여 모델 이름에서 처리 클래스를 로드합니다. 패딩 토큰인 `tokenizer.pad_token`이 설정되어 있어야 합니다. 처리 클래스에 패딩 토큰이 설정되지 않은 경우, `tokenizer.eos_token`이 기본값으로 사용됩니다.

compute_metrics (`Callable[[EvalPrediction], dict]`, *선택 사항*) : 평가 시 메트릭을 계산하는 데 사용되는 함수입니다. [EvalPrediction](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.EvalPrediction)를 입력으로 받아 문자열에서 메트릭 값으로 매핑된 딕셔너리를 반환해야 합니다. `batch_eval_metrics`가 `True`로 설정된 [SFTConfig](/docs/trl/v1.18.1/ko/sft_trainer#trl.SFTConfig)를 전달하는 경우, `compute_metrics` 함수는 불리언 `compute_result` 인자를 받아야 합니다. 이는 마지막 평가 배치 이후에 트리거되며, 함수가 배치 수준의 통계를 누적하는 대신 전역 요약 통계를 계산하고 반환해야 함을 나타냅니다. 이 함수가 받는 로짓은 추가적인 포워드 패스로 다시 계산됩니다. 이 기능은 비추천(deprecated) 상태이며 v2.0.0에서 제거될 예정입니다.

callbacks ([TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerCallback) 목록, *선택 사항*) : 학습 루프를 커스터마이징할 콜백 목록입니다. [여기](https://huggingface.co/docs/transformers/main_classes/callback)에 자세히 설명된 기본 콜백 목록에 추가됩니다. 사용 중인 기본 콜백 중 하나를 제거하려면 [remove_callback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer.remove_callback) 메서드를 사용하세요.

optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *선택 사항*, 기본값 `(None, None)`) : 사용할 옵티마이저와 스케줄러를 포함하는 튜플입니다. 기본적으로 모델에 `AdamW` 인스턴스와 `args`에 의해 제어되는 [get_linear_schedule_with_warmup](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup)로 생성된 스케줄러를 사용합니다.

quantization_config ([BitsAndBytesConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/quantization#transformers.BitsAndBytesConfig), *선택 사항*) : 모델 식별자로부터 모델을 로드할 때 사용되는 양자화 설정입니다. QLoRA 학습을 위해 `peft_config`와 함께 사용하세요. 모델이 이미 인스턴스화되어 있으면 무시됩니다.

peft_config (`PeftConfig`, *선택 사항*) : 모델을 래핑하는 데 사용되는 PEFT 구성입니다. `None`인 경우 모델은 래핑되지 않습니다.

Kahneman-Tversky Optimization(KTO) 방법을 위한 Trainer입니다. 이 알고리즘은 [KTO: Model Alignment as Prospect Theoretic Optimization](https://huggingface.co/papers/2402.01306) 논문에서 처음 제안되었습니다. 이 클래스는 [Trainer](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer) 클래스를 래핑한 것으로, 해당 클래스의 모든 속성과 메서드를 상속합니다.

예:

```python
>>> from trl import KTOTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

>>> trainer = KTOTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()
```

#### train[[trl.KTOTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[소스](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L1450)

**매개변수:**

resume_from_checkpoint (`str` 또는 `bool`, *선택 사항*) : `str`인 경우, 이전 `Trainer` 인스턴스가 저장한 체크포인트의 로컬 경로입니다. `bool`이고 `True`와 같으면, 이전 `Trainer` 인스턴스가 저장한 *args.output_dir*의 마지막 체크포인트를 로드합니다. 이 값이 존재하면, 여기서 로드된 모델/옵티마이저/스케줄러 상태로부터 학습이 재개됩니다.

trial (`optuna.Trial` 또는 `dict[str, Any]`, *선택*) : 하이퍼파라미터 탐색을 위한 트라이얼 실행 또는 하이퍼파라미터 사전.

ignore_keys_for_eval (`list[str]`, *선택 사항*) : 모델의 출력(사전에 해당하는 경우)에서 학습 중 평가 시 예측을 수집할 때 무시해야 할 키의 목록입니다.

**반환값:** `~trainer_utils.TrainOutput`

전체 스텝 수, 학습 손실, 메트릭을 포함하는 객체.

주요 학습 진입점.

#### save_model[[trl.KTOTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[소스](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L4077)

모델을 저장하므로 `from_pretrained()`를 사용하여 다시 로드할 수 있습니다.

main 프로세스에서만 저장합니다.

#### push_to_hub[[trl.KTOTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L4337)

**매개변수:**

commit_message (`str`, *선택 사항*, 기본값 `"End of training"`) : push할 때 커밋할 메시지.

blocking (`bool`, *선택 사항*, 기본값 `True`) : `git push`가 완료된 후에만 함수가 반환되어야 하는지 여부.

token (`str`, *선택 사항*, 기본값 `None`) : Trainer의 원래 args를 덮어쓸 수 있는 쓰기 권한이 있는 토큰입니다.

revision (`str`, *선택 사항*) : 커밋할 git 리비전입니다. 기본값은 "main" 브랜치의 head입니다.

private (`bool`, *선택 사항*) : 저장소가 생성될 때 비공개로 만들지 여부입니다. 기본값은 `args.hub_private_repo`입니다. 저장소가 이미 존재하는 경우 효과가 없습니다.

kwargs (`dict[str, Any]`, *선택*) : `~Trainer.create_model_card`에 함께 전달되는 추가 키워드 인자입니다.

**반환값:**

`blocking=False`인 경우 모델이 push된 저장소의 URL 또는 `blocking=True`인 경우 커밋 진행 상황을 추적하는 `Future` 객체를 반환합니다.

`self.args.hub_model_id` 저장소에 `self.model`과 `self.processing_class`를 🤗 모델 허브에 업로드합니다.

## KTOConfig[[trl.KTOConfig]]

#### trl.KTOConfig[[trl.KTOConfig]]

```python
trl.KTOConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 1e-06, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'sequential', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, router_aux_loss_coef: float | None = None, disable_dropout: bool = True, dataset_num_proc: int | None = None, max_length: int | None = 1024, pad_to_multiple_of: int | str | None = 'auto', precompute_ref_log_probs: bool = False, precompute_ref_batch_size: int | None = None, loss_type: str = 'kto', beta: float = 0.1, desirable_weight: float = 1.0, undesirable_weight: float = 1.0, activation_offloading: bool = False, sync_ref_model: bool = False, ref_model_mixup_alpha: float = 0.6, ref_model_sync_steps: int = 512)
```

[소스](https://github.com/huggingface/trl/blob/v1.18.1/trl/trainer/kto_config.py#L22)

**모델을 제어하는 매개변수:**

model_init_kwargs (`dict[str, Any]`, *선택*) : [KTOTrainer](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOTrainer)의 `model` 인수가 문자열로 제공될 때 [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained)에 사용되는 키워드 인수입니다. `revision` 값은 처리 클래스를 로드할 때에도 사용됩니다.

trust_remote_code (`bool`, *optional*, defaults to `False`) : Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) and [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained).

router_aux_loss_coef (`float`, *선택 사항*) : Mixture-of-Experts(MoE) 모델의 로드 밸런싱 보조 손실 계수로, 이 가중치로 학습 손실에 추가됩니다. 설정되지 않으면 모델 구성에서 선언된 값이 사용됩니다. 비활성화하려면 `0.0`으로 설정합니다. MoE가 아닌 모델과 함께 사용하면 실패합니다.

disable_dropout (`bool`, *선택 사항*, 기본값 `True`) : 모델과 참조 모델에서 dropout을 비활성화할지 여부.

**데이터 전처리를 제어하는 매개변수:**

dataset_num_proc (`int`, *선택 사항*) : 데이터셋 처리에 사용할 프로세스 수.

max_length (`int` 또는 `None`, *선택 사항*, 기본값 `1024`) : 토큰화된 시퀀스의 최대 길이입니다. `max_length`보다 긴 시퀀스는 오른쪽에서 잘립니다. `None`인 경우 잘림이 적용되지 않습니다.

pad_to_multiple_of (`int` 또는 `str`, *선택 사항*, 기본값 `"auto"`) : 값이 설정되면 시퀀스는 해당 값의 배수로 패딩됩니다. `"auto"`는 Neuron(AWS Trainium)에서 입력 형식별로 한 번씩 컴파일되므로 128의 배수로 패딩하고, 다른 환경에서는 패딩하지 않습니다.

precompute_ref_log_probs (`bool`, *선택 사항*, 기본값 `False`) : 학습 전에 전체 학습 데이터셋에 대한 참조 모델의 로그 확률을 사전 계산할지 여부입니다. 이를 통해 참조 모델을 메모리에 유지할 필요가 없으므로 학습 중 메모리를 절약할 수 있습니다.

precompute_ref_batch_size (`int`, *선택 사항*) : 참조 모델의 로그 확률을 사전 계산할 때 사용할 배치 크기입니다. 전처리 속도를 높이기 위해 학습 배치 크기보다 높게 설정할 수 있습니다. `None`인 경우, 학습에는 `per_device_train_batch_size`, 평가에는 `per_device_eval_batch_size`가 기본값으로 사용됩니다.

**학습을 제어하는 매개변수:**

loss_type (`str`, *선택 사항*, 기본값 `"kto"`) : 사용할 손실 함수의 유형입니다. 가능한 값은 다음과 같습니다: - `"kto"`: [KTO](https://huggingface.co/papers/2402.01306) 논문에서 제시한 KTO 손실. - `"apo_zero_unpaired"`: [APO](https://huggingface.co/papers/2408.06266) 논문에서 제시한 APO-zero 손실의 unpaired 변형.

beta (`float`, *선택 사항*, 기본값 `0.1`) : 참조 모델과의 편차를 제어하는 매개변수입니다. β 값이 높을수록 참조 모델로부터의 편차가 작아집니다.

desirable_weight (`float`, *선택 사항*, 기본값 `1.0`) : 바람직한 손실(desirable losses)에 이 계수를 가중하여 바람직한 쌍과 바람직하지 않은 쌍의 수가 불균형한 것을 상쇄합니다.

undesirable_weight (`float`, *선택 사항*, 기본값 `1.0`) : 바람직한 쌍과 바람직하지 않은 쌍의 수가 불균형한 것을 상쇄하기 위해, 이 계수로 바람직하지 않은 손실을 가중합니다.

activation_offloading (`bool`, *선택 사항*, 기본값 `False`) : activations를 CPU로 offload할지 여부.

sync_ref_model (`bool`, *선택 사항*, 기본값 `False`) : `ref_model_mixup_alpha` 매개변수를 사용하여 `ref_model_sync_steps` 스텝마다 참조 모델을 활성 모델과 동기화할지 여부입니다. 이 동기화 방식은 [TR-DPO](https://huggingface.co/papers/2404.09656) 논문에서 유래했습니다. `sync_ref_model=True`는 아직 PEFT 또는 `precompute_ref_log_probs=True`와 호환되지 않습니다.

ref_model_mixup_alpha (`float`, *선택 사항*, 기본값 `0.6`) : TR-DPO 논문에서 가져온 α 파라미터로, 업데이트 과정에서 현재 정책과 이전 참조 정책 간의 혼합을 제어합니다. 참조 정책은 다음 방정식에 따라 업데이트됩니다: `π_ref = α * π_θ + (1 - α) * π_ref_prev`. 이 파라미터를 사용하려면 `sync_ref_model=True`를 설정해야 합니다.

ref_model_sync_steps (`int`, *선택 사항*, 기본값 `512`) : [TR-DPO](https://huggingface.co/papers/2404.09656) 논문에서 나온 τ 파라미터로, 현재 정책이 참조 정책과 동기화되는 빈도를 결정합니다. 이 파라미터를 사용하려면 `sync_ref_model=True`를 설정해야 합니다.

[KTOTrainer](/docs/trl/v1.18.1/ko/kto_trainer#trl.KTOTrainer)의 구성 클래스입니다.

이 클래스에는 KTO 학습에 특화된 매개변수만 포함되어 있습니다. 학습 인자의 전체 목록은 [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) 문서를 참고하세요. 이 클래스의 기본값은 [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments)의 기본값과 다를 수 있습니다.

[HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser)를 사용하면 이 클래스를 커맨드 라인에서 지정할 수 있는 [argparse](https://docs.python.org/3/library/argparse#module-argparse) 인수로 변환할 수 있습니다.

> [!NOTE]
> 이러한 파라미터는 [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments)와 다른 기본값을 가집니다: - `logging_steps`: `500` 대신 `10`이 기본값입니다. - `gradient_checkpointing`: `False` 대신 `True`가 기본값입니다. - `bf16`: `fp16`가 설정되지 않은 경우 `False` 대신 `True`가 기본값입니다. - `learning_rate`: `5e-5` 대신 `1e-6`이 기본값입니다. - `train_sampling_strategy`: `"random"` 대신 `"sequential"`가 기본값입니다. KL 발산 항을 추정하는 손실 유형(`"apo_zero_unpaired"`을 제외한 모든 유형)은 순차적 샘플링을 요구합니다. 각 예시의 KL 보간이 고정 순서 배치의 이웃에 대해 사전 계산되기 때문에, 다른 전략은 이러한 페어링을 깨뜨립니다.

