Büyük Dil Modellerinizi Hangi Sınıf ile Eğitmelisiniz?

Trainer, SFTTrainer, AutoTrainer ve DataCollator sınıflarını tanıyıp parametrelerini öğreneceğiz ve ardından Auto Train hakkında konuşacağız.

Modellerimizi eğitirken Trainer, SFTTrainer veya AutoTrainer gibi çerçeveleri kullanabiliriz. Gelin bunların ne olduğunu ve nasıl çalıştıklarını öğrenelim.

Trainer Sınıfı

Trainer sınıfı, PyTorch’ta özellik tamamlama eğitimi için bir API sağlar ve birden fazla NVIDIA veya AMD GPU’lar veya TPU’lar üzerinde dağıtılmış eğitimi ve PyTorch için torch.amp’i destekler. Trainer, bir modelin eğitilme şeklini özelleştirmek için geniş bir seçenek yelpazesi sunan TrainingArguments sınıfıyla birlikte çalışır. Bu iki sınıf birlikte eksiksiz bir eğitim API’si sağlarlar. [1]

Huggingface’ten Olmayan Bir Model Eğitecekseniz

Trainer sınıfı Huggingface transformers modelleri için optimize edilmiştir ve diğer modellerle kullanıldığında şaşırtıcı davranışlara sahip olabilir. Kendi modelinizle kullanırken şunlardan emin olun[1]:

• Modeliniz her zaman ModelOutput ’un tuple’larını veya alt sınıflarını döndürmelidir.[1]
• Bir labels argümanı sağlanırsa ve bu kayıp, tuple’ın ilk öğesi olarak döndürülürse (eğer modeliniz tuple’lar döndürüyorsa), modeliniz kaybı hesaplayabilir. [1]
• Modeliniz birden fazla etiket bağımsız değişkenini kabul edebilir (adlarını Trainer’a belirtmek için TrainingArguments’ta label_names kullanın) ancak bunların hiçbiri “label” olarak adlandırılmamalıdır. [1]

transformers.Trainer

Aşağıda Trainer sınıfının parametrelerini ve onların varsayılan değerlerini görebilirsiniz.

transformers.Trainer(model: Union = None,
                     args: TrainingArguments = None,
                     data_collator: Optional = None,
                     train_dataset: Union = None,
                     eval_dataset: Union = None,
                     tokenizer: Optional = None,
                     model_init: Optional = None,
                     compute_metrics: Optional = None,
                     callbacks: Optional = None,
                     optimizers: Tuple = (None, None),
                     preprocess_logits_for_metrics: Optional = None
)

Hadi bu parametreleri daha yakından tanıyalım. Önce Trainer’ın önemli olan parametrelerini inceleyelim ardından da hala öğrenmek istiyorsanız geri kalan parametrelerine bakalım:

Aşağıda Trainer’ın önemli olan parametreleri bulunmaktadır:

• model — Her zaman core (çekirdek) modele işaret eder. Transformer modeli kullanılıyorsa bu, PreTrainedModel’in alt sınıfı olmalıdır.[1]
• model_wrapped: Bir veya daha fazla modülün orijinal modeli sarması durumunda her zaman en dış modeli işaret eder. Forward pass için kullanılması gereken model budur. Örneğin, DeepSpeed altında, iç model DeepSpeed’e ve ardından tekrar torch.nn.DistributedDataParallel’e sarılır (wrap edilir). İç model sarılmamışsa self.model_wrapped, self.model ile aynıdır.[1]
• is_model_parallel: Bir modelin model paralel moduna geçirilip geçirilmediği (veri paralelliğinden farklı olarak bu, bazı model katmanlarının farklı GPU’larda bölündüğü anlamına gelir).[1]
• place_model_on_device: Modelin cihaza otomatik olarak yerleştirilip yerleştirilmeyeceğini gösterir. Model paralel veya deepspeed kullanılırsa veya varsayılan TrainingArguments.place_model_on_device False değerini döndürecek şekilde geçersiz kılınırsa False olarak ayarlanacaktır.[1]
• is_in_train: Bir modelin şu anda eğitim yapıp yapmadığıdır.[1]

Trainer’ın Tüm Parametreleri

