# Genel Çevrimiçi Logit Damıtma (GOLD) Eğiticisi

[![All_models-GOLD-blue](https://img.shields.io/badge/All_models-GOLD-blue)](https://huggingface.co/models?other=sft,gold)

## Genel Bakış

Genel Çevrimiçi Logit Damıtma (GOLD), farklı tokenizatorlara sahip öğrenci/öğretmen çiftlerini destekleyen Evrensel Logit Damıtma (ULD) yönteminin bir uzantısıdır. Her iki tokenizatorun ürettiği metin aralıklarını hizalar ve ilişkili logitleri birleştirir, böylece hiçbir tamamlama tokenı düşmez. Bu, karışık model aileleri dahil olmak üzere (örneğin, LLaMA öğrencileri ile Qwen öğretmenleri) tokenizatorlar arası bilgi damıtmasını mümkün kılar.

Temel yetenekler:

1. **Çapraz tokenleştirici hizalama** – GOLD, öğrenci ve öğretmen tokenlerini kademeli olarak çözer, aynı görünür metne sahip pasajları gruplar ve her grup içinde olasılıkları birleştirir. Bu, token sınırları farklı olsa bile kayıp terimlerinin tamamlamanın tamamı üzerinden hesaplandığını garanti eder.
2. **Hybrid ULD kaybı** – `uld_use_hybrid_loss` etkinleştirildiğinde, GOLD tam sözlük eşleşmelerini doğrudan karşılaştırır ve eşleşmeyen jetonlar için orijinal sıralı olasılık ULD kaybına geri döner. Bu, sözlükleri öğretmenden yalnızca kısmen örtüşen öğrenciler için kararlılığı artırır.
3. **GKD ile sorunsuz entegrasyon** – GOLD, [experimental.gkd.GKDTrainer](/docs/trl/v1.18.0/tr/gkd_trainer#trl.experimental.gkd.GKDTrainer)'dan on-policy ve off-policy zamanlamasını devraldığından, dizin düzeyinde KD, genelleştirilmiş JSD ve çapraz tokenizer damıtma işlemlerini tek bir eğitim çalışmasında birleştirebilirsiniz.

> [!NOTE]
> GOLD şu anda `trl.experimental` ad alanının bir parçasıdır. Özellik üzerinde çalışmaya devam edilirken API'ler haber verilmeksizin değiştirilebilir.

## Kullanım ipuçları

[experimental.gold.GOLDTrainer](/docs/trl/v1.18.0/tr/gold_trainer#trl.experimental.gold.GOLDTrainer), [SFTTrainer](/docs/trl/v1.18.0/tr/sft_trainer#trl.SFTTrainer)'in bir alt sınıfıdır ve diğer TRL eğitimcileriyle aynı veri kümelerini (ChatML tarzı mesaj listeleri) kabul eder. [experimental.gold.GOLDConfig](/docs/trl/v1.18.0/tr/gold_trainer#trl.experimental.gold.GOLDConfig)'deki önemli yapılandırma bayrakları şunlardır:

* `use_uld_loss` – Universal Logit Distillation'ı açar/kapatır. Farklı tokenizer'lar için bu değeri `True` olarak ayarlayın.
* `teacher_tokenizer_name_or_path` – `use_uld_loss=True` olduğunda zorunludur; GOLD, tokenleri hizalamak için öğretmen tokenizer'ını kullanır.
* `uld_use_hybrid_loss`, `uld_hybrid_matched_weight`, `uld_hybrid_unmatched_weight` – hibrit eşleşmiş/eşleşmemiş kaybı etkinleştirir ve ağırlıklandırır.
* `beta`, `lmbda`, `seq_kd` – [experimental.gkd.GKDConfig](/docs/trl/v1.18.0/tr/gkd_trainer#trl.experimental.gkd.GKDConfig) sınıfından devralınır; genelleştirilmiş JSD interpolasyonunu ve on-policy örneklem oranını kontrol eder.
* `use_privileged_context`, `teacher_prompt_template`, `privileged_context_column` – öğrenci promptu değiştirilmeden, öğretmenin örnek başına ek bağlam görmesini sağlar. Bu özellik şu anda yalnızca metin, off-policy ve standart-JSD eğitimine sınırlıdır.
* `num_generations`, `generation_batch_size` – gradyan biriktirme pencereleri boyunca tamponlu rollout üretimini kontrol eder. `generation_batch_size`, işçi başına ve optimizasyon adımı başına benzersiz istem sayısını belirtir.

Minimal uçtan uca bir örnek:

```python
from datasets import load_dataset
from trl.experimental.gold import GOLDConfig, GOLDTrainer

train_dataset = load_dataset(
    "HuggingFaceTB/OpenR1-Math-220k-default-verified",
    "all",
    split="train[:1024]",
)

trainer = GOLDTrainer(
    model="meta-llama/Llama-3.2-1B-Instruct",
    teacher_model="Qwen/Qwen2.5-0.5B-Instruct",
    args=GOLDConfig(output_dir="gold-model", use_uld_loss=True, teacher_tokenizer_name_or_path="Qwen/Qwen2.5-0.5B-Instruct"),
    train_dataset=train_dataset,
)
trainer.train()
```

Hızlı başlangıç iş akışlarında, yukarıda gösterildiği gibi dizgi tanımlayıcılarına güvenebilirsiniz—eğitmen modeli ve belirteçleyiciyi sizin için yükleyecektir. `AutoModelForCausalLM`, `AutoTokenizer` sınıflarını açıkça örneklemek veya `GOLDConfig` yapılandırmasını doldurmak, yalnızca başlatma üzerinde ince ayar düzeyinde kontrol gerektiren ileri düzey kullanım durumları için önerilir.

Model yükleme, tokenizer ayarları veya eğitim argümanlarını özelleştirmeniz gerektiğinde daha açık bir kurulum aşağıdaki gibi görünebilir:

```python
from datasets import load_dataset
from trl.experimental.gold import GOLDConfig, GOLDTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

student_name = "meta-llama/Llama-3.2-1B-Instruct"
teacher_name = "Qwen/Qwen2.5-0.5B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(student_name)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(student_name)
teacher_model = AutoModelForCausalLM.from_pretrained(teacher_name)

train_dataset = load_dataset(
    "HuggingFaceTB/Countdown-Task-GOLD",
    "verified_Qwen2.5-0.5B-Instruct",
    split="train",
)

training_args = GOLDConfig(
    output_dir="gold-model",
    per_device_train_batch_size=1,
    teacher_model_name_or_path=teacher_name,
    teacher_tokenizer_name_or_path=teacher_name,
    use_uld_loss=True,
    uld_use_hybrid_loss=True,
)

trainer = GOLDTrainer(
    model=model,
    teacher_model=teacher_model,
    args=training_args,
    processing_class=tokenizer,
    train_dataset=train_dataset,
)
trainer.train()
```

> [!NOTE]
> GOLD, tam bir optimizör penceresi üretim partisini (`per_device_train_batch_size * gradient_accumulation_steps`) tamponlar ve bunu birikim adımları arasında yeniden kullanır. Son parti boyutundan küçükse, GOLD uyarı verir ve son partiyi atar (`Dropping last batch due to unexpected batch size`). Bu uyarıdan kaçınmak için `dataloader_drop_last=True` değerini ayarlayın.

### Beklenen veri seti türü

GOLD, [konuşma](dataset_formats#conversational) [dil modelleme](dataset_formats#language-modeling) veri seti gerektirir, örn.:

```python
{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}
```

`GOLDTrainer`, ChatML collator'ın doğru sınırlarla prompt ve tamamlamaları oluşturabilmesi için ham mesajları saklar.

## Özel Bağlam

Özel bağlam damıtma, öğrencinin çıkarım sırasında erişemeyeceği ek bilgiyi öğretmene sağlar. Normal bir istem/tamamlama veri setine bir bağlam sütunu ekleyin, ardından bu özelliği açıkça etkinleştirin:

```python
from datasets import Dataset

dataset = Dataset.from_list(
    [
        {
            "prompt": [{"role": "user", "content": "What caused the outage?"}],
            "completion": [{"role": "assistant", "content": "A timeout change caused the outage."}],
            "privileged_context": "The deployment changed the timeout immediately before errors began.",
        }
    ]
)

args = GOLDConfig(
    output_dir="gold-model",
    lmbda=0.0,
    use_privileged_context=True,
)
```

Öğrenci, orijinal istem ve tamamlama üzerinde eğitilir. Öğretmen, varsayılan olarak `"{prompt}\n\n{privileged_context}"` içinden oluşturulan ayrı bir istemi alır ve ardından tam olarak aynı tamamlamayı puanlar. Sohbet verisi için GOLD, sohbet şablonunun yeniden uygulanmasından önce yalnızca son kullanıcı turunu yeniden yazar; sistem, araç ve asistan turları değiştirilmez. Bu istemi özelleştirmek için `teacher_prompt_template` değerini ayarlayın ve `"privileged_context"` dışında bir sütun kullanmak için `privileged_context_column` değerini ayarlayın.

Öğretmen istemi asla kısaltılmaz, bu nedenle öğretmen modelinin bağlam penceresine sığdığından emin olun. Bu ilk destek, bilinçli olarak metne ve off-policy standart JSD damıtmasına sınırlıdır: `lmbda` `0` olmalı ve `seq_kd=True`, `use_uld_loss=True`, X-Token KD (`xtoken_loss_type` `"none"` dışında), packing, VLM'ler ve Liger Kernel ayrıcalıklı bağlamla desteklenmez.

## Token Birleştirme Nasıl Çalışır

Öğrenci ve öğretmen farklı tokenizörler kullandığında, aynı metin farklı şekilde bölünebilir:

- **Öğrenci**: `"Hugging Face"` → 1 token
- **Öğretmen**: `"Hugging"`, `" Face"` → 2 token

GOLD bu dizileri hizalar ve öğretmenin çoklu jeton olasılıklarını, öğrencinin tek jeton dağılımıyla karşılaştırılabilecek tek bir dağıtıma birleştirir.

### Olasılık Birleştirme

Tek bir öğrenci jetonuna eşlenen `[token₀, token₁, ..., tokenₖ]` jetonlarından oluşan bir öğretmen dizisi için GOLD şu işlemi hesaplar:

```
P_merged(y) = P(y | context) × P(token₁ | token₀, context) × ... × P(tokenₖ | ..., context)
```

burada:
- `P(y | context)`, ilk konumdaki tüm sözlük belirteçleri üzerindeki marjinal olasılık dağılımıdır
- `P(tokenᵢ | ..., context)`, üretilen gerçek tokenların **skaler** koşullu olasılıklarıdır

**Temel içgörü**: Sadece **gerçek devam jetonlarının** koşullu olasılıkları skalerler olarak çıkarılır. İlk konumdaki tam marjinal dağılım, bu skaler olasılıklarla çarpılarak ölçeklendirilir.

Bununla şunlar sağlanır:
1. Gerçek üretilen dizinin **doğru ortak olasılığı** (zincir kuralı ile)
2. **Makul yaklaşım** karşıfaktüel jetonlar için (aynı devam olasılığıyla ölçeklenmiş)
3. ULD kaybı hesaplama için doğru göreli olasılıkları koruyan **normalize edilmemiş dağılımlar**

### Örnek

Verilen:
```
P(x₀):         ["HF": 0.6,  "is": 0.3,  "cool": 0.1]
P(x₁ | "HF"):  ["HF": 0.05, "is": 0.9,  "cool": 0.05]
```

0 ve 1 numaralı jetonlar birleştirildiyse ve asıl dizi `["HF", "is"]` idiysa:
```
P_merged("HF")   = 0.6 × 0.9 = 0.54  ✓ (correct joint probability)
P_merged("is")   = 0.3 × 0.9 = 0.27
P_merged("cool") = 0.1 × 0.9 = 0.09
```

Birleştirilmiş dağılım normalize edilmemiştir (toplamı 0.81'dir), ancak bu ULD kayıp hesabı için kasıtlı ve doğrudur; bu hesaplama sıralama ve L1 mesafesi kullanır.

## Örnek betik

Komut satırından GOLD eğitimini başlatmak için [`examples/gold_chatbot_arena/gold_chatbot_arena.py`](https://github.com/huggingface/trl/blob/main/examples/gold_chatbot_arena/gold_chatbot_arena.py) dosyasını kullanın. Betik, standart `ModelConfig` bayrakları aracılığıyla tam eğitim ve LoRA'yı destekler.

```bash
python examples/gold_chatbot_arena/gold_chatbot_arena.py \
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
    --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \
    --dataset_name trl-lib/chatbot_arena_completions \
    --learning_rate 2e-5 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 8 \
    --output_dir gold-model \
    --num_train_epochs 1 \
    --push_to_hub
```

## Görsel Dil Modellerinin Eğitimi

[experimental.gold.GOLDTrainer](/docs/trl/v1.18.0/tr/gold_trainer#trl.experimental.gold.GOLDTrainer), VLM'den VLM'ye damıtma (distillation) destekler. Hem öğrenci hem de öğretmen, görsel-dil modelleri olmalıdır. Bir VLM eğitmek için, veri setinde `image` sütunu (örnek başına tek görsel) veya `images` sütunu (örnek başına görsel listesi) bulunmalıdır. Beklenen veri seti yapısı hakkında daha fazla bilgi için [Veri Seti Biçimi — Görsel veri setleri](dataset_formats#vision-datasets) bölümüne bakın.

Öğrenci ve öğretmen aynı mimariyi ve tokenizer'ı paylaşıyorsa (ör. Qwen3-VL-8B'den Qwen3-VL-2B'ye), standart genelleştirilmiş JSD kaybı doğrudan uygulanır. Farklı `model_type` değerlerine sahiplerse (ör. Qwen3-VL'den LFM2.5-VL'ye), Universal Logit Distillation ile cross-tokenizer hizalamayı etkinleştirmek için `use_uld_loss=True` ayarlayın. Görseller, her modelin kendi işlemcisi üzerinden ayrı ayrı işlenir.

```python
from datasets import load_dataset
import torch
from transformers import AutoModelForImageTextToText, AutoProcessor
from trl.experimental.gold import GOLDConfig, GOLDTrainer

student_name = "Qwen/Qwen3-VL-2B-Instruct"
teacher_name = "Qwen/Qwen3-VL-8B-Instruct"

processor = AutoProcessor.from_pretrained(student_name, padding_side="left")
student_model = AutoModelForImageTextToText.from_pretrained(student_name, dtype=torch.bfloat16)
teacher_model = AutoModelForImageTextToText.from_pretrained(teacher_name, dtype=torch.bfloat16)

train_dataset = load_dataset("trl-lib/llava-instruct-mix", split="train")

trainer = GOLDTrainer(
    model=student_model,
    teacher_model=teacher_model,
    args=GOLDConfig(
        output_dir="gold-vlm-model",
        max_length=None,
        teacher_model_name_or_path=teacher_name,
        use_uld_loss=False,
    ),
    train_dataset=train_dataset,
    processing_class=processor,
)
trainer.train()
```

Aileler arası damıtma için `use_uld_loss=True` ve `teacher_tokenizer_name_or_path` değerlerini öğretmen model adıyla ayarlayın.

Komut satırından GOLD VLM eğitimini başlatmak için [`examples/gold_qwen3_vl/gold_qwen3_vl.py`](https://github.com/huggingface/trl/blob/main/examples/gold_qwen3_vl/gold_qwen3_vl.py) dosyasını kullanın:

```bash
# Same-family distillation (JSD loss, vLLM enabled)
torchrun --nproc_per_node 8 examples/gold_qwen3_vl/gold_qwen3_vl.py \
    --student_model_name Qwen/Qwen3-VL-2B-Instruct \
    --teacher_model_name Qwen/Qwen3-VL-8B-Instruct

# Cross-family distillation (ULD loss, local generation)
torchrun --nproc_per_node 8 examples/gold_qwen3_vl/gold_qwen3_vl.py \
    --student_model_name LiquidAI/LFM2.5-VL-1.6B \
    --teacher_model_name Qwen/Qwen3-VL-8B-Instruct \
    --use_uld_loss \
    --no-use_vllm
```

> [!TIP]
> VLM'ler için, görüntü token'ları dizinin istem (prompt) bölümünde yer aldığı ve sessizce atılabilme riski taşıdığından `truncation_mode='keep_end'` desteklenmez. Bunun yerine `truncation_mode='keep_start'` (varsayılan) kullanın veya [experimental.gold.GOLDConfig](/docs/trl/v1.18.0/tr/gold_trainer#trl.experimental.gold.GOLDConfig) içinde `max_length=None` olarak ayarlayın. Bu, modelin görüntü token'larını kısaltmadan tam dizi uzunluğunu işlemesine olanak tanır.
>
> ```python
> GOLDConfig(max_length=None, ...)
> ```
>
> Tüm veri seti için kırpmanın görüntü belirteçlerini kaldırmayacağını doğruladığınızda yalnızca `max_length` kullanın.

> [!NOTE]
> Mimari arası VLM damıtma işlemi `use_uld_loss=True` parametresini gerektirir. ULD kaybı olmadan mimari arası damıtma işlemi denendiğinde eğitimci bir hata oluşturur.

## GOLDTrainer[[trl.experimental.gold.GOLDTrainer]]

#### trl.experimental.gold.GOLDTrainer[[trl.experimental.gold.GOLDTrainer]]

```python
trl.experimental.gold.GOLDTrainer(model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str, NoneType] = None, teacher_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str] = None, args: trl.experimental.gold.gold_config.GOLDConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: datasets.arrow_dataset.Dataset | None = None, eval_dataset: datasets.arrow_dataset.Dataset | dict[str, datasets.arrow_dataset.Dataset] | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | 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[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, peft_config: typing.Optional[ForwardRef('PeftConfig')] = None)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/gold/gold_trainer.py#L1233)

#### train[[trl.experimental.gold.GOLDTrainer.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)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L1450)

**Parametreler:**

resume_from_checkpoint (`str` veya `bool`, *isteğe bağlı*) : `str` ise, önceki bir `Trainer` örneği tarafından kaydedilen bir kontrol noktasının yerel yolu. `bool` ise ve `True` değerine eşitse, önceki bir `Trainer` örneği tarafından *args.output_dir* içinde kaydedilen son kontrol noktasını yükler. Mevcut ise, eğitim burada yüklenen model/optimizer/scheduler durumlarından devam eder.

trial (`optuna.Trial` veya `dict[str, Any]`, *isteğe bağlı*) : Hiperparametre araması için deneme çalışması veya hiperparametre sözlüğü.

ignore_keys_for_eval (`list[str]`, *isteğe bağlı*) : Modelinizin çıktısında (bir sözlükse) eğitim sırasında değerlendirme için tahminleri toplarken yok sayılması gereken anahtarların listesi.

**Dönüş:** `~trainer_utils.TrainOutput`

Küresel adım sayısını, eğitim kaybını ve metrikleri içeren nesne.

Ana eğitim giriş noktası.

#### generate_on_policy_outputs[[trl.experimental.gold.GOLDTrainer.generate_on_policy_outputs]]

```python
generate_on_policy_outputs(model, inputs, generation_config)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/gold/gold_trainer.py#L3356)

#### save_model[[trl.experimental.gold.GOLDTrainer.save_model]]

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

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4077)

Modeli kaydeder, böylece `from_pretrained()` kullanarak yeniden yükleyebilirsiniz.

Yalnızca ana süreçten kaydedecektir.

#### push_to_hub[[trl.experimental.gold.GOLDTrainer.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)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4337)

**Parametreler:**

commit_message (`str`, *isteğe bağlı*, varsayılan `"End of training"`) : İterlerken gönderilecek mesaj.

blocking (`bool`, *isteğe bağlı*, varsayılan `True`) : Fonksiyonun yalnızca `git push` işlemi tamamlandığında mı dönmeli.

token (`str`, *isteğe bağlı*, varsayılan `None`) : Trainer'ın orijinal argümanlarını üzerine yazma iznine sahip jeton.

revision (`str`, *isteğe bağlı*) : Taahhüt edilecek git revizyonu. Varsayılan olarak "main" dalının başıdır.

private (`bool`, *isteğe bağlı*) : Oluşturulduğunda depoyu özel yapılıp yapılmayacağını belirtir. Varsayılan olarak `args.hub_private_repo` değerini kullanır. Depo zaten mevcutsa etkisi yoktur.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : `~Trainer.create_model_card`'e iletilen ek anahtar kelime argümanları.

**Dönüş:**

`blocking=False` ise modelin itildiği depoyun URL'si, `blocking=True` ise commit'in ilerlemesini izleyen bir `Future` nesnesi.

`self.model` ve `self.processing_class` öğelerini `self.args.hub_model_id` deposundaki 🤗 model hub'ına yükleyin.

## GOLDConfig[[trl.experimental.gold.GOLDConfig]]

#### trl.experimental.gold.GOLDConfig[[trl.experimental.gold.GOLDConfig]]

```python
trl.experimental.gold.GOLDConfig(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-07, 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 = True, 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 = 'random', 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, chat_template_path: str | None = None, dataset_text_field: str = 'text', dataset_kwargs: dict[str, typing.Any] | str | None = None, dataset_num_proc: int | None = None, eos_token: str | None = None, max_length: int | None = 1024, truncation_mode: str = 'keep_start', shuffle_dataset: bool = False, packing: bool = False, packing_strategy: str = 'bfd', padding_free: bool = False, pad_to_multiple_of: int | str | None = 'auto', eval_packing: bool | None = None, completion_only_loss: bool | None = None, assistant_only_loss: bool = False, loss_type: str = 'nll', activation_offloading: bool = False, pad_token: str | None = None, temperature: float = 0.9, top_p: float = 0.95, top_k: int = 0, lmbda: float = 0.5, beta: float = 0.5, max_completion_length: int = 128, teacher_model_name_or_path: str | None = None, teacher_model_revision: str | None = None, teacher_model_init_kwargs: dict[str, typing.Any] | str | None = None, teacher_tokenizer_name_or_path: str | None = None, disable_dropout: bool = True, seq_kd: bool = False, use_privileged_context: bool = False, teacher_prompt_template: str | None = None, privileged_context_column: str = 'privileged_context', num_generations: int = 1, generation_batch_size: int | None = None, use_uld_loss: bool = False, uld_token_merge_strategy: str = 'observed', use_extended_uld: bool = True, uld_use_hybrid_loss: bool = False, uld_hybrid_matched_weight: float | None = None, uld_hybrid_unmatched_weight: float | None = None, uld_crossentropy_weight: float = 0.0, uld_distillation_weight: float = 1.0, uld_student_temperature: float = 1.0, uld_teacher_temperature: float = 1.0, uld_skip_student_eos: bool = True, uld_skip_teacher_eos: bool = True, xtoken_loss_type: str = 'none', xtoken_projection_matrix_path: str | None = None, xtoken_temperature: float = 1.0, xtoken_dynamic_scaling: bool = True, xtoken_uncommon_topk: int = 8192, xtoken_vocab_topk: int = 8192, xtoken_kl_weight: float = 1.0, xtoken_ce_scale: float = 0.1, use_vllm: bool = False, vllm_mode: str = 'colocate', vllm_server_base_url: str | None = None, vllm_server_host: str = '0.0.0.0', vllm_server_port: int = 8001, vllm_server_timeout: float = 240.0, vllm_group_port: int = 51216, vllm_gpu_memory_utilization: float = 0.9, vllm_tensor_parallel_size: int = 1, vllm_max_model_length: int | None = None, vllm_model_impl: str = 'vllm', vllm_structured_outputs_regex: str | None = None, vllm_sync_frequency: int = 1, vllm_enable_sleep_mode: bool = False, log_completions: bool = False, log_completions_steps: int = 100, num_completions_to_print: int | None = None, wandb_log_unique_prompts: bool = True, callbacks: list[str] = <factory>)
```

[Kaynak](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/gold/gold_config.py#L23)

**Üretim ve eğitim döngüsünü kontrol eden parametreler:**

temperature (`float`, *isteğe bağlı*, varsayılan `0.9`) : Örnekleme için sıcaklık. Sıcaklık ne kadar yüksekse, tamamlamalar o kadar rastgele olur.

top_p (`float`, *opsiyonel*, varsayılan `0.95`) : float < 1 olarak ayarlanırsa, üretim için yalnızca olasılıkları `top_p` veya daha yüksek bir toplamda birleşen en küçük en olası token kümesi korunur.

top_k (`int`, *opsiyonel*, varsayılan `0`) : top-k filtreleme için en yüksek olasılığa sahip kaç sözlük token'ının tutulacağı. `0` ise top-k filtreleme devre dışıdır ve tüm token'lar dikkate alınır.

lmbda (`float`, *isteğe bağlı*, varsayılan `0.5`) : Öğrenci veri oranını (yani, politika üzerinde öğrenci tarafından üretilen çıktıların oranını) kontrol eden Lambda parametresi.

beta (`float`, *opsiyonel*, varsayılan `0.5`) : Genel Jensen-Shannon Divergence kaybının `0.0` ile `1.0` arasındaki interpolasyon katsayısı. beta `0.0` olduğunda, kayıp KL divergence'dır. beta `1.0` olduğunda, kayıp Inverse KL Divergence'dır.

max_completion_length (`int`, *isteğe bağlı*, varsayılan `128`) : Tamamlama başına üretilecek maksimum token sayısı.

teacher_model_name_or_path (`str`, *isteğe bağlı*) : Öğretmen modelinin adı veya yolu. `None` ise, öğretmen modeli eğitilen modelle aynı olacaktır.

teacher_model_revision (`str` veya `None`, *isteğe bağlı*, varsayılan `None`) : Öğretmen modelinin revizyonu (ör. dal adı, etiket veya commit hash'i). `None` ise varsayılan revizyon kullanılır.

teacher_model_init_kwargs (`dict[str, Any]`, *isteğe bağlı*) : Öğretmen modelini bir dizgeden örneklerken `AutoModelForCausalLM.from_pretrained` fonksiyonuna iletilecek anahtar kelime argümanları. `revision` değeri, öğretmen işleme sınıfı yüklenirken de kullanılır.

teacher_tokenizer_name_or_path (`str`, *isteğe bağlı*) : Öğretmen modeli için tokenizer adı veya yolu. ULD kaybı kullanılırken None ise, öğrenci modeliyle aynı tokenizer kullanılır (çapraz tokenizer damıtması için önerilmez).

disable_dropout (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelde dropout'un devre dışı bırakılıp bırakılmayacağı.

seq_kd (`bool`, *isteğe bağlı*, varsayılan `False`) : Sequence-Level KD'nin (öğretmen tarafından üretilen çıktı üzerinde denetimli FT olarak görülebilir) uygulanıp uygulanmayacağını kontrol eden Seq_kd parametresi.

use_privileged_context (`bool`, *isteğe bağlı*, varsayılan `False`) : Öğrenci istemini değiştirmeden, öğretmenin örnek başına ayrıcalıklı bağlama koşullandırılıp koşulmayacağını belirtir. Bu, yalnızca metin için, politika dışı standart JSD damıtma ile desteklenir.

teacher_prompt_template (`str`, *isteğe bağlı*) : Öğretmen istemini oluşturmak için kullanılan şablon. `{prompt}` içermesi zorunludur ve `{privileged_context}` içerebilir. `None` olduğunda, varsayılan olarak `"{prompt}\n\n{privileged_context}"` kullanılır.

privileged_context_column (`str`, *isteğe bağlı*, varsayılan `"privileged_context"`) : Öğretmen istemini oluşturmak için örnek başına ayrıcalıklı bağlamı içeren veri seti sütunu.

num_generations (`int`, *isteğe bağlı*, varsayılan `1`) : İstek başına üretim sayısı. Her istek, üretim grubunda bu kadar kez tekrarlanır.

generation_batch_size (`int` veya `None`, *isteğe bağlı*, varsayılan `None`) : İşçi başına ve optimizasyon adımı başına benzersiz istem sayısı. `None` ise, `(per_device_train_batch_size * gradient_accumulation_steps) // num_generations` ifadesinden hesaplanır.

**ULD kaybını kontrol eden parametreler:**

use_uld_loss (`bool`, *isteğe bağlı*, varsayılan `False`) : Genel Jensen-Shannon Divergence kaybı yerine Universal Logit Distillation (ULD) kaybının kullanılıp kullanılmayacağı.

use_extended_uld (`bool`, *isteğe bağlı*, varsayılan `True`) : Öğrenci ve öğretmen tokenizasyonları arasında token olasılıklarını hizalamak ve birleştirmek için tokenizörler kullanan genişletilmiş ULD hizalamasını etkinleştirip etkinleştirmeyeceğini belirtir. `True` olduğunda, eğitimci bölünmüş tokenlar için token eşlemelerini hesaplar ve olasılıkları birleştirir; `False` olduğunda, ULD orijinal ULD makalesindeki gibi basit konumsal kırpma kullanır. Ne ByteLevel ne de byte-fallback BPE olan tokenizörler (ör. Llama 2) için `False` olarak ayarlayın.

uld_token_merge_strategy (`str`, *isteğe bağlı*, varsayılan `"observed"`) : ULD kaybında cevap logitlerini hizalamak ve token olasılıklarını birleştirmek için kullanılan strateji. `"observed"` ile, cevap logitleri cevap konumlarında dilimlenir ve bölünmüş tokenlar (`use_extended_uld=True` olduğunda) ilk konumdaki marjinal dağılımın, gerçek sonraki tokenların skaler koşullu olasılıklarıyla çarpılması yoluyla birleştirilir. `"bayesian"` ile, cevap-logit dilimi bir konum öncesine kaydırılır, böylece `probs[k]` `token_ids[k]` değerini tahmin eder (zincir kuralı) ve bölünmüş tokenlar, gerçek önek tokenlarına koşullu son konumun tam dağılımı ile, önceki tokenların skaler olasılıklarıyla çarpılarak birleştirilir. Logit hizalama kayması, `use_extended_uld` etkinleştirilip etkinleştirilmediğine bakılmaksızın uygulanır.

uld_use_hybrid_loss (`bool`, *isteğe bağlı*, varsayılan `False`) : ULD kaybını ve JSD kaybını birleştiren hibrit bir kayıp kullanılıp kullanılmayacağı. `True` olduğunda, nihai kayıp bilinen token eşlemeleri için JSD ve bilinmeyen token eşlemeleri için ULD'nin bir kombinasyonudur.

uld_hybrid_matched_weight (`float` veya `None`, *isteğe bağlı*) : Hibrit ULD + JSD kaybı kullanılırken eşleşen token kaybı bileşeni için ağırlık. Bu ağırlık, öğrenci ve öğretmen tokenizasyonları arasında doğrudan bir eşleme bulunan tokenlar üzerinde hesaplanan JSD kaybını ölçekler. `None` ise, sözlük örtüşmesine dayalı adaptif ağırlama kullanılır. `uld_hybrid_unmatched_weight` ile birlikte ayarlanmalıdır (ikisi de `None` veya ikisi de `float` olmalıdır).

uld_hybrid_unmatched_weight (`float` veya `None`, *isteğe bağlı*) : Hibrit ULD + JSD kaybı kullanıldığında eşleşmeyen token kaybı bileşeni için ağırlık. Bu ağırlık, öğrenci ve öğretmen tokenizasyonları arasında doğrudan bir eşleme bulunmayan tokenlar üzerinde hesaplanan ULD kaybını ölçekler. `None` ise, sözlük örtüşmesine dayalı adaptif ağırlama kullanılır. `uld_hybrid_matched_weight` ile birlikte ayarlanmalıdır (ikisi de `None` veya ikisi de `float`).

uld_crossentropy_weight (`float`, *isteğe bağlı*, varsayılan `0.0`) : ULD kaybında çapraz entropi kaybı bileşeninin ağırlığı. 0 ise yalnızca ULD damıtma kaybı kullanılır.

uld_distillation_weight (`float`, *isteğe bağlı*, varsayılan `1.0`) : ULD kaybında damıtma kaybı bileşeni için ağırlık.

uld_student_temperature (`float`, *isteğe bağlı*, varsayılan `1.0`) : ULD kaybı hesabında öğrenci logitleri için sıcaklık.

uld_teacher_temperature (`float`, *isteğe bağlı*, varsayılan `1.0`) : ULD kaybı hesabında öğretmen logitleri için sıcaklık.

uld_skip_student_eos (`bool`, *isteğe bağlı*, varsayılan `True`) : ULD kayıp hesabında öğrenci için EOS token'ının atlanıp atlanmayacağı.

uld_skip_teacher_eos (`bool`, *isteğe bağlı*, varsayılan `True`) : ULD kayıp hesabında öğretmen için EOS token'ının atlanıp atlanmayacağı.

**X-Token çapraz-tokenizer KD parametreleri (https:**

xtoken_loss_type (`str`, *isteğe bağlı*, varsayılan `"none"`) : Cross-tokenizer KD varyantı: `"none"` (devre dışı), `"p_kl"` (projection KL) veya `"h_kl"` (gevşetilmiş ortak küme ile hibrit KL). `teacher_tokenizer_name_or_path` ve `xtoken_projection_matrix_path` gerektirir.

xtoken_projection_matrix_path (`str`, *isteğe bağlı*) : Ön hesaplanmış bir projeksiyon matrisi dosyasının yolu. `xtoken_loss_type != "none"` olduğunda zorunludur.

xtoken_temperature (`float`, *isteğe bağlı*, varsayılan `1.0`) : X-Token KD kaybı için sıcaklık T; kayıp T² ile çarpılır (Hinton 2015).

xtoken_dynamic_scaling (`bool`, *isteğe bağlı*, varsayılan `True`) : Kayıp büyüklüklerini dengelemek için (kağıt Denk. 7) KD'yi her mikrotoplu için `stop_gradient(abs(CE) / abs(KD))` ile ölçekler.

xtoken_uncommon_topk (`int`, *isteğe bağlı*, varsayılan `8192`) : H-KL: sıralanmış-L1 nadir karşılaştırmayı, her taraf için en iyi-k token'a sınırlar.

xtoken_vocab_topk (`int`, *isteğe bağlı*, varsayılan `8192`) : P-KL: KL'yi, en yüksek logit'e göre küresel üst-k öğretmen tokenlarına sınırlar. `--top-k` projeksiyon matrisiyle etkileşime girer: matrisin erişim alanı dışındaki öğretmen tokenları, neredeyse sıfıra yakın projekte edilmiş öğrenci kütlesi alır ve KL'yi baskı altına alır; bu nedenle daha küçük değerler, kaybı öğrencinin eşleştirebileceği tokenlara yoğunlaştırır.

xtoken_kl_weight (`float`, *isteğe bağlı*, varsayılan `1.0`) : `xtoken_dynamic_scaling=False` olduğunda X-Token KD terimi için ağırlık.

xtoken_ce_scale (`float`, *isteğe bağlı*, varsayılan `0.1`) : `xtoken_dynamic_scaling=False` olduğunda X-Token kaybındaki CE terimi için ölçekleme faktörü.

**vLLM entegrasyonunu kontrol eden parametreler:**

use_vllm (`bool`, *isteğe bağlı*, varsayılan `False`) : Öğrenci modelinden tamamlamalar üretmek için vLLM kullanılacak mı? Bunun için `vllm`'in yüklü olması gerekir.

vllm_mode (`str`, *isteğe bağlı*, varsayılan `"colocate"`) : Öğrenci vLLM entegrasyonu için mod. Ya `"server"` (çalışan bir vLLM sunucusuna bağlan) ya da `"colocate"` (vLLM'yi aynı süreçte çalıştır).

vllm_server_host (`str`, *isteğe bağlı*, varsayılan `"0.0.0.0"`) : Öğrenci modeli için vLLM sunucusunun ana makinesi (eğer `vllm_mode="server"` ise).

vllm_server_port (`int`, *isteğe bağlı*, varsayılan `8001`) : Öğrenci modeli için vLLM sunucusunun portu (`vllm_mode="server"` ise).

vllm_server_timeout (`float`, *isteğe bağlı*, varsayılan `240.0`) : Öğrenci vLLM sunucusuna bağlanma zaman aşımı (eğer `vllm_mode="server"` ise).

vllm_gpu_memory_utilization (`float`, *isteğe bağlı*, varsayılan `0.9`) : Yerleşik (colocated) öğrenci vLLM motoru için GPU bellek kullanımı (`vllm_mode="colocate"` ise). Öğrenci ve öğretmen modelleri aynı GPU'yu paylaşıyorsa, bu değerin düşük bir değere ayarlanması önerilir.

vllm_tensor_parallel_size (`int`, *isteğe bağlı*, varsayılan `1`) : Yerleşik (colocated) öğrenci vLLM motoru için Tensor paralel boyutu (eğer `vllm_mode="colocate"` ise).

vllm_structured_outputs_regex (`str`, *isteğe bağlı*) : Öğrenci modeli için vLLM yapılandırılmış çıktıları için regex.

vllm_server_base_url (`str`, *isteğe bağlı*) : vLLM sunucusu için temel URL (ör. `"http://localhost:8001"`). Sağlanırsa, `vllm_server_host` ve `vllm_server_port` yok sayılır.

vllm_group_port (`int`, *isteğe bağlı*, varsayılan `51216`) : vLLM ağırlık güncelleme grubu (NCCL iletişimcisi) için port. Port meşgul değilse değiştirmeye gerek yoktur.

vllm_max_model_length (`int`, *isteğe bağlı*) : `vllm_mode="colocate"` olduğunda, yerleşik (colocated) vLLM motoru için maksimum model dizisi uzunluğu. Varsayılan olarak modelin maksimum bağlam uzunluğuna ayarlanır.

vllm_model_impl (`str`, *isteğe bağlı*, varsayılan `"vllm"`) : vLLM'de kullanılacak model uygulama arka ucu. `"vllm"` (varsayılan) veya `"transformers"` kullanın.

vllm_sync_frequency (`int`, *isteğe bağlı*, varsayılan `1`) : Öğrenci model ağırlıklarının vLLM motoruyla senkronize edileceği sıklık (eğitim adımı cinsinden). Her adımdan sonra senkronize etmek için 1 olarak ayarlayın.

vllm_enable_sleep_mode (`bool`, *isteğe bağlı*, varsayılan `False`) : Optimizer adımında öğrenci ağırlıklarını/önbelleğini boşaltmak için vLLM uyku modunu etkinleştirir. GPU bellek kullanımını düşük tutar, ancak motorun uyanması host–cihaz aktarma gecikmesi ekler.

**Kayıtları kontrol eden parametreler:**

log_completions (`bool`, *isteğe bağlı*, varsayılan `False`) : Her `logging_steps` adımında (prompt, completion) çiftlerinin bir örneğinin günlüğe kaydedilip kaydedilmeyeceğini belirtir. `rich` yüklüyse, örnek yazdırılır. `wandb` günlüğü etkinleştirildiyse, `wandb` üzerinden günlüğe kaydedilir.

log_completions_steps (`int`, *isteğe bağlı*, varsayılan `100`) : Günlüğe kaydedilen (prompt, completion) çiftleri arasındaki adım sayısı. Yalnızca `log_completions` `True` olarak ayarlanırsa kullanılır.

num_completions_to_print (`int` veya `None`, *isteğe bağlı*) : `rich` ile yazdırılacak tamamlama sayısı. `None` ise tüm tamamlamalar günlüğe kaydedilir.

wandb_log_unique_prompts (`bool`, *isteğe bağlı*, varsayılan `True`) : Benzersiz istemlerin wandb'ye kaydedilip kaydedilmeyeceğini belirtir. Bu, her benzersiz istem için yeni bir çalışma oluşturur.

callbacks (`list[str]`, *isteğe bağlı*, varsayılan `[]`) : Eğitim sırasında çalıştırılacak geri bildirimler.

[experimental.gold.GOLDTrainer](/docs/trl/v1.18.0/tr/gold_trainer#trl.experimental.gold.GOLDTrainer) için yapılandırma sınıfı.

Bu sınıf yalnızca GOLD eğitimine özgü parametreleri içerir. Eğitim argümanlarının tam listesi için lütfen [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) ve [SFTConfig](/docs/trl/v1.18.0/tr/sft_trainer#trl.SFTConfig) belgelerine başvurun.

> [!NOTE]
> Bu parametrenin [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments)'ten farklı varsayılan değerleri vardır: - `learning_rate`: Varsayılan olarak `5e-5` yerine `1e-7` değerini alır.

