TRL documentation

KTO Trainer

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

KTO Trainer

All_models-KTO-blue

개요

TRL은 Kawin Ethayarajh, Winnie Xu, Niklas Muennighoff, Dan Jurafsky, Douwe Kiela의 논문 KTO: Model Alignment as Prospect Theoretic Optimization에 설명된 대로 언어 모델 학습을 위한 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에서 찾을 수 있습니다.

이 포스트 트레이닝 방법은 Kashif Rasul, Younes Belkada, Lewis Tunstall, Pablo Vicente가 기여했으며, 이후 Albert Villanova del Moral이 리팩토링했습니다.

빠른 시작

이 예제는 KTO 방법을 사용하여 모델을 학습하는 방법을 보여줍니다. 기본 모델로 Qwen 0.5B 모델을 사용합니다. 선호 데이터로는 KTO Mix 14k를 사용합니다. 해당 데이터셋에서 데이터를 확인할 수 있습니다:

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

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

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

torchrun --nproc_per_node 8 train_kto.py

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

kto qwen2 reward margin

학습된 모델의 성능을 확인하려면 Transformers Chat CLI를 사용할 수 있습니다.

$ transformers chat trl-lib/Qwen2-0.5B-KTO
<quentin_gallouedec>:
What is the best programming language?

<trl-lib/Qwen2-0.5B-KTO>:
The best programming language can vary depending on individual preferences, industry-specific requirements, technical skills, and familiarity with the specific use case or task. Here are some widely-used programming languages that have been noted as popular and widely used:

Here are some other factors to consider when choosing a programming language for a project:

 1 JavaScript: JavaScript is at the heart of the web and can be used for building web applications, APIs, and interactive front-end applications like frameworks like React and Angular. It's similar to C, C++, and F# in syntax structure and is accessible and easy to learn, making it a popular choice for beginners and professionals alike.
 2 Java: Known for its object-oriented programming (OOP) and support for Java 8 and .NET, Java is used for developing enterprise-level software applications, high-performance games, as well as mobile apps, game development, and desktop applications.
 3 C++: Known for its flexibility and scalability, C++ offers comprehensive object-oriented programming and is a popular choice for high-performance computing and other technical fields. It's a powerful platform for building real-world applications and games at scale.
 4 Python: Developed by Guido van Rossum in 1991, Python is a high-level, interpreted, and dynamically typed language known for its simplicity, readability, and versatility.

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

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

KTOTrainer는 standard 및 conversational 데이터셋 형식 모두와 호환됩니다. conversational 데이터셋이 제공되면 트레이너는 데이터셋에 채팅 템플릿을 자동으로 적용합니다.

# 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를 참고하세요. KTOTrainer는 모델의 tokenizer를 사용하여 각 입력을 토큰화합니다.

손실 계산

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

KTO에서 사용되는 손실(논문 식 7의 논문) )은 다음과 같이 정의됩니다: LKTO(θ)=E(x,y) ⁣[w(y)(1−v(x,y))] \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) 은 다음과 같습니다 v(x,y)={σ ⁣(β(log⁡πθ(y∣x)πref(y∣x)−KL))if y is desirableσ ⁣(β(KL−log⁡πθ(y∣x)πref(y∣x)))if y is undesirable 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 x 는 프롬프트, y y 는 completion, πθ \pi_{\theta} 는 학습 중인 정책 모델, πref \pi_{\mathrm{ref}} 는 참조 모델, σ \sigma 는 시그모이드 함수, β>0 \beta > 0 는 참조 모델로부터의 이탈을 제어하고, KL \mathrm{KL} 는 추정된 KL 발산 항입니다. 가중치 w(y) w(y) 는 desirable_weight 는 바람직한 completion에 대해 undesirable_weight 는 바람직하지 않은 completion에 대해 사용되며, 바람직하고 바람직하지 않은 예시의 수 사이의 불균형을 상쇄하는 데 사용됩니다.

손실 유형

loss_type=설명
"kto" (기본값)KTO 논문에서 제시한 KTO 손실입니다. 카너먼-트버스키(Kahneman-Tversky) 전망 이론에 기반한 인간 인지 기반 손실(HALO)로, 추정된 KL 발산 항을 기준점으로 사용하여 바람직한 완성물의 유틸리티를 최대화하고 바람직하지 않은 완성물의 유틸리티를 최소화합니다.
"apo_zero_unpaired"APO 논문에서 제시된 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: 선택된(원하는) completion에 대해 계산된 평균 implicit reward로, 다음과 같이 계산됩니다. βlog⁡πθ(y∣x)πref(y∣x) \beta \log \frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} .
  • rewards/rejected: 거절된(비선호) completion에 대해 계산된 평균 implicit reward로, 다음과 같이 계산됩니다. βlog⁡πθ(y∣x)πref(y∣x) \beta \log \frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} .
  • rewards/margins: 선택된 완료와 거부된 완료 사이의 평균 암시적 보상 마진입니다.