• model (PreTrainedModel or torch.nn.Module, optional) : Tahminler için eğitilecek, değerlendirilecek veya kullanılacak model. Sağlanmazsa model_init değeri iletilmelidir.[1]
• Trainer, kütüphane tarafından sağlanan PreTrainedModel ile çalışacak şekilde optimize edilmiştir. torch.nn.Module olarak tanımlanan kendi modellerinizi, huggingface Transformers modelleri ile aynı şekilde çalıştığı sürece kullanmaya devam edebilirsiniz.[1]
• args (TrainingArguments, optional): Eğitim için ince ayar yapılan argümanlar. Sağlanmadığı takdirde, geçerli dizinde tmp_trainer adlı bir dizine ayarlanan output_dir içeren TrainingArguments’ın temel bir örneğini varsayılan olarak kullanacaktır.[1]
• data_collator (DataCollator, optional) : train_dataset veya eval_dataset öğelerinin listesinden bir batch oluşturmak için kullanılacak işlev. Tokenizer sağlanmazsa varsayılan olarak default_data_collator(), aksi takdirde DataCollatorWithPadding instance’ı kullanılır.[1]
• train_dataset (Union[torch.utils.data.Dataset, torch.utils.data.IterableDataset, datasets.Dataset], optional): Eğitim için kullanılacak veri kümesi. Eğer Dataset sınıfı ise model.forward() yöntemi tarafından kabul edilmeyen sütunlar otomatik olarak kaldırılır.[1]
• Distributed training yapıyorsanız ve bir torch.utils.data.IterableDataset kullandığınızda, içinde bir miktar rastgeleleştirme yapılıyorsa, unutmayın ki yinelenebilir veri kümenizin tüm işlemlerde aynı olması gereken rastgeleleştirme için bir torch.Generator nesnesi içermesi gerekir. Ayrıca, Trainer her epoch için bu oluşturucunun seed’ini manuel olarak ayarlayacaktır veya kullanılan RNG’lerin seed’ini dahili olarak ayarlayan bir set_epoch() yöntemine sahip olacaktır.[1]
• eval_dataset (Union[torch.utils.data.Dataset, Dict[str, torch.utils.data.Dataset, datasets.Dataset]), optional) : Değerlendirme için kullanılacak veri kümesi. Dataset sınıfı ise model.forward() yöntemi tarafından kabul edilmeyen sütunlar otomatik olarak kaldırılır. Eğer bir dictionary, dictionary key’inin metrik adının başına getiren her veri kümesini değerlendirecektir.[1]
• tokenizer (PreTrainedTokenizerBase, optional): Verileri ön işlemek için kullanılan tokenizer. Eğer sağlanırsa, girdileri toplu halde işlerken otomatik olarak girdileri maksimum uzunluğa kadar doldurmak için kullanılır ve kesintiye uğramış bir eğitimi yeniden çalıştırmayı veya fine-tune edilmiş modeli yeniden kullanmayı kolaylaştırmak için modelle birlikte kaydedilir.
• model_init (Callable[[], PreTrainedModel], optional): Kullanılacak modeli başlatan bir işlev. Sağlandığı takdirde, train()’e yapılan her çağrı, bu işlev tarafından verilen modelin yeni bir örneğinden başlayacaktır.[1]
• Hiper parametrelere göre (layer count, sizes of inner layers, dropout probabilities vb. gibi) farklı mimarileri seçebilmek için işlevin sıfır argümanı veya optuna/Ray Tune/SigOpt trial nesnesini içeren tek bir argümanı olabilir.[ 1]
• compute_metrics (Callable[[EvalPrediction], Dict], optional): Değerlendirme sırasında metrikleri hesaplamak için kullanılacak işlev. Bir EvalPrediction almalı ve bir dictionary string’ini metrik değerlere döndürmelidir.[1]
• callbacks (List of TrainerCallback, optional): Eğitim döngüsünü özelleştirmek için callback’lerin listesi. Bunları, burada ayrıntıları verilen varsayılan callbacks listesine ekleyeceğiz.[1]
• Kullanılan varsayılan geri çağırmalardan birini kaldırmak istiyorsanız Trainer.remove_callback() yöntemini kullanın.[1]
• optimizers (Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR], optional, defaults to (None, None)): Kullanılacak optimizer’ı ve scheduler’ı içeren bir tanımlama grubu. Modelinizde varsayılan olarak bir AdamW örneği ve args tarafından kontrol edilen get_linear_schedule_with_warmup() tarafından verilen bir scheduler kullanılacaktır.[1]
• preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], optional): Logit’leri her değerlendirme adımında önbelleğe almadan hemen önce ön işleyen bir işlev. Logitleri ve etiketleri olmak üzere iki tensör almalı ve istenildiği gibi işlendikten sonra logitleri döndürmelidir. Bu işlev tarafından yapılan değişiklikler, compute_metrics tarafından alınan tahminlere yansıtılacaktır.[1]
• Veri kümesinde etiketler yoksa etiketlerin (ikinci parametre) None olacağını unutmayın.[1]

