TRL documentation

RapidFire AI 統合

You are viewing v1.18.0 version. A newer version v1.18.1 is available.
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

RapidFire AI 統合

RapidFire AIは、TRLと統合して「一度に1つの設定を訓練する」ワークフローを、同じGPU上で多数の設定をリアルタイムかつ並列で比較するものに変えるオープンソースの実験実行フレームワークです。これにより、ハイパーパラメータ、LoRA設定、プロンプトスキーム、アブレーションを、追加のハードウェアなしで16〜24倍の速度で反復できます。

リンク: GitHub · ドキュメント · Colabで試す

TRLでRapidFire AIを使用する理由

TRLでファインチューニングやポストトレーニングを行う場合、通常は以下が必要です:

  • 異なるハイパーパラメータ設定を試す
  • 異なるLoRA設定を比較する
  • 異なるプロンプトスキームをテストする
  • アブレーションスタディを実行する
シナリオ: 同じ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]

これにより、以下が可能になります:

  • 同じデータサブセット上で設定を段階的に比較する
  • GPUの効率的な活用とアイドル時間の最小化
  • リアルタイムかつ自動的な実験メトリクスの追跡
  • 実験をより多く行うことを促すために、実行中のランに対する動的な制御

主な機能

  • 16〜24倍の高速な実験スループットを、逐次学習と比較して実現します。
  • コードの修正はほぼ不要 - 既存のTRLおよびPEFTの設定APIをラップするだけのシンプルなドロップイン設定APIです。
  • インタラクティブな制御操作 - 実行中のトレーニングランをリアルタイムで停止、再開、クローンして修正(ウォームスタートの有無を問わず)するための制御。
  • Fully Sharded Data Parallel (FSDP)との統合。パラメータ、勾配、オプティマイザの状態を複数のGPUにシャーディングすることで、単一のGPUに収まらない大規模モデルの学習を行います。
  • 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()

実行時に何が起きるか

この例を実行すると:

  1. 設定の展開: 2つのベース設定 × 2つのPEFT設定 = 合計4回のトレーニング実行
  2. チャンクベースのスケジューリング: 学習データをチャンクに分割し、4つの設定すべてを並行して学習します
  3. GPUスワッピング: モデルはチャンクの境界に基づいてGPUメモリに読み込まれたり書き出されたりします
  4. リアルタイムトラッキング: http://localhost:8853 のダッシュボードですべてのメトリクスを確認できます
  5. インタラクティブな制御: ダッシュボードから任意の構成を停止、再開、またはクローンして変更

この方法により、各設定を順番に学習させる場合と比べて、スループットが16〜24倍向上します!

サポートされているTRLトレーナー

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
)

サンプルノートブック: カスタマーサポート向け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
)

サンプルノートブック: 好みに基づくアライメントのための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
)

サンプルノートブック: 数学的推論のためのGRPO

コアコンセプト

チャンクベースの並行トレーニング

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: 変更を加えて設定を複製します(新しい実行は最初から開始されます)
  • ウォームスタートによるクローン・修正: クローン・修正し、親の重みから初期化します
  • 削除: 失敗した実行や不要な実行を削除します

これにより、適応的な実験が可能になります。パフォーマンスが低い設定は早期に停止し、有望な設定はハイパーパラメータを調整して複製できます。

マルチ設定実験

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 で同時に実行するには、特別なセットアップは不要です。

1つのGPUに収まらないモデルについては、RapidFire AIはFully Sharded Data Parallel (FSDP)もサポートしており、単一の構成を複数のGPUにシャードできます。詳細は次のセクションを参照してください。

FSDPによるマルチGPUトレーニング

モデルが1つの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(ウォームスタートの有無を問わず、停止/再開/クローン化して変更)、およびサポートされているすべてのメトリック追跡バックエンドと、透過的に動作します。
  • FSDPはPEFT / LoRAと完全に互換性があります。チェックポイントを保存する際、LoRAアダプター重みはシャード間で効率的に収集されます。
  • FSDPはグリッドサーチやランダムサーチと組み合わせることができます。展開された各設定に対して、個別のシャード化されたトレーニング実行が行われます。

サンプルノートブック:

実験トラッキングバックエンド

RapidFire AIは、個別に、または組み合わせて使用できる3つのメトリクスロギングバックエンドをサポートしています: MLflow(ローカルインストール時のデフォルト)、TensorBoard(Google Colabでのデフォルト)、およびTrackio。

サーバー起動時に--tracking-backendsフラグで1つ以上のバックエンドを選択します:

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

3つのバックエンドはすべて同じメトリクス(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。

ベストプラクティス

チューニングチャンク粒度

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つのGPU120分7.5分16×
8つの設定、1つのGPU240分12分20×
4つのconfigs、2つのGPU60分4分15×
8つの設定、4つのGPU60分3分20×

NVIDIA A100 40GBでTinyLlama-1.1BおよびLlama-3.2-1Bモデルを使用して実行したベンチマーク

トラブルシューティング

トラブルシューティングのガイダンスについては、RapidFire AI Troubleshooting Guideを参照してください。

追加のリソース

RapidFire AIの詳細については、公式リポジトリおよびドキュメントをご覧ください。

Update on GitHub