RapidFire AI Entegrasyonu

RapidFire AI, TRL ile entegre olan ve “aynı anda tek bir yapılandırma eğit” yaklaşımını aynı GPU(lar) üzerinde birçok yapılandırmanın gerçek zamanlı, yan yana karşılaştırılmasına dönüştüren açık kaynak bir deney yürütme çerçevesidir; böylece hiperparametreler, LoRA ayarları, prompt şemaları ve ablasyonlar üzerinde ek donanım gerektirmeden 16–24 kat daha hızlı iterasyon yapabilirsiniz.

Bağlantılar: GitHub · Belgeler · Colab'da deneyin

TRL ile RapidFire AI neden kullanılmalı?

TRL ile ince ayar veya eğitim sonrası işlem yaparken genellikle şunlara ihtiyacınız olur:

• Farklı hiperparametre yapılandırmalarını deneyin
• Farklı LoRA ayarlarını karşılaştırın
• Farklı istem şemalarını test edin
• Ablasyon çalışmaları yürütme

Nasıl Çalışır

RapidFire AI uyarlanabilir parça tabanlı zamanlamayı kullanır:

GPU Timeline (Single GPU):
Chunk 1: [Config A] → [Config B] → [Config C] → [Config D]
Chunk 2: [Config A] → [Config B] → [Config C] → [Config D]
Chunk 3: [Config A] → [Config B] → [Config C] → [Config D]

Bununla şunlar sağlanır:

• Aynı veri alt kümeleri üzerinde yapılandırmaların erken karşılaştırması, kademeli olarak
• Verimli GPU kullanımı ve boşta kalma sürelerinin en aza indirilmesi
• Gerçek zamanlı ve otomatik deneysel metrik takibi
• Daha fazla deneyi teşvik etmek için uçuştaki çalıştırmalar üzerinde dinamik kontrol

Öne Çıkan Özellikler

• Sıralı eğitime kıyasla 16-24 kat daha yüksek deneysel işleme hızı.
• Neredeyse hiç kod değişikliği - mevcut TRL ve PEFT yapılandırma API'lerini saran basit yerleştirilebilir yapılandırma API'leri.
• Etkileşimli Kontrol İşlemleri - uçuştaki eğitim çalıştırmalarını durdurmak, yeniden başlatmak ve klonlayıp değiştirmek (sıcak başlatma ile veya olmadan) için gerçek zamanlı kontrol.
• Tek bir GPU'ya sığmayan büyük modelleri eğitmek için parametreleri, gradyanları ve optimizör durumlarını birden fazla GPU arasında dağıtarak Fully Sharded Data Parallel (FSDP) ile entegrasyon.
• Transformers, PEFT, SFTTrainer, DPOTrainer ve GRPOTrainer ile tam uyumluluk.
• Yerleştirilebilir deney izleme: MLflow (varsayılan), TensorBoard ve Trackio, tek başına veya birlikte etkinleştirilebilir.
• Sıfır kurulumlu Google Colab desteği: ücretsiz T4 GPU'larında SFT, DPO ve GRPO için tek tıkla başlatılabilir eğitim defterleri.
• Üretime Hazır: Tamamen çalışan örneklerle birlikte üretim ortamlarında zaten kullanılmaktadır.

Kurulum

Ön koşullar

• Python 3.12.x
• Hesaplama Yeteneği 7.x veya 8.x olan bir NVIDIA GPU (FSDP için birden fazla GPU gereklidir)
• CUDA Toolkit 11.8+
• PyTorch 2.8+

pip install

pip install rapidfireai

Yüklendikten sonra Hugging Face ile kimlik doğrulaması yapın ve RapidFire AI'ı başlatın:

# Authenticate with Hugging Face
hf auth login --token YOUR_TOKEN

# Workaround for current issue: https://github.com/huggingface/xet-core/issues/527
pip uninstall -y hf-xet

# Initialize RapidFire AI
rapidfireai init

# Start the RapidFire AI server
rapidfireai start

Panel, deneyleri gerçek zamanlı olarak izleyip kontrol edebileceğiniz http://localhost:8853 adresinde kullanılabilir olacaktır.

Hızlı Başlangıç: Birden Çok Yapılandırma ile SFT Eğitimi

Birden fazla SFT yapılandırmasını eşzamanlı olarak eğitmenin nasıl yapılacağını gösteren eksiksiz bir örnek:

from rapidfireai import Experiment
from rapidfireai.automl import List, RFGridSearch, RFModelConfig, RFLoraConfig, RFSFTConfig
from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer

# Load dataset
dataset = load_dataset("bitext/Bitext-customer-support-llm-chatbot-training-dataset")
train_dataset = dataset["train"].select(range(128)).shuffle(seed=42)
eval_dataset = dataset["train"].select(range(100, 124)).shuffle(seed=42)