커스터마이징

호환성 및 제약

현재 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에 직접 전달할 수 있습니다. 예를 들어, 다른 정밀도로 모델을 로드하려면

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

model_init_kwargs={"dtype": torch.bfloat16} 인수를 KTOConfig에 전달하여 이를 수행할 수 있습니다.

from trl import KTOConfig

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

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

PEFT로 어댑터 학습

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

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 외부에서 PeftModel을 로드한 후, peft_config 인자를 전달하지 않고 trainer에 직접 전달합니다.

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

KTO를 활용한 Tool Calling

KTOTrainer는 tool calling 기능이 있는 모델의 fine-tuning을 완전히 지원합니다. 이 경우, 각 데이터셋 예시에는 다음이 포함되어야 합니다:

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

기대하는 데이터셋 구조에 대한 자세한 내용은 Dataset Format — Tool Calling 섹션을 참고하세요.

비전 언어 모델 학습

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

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

VLM의 경우, 잘라내기(truncation)로 인해 이미지 토큰이 제거되어 학습 중 오류가 발생할 수 있습니다. 이를 방지하려면 KTOConfig에서 max_length=None을 설정하세요. 이렇게 하면 모델이 이미지 토큰을 잘라내지 않고 전체 시퀀스 길이를 처리할 수 있습니다.

KTOConfig(max_length=None, ...)

max_length은 데이터셋 전체에서 잘라내기(truncation)가 이미지 토큰을 제거하지 않는지 확인한 후에만 사용하세요.

예제 스크립트

KTO 방법으로 모델을 학습하는 예제 스크립트를 제공합니다. 해당 스크립트는 trl/scripts/kto.py에서 사용할 수 있습니다.

Qwen2 0.5B 모델로 UltraFeedback 데이터셋에서 KTO 스크립트를 테스트하려면 다음 명령을 실행하세요:

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는 부하가 전문가들 사이에 거의 균등하게 분배될 때 가장 효율적입니다.
선호도 튜닝 과정에서 MOE를 유사하게 학습시키기 위해, 로드 밸런서의 보조 손실을 최종 손실에 추가하는 것이 유익합니다.

