Intégration de RapidFire AI

RapidFire AI permet des expérimentations rapides pour une personnalisation de l’IA plus simple, plus rapide et plus efficace. Conçu pour le RAG agentique, l’ingénierie du contexte, le fine-tuning et le post-training de LLM et d’autres modèles DL, il offre un débit 16 à 24 fois supérieur sans ressources supplémentaires. Il prend en charge deux cas d’usage clés :

• Ajustement fin et entraînement postérieur : Comparez les taux d'apprentissage, les configurations LoRA, les tailles de lot et d'autres hyperparamètres d'entraînement
• Optimisation du RAG : Évaluer les stratégies de découpage, les modèles d'embeddings, les approches de récupération et les paramètres de réordonnancement

Lors de l’exécution d’expériences, vous avez souvent de nombreuses configurations qui s’exécutent simultanément. RapidFire AI fournit une intégration native à Trackio pour suivre et visualiser l’ensemble de ces exécutions avec un minimum de configuration.

Installation

Trackio est inclus en tant que dépendance de RapidFire AI :

pip install rapidfireai

Configuration

Activez Trackio en tant que backend de suivi en définissant les variables d’environnement avant d’importer les composants de RapidFire :

import os

# Enable Trackio as the tracking backend
os.environ["RF_TRACKIO_ENABLED"] = "true"

# Optionally disable other tracking backends for standalone Trackio usage
os.environ["RF_MLFLOW_ENABLED"] = "false"
os.environ["RF_TENSORBOARD_ENABLED"] = "false"

Vous pouvez également définir le nom du projet Trackio :

export TRACKIO_PROJECT_NAME="my-experiment"

Exemple de fine-tuning

Pour des exemples complets et fonctionnels, consultez les notebooks de tutoriel :

• Tutoriel sur le SFT avec Trackio
• Tutoriel SFT avec Trackio (version Colab)

Voici un exemple minimal d’exécution d’une expérience de fine-tuning avec le suivi Trackio :

import os
os.environ["RF_TRACKIO_ENABLED"] = "true"

from rapidfireai import Experiment
from rapidfireai.automl import RFGridSearch, RFModelConfig, RFLoraConfig, RFSFTConfig

experiment = Experiment(experiment_name="my-sft-experiment", mode="fit")

config = RFModelConfig(
    model_name="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
    peft_config=RFLoraConfig(r=8, lora_alpha=16, target_modules=["q_proj", "v_proj"]),
    training_args=RFSFTConfig(
        learning_rate=1e-4,
        max_steps=128,
        logging_steps=2,
        eval_strategy="steps",
        eval_steps=4,
    ),
    model_type="causal_lm",
)

experiment.run_fit(
    RFGridSearch(configs=[config], trainer_type="SFT"),
    create_model_fn,
    train_dataset,
    eval_dataset,
    num_chunks=4
)

Exemple d’optimisation du RAG

Pour des exemples complets et fonctionnels, consultez les notebooks de tutoriel :

• Tutoriel RAG FiQA avec Trackio
• Tutoriel RAG FiQA avec Trackio (version Colab)

RapidFire AI prend également en charge l’optimisation des pipelines RAG. Activez le suivi Trackio de la même manière :

import os
os.environ["RF_TRACKIO_ENABLED"] = "true"

from rapidfireai import Experiment
from rapidfireai.evals.automl import List, RFGridSearch, RFLangChainRagSpec, RFvLLMModelConfig

experiment = Experiment(experiment_name="my-rag-experiment", mode="evals")

rag_spec = RFLangChainRagSpec(
    document_loader=your_document_loader,
    text_splitter=your_text_splitter,
    embedding_cls=your_embedding_class,
    search_kwargs={"k": List([5, 10])},  # 2 retrieval configs to compare
)

config_group = RFGridSearch({
    "vllm_config": RFvLLMModelConfig(rag=rag_spec, ...),
    "batch_size": 32,
    ...
})

experiment.run_evals(
    config_group=config_group,
    dataset=eval_dataset,
    num_actors=1,
    num_shards=4,
)

Ce qui est suivi

RapidFire AI enregistre automatiquement les éléments suivants dans Trackio :

Métriques d'ajustement fin :

• loss, learning_rate, epoch, step - Progression de l'entraînement
• eval_loss - Perte de validation
• Métriques personnalisées issues de votre fonction compute_metrics (par exemple, rougeL, bleu)

Métriques d'évaluation du RAG :

• Métriques de récupération : Precision, Recall, F1 Score, NDCG@K, MRR
• Métriques de génération : Métriques personnalisées que vous définissez (par exemple, Accuracy)

Configuration d’exécution :

• Tous les hyperparamètres pour chaque exécution
• Paramètres du modèle, configurations LoRA, stratégies de découpage, etc.

Affichage du tableau de bord

Lancez le tableau de bord Trackio pour visualiser vos expériences :

trackio show --project "my-sft-experiment"

Ou depuis Python :

import trackio
trackio.show(project="my-sft-experiment")

Le tableau de bord affiche les courbes d’entraînement en temps réel pour toutes vos exécutions, ce qui facilite la comparaison des configurations côte à côte :

Tableau de bord Trackio comparant 4 exécutions de fine-tuning avec différents hyperparamètres. Les graphiques affichent la perte d'entraînement, la perte de validation, les calendriers de taux d'apprentissage et les scores ROUGE-L, ce qui facilite l'identification de la configuration (Run 4, en orange) qui atteint la perte la plus basse et la meilleure qualité de génération.

Documentation :

• Documentation RapidFire AI - Guide de démarrage
• GitHub de RapidFire AI - Code source et tutoriels