Integrasi RapidFire AI

RapidFire AI adalah kerangka kerja eksekusi eksperimen open-source yang terintegrasi dengan TRL untuk mengubah “melatih satu konfigurasi pada satu waktu” menjadi perbandingan real-time berdampingan dari banyak konfigurasi pada GPU yang sama — sehingga Anda dapat mengiterasi hyperparameter, pengaturan LoRA, skema prompt, dan ablation 16–24× lebih cepat tanpa perangkat keras tambahan.

Tautan: GitHub · Dokumentasi · Coba di Colab

Mengapa menggunakan RapidFire AI dengan TRL?

Saat melakukan fine-tuning atau post-training dengan TRL, Anda biasanya perlu:

• Coba berbagai konfigurasi hiperparameter
• Bandingkan berbagai pengaturan LoRA
• Uji skema prompt yang berbeda
• Jalankan studi ablas

Cara Kerjanya

RapidFire AI menerapkan penjadwalan berbasis chunk adaptif:

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]

Hal ini memungkinkan:

• Perbandingan awal konfigurasi pada subset data yang sama secara bertahap
• Pemanfaatan GPU yang efisien dan meminimalkan waktu menganggur
• Pelacakan metrik eksperimen secara real-time dan otomatis
• Kontrol dinamis atas eksekusi yang sedang berjalan untuk mendorong lebih banyak eksperimen

Fitur Utama

• 16-24× lebih tinggi throughput eksperimen dibandingkan dengan pelatihan berurutan.
• Hampir tidak ada perubahan kode - API konfigurasi drop-in sederhana yang hanya membungkus API konfigurasi TRL dan PEFT yang sudah ada.
• Operasi Kontrol Interaktif - kontrol waktu nyata untuk menghentikan, melanjutkan, dan melakukan klon-modifikasi (dengan atau tanpa warm starting) pada jalannya pelatihan.
• Integrasi dengan Fully Sharded Data Parallel (FSDP) untuk melatih model besar yang tidak muat di satu GPU dengan cara membagi parameter, gradien, dan status optimizer di beberapa GPU.
• Kompatibilitas penuh dengan transformers, PEFT, SFTTrainer, DPOTrainer, dan GRPOTrainer.
• Pelacakan eksperimen yang dapat dicolokkan: MLflow (default), TensorBoard, dan Trackio, diaktifkan secara individual atau dalam kombinasi.
• Dukungan Google Colab tanpa konfigurasi: notebook tutorial sekali klik untuk SFT, DPO, dan GRPO pada GPU T4 gratis.
• Siap untuk Produksi: Sudah digunakan di lingkungan produksi dengan contoh kerja lengkap.

Instalasi

Prasyarat

• Python 3.12.x
• NVIDIA GPU dengan Compute Capability 7.x atau 8.x (beberapa GPU diperlukan untuk FSDP)
• CUDA Toolkit 11.8+
• PyTorch 2.8+

pip install

pip install rapidfireai

Setelah terinstal, autentikasi dengan Hugging Face dan inisialisasi RapidFire AI:

# 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

Dasbor akan tersedia di http://localhost:8853 di mana Anda dapat memantau dan mengontrol eksperimen secara real-time.

Mulai Cepat: Pelatihan SFT dengan Beberapa Konfigurasi

Berikut adalah contoh lengkap yang menunjukkan cara melatih beberapa konfigurasi SFT secara bersamaan:

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

Apa yang Terjadi Selama Eksekusi

Saat Anda menjalankan contoh ini:

1. Ekspansi Konfigurasi: 2 konfigurasi dasar × 2 konfigurasi PEFT = 4 total run pelatihan
2. Jadwal Berbasis Chunk: Data pelatihan dibagi menjadi chunk, dan semua 4 konfigurasi dilatih secara bersamaan
3. Penukaran GPU: Model ditukar masuk/keluar dari memori GPU berdasarkan batas chunk
4. Tracking Real-time: Semua metrik terlihat di dasbor pada http://localhost:8853
5. Kontrol Interaktif: Hentikan, lanjutkan, atau klon-modifikasi konfigurasi apa pun dari dasbor

Ini memberikan throughput 16-24× lebih tinggi dibandingkan melatih setiap konfigurasi secara berurutan!

Pelatih TRL yang Didukung

SFTTrainer

Gunakan RFSFTConfig sebagai pengganti langsung untuk SFTConfig:

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
)

Contoh Notebook: SFT untuk Dukungan Pelanggan

DPOTrainer

Gunakan RFDPOConfig sebagai pengganti langsung untuk DPOConfig:

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
)

Contoh Notebook: DPO untuk Penyelarasan Preferensi

GRPOTrainer

Gunakan RFGRPOConfig sebagai pengganti langsung untuk GRPOConfig:

from rapidfireai.automl import RFGRPOConfig

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

Contoh Notebook: GRPO untuk Penalaran Matematika

Konsep Inti

Pelatihan Konkuren Berbasis Chunk

RapidFire AI membagi data pelatihan menjadi potongan-potongan dan bergantian antara konfigurasi:

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

Pendekatan ini memaksimalkan pemanfaatan GPU dan memungkinkan perbandingan awal konfigurasi sambil menjaga stabilitas pelatihan melalui checkpointing otomatis.

Operasi Kontrol Interaktif (IC Ops)

Melalui dasbor RapidFire AI, Anda dapat mengontrol eksperimen yang sedang berjalan secara dinamis:

• Berhenti: Jeda konfigurasi (checkpoint dilakukan secara otomatis)
• Ringkasan: Lanjutkan dari checkpoint terakhir
• Clone-Modify: Duplikasi konfigurasi dengan modifikasi (jalur baru dimulai dari awal)
• Clone-Modify dengan Warm Start: Clone-modify dan inisialisasi dari bobot induk
• Hapus: Hapus run yang gagal atau tidak diinginkan

Hal ini memungkinkan eksperimen adaptif di mana Anda dapat menghentikan konfigurasi yang kinerjanya rendah lebih awal dan mengkloning konfigurasi yang menjanjikan dengan hiperparameter yang disesuaikan.

Eksperimen Multi-Konfigurasi

Gunakan RFGridSearch atau RFRandomSearch untuk secara otomatis menghasilkan kombinasi konfigurasi:

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

Fitur Lanjutan

Integrasi PEFT/LoRA

Dukungan penuh untuk penyesuaian halus yang efisien parameter:

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

Fungsi Reward Kustom (GRPO)

Definisikan beberapa fungsi reward untuk pelatihan GRPO:

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
)

Dukungan Multi-GPU

RapidFire AI secara otomatis mendeteksi dan memanfaatkan semua GPU yang tersedia. Secara default, scheduler mendistribusikan konfigurasi independen di antara GPU (data-parallel antar konfigurasi), sehingga tidak diperlukan pengaturan khusus untuk menjalankan N konfigurasi di N GPU secara bersamaan.

Untuk model yang tidak muat di satu GPU, RapidFire AI juga mendukung Fully Sharded Data Parallel (FSDP) untuk membagi satu konfigurasi ke beberapa GPU — lihat bagian berikutnya.

Pelatihan Multi-GPU dengan FSDP

Ketika model terlalu besar untuk satu GPU, aktifkan FSDP langsung melalui argumen pelatihan dari RFSFTConfig atau RFDPOConfig — yaitu bidang fsdp dan fsdp_config yang sama yang disediakan oleh TrainingArguments Hugging Face:

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"},
)

Poin-poin utama:

• FSDP bekerja secara transparan dengan penjadwalan berbasis chunk dari RapidFire AI, IC Ops (stop / resume / clone-modify dengan atau tanpa warm-starting), dan semua backend pelacakan metrik yang didukung.
• FSDP sepenuhnya kompatibel dengan PEFT / LoRA — bobot adapter LoRA dikumpulkan secara efisien di seluruh shard saat menyimpan checkpoint.
• FSDP dapat dikombinasikan dengan grid search dan random search: setiap konfigurasi yang diperluas mendapatkan run pelatihan ter-shard-nya sendiri.

Notebook Contoh:

• SFT dengan FSDP (lite, model kecil)
• SFT dengan FSDP (model besar)
• DPO dengan FSDP

Backend Pelacakan Eksperimen

RapidFire AI mendukung tiga backend pencatatan metrik yang dapat digunakan secara terpisah atau bersamaan: MLflow (default untuk instalasi lokal), TensorBoard (default di Google Colab), dan Trackio.

Pilih satu atau lebih backend saat server dimulai dengan flag --tracking-backends:

# 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

Variabel lingkungan yang setara juga tersedia:

• RF_MLFLOW_ENABLED (default true, atau false di Colab)
• RF_TENSORBOARD_ENABLED (default false, atau true di Colab)
• RF_TRACKIO_ENABLED (default false)

Ketiga backend menerima metrik yang sama (loss, skor evaluasi, learning rate, dll.) dan menghormati peristiwa siklus hidup run IC Ops, sehingga Anda dapat menggunakan, misalnya, Trackio untuk berbagi ringan di samping MLflow untuk dashboard lokal lengkap.

Menjalankan di Google Colab

RapidFire AI berjalan di GPU T4 Google Colab gratis, dengan notebook tutorial untuk alur kerja SFT, DPO, GRPO, dan RAG / rekayasa konteks. Di Colab, TensorBoard adalah backend pelacakan default (MLflow dinonaktifkan untuk kesederhanaan), dan perintah rapidfireai init / rapidfireai start yang biasa dijalankan langsung dari sel notebook — tanpa perlu akses terminal.

Mulai: RapidFire AI di Google Colab.

Praktik Terbaik

Menyetel Granularitas Chunk

Parameter num_chunks mengontrol frekuensi swap:

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

Aturan praktis: Mulai dengan num_chunks=4 dan sesuaikan berdasarkan ukuran dataset dan jumlah konfigurasi.

Manajemen Memori

Untuk model besar, gunakan kuantisasi:

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",
}

Benchmarks Kinerja

Berdasarkan benchmark internal yang membandingkan pelatihan berurutan vs. pelatihan konkuren RapidFire AI:

Benchmark yang dilakukan pada NVIDIA A100 40GB dengan model TinyLlama-1.1B dan Llama-3.2-1B

Pemecahan Masalah

Untuk panduan pemecahan masalah, lihat RapidFire AI Troubleshooting Guide.

Sumber Daya Tambahan

• Notebook Colab: RapidFire AI di Google Colab
• Dokumentasi: oss-docs.rapidfire.ai
• GitHub: RapidFireAI/rapidfireai
• PyPI: pypi.org/project/rapidfireai
• Discord: Bergabunglah dengan Discord kami
• Notebook Tutorial: Repositori GitHub

Pelajari lebih lanjut tentang RapidFire AI di repositori resmi dan dokumentasi mereka.