이 옵션은 모델 설정(예: 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를 사용하여 더 나은 결과를 얻으세요.

불균형 데이터

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

KTOTrainer

클래스 trl.KTOTrainer

< >

( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.kto_config.KTOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_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 = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

매개변수

  • model (str 또는 PreTrainedModel 또는 PeftModel) — 학습할 모델. 다음 중 하나일 수 있습니다:
    • huggingface.co의 모델 저장소에 호스팅된 사전 학습 모델의 model id인 문자열, 또는 save_pretrained를 사용하여 모델 가중치를 저장한 디렉터리의 경로, 예: './my_model_directory/'입니다. 모델은 args.model_init_kwargs의 키워드 인수를 사용하여 <ModelArchitecture>.from_pretrained(여기서 <ModelArchitecture>는 모델 구성에서 파생됨)로 로드됩니다. args.model_init_kwargs에 dtype이 지정되지 않은 경우 기본값은 float32입니다. 이는 from_pretrained와 다르며, 후자의 경우(Transfomers v5부터) dtype은 모델 구성에서 추론됩니다.
    • PreTrainedModel 객체입니다. 인과적 언어 모델만 지원됩니다.
    • PeftModel 객체입니다. 인과 언어 모델만 지원됩니다.
  • ref_model (PreTrainedModel, 선택 사항) — 기준 로그 확률을 계산하는 데 사용되는 기준 모델입니다. 제공된 경우, 이 모델이 직접 기준 정책으로 사용됩니다. PeftModel일 수 없습니다. None인 경우, 트레이너는 KTO 학습이 시작되기 전의 모델 상태, 즉 model에 해당하는 초기 정책을 자동으로 사용합니다.
    • 제공된 경우, 이 모델은 참조 정책(reference policy)으로 직접 사용됩니다. PeftModel일 수 없습니다.
    • None인 경우, trainer는 KTO 학습이 시작되기 전의 모델 상태, 즉 model에 해당하는 초기 정책을 자동으로 사용합니다.
  • args (KTOConfig, 선택) — 이 trainer에 대한 설정입니다. None인 경우 기본 설정이 사용됩니다.
  • data_collator (DataCollator, 선택 사항) — 처리된 train_dataset 또는 eval_dataset 요소 목록에서 배치(batch)를 형성하는 데 사용할 함수입니다. 모델이 언어 모델인 경우 기본값은 DataCollatorForUnpairedPreference이고, 비전-언어 모델인 경우 DataCollatorForVisionUnpairedPreference입니다. 사용자 정의 collator는 패딩(padding) 전에 시퀀스를 잘라야 하며, trainer는 collation 후 truncation을 적용하지 않습니다.
  • train_dataset (Dataset 또는 IterableDataset) — 학습에 사용할 Dataset입니다. 이 trainer는 unpaired preference 타입을 지원합니다. 샘플의 형식은 다음과 같습니다:
    • Standard: 각 샘플에는 일반 텍스트가 포함됩니다.
    • 대화형: 각 샘플에는 구조화된 메시지(예: 역할 및 내용)가 포함됩니다.

    train_dataset이 IterableDataset(예: 스트리밍 데이터셋)인 경우, 그 길이를 추론할 수 없으므로 학습 루프를 제한하고 학습률 스케줄러를 구성하는 데 필요한 총 학습 단계 수를 지정하기 위해 학습 인자에 max_steps를 설정해야 합니다.

  • eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict 또는 dict[str, Dataset | IterableDataset]) — 평가에 사용할 Dataset입니다. train_dataset과 동일한 요구 사항을 충족해야 합니다.
  • processing_class (PreTrainedTokenizerBase 또는 ProcessorMixin, 선택 사항) — 데이터를 처리하는 데 사용되는 처리 클래스입니다. 패딩 쪽은 “left”로 설정해야 합니다. None인 경우, from_pretrained를 사용하여 모델 이름에서 처리 클래스를 로드합니다. 패딩 토큰인 tokenizer.pad_token이 설정되어 있어야 합니다. 처리 클래스에 패딩 토큰이 설정되지 않은 경우, tokenizer.eos_token이 기본값으로 사용됩니다.
  • compute_metrics (Callable[[EvalPrediction], dict], 선택 사항) — 평가 시 메트릭을 계산하는 데 사용되는 함수입니다. EvalPrediction를 인자로 받아 문자열에서 메트릭 값으로 매핑된 딕셔너리를 반환해야 합니다. SFTConfig에 batch_eval_metrics가 True로 설정된 경우, compute_metrics 함수는 불리언 compute_result 인자를 받아야 합니다. 이는 마지막 평가 배치 이후에 트리거되며, 함수가 배치 수준의 통계를 누적하는 대신 전역 요약 통계를 계산하고 반환해야 함을 나타냅니다. 이 함수가 받는 로짓은 추가적인 포워드 패스로 다시 계산됩니다. 이 기능은 비추천(deprecated) 상태이며 v2.0.0에서 제거될 예정입니다.
  • callbacks (의 목록 TrainerCallback, 선택 사항) — 학습 루프를 사용자 정의할 콜백 목록입니다. 여기.

    기본으로 사용되는 콜백 중 하나를 제거하려면 remove_callback 메서드를 사용하세요.

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], 선택 사항, 기본값 (None, None)) — 사용할 옵티마이저와 스케줄러를 포함하는 튜플입니다. 기본적으로 모델에 AdamW 인스턴스와 args에 의해 제어되는 get_linear_schedule_with_warmup로 생성된 스케줄러를 사용합니다.
  • quantization_config (BitsAndBytesConfig, 선택 사항) — 모델 식별자로부터 모델을 로드할 때 사용되는 양자화 구성입니다. QLoRA 학습을 위해 peft_config와 함께 사용하세요. 모델이 이미 인스턴스화되어 있으면 무시됩니다.
  • peft_config (PeftConfig, 선택 사항) — 모델을 래핑하는 데 사용되는 PEFT 구성입니다. None인 경우 모델은 래핑되지 않습니다.