SFTTrainer Sınıfı: Supervised Fine-tuning Trainer (Denetimli İnce Ayar Eğitmeni)

Denetimli Finetuning Trainer (SFT), denetimli öğrenme görevlerinde daha küçük veri kümelerine sahip önceden eğitilmiş modellerde ince ayar yapmak için optimize edilmiştir. Büyük bir veri kümeniz varsa ve eğitim döngünüz veya karmaşık eğitim iş akışlarınız için kapsamlı özelleştirmeye ihtiyacınız varsa Trainer’ı kullanın. Önceden eğitilmiş bir modeliniz ve nispeten daha küçük bir veri kümeniz varsa ve verimli bellek kullanımıyla daha basit ve daha hızlı bir finetune deneyimi istiyorsanız SFTTrainer’ı kullanın. [2]

SFT Trainer daha az yapılandırma seçeneğiyle akıcı bir iş akışı sağlayarak başlamayı kolaylaştırır. Eğitim sırasında bellek tüketimini azaltmak için parametre verimliliği (PEFT) ve paketleme optimizasyonları gibi teknikleri kullanır. Daha küçük veri kümeleri ve Trainer’a göre daha kısa eğitim süreleriyle karşılaştırılabilir veya daha iyi doğruluk elde edebilir.[2]

trl.SFTTrainer(model: Union = None,
               args: Optional = None,
               data_collator: Optional = None,
               train_dataset: Optional = None,
               eval_dataset: Union = None,
               tokenizer: Optional = None,
               model_init: Optional = None,
               compute_metrics: Optional = None,
               callbacks: Optional = None,
               optimizers: Tuple = (None, None),
               preprocess_logits_for_metrics: Optional = None,
               peft_config: Optional = None,
               dataset_text_field: Optional = None,
               packing: Optional = False,
               formatting_func: Optional = None,
               max_seq_length: Optional = None,
               infinite: Optional = None,
               num_of_sequences: Optional = 1024,
               chars_per_token: Optional = 3.6,
               dataset_num_proc: Optional = None,
               dataset_batch_size: int = 1000,
               neftune_noise_alpha: Optional = None,
               model_init_kwargs: Optional = None,
               dataset_kwargs: Optional = None,
               eval_packing: Optional = None
)

Parametereler