# Define data formatting function
def formatting_function(row):
    return {
        "prompt": [
            {"role": "system", "content": "You are a helpful customer support assistant."},
            {"role": "user", "content": row["instruction"]},
        ],
        "completion": [
            {"role": "assistant", "content": row["response"]}
        ]
    }

# Initialize experiment
experiment = Experiment(experiment_name="sft-customer-support")

# Define multiple LoRA configurations to compare
peft_configs = List([
    RFLoraConfig(r=8, lora_alpha=16, lora_dropout=0.1,
                 target_modules=["q_proj", "v_proj"], bias="none"),
    RFLoraConfig(r=32, lora_alpha=64, lora_dropout=0.1,
                 target_modules=["q_proj", "k_proj", "v_proj", "o_proj"], bias="none")
])

# Define multiple training configurations
# 2 base configs × 2 PEFT configs = 4 total training runs
config_set = List([
    RFModelConfig(
        model_name="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
        peft_config=peft_configs,
        training_args=RFSFTConfig(  # Wraps TRL's SFTConfig
            learning_rate=1e-3,
            per_device_train_batch_size=4,
            max_steps=128,
            fp16=True,
        ),
        model_type="causal_lm",
        model_kwargs={"device_map": "auto", "dtype": "auto", "use_cache": False},
        formatting_func=formatting_function,
    ),
    RFModelConfig(
        model_name="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
        peft_config=peft_configs,
        training_args=RFSFTConfig(
            learning_rate=1e-4,  # Different learning rate
            per_device_train_batch_size=4,
            max_steps=128,
            fp16=True,
        ),
        model_type="causal_lm",
        model_kwargs={"device_map": "auto", "dtype": "auto", "use_cache": False},
        formatting_func=formatting_function,
    )
])

# Define model creation function
def create_model(model_config):
    model = AutoModelForCausalLM.from_pretrained(
        model_config["model_name"],
        **model_config["model_kwargs"]
    )
    tokenizer = AutoTokenizer.from_pretrained(model_config["model_name"])
    return (model, tokenizer)

# Create grid search over all configurations
config_group = RFGridSearch(configs=config_set, trainer_type="SFT")

# Run all 4 configurations concurrently with chunk-based scheduling
experiment.run_fit(config_group, create_model, train_dataset, eval_dataset,
                   num_chunks=4, seed=42)

# End experiment
experiment.end()

Çalışma Sırasında Ne Olur

Bu örneği çalıştırdığınızda:

1. Yapılandırma Genişletme: 2 temel yapılandırma × 2 PEFT yapılandırması = 4 toplam eğitim çalıştırması
2. Parça tabanlı zamanlama: Eğitim verisi parçalara bölünür ve tüm 4 yapılandırma eşzamanlı olarak eğitilir
3. GPU Değiştirme: Modeller, parça sınırlarına göre GPU belleğine alınır/çıkarılır
4. Gerçek zamanlı izleme: http://localhost:8853 adresindeki panelde tüm metrikler görünür
5. Etkileşimli Kontrol: Panelden herhangi bir yapılandırmayı durdurun, yeniden başlatın veya klonlayıp değiştirin

Bu, her yapılandırmayı sıralı olarak eğitmeye kıyasla 16-24× daha yüksek bir işleme hızı sağlar!

Desteklenen TRL Eğitimcileri

SFTTrainer

RFSFTConfig'i SFTConfig'in doğrudan yerine kullanılabilir bir alternatifi olarak kullanın:

from rapidfireai.automl import RFSFTConfig

training_args = RFSFTConfig(
    learning_rate=5e-5,
    per_device_train_batch_size=4,
    num_train_epochs=3,
    max_length = 512,
    # ... all other SFTConfig parameters supported
)

Örnek Defter: Müşteri Destek için SFT

DPOTrainer

RFDPOConfig'i DPOConfig'in doğrudan yerine kullanılabilir bir alternatifi olarak kullanın:

from rapidfireai.automl import RFDPOConfig

training_args = RFDPOConfig(
    beta=0.1,
    loss_type="sigmoid",
    max_length=1024,
    learning_rate=5e-4,
    # ... all other DPOConfig parameters supported
)

Örnek Defter: Tercih Hizalama için DPO

GRPOTrainer

RFGRPOConfig'i GRPOConfig'in doğrudan yerine kullanılabilir bir alternatifi olarak kullanın:

from rapidfireai.automl import RFGRPOConfig

training_args = RFGRPOConfig(
    learning_rate=5e-6,
    num_generations=8,
    max_completion_length=256,
    # ... all other GRPOConfig parameters supported
)

Örnek Defter: Matematiksel Muhakeme için GRPO

Temel Kavramlar

Parça Tabanlı Eşzamanlı Eğitim

RapidFire AI, eğitim verilerini parçalara ayırır ve yapılandırmalar arasında dönüşümlü olarak ilerler:

GPU Timeline (Single GPU):
Chunk 1: [Config A] → [Config B] → [Config C] → [Config D]
Chunk 2: [Config A] → [Config B] → [Config C] → [Config D]
Chunk 3: [Config A] → [Config B] → [Config C] → [Config D]
...

Bu yaklaşım, otomatik kontrol noktası alma yoluyla eğitim kararlılığını koruyarak GPU kullanımını en üst düzeye çıkarır ve yapılandırmaların erken karşılaştırılmasını sağlar.

Etkileşimli Kontrol Operasyonları (IC Ops)

RapidFire AI paneli aracılığıyla, çalışan deneyleri dinamik olarak kontrol edebilirsiniz:

• Durdur: Bir yapılandırmayı duraklat (otomatik olarak kontrol noktası alınır)
• Devam et: Son kontrol noktasından devam et
• Klonla-Değiştir: Bir yapılandırmayı değişikliklerle çoğaltın (yeni çalışma baştan başlar)
• Sıcak Başlatma ile Klonla-Düzenle: Klonla-düzenle ve ebeveynin ağırlıklarından başlat
• Sil: Başarısız veya istenmeyen çalıştırmaları kaldır

Bu, performans düşüklüğü gösteren yapılandırmaları erken durdurup, ayarlanmış hiperparametrelerle umut verici olanları klonlayarak adaptif deney yapmanızı sağlar.

Çoklu Yapılandırma Deneyleri

RFGridSearch veya RFRandomSearch kullanarak yapılandırma kombinasyonlarını otomatik olarak oluşturun:

# Grid search: tests all combinations
config_group = RFGridSearch(configs=config_list, trainer_type="SFT")

# Random search: samples N configurations
config_group = RFRandomSearch(configs=config_list, trainer_type="DPO", num_samples=10)

Gelişmiş Özellikler

PEFT/LoRA Entegrasyonu

Parametre-verimli ince ayar için tam destek:

from rapidfireai.automl import RFLoraConfig
from peft import TaskType

lora_config = RFLoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=64,
    lora_alpha=64,
    lora_dropout=0.1,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    bias="none"
)

Özel Ödül Fonksiyonları (GRPO)

GRPO eğitimi için birden fazla ödül fonksiyonu tanımlayın:

def correctness_reward(prompts, completions, answer, **kwargs):
    """Reward for correct answers"""
    responses = [completion[0]['content'] for completion in completions]
    extracted = [extract_answer(r) for r in responses]
    return [2.0 if r == a else 0.0 for r, a in zip(extracted, answer)]

def format_reward(completions, **kwargs):
    """Reward for proper formatting"""
    import re
    pattern = r"<reasoning>.*?</reasoning>\s*<answer>.*?</answer>"
    responses = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, r) for r in responses]
    return [0.5 if match else 0.0 for match in matches]

# Use in model config
config = RFModelConfig(
    reward_funcs=[correctness_reward, format_reward],
    # ... other parameters
)

Çoklu GPU Desteği

RapidFire AI, kullanılabilir tüm GPU'ları otomatik olarak algılar ve kullanır. Varsayılan olarak zamanlayıcı, bağımsız yapılandırmaları GPU'lar arasında dağıtır (yapılandırmalar arasında veri paralelliği), bu nedenle N yapılandırmayı N GPU üzerinde eşzamanlı olarak çalıştırmak için özel bir kurulum gerekmez.

Tek bir GPU'ya sığmayan modeller için RapidFire AI, tek bir yapılandırmayı birden fazla GPU arasında dağıtmak için Fully Sharded Data Parallel (FSDP) desteği de sunar — bir sonraki bölüme bakın.

FSDP ile Çoklu GPU Eğitimi

Bir model tek bir GPU için çok büyükse, FSDP'yi doğrudan RFSFTConfig veya RFDPOConfig eğitim argümanları üzerinden etkinleştirin — Hugging Face TrainingArguments tarafından sunulan aynı fsdp ve fsdp_config alanları:

from rapidfireai.automl import RFModelConfig, RFSFTConfig, RFLoraConfig

model_config = RFModelConfig(
    model_name="meta-llama/Llama-3.1-8B-Instruct",
    peft_config=RFLoraConfig(
        r=16, lora_alpha=32, lora_dropout=0.05,
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
        bias="none",
    ),
    training_args=RFSFTConfig(
        learning_rate=2e-4,
        per_device_train_batch_size=1,
        gradient_accumulation_steps=8,
        fsdp="full_shard auto_wrap",
        fsdp_config={
            "sharding_strategy": "FULL_SHARD",
            "auto_wrap_policy": "TRANSFORMER_BASED_WRAP",
            "backward_prefetch": "backward_pre",
            "forward_prefetch": True,
            "use_orig_params": False,
            "cpu_ram_efficient_loading": True,
            "offload_params": True,
            "sync_module_states": True,
            "limit_all_gathers": True,
        },
    ),
    model_type="causal_lm",
    model_kwargs={"dtype": "auto"},
)

Önemli noktalar:

• FSDP, RapidFire AI’nin parça tabanlı zamanlaması, IC Ops (sıcak başlatma ile veya olmadan duraklat / devam et / klonla-değiştir) ve desteklenen tüm metrik izleme arka uçlarıyla şeffaf bir şekilde çalışır.
• FSDP, PEFT / LoRA ile tam uyumludur — LoRA adaptör ağırlıkları, denetim noktaları kaydedilirken şarlar arasında verimli bir şekilde toplanır.
• FSDP, grid search ve random search ile birleştirilebilir: her genişletilen yapılandırma, kendi shard edilmiş eğitim çalışmasını alır.

Örnek Defterler:

• FSDP ile SFT (lite, küçük model)
• FSDP ile SFT (büyük model)
• FSDP ile DPO

Deney İzleme Arka Uçları

RapidFire AI, tek başına veya birlikte kullanılabilen üç metrik günlükleme arka ucunu destekler: MLflow (yerel kurulumlar için varsayılan), TensorBoard (Google Colab'da varsayılan) ve Trackio.

Sunucu başlatılırken --tracking-backends bayrağıyla bir veya daha fazla arka uç seçin:

# MLflow only (default on local installs)
rapidfireai start --tracking-backends mlflow

# TensorBoard only
rapidfireai start --tracking-backends tensorboard

# Any combination
rapidfireai start --tracking-backends mlflow tensorboard trackio

Eşdeğer ortam değişkenleri de kullanılabilir:

• RF_MLFLOW_ENABLED (varsayılan true, Colab'da false)
• RF_TENSORBOARD_ENABLED (varsayılan false, Colab'da true)
• RF_TRACKIO_ENABLED (varsayılan false)

Üç backend de aynı metrikleri (kayıp, değerlendirme puanları, öğrenme oranı vb.) alır ve IC Ops çalışma yaşam döngüsü olaylarına uyar; bu sayede, örneğin, tam yerel bir panel için MLflow ile birlikte hafif paylaşım için Trackio kullanabilirsiniz.

Google Colab'da Çalıştırma

RapidFire AI, ücretsiz Google Colab T4 GPU'larında çalışır ve SFT, DPO, GRPO ile RAG / bağlam mühendisliği iş akışları için eğitim defterleri sunar. Colab'da varsayılan izleme arka ucu TensorBoard'dur (basitlik için MLflow devre dışıdır) ve standart rapidfireai init / rapidfireai start komutları doğrudan defter hücrelerinden çalıştırılır — terminal erişimi gerekmez.

Başlayın: Google Colab'da RapidFire AI.

En İyi Uygulamalar

Parça İnce Ayarını Ayarlama

num_chunks parametresi, takas sıklığını kontrol eder:

# Fewer chunks = less overhead, less frequent comparison
experiment.run_fit(..., num_chunks=2)

# More chunks = more overhead, more frequent comparison
experiment.run_fit(..., num_chunks=16)

Genel kural: num_chunks=4 ile başlayın ve veri seti boyutuna ve yapılandırma sayısına göre ayarlayın.

Bellek Yönetimi

Büyük modeller için kuantizasyon kullanın:

from transformers import BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
)

model_kwargs = {
    "quantization_config": bnb_config,
    "device_map": "auto",
}

Performans Ölçümleri

Sıralı ve RapidFire AI eşzamanlı eğitimini karşılaştıran dahili kıyaslamalara dayalı olarak:

NVIDIA A100 40GB üzerinde TinyLlama-1.1B ve Llama-3.2-1B modelleriyle gerçekleştirilen testler

Sorun Giderme

Sorun giderme yönergeleri için RapidFire AI Sorun Giderme Kılavuzu'na bakın.

Ek Kaynaklar

• Colab Defter Notu: Google Colab'da RapidFire AI
• Belgeler: oss-docs.rapidfire.ai
• GitHub: RapidFireAI/rapidfireai
• PyPI: pypi.org/project/rapidfireai
• Discord: Discord sunucumuza katılın
• Eğitim Defterleri: GitHub Deposu

RapidFire AI hakkında daha fazla bilgi için resmi deposuna ve belgelerine göz atın.