Ray Tune

Intégrez W&B à Ray Tune pour suivre les essais d’optimisation d’hyperparamètres, consigner des métriques et comparer les résultats des expériences.

Cette page explique comment utiliser W&B avec Ray Tune afin de suivre les essais d’optimisation d’hyperparamètres, de consigner des métriques et de comparer les résultats des expériences d’une exécution à l’autre. W&B propose deux intégrations légères avec Ray, et vous pouvez choisir celle qui correspond le mieux à votre flux de travail d’entraînement :

• La fonction WandbLoggerCallback journalise automatiquement dans W&B les métriques transmises à Tune.
• La fonction setup_wandb(), que vous pouvez utiliser avec l’API fonctionnelle, initialise automatiquement le SDK Python W&B (wandb) avec les informations d’entraînement de Tune. Vous pouvez utiliser l’API W&B comme d’habitude, par exemple en appelant run.log() pour journaliser votre entraînement.

Configurer l’intégration

Cette section explique comment configurer WandbLoggerCallback, qui constitue le moyen le plus direct d’envoyer les métriques des essais Tune à W&B.

from ray.air.integrations.wandb import WandbLoggerCallback

Pour configurer W&B, fournissez une clé wandb au paramètre config de tune.run(). Voir l’exemple pour savoir comment l’utiliser.

L’intégration transmet le contenu de l’entrée de configuration wandb à wandb.init() sous forme d’arguments nommés. Les seules exceptions sont les paramètres qui configurent WandbLoggerCallback lui-même.

Paramètres

Le WandbLoggerCallback accepte les paramètres suivants :

• project (str) : Nom du projet W&B. Requis.
• api_key_file (str) : Chemin vers le fichier contenant la clé API W&B.
• api_key (str) : Clé API W&B. Alternative à api_key_file.
• excludes (list) : Liste des métriques à exclure du journal.
• log_config (bool) : Indique s’il faut journaliser le paramètre config du dictionnaire de résultats. Par défaut : False.
• upload_checkpoints (bool) : Si True, téléverse les points de contrôle du modèle en tant qu’artefacts. Par défaut : False.

Exemple

from ray import tune, train
from ray.air.integrations.wandb import WandbLoggerCallback


def train_fc(config):
    for i in range(10):
        train.report({"mean_accuracy": (i + config["alpha"]) / 10})


tuner = tune.Tuner(
    train_fc,
    param_space={
        "alpha": tune.grid_search([0.1, 0.2, 0.3]),
        "beta": tune.uniform(0.5, 1.0),
    },
    run_config=train.RunConfig(
        callbacks=[
            WandbLoggerCallback(
                project="<your-project>", api_key="<your-api-key>", log_config=True
            )
        ]
    ),
)

results = tuner.fit()

setup_wandb

Utilisez setup_wandb() lorsque vous souhaitez contrôler directement la journalisation W&B depuis votre fonction d’entraînement, par exemple pour appeler run.log() avec des métriques personnalisées aux côtés du reporting de Tune.

from ray.air.integrations.wandb import setup_wandb

Cette fonction utilitaire permet d’initialiser W&B pour l’utiliser avec Ray Tune. Pour une utilisation de base, appelez setup_wandb() dans votre fonction d’entraînement :

from ray import tune
from ray.air.integrations.wandb import setup_wandb


def train_fn(config):
    # Initialiser wandb
    wandb = setup_wandb(config)
    run = wandb.init(
        project=config["wandb"]["project"],
        api_key_file=config["wandb"]["api_key_file"],
    )

    for i in range(10):
        loss = config["a"] + config["b"]
        run.log({"loss": loss})
        tune.report(loss=loss)
    run.finish()


tuner = tune.Tuner(
    train_fn,
    param_space={
        # définir l'espace de recherche ici
        "a": tune.choice([1, 2, 3]),
        "b": tune.choice([4, 5, 6]),
        # configuration wandb
        "wandb": {"project": "Optimization_Project", "api_key_file": "/path/to/file"},
    },
)
results = tuner.fit()

Exemple de code

Pour des références complètes, consultez les exemples suivants, qui montrent comment fonctionne l’intégration :

• Essayez l’intégration dans Colab : une démo pour essayer l’intégration.
• Voir le tableau de bord de l’exemple : voir le tableau de bord généré à partir de l’exemple.