• model (Union[transformers.PreTrainedModel, nn.Module, str]): Eğitilecek model bir PreTrainedModel, bir torch.nn.Module veya önbellekten yüklenecek veya indirilecek model adının bulunduğu bir string olabilir. Peft_config argümanına bir PeftConfig nesnesi iletilirse model ayrıca bir PeftModel’e de dönüştürülebilir.[2]
• args (Optionaltransformers.TrainingArguments): Eğitim için finetune yapılmasına yönelik argümanlar. Daha fazla bilgi için lütfen transformers.TrainingArguments sınıfının dokümantasyonuna bakın.[2]
• data_collator (Optionaltransformers.DataCollator): Eğitim için kullanılacak data collator.[2]
• train_dataset (Optionaldatasets.Dataset): Eğitim için kullanılacak veri kümesi. Kullanıcıların veri kümelerini oluşturmak için trl.trainer.ConstantLengthDataset’i kullanmalarını önerilir.[2]
• eval_dataset (Optional[Union[datasets.Dataset, Dict[str, datasets.Dataset]]]): Değerlendirme için kullanılacak veri kümesi. Kullanıcıların veri kümelerini oluşturmak için trl.trainer.ConstantLengthDataset’i kullanılması önerilir.[2]
• tokenizer (Optionaltransformers.PreTrainedTokenizer): Eğitim için kullanılacak tokenizer. Belirtilmediği takdirde modelle ilişkili tokenizer kullanılacaktır.[2]
• model_init (Callable[[], transformers.PreTrainedModel]): Eğitim için kullanılacak model initializer. Hiçbiri belirtilmezse, varsayılan model initializer kullanılacaktır.[2]
• compute_metrics (Callable[[transformers.EvalPrediction], Dict], optional defaults to None): Değerlendirme sırasında metrikleri hesaplamak için kullanılan işlev. Metrik adlarını metrik değerlerine eşleyen bir dictionary döndürmelidir. Belirtilmediği takdirde değerlendirme sırasında sadece loss hesaplanacaktır.[2]
• callbacks (List[transformers.TrainerCallback]): Eğitim için kullanılacak callback’ler.[2]
• optimizers (Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]) Eğitim için kullanılacak optimizer ve scheduler.[2]
• preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): Metrikleri hesaplamadan önce logitleri ön işlemek için kullanılacak işlev.[2]
• peft_config (Optional[PeftConfig]) : PeftModel’i başlatmak için kullanılacak PeftConfig nesnesi.[2]
• dataset_text_field (Optional[str]): Veri kümesinin metin alanının adı; bunun bir kullanıcı tarafından iletilmesi durumunda trainer, dataset_text_field argümanını temel alarak otomatik olarak bir ConstantLengthDataset oluşturacaktır.[2]
• formatting_func (Optional[Callable]): ConstantLengthDataset’i oluşturmak için kullanılacak formatlama işlevi.[2]
• max_seq_length (Optional[int]) : ConstantLengthDataset için ve Dataset otomatik olarak oluşturmak için kullanılacak maksimum dizi uzunluğu. Varsayılan 512'dir.[2]
• infinite (Optional[bool]): Sonsuz bir veri kümesinin kullanılıp kullanılmayacağı. Varsayılan olarak False’tur.[2]
• num_of_sequences (Optional[int]) : ConstantLengthDataset için kullanılacak sequence sayısı. Varsayılan 1024'tür.[2]
• chars_per_token (Optional[float]): ConstantLengthDataset için kullanılacak token başına karakter sayısı. Varsayılan olarak 3.6'dır. Stack-llama örneğinde bunun nasıl hesaplandığını kontrol edebilirsiniz: https://github.com/huggingface/trl/blob/08f550674c553c36c51d1027613c29f14f3676a5/examples/stack_llama/scripts/supervised_finetuning.py#L53. [2]
• packing (Optional[bool]): Yalnızca dataset_text_field’ın iletilmesi durumunda kullanılır. Bu bağımsız değişken, ConstantLengthDataset tarafından veri kümesinin dizilerini paketlemek için kullanılır. [2]
• dataset_num_proc (Optional[int]): Verileri tokenleştirmek için kullanılacak çalışan sayısı. Yalnızca packing = False olduğunda kullanılır. Varsayılan olarak None’dur. [2]
• dataset_batch_size (int): Batch başına belirtilecek örneklerin sayısı. Batch_size <= 0 veya Batch_size == None ise, tüm veri kümesini tek bir batch olarak tokenize edilir. Varsayılan 1000'dir. [2]
• neftune_noise_alpha (Optional[float]) — None değilse, bu NEFTune gürültü embedding’leri etkinleştirecektir. Bunun, instruct finetune için model performanslarını büyük ölçüde iyileştirdiği kanıtlanmıştır. Orijinal makaleye buradan göz atabilirsiniz: https://arxiv.org/abs/2310.05914 ve orijinal kodu burada bulabilirsiniz: https://github.com/neelsjain/NEFTune
• model_init_kwargs — (Optional[Dict], optional): Modeli bir string’ten başlatırken verielecek isteğe bağlı kwargs’ın dictionary’si
• dataset_kwargs — (Optional[Dict], optional): Paketlenmiş veya paketlenmemiş veri kümeleri oluştururken verilecek isteğe bağlı kwarg’ların dictonary’si
• eval_packing — (Optional[bool], optional): Değerlendirme veri kümesinin de paketlenip paketlenmeyeceği. None değeri verilmezse varsayılan olarak paketleme yapılır. [2]