Kahneman-Tversky Optimization (KTO) 방법용 Trainer입니다. 이 알고리즘은 KTO: Model Alignment as Prospect Theoretic Optimization 논문에서 처음 제안되었습니다. 이 클래스는 Trainer 클래스를 래핑한 것으로, 해당 클래스의 모든 속성과 메서드를 상속합니다.

예:

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

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

매개변수

  • 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

< >

( output_dir: str | None = None_internal_call: bool = False )

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

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

push_to_hub

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

매개변수

  • commit_message (str, 선택 사항, 기본값 "End of training") — 푸시할 때 커밋할 메시지입니다.
  • blocking (bool, 선택 사항, 기본값 True) — git push가 완료된 후에만 함수가 반환되어야 하는지 여부.
  • token (str, 선택 사항, 기본값 None) — Trainer의 원래 args를 덮어쓸 수 있는 쓰기 권한이 있는 토큰.
  • revision (str, 선택 사항) — 커밋할 git revision입니다. 기본값은 “main” 브랜치의 head입니다.
  • private (bool, 선택 사항) — 리포지토리가 생성될 때 비공개로 만들지 여부입니다. 기본값은 args.hub_private_repo입니다. 리포지토리가 이미 존재하는 경우 효과가 없습니다.
  • kwargs (dict[str, Any], 선택) — ~Trainer.create_model_card에 함께 전달되는 추가 키워드 인자입니다.

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

KTOConfig

클래스 trl.KTOConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'sequential'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Nonemax_length: int | None = 1024pad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: str = 'kto'beta: float = 0.1desirable_weight: float = 1.0undesirable_weight: float = 1.0activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512 )

모델을 제어하는 매개변수

  • model_init_kwargs (dict[str, Any], 선택) — model 인수가 KTOTrainer에 문자열로 제공될 때 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 and 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 논문에서 가져온 KTO 손실.
    • "apo_zero_unpaired": APO 논문에서 제시한 APO-zero 손실의 Unpaired 변형입니다.
  • beta (float, 선택 사항, 기본값 0.1) — 참조 모델과의 편차를 제어하는 매개변수입니다. β 값이 높을수록 참조 모델로부터의 편차가 작아집니다.
  • desirable_weight (float, 선택 사항, 기본값 1.0) — 원하는 손실(desirable loss)은 이 계수로 가중되어, 원하는 쌍과 원하지 않는 쌍의 수가 불균형한 것을 상쇄합니다.
  • undesirable_weight (float, 선택 사항, 기본값 1.0) — 원치 않는 손실은 이 계수로 가중되어, 원치 않는 쌍과 원치 않는 쌍의 수가 불균형한 것을 상쇄합니다.
  • activation_offloading (bool, 선택 사항, 기본값 False) — 활성화를 CPU로 오프로딩할지 여부입니다.
  • sync_ref_model (bool, 선택 사항, 기본값 False) — ref_model_sync_steps 스텝마다 ref_model_mixup_alpha 매개변수를 사용하여 참조 모델을 활성 모델과 동기화할지 여부입니다. 이 동기화 방식은 TR-DPO 논문에서 유래했습니다. 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 논문에서 제시한 τ 파라미터로, 현재 정책이 참조 정책과 얼마나 자주 동기화되는지를 결정합니다. 이 파라미터를 사용하려면 sync_ref_model=True를 설정해야 합니다.

KTOTrainer의 구성 클래스입니다.

이 클래스에는 KTO 학습에 특화된 매개변수만 포함되어 있습니다. 학습 인자의 전체 목록은 TrainingArguments 문서를 참고하세요. 이 클래스의 기본값은 TrainingArguments의 기본값과 다를 수 있습니다.

HfArgumentParser를 사용하면 이 클래스를 커맨드 라인에서 지정할 수 있는 argparse 인수로 변환할 수 있습니다.

이러한 파라미터는 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 보간이 고정 순서 배치의 이웃 예시와 사전 계산되기 때문에, 다른 전략은 이러한 페어링을 깨뜨립니다.
Update on GitHub