> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-2751.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

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

# Ray Tune

Cette page explique comment utiliser W\&B avec [Ray](https://github.com/ray-project/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.

<div id="configure-the-integration">
  ## Configurer l’intégration
</div>

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

```python theme={null}
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](#example) 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.

<div id="parameters">
  ### Paramètres
</div>

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

<div id="example">
  ### Exemple
</div>

```python theme={null}
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()
```

<div id="setup_wandb">
  ## setup\_wandb
</div>

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.

```python theme={null}
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 :

```python theme={null}
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()
```

<div id="example-code">
  ## Exemple de code
</div>

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

* [Essayez l’intégration dans Colab](https://wandb.me/raytune-colab) : une démo pour essayer l’intégration.
* [Voir le tableau de bord de l’exemple](https://wandb.ai/anmolmann/ray_tune) : voir le tableau de bord généré à partir de l’exemple.