Veri kümesi format desteği

SFTTrainer popüler dataset formatlarını destekler. Bu, dataseti doğrudan herhangi bir ön işleme gerek kalmadan trainer’a aktarmanıza olanak tanır. Aşağıdaki formatlar desteklenir[2]:

Conversational format[2]:

{"messages": [{"role": "system", "content": "You are helpful"}, {"role": "user", "content": "What's the capital of France?"}, {"role": "assistant", "content": "..."}]}
{"messages": [{"role": "system", "content": "You are helpful"}, {"role": "user", "content": "Who wrote 'Romeo and Juliet'?"}, {"role": "assistant", "content": "..."}]}
{"messages": [{"role": "system", "content": "You are helpful"}, {"role": "user", "content": "How far is the Moon from Earth?"}, {"role": "assistant", "content": "..."}]}

İnstruction format[2]:

{"prompt": "<prompt text>", "completion": "<ideal generated text>"}
{"prompt": "<prompt text>", "completion": "<ideal generated text>"}
{"prompt": "<prompt text>", "completion": "<ideal generated text>"}

Kod Örneği [3]:

import logging
import os
from contextlib import nullcontext

TRL_USE_RICH = os.environ.get("TRL_USE_RICH", False)

from trl.commands.cli_utils import init_zero_verbose, SFTScriptArguments, TrlParser

if TRL_USE_RICH:
    init_zero_verbose()
    FORMAT = "%(message)s"

    from rich.console import Console
    from rich.logging import RichHandler

import torch
from datasets import load_dataset

from tqdm.rich import tqdm
from transformers import AutoTokenizer

from trl import (
    ModelConfig,
    RichProgressCallback,
    SFTConfig,
    SFTTrainer,
    get_peft_config,
    get_quantization_config,
    get_kbit_device_map,
)

tqdm.pandas()

if TRL_USE_RICH:
    logging.basicConfig(format=FORMAT, datefmt="[%X]", handlers=[RichHandler()], level=logging.INFO)


if __name__ == "__main__":
    parser = TrlParser((SFTScriptArguments, SFTConfig, ModelConfig))
    args, training_args, model_config = parser.parse_args_and_config()

    # Force use our print callback
    if TRL_USE_RICH:
        training_args.disable_tqdm = True
        console = Console()

    ################
    # Model & Tokenizer
    ################
    torch_dtype = (
        model_config.torch_dtype
        if model_config.torch_dtype in ["auto", None]
        else getattr(torch, model_config.torch_dtype)
    )
    quantization_config = get_quantization_config(model_config)
    model_kwargs = dict(
        revision=model_config.model_revision,
        trust_remote_code=model_config.trust_remote_code,
        attn_implementation=model_config.attn_implementation,
        torch_dtype=torch_dtype,
        use_cache=False if training_args.gradient_checkpointing else True,
        device_map=get_kbit_device_map() if quantization_config is not None else None,
        quantization_config=quantization_config,
    )
    tokenizer = AutoTokenizer.from_pretrained(model_config.model_name_or_path, use_fast=True)
    tokenizer.pad_token = tokenizer.eos_token

    ################
    # Dataset
    ################
    raw_datasets = load_dataset(args.dataset_name)

    train_dataset = raw_datasets[args.dataset_train_split]
    eval_dataset = raw_datasets[args.dataset_test_split]

    ################
    # Optional rich context managers
    ###############
    init_context = nullcontext() if not TRL_USE_RICH else console.status("[bold green]Initializing the SFTTrainer...")
    save_context = (
        nullcontext()
        if not TRL_USE_RICH
        else console.status(f"[bold green]Training completed! Saving the model to {training_args.output_dir}")
    )

    ################
    # Training
    ################
    with init_context:
        trainer = SFTTrainer(
            model=model_config.model_name_or_path,
            model_init_kwargs=model_kwargs,
            args=training_args,
            train_dataset=train_dataset,
            eval_dataset=eval_dataset,
            tokenizer=tokenizer,
            peft_config=get_peft_config(model_config),
            callbacks=[RichProgressCallback] if TRL_USE_RICH else None,
        )

    trainer.train()

    with save_context:
        trainer.save_model(training_args.output_dir)

PEFT ile veya PEFT olmadan çalıştırabilirsiniz[3]:

PEFT’siz [3]:

python examples/scripts/sft.py \
    --model_name_or_path="facebook/opt-350m" \
    --report_to="wandb" \
    --learning_rate=1.41e-5 \
    --per_device_train_batch_size=64 \
    --gradient_accumulation_steps=16 \
    --output_dir="sft_openassistant-guanaco" \
    --logging_steps=1 \
    --num_train_epochs=3 \
    --max_steps=-1 \
    --push_to_hub \
    --gradient_checkpointing

PEFT’li [3]:

python examples/scripts/sft.py \
    --model_name_or_path="facebook/opt-350m" \
    --report_to="wandb" \
    --learning_rate=1.41e-5 \
    --per_device_train_batch_size=64 \
    --gradient_accumulation_steps=16 \
    --output_dir="sft_openassistant-guanaco" \
    --logging_steps=1 \
    --num_train_epochs=3 \
    --max_steps=-1 \
    --push_to_hub \
    --gradient_checkpointing \
    --use_peft \
    --lora_r=64 \
    --lora_alpha=16

Data Collator (Veri Harmanlayıcılar)

Data collators, veri kümesi öğelerinin bir listesini girdi olarak kullanarak bir toplu iş oluşturacak nesnelerdir. Bu öğeler train_dataset veya eval_dataset öğeleriyle aynı türdedir. [4]

Toplu iş oluşturabilmek için data collator’lar bazı işlemler (padding gibi) uygulayabilir. Bunlardan bazıları (DataCollatorForLanguageModeling gibi) ayrıca oluşturulan toplu iş üzerinde bazı rastgele veri büyütme (rastgele maskeleme gibi) uygular. [4]

Özetle, data collator’lar mini bir eğitim grubu halinde bir örnek listesi hazırlarlar. Yaptıkları şey, tanımlandıkları göreve bağlıdır, ancak en azından bir mini gruptaki tüm örneklerin aynı uzunlukta olduğundan emin olmak için örneklere padding veya truncate yaparlar. Tipik mini parti boyutları, model boyutuna, verilere ve donanım kısıtlamalarına bağlı olarak 16 ila 256 arasında değişir.

Data collator’lar göreve özeldir. Aşağıdaki görevlerin her biri için bir data collator vardır[4]:

• Causal language modelling (CLM)
• Masking language modelling (MLM)
• Sequence classification
• Seq2Seq
• Token classification

Bazı data collator’lar basittir. Örneğin, “sequence classification” görevi için veri derleyicinin, aynı uzunlukta olduklarından emin olmak için tüm dizileri bir mini grup halinde doldurması yeterlidir. Daha sonra bunları tek bir tensörde birleştirecekti. Bazı veri derleyiciler, bu görev için veri işlemeyi yürütmeleri gerektiğinden oldukça karmaşıktır.[4]

Basic Data Collator’lar

1.DefaultDataCollator: Bu herhangi bir padding veya truncation işlemi yapmaz. Tüm girdi örneklerinin aynı uzunlukta olduğunu varsayar. Girdi örnekleriniz aynı uzunlukta değilse bu durum hatalara neden olur.[4]

import torch
from transformers import DefaultDataCollator

texts = ["Who are you?", "How are you?"] # Each one of them must have same length

# Tokenize
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
tokens = [tokenizer(t) for t in texts]

# Default collate function 
collate_fn = DefaultDataCollator()

# Pass it to dataloader
dataloader = torch.utils.data.DataLoader(dataset=tokens, collate_fn=collate_fn, batch_size=2) 

# this will end in error
for batch in dataloader:
    print(batch)
    break

2.DataCollatorWithPadding: Bu collator, girdi sample’ları, hepsi aynı uzunlukta olacak şekilde doldurur. Doldurma için, ya sağlanan max_length argümanına padding yapar ya da gruptaki en büyük sequence’a padding yapar. Buna ek olarak, bu harmanlayıcı, birçok token oluşturucunun farklı padding tokenlerine sahip olması nedeniyle tokenleri kabul eder ve bu nedenle DataCollatorWithPadding, token’lara padding yaparken padding token’ı bulmak için tokenleri kabul eder. sıra.[4]

import torch
from transformers import DataCollatorWithPadding

texts = ["Hello world", "How are you?"] # Works even though their length does not match

# Tokenize
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
tokens = [tokenizer(t) for t in texts]

# Default collate function 
collate_fn = DataCollatorWithPadding(tokenizer, padding=True) #padding=True, 'max_length'


dataloader = torch.utils.data.DataLoader(dataset=tokens, collate_fn=collate_fn, batch_size=2) 

for batch in dataloader:
    print(batch)
    break

Daha karmaşık veriler için başka data collator’lar da vardır; örneğin MLM, tokenleri maskelemek için kullanılır ve CLM, bir sonraki token’i tahmin etmek için kullanılır. Ayrıca kendi özel data collator’ınızı da oluşturabilirsiniz.[4]

Son olarak Auto Train’den bahsedelim.

Auto Train

Trainer ve SFTTrainer sınıflarının aksine Auto Train bir sınıf değil, son teknoloji Makine Öğrenimi modellerini ücretli olarak otomatik olarak eğitmek, değerlendirmek ve dağıtmak için kullanılan bir no-code platformdur. Auto Train’e yalnızca bulut GPU’lar için saatlik kullanıma göre ödeme yapılır.[5]

Fiyatlandırma için linke bakın: [https://huggingface.co/pricing#spaces]

Auto Train’i kimler içindir?

AutoTrain, bir NLP, CV, Konuşma ve hatta Tablo görevleri veya özel bir veri kümesi için son teknoloji ürünü bir modeli eğitmek isteyen ancak bir model eğitiminin teknik ayrıntılarına zaman harcamak istemeyen herkes içindir. [6]

Auto Train nasıl kullanılır?

• No code kullanıcıları AutoTrain Docker imajı ile yeni bir space oluşturarak AutoTrain Advanced’i kullanabilir: Alanı private tuttuğunuzdan ve alana uygun donanımı seçtiğinizden emin olmalısınız.[6]
• Geliştiriciler, python API kullanarak AutoTrain’e erişebilir ve onun üzerinde geliştirme yapabilir veya AutoTrain Advanced UI’ı lokal cihazlarında çalıştırabilirler. Python API, autotrain-advanced paketinde mevcuttur.[6]

AutoTrain’i Lokal Olarak Çalıştırma

Autotrain uygulamasını yerel olarak çalıştırmak için aşağıdaki komutu kullanabilirsiniz[6]:

$ export HF_TOKEN=your_hugging_face_write_token
$ autotrain app --host 127.0.0.1 --port 8000

Bu, uygulamayı http://127.0.0.1:8000 adresinde başlatacaktır.[6]

Diğer paketlerle herhangi bir çakışmayı önlemek için autotrain-advanced’ın sanal ortamda kurulması tavsiye edilir.[6]

$ conda create -n autotrain python=3.10
$ conda activate autotrain
$ pip install autotrain-advanced
$ conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia
$ conda install -c "nvidia/label/cuda-12.1.0" cuda-nvcc
$ export HF_TOKEN=your_hugging_face_write_token
$ autotrain app --host 127.0.0.1 --port 8000

Kaynaklar

[1] Huggingface documentation, Trainer:

[https://huggingface.co/docs/transformers/main_classes/trainer]

[1] Huggingface documentation, SFT Trainer:

[https://huggingface.co/docs/trl/sft_trainer]

[3] Github Huggingface, SFT Example:

[https://github.com/huggingface/trl/blob/main/examples/scripts/sft.py]

[4] Huggingface Documents, Data Collator:

[https://huggingface.co/docs/transformers/main_classes/data_collator]

[5] Huggingface Documents, Auto Train:

[https://huggingface.co/autotrain]

[6] Huggingface Documents, Auto Train Index:

[https://huggingface.co/docs/autotrain/index]