MosaicML Composer

Des algorithmes de pointe pour entraîner vos réseaux neuronaux

Composer est une bibliothèque conçue pour entraîner des réseaux neuronaux plus efficacement, plus rapidement et à moindre coût. Elle propose de nombreuses méthodes de pointe pour accélérer l’entraînement des réseaux neuronaux et améliorer la généralisation, ainsi qu’une API Trainer facultative qui permet de composer facilement de nombreuses améliorations.

W&B fournit un wrapper léger pour consigner vos expériences de ML. Mais vous n’avez pas besoin de les combiner vous-même : W&B est directement intégré à la bibliothèque Composer via WandBLogger.

Commencez à journaliser avec W&B

from composer import Trainer
from composer.loggers import WandBLogger

trainer = Trainer(..., logger=WandBLogger())

Utiliser le WandBLogger de Composer

La bibliothèque Composer utilise la classe WandBLogger dans le Trainer pour journaliser des métriques dans W&B. Il suffit d’instancier le logger et de le passer au Trainer.

wandb_logger = WandBLogger(project="gpt-5", log_artifacts=True)
trainer = Trainer(logger=wandb_logger)

Arguments du logger

Vous trouverez ci-dessous les paramètres de WandbLogger ; consultez la documentation Composer pour obtenir la liste complète et leur description.

Paramètre	Description
project	Nom du projet W&B (str, facultatif)
group	Nom du groupe W&B (str, facultatif)
name	Nom de l’exécution W&B. S’il n’est pas spécifié, State.run_name est utilisé (str, facultatif)
entity	Nom de l’entité W&B, par exemple votre nom d’utilisateur ou votre nom Teams W&B (str, facultatif)
tags	Tags W&B (List[str], facultatif)
log_artifacts	Indique s’il faut journaliser les checkpoints dans wandb, par défaut : false (bool, facultatif)
rank_zero_only	Indique s’il faut journaliser uniquement sur le processus de rang zéro. Lors de la journalisation des Artifacts, il est fortement recommandé de journaliser sur tous les rangs. Les Artifacts des rangs ≥1 ne sont pas stockés, ce qui peut entraîner la perte d’informations pertinentes. Par exemple, lors de l’utilisation de Deepspeed ZeRO, il serait impossible de restaurer à partir des checkpoints sans les Artifacts de tous les rangs, par défaut : True (bool, facultatif)
init_kwargs	Paramètres à transmettre à wandb.init(), comme votre config wandb, entre autres. Voir les paramètres de wandb.init() pour les paramètres acceptés par wandb.init().

Voici un exemple d’utilisation :

init_kwargs = {"notes":"Testing higher learning rate in this experiment", 
               "config":{"arch":"Llama",
                         "use_mixed_precision":True
                         }
               }

wandb_logger = WandBLogger(log_artifacts=True, init_kwargs=init_kwargs)

Journaliser des échantillons de prédictions

Vous pouvez utiliser le système de Callbacks de Composer pour contrôler quand vous journalisez dans W&B via le WandBLogger ; dans cet exemple, un échantillon d’images de validation et de prédictions est journalisé :

import wandb
from composer import Callback, State, Logger

class LogPredictions(Callback):
    def __init__(self, num_samples=100, seed=1234):
        super().__init__()
        self.num_samples = num_samples
        self.data = []
        
    def eval_batch_end(self, state: State, logger: Logger):
        """Calcule les prédictions par lot et les stocke dans self.data"""
        
        if state.timer.epoch == state.max_duration: #à la dernière époque de validation
            if len(self.data) < self.num_samples:
                n = self.num_samples
                x, y = state.batch_pair
                outputs = state.outputs.argmax(-1)
                data = [[wandb.Image(x_i), y_i, y_pred] for x_i, y_i, y_pred in list(zip(x[:n], y[:n], outputs[:n]))]
                self.data += data
            
    def eval_end(self, state: State, logger: Logger):
        with wandb.init() as run:
            "Crée un wandb.Table et le journalise"
            columns = ['image', 'ground truth', 'prediction']
            table = wandb.Table(columns=columns, data=self.data[:self.num_samples])
            run.log({'sample_table':table}, step=int(state.timer.batch))         
...

trainer = Trainer(
    ...
    loggers=[WandBLogger()],
    callbacks=[LogPredictions()]
)