TRL documentation

RapidFire AI 통합

TRL

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.17.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

RapidFire AI 통합

RapidFire AI는 TRL과 통합되어 “한 번에 하나의 구성만 학습”하는 방식을 같은 GPU에서 여러 구성을 실시간으로 나란히 비교하는 방식으로 전환하는 오픈소스 실험 실행 프레임워크입니다. 이를 통해 추가 하드웨어 없이 하이퍼파라미터, LoRA 설정, 프롬프트 스키마, 아블레이션 등을 16–24배 빠르게 반복할 수 있습니다.

링크: GitHub · 문서 · Colab에서 사용

TRL과 함께 RapidFire AI를 사용하는 이유

TRL로 fine-tuning 또는 post-training을 수행할 때 일반적으로 다음이 필요합니다:

Try different hyperparameter configurations
다른 LoRA 설정 비교
Test different prompt schemes
…

시나리오: 동일한 GPU에서 N개의 학습 구성 비교	TRL 단독	TRL + RapidFire AI
학습 전략	N개의 구성을 순차적으로 실행	N개의 구성을 동시에 실행
언제 설정을 비교할 수 있나요?	모든 실행이 완료된 후	첫 번째 청크부터 실시간으로
학습 중 실패한 모델 중단 / 성공한 모델 복제	아니요	예 (인터랙티브 제어 작업)

작동 방식

RapidFire AI는 적응형 청크 기반 스케줄링을 사용합니다:

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]

이를 통해 다음을 수행할 수 있습니다:

Early comparison of configurations on same data subsets incrementally
효율적인 GPU 활용 및 유휴 시간 최소화
실시간 및 자동화된 실험 지표 추적
실험을 장려하기 위해 실행 중인 런에 대한 동적 제어

주요 기능

순차적 학습과 비교하여 16~24배 높은 실험 처리량
코드 변경이 거의 없음 - 기존 TRL 및 PEFT 설정 API를 단순히 감싸는 간단한 드롭인 설정 API입니다.
인터랙티브 제어 작업 - 실행 중인 학습 실행을 실시간으로 중지, 재개 및 복제-수정(웜 스타팅 포함 또는 제외)하는 제어 기능.
하나의 GPU에 맞지 않는 대규모 모델을 학습하기 위해 매개변수, 기울기, 옵티마이저 상태를 여러 GPU에 걸쳐 샤딩하는 Fully Sharded Data Parallel(FSDP)과의 통합
Transformers, PEFT, SFTTrainer, DPOTrainer, GRPOTrainer와의 완전한 호환성.
플러그인 실험 추적: MLflow(기본값), TensorBoard, Trackio를 개별 또는 조합으로 활성화할 수 있습니다.
설치 불필요한 Google Colab 지원: 무료 T4 GPU에서 SFT, DPO, GRPO를 위한 원클릭 튜토리얼 노트북.
프로덕션 준비 완료: 이미 프로덕션 환경에서 사용 중이며, 완전히 동작하는 예제가 포함되어 있습니다.

설치

필수 조건

Python 3.12.x
Compute Capability 7.x 또는 8.x를 지원하는 NVIDIA GPU (FSDP의 경우 여러 GPU 필요)
CUDA Toolkit 11.8 이상
PyTorch 2.8 이상

pip install

pip install rapidfireai

설치 후 Hugging Face로 인증하고 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

대시보드는 http://localhost:8853에서 사용할 수 있으며, 여기서 실험을 실시간으로 모니터링하고 제어할 수 있습니다.

빠른 시작: 여러 구성을 사용한 SFT 학습

여러 SFT 구성을 동시에 학습하는 방법을 보여주는 완전한 예시입니다:

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

실행 중 발생하는 일

이 예제를 실행하면:

설정 확장: 2개의 기본 설정 × 2개의 PEFT 설정 = 총 4개의 학습 실행
청크 기반 스케줄링: 학습 데이터는 청크로 나뉘며, 모든 4개의 구성이 동시에 학습됩니다
GPU 스왑핑: 모델은 청크 경계에 따라 GPU 메모리에 스왑 인/아웃됩니다
실시간 추적: http://localhost:8853의 대시보드에서 모든 메트릭을 확인할 수 있습니다
인터랙티브 제어: 대시보드에서 모든 구성을 중지, 재개 또는 복제하여 수정

각 구성을 순차적으로 학습하는 것과 비교하여 16-24배 높은 처리량을 제공합니다!

지원되는 TRL Trainer

SFTTrainer

RFSFTConfig를 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
)

예제 Notebook: 고객 지원을 위한 SFT

DPOTrainer

RFDPOConfig를 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
)

예제 Notebook: 선호 정렬을 위한 DPO

GRPOTrainer

RFGRPOConfig를 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
)

예제 Notebook: 수학 추론을 위한 GRPO

핵심 개념

Chunk 기반 동시 학습

RapidFire AI는 학습 데이터를 청크로 나누고 구성을 번갈아 사용합니다:

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

이 접근 방식은 GPU 활용률을 극대화하고, 자동 체크포인트를 통해 학습 안정성을 유지하면서 구성의 조기 비교를 가능하게 합니다.

인터랙티브 제어 작업(IC Ops)

RapidFire AI 대시보드를 통해 실행 중인 실험을 동적으로 제어할 수 있습니다:

중지: 구성을 일시 중지합니다(자동으로 체크포인트가 생성됩니다)
재개: 마지막 체크포인트에서 계속
Clone-Modify: 수정 사항을 적용하여 구성을 복제합니다(새 실행은 처음부터 시작됩니다)
Warm Start를 사용한 Clone-Modify: Clone-modify를 사용하고 부모의 가중치에서 초기화
삭제: 실패하거나 원치 않는 실행 제거

…

멀티-설정 실험

RFGridSearch 또는 RFRandomSearch를 사용하여 구성 조합을 자동으로 생성합니다:

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

고급 기능

PEFT/LoRA 통합

매개변수 효율적 미세 조정의 완전한 지원:

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

커스텀 보상 함수 (GRPO)

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
)

멀티 GPU 지원

RapidFire AI는 사용 가능한 모든 GPU를 자동으로 감지하고 활용합니다. 기본적으로 스케줄러는 독립적인 구성을 GPU에 분배하므로(구성 간 데이터 병렬), N개의 구성을 N개의 GPU에서 동시에 실행하려면 특별한 설정이 필요하지 않습니다.

단일 GPU에 맞지 않는 모델의 경우, RapidFire AI는 Fully Sharded Data Parallel (FSDP)를 지원하여 단일 구성을 여러 GPU에 걸쳐 샤딩합니다. 다음 섹션을 참조하세요.

FSDP를 활용한 멀티 GPU 학습

모델이 단일 GPU에 너무 크다면, RFSFTConfig 또는 RFDPOConfig의 학습 인수를 통해 FSDP를 직접 활성화할 수 있습니다. Hugging Face TrainingArguments에서 노출하는 fsdp 및 fsdp_config 필드와 동일합니다:

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

주요 사항:

FSDP는 RapidFire AI의 청크 기반 스케줄링, IC Ops(워밍 스타팅을 사용하거나 사용하지 않는 stop / resume / clone-modify), 그리고 모든 지원되는 메트릭 추적 백엔드와 투명하게 작동합니다.
FSDP는 PEFT / LoRA와 완전히 호환됩니다. 체크포인트를 저장할 때 LoRA 어댑터 가중치는 샤드 간에 효율적으로 수집됩니다.
FSDP는 그리드 서치와 랜덤 서치와 함께 사용할 수 있습니다. 각 확장된 구성은 자체 샤드된 학습 실행을 갖습니다.

예제 노트북:

실험 추적 백엔드

RapidFire AI는 개별 또는 함께 사용할 수 있는 세 가지 메트릭 로깅 백엔드를 지원합니다: MLflow(로컬 설치의 기본값), TensorBoard(Google Colab의 기본값), Trackio.

서버 시작 시 --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

동등한 환경 변수도 사용할 수 있습니다:

RF_MLFLOW_ENABLED (기본값 true, Colab에서는 false)
RF_TENSORBOARD_ENABLED (기본값 false, Colab에서는 true)
RF_TRACKIO_ENABLED (기본값 false)

세 가지 백엔드 모두 동일한 지표(loss, 평가 점수, 학습률 등)를 수신하며 IC Ops 실행 라이프사이클 이벤트를 준수하므로, 예를 들어 Trackio를 경량 공유용으로, MLflow를 전체 로컬 대시보드로 함께 사용할 수 있습니다.

Google Colab에서 실행

RapidFire AI는 무료 Google Colab T4 GPU에서 실행되며, SFT, DPO, GRPO 및 RAG / 컨텍스트 엔지니어링 워크플로우에 대한 튜토리얼 노트북을 제공합니다. Colab에서는 TensorBoard가 기본 추적 백엔드로 사용되며(간소화를 위해 MLflow는 비활성화됨), 일반적인 rapidfireai init / rapidfireai start 명령은 터미널 접근 없이 노트북 셀에서 바로 실행됩니다.

시작하기: Google Colab에서 RapidFire AI.

최적의 관행

Chunk Granularity 조정

num_chunks 매개변수는 스왑 빈도를 제어합니다:

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

경험칙: num_chunks=4로 시작하여 데이터셋 크기와 구성 개수에 따라 조정하세요.

메모리 관리

대형 모델의 경우 양자화를 사용하세요:

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

성능 벤치마크

순차적 학습과 RapidFire AI 동시 학습을 비교한 내부 벤치마크에 따르면:

시나리오	순차 시간	RapidFire AI Time	속도 향상
4개의 구성, 1개의 GPU	120분	7.5분	16×
8개의 구성, 1개의 GPU	240분	12분	20×
4개의 구성, 2개의 GPU	60분	4분	15×
8개의 구성, 4개의 GPU	60분	3분	20×

NVIDIA A100 40GB에서 TinyLlama-1.1B 및 Llama-3.2-1B 모델을 사용하여 수행한 벤치마크

문제 해결

문제 해결 가이드에 대한 자세한 내용은 RapidFire AI Troubleshooting Guide를 참조하세요.

추가 자료

Colab Notebook: Google Colab에서 RapidFire AI
문서: oss-docs.rapidfire.ai
GitHub: RapidFireAI/rapidfireai
PyPI: pypi.org/project/rapidfireai
Discord: Discord에 참여하기
튜토리얼 노트북: GitHub 저장소

RapidFire AI에 대해 자세히 알아보려면 공식 저장소와 문서를 참고하세요.

Update on GitHub

←PEFT Trackio→