> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Journaliser des modèles
> Journalisez des artifacts de modèle dans un run W&B et récupérez-les par la suite à l’aide des méthodes log_model et use_model du SDK.
export const ColabLink = ({url}) =>
Try in Colab
;
Journaliser des modèles
Ce guide explique comment journaliser des modèles dans un run W\&B et comment interagir avec eux.
Les API suivantes sont utiles pour suivre des modèles dans le cadre de votre flux de travail de suivi des expériences. Utilisez les API présentées sur cette page pour journaliser des modèles dans un run et pour accéder aux métriques, aux tableaux, aux médias et à d’autres objets.
W\&B vous recommande d’utiliser [W\&B Artifacts](/fr/products/wandb/artifacts) si vous souhaitez :
* Créer et suivre différentes versions de données sérialisées autres que des modèles, comme des jeux de données, des prompts, etc.
* Explorer les [graphes de traçabilité](/fr/products/wandb/artifacts/explore-and-traverse-an-artifact-graph) d’un modèle ou de tout autre objet suivi dans W\&B.
* Interagir avec les artifacts de modèle créés par ces méthodes, par exemple en [mettant à jour leurs propriétés](/fr/products/wandb/artifacts/update-an-artifact) (métadonnées, alias et descriptions)
Pour plus d’informations sur W\&B Artifacts et sur les cas d’usage avancés de gestion des versions, consultez la documentation [Artifacts](/fr/products/wandb/artifacts).
Journaliser un modèle dans un run
Utilisez [`log_model`](/fr/products/wandb/ref/python/experiments/run#log_model) pour journaliser un artifact de modèle contenant les fichiers d’un répertoire que vous spécifiez. La méthode [`log_model`](/fr/products/wandb/ref/python/experiments/run#log_model) marque également l’artifact de modèle obtenu comme sortie du run W\&B.
Si vous marquez un modèle comme entrée ou sortie d’un run W\&B, vous pouvez suivre ses dépendances et ses associations. Consultez la traçabilité du modèle dans l’interface de l’application W\&B. Pour plus d’informations, voir la page [Explorer et parcourir les graphes d’artifacts](/fr/products/wandb/artifacts/explore-and-traverse-an-artifact-graph) du chapitre [Artifacts](/fr/products/wandb/artifacts).
Transmettez au paramètre `path` le chemin où vos fichiers de modèle sont enregistrés. Ce chemin peut désigner un fichier local, un répertoire ou un [URI de référence](/fr/products/wandb/artifacts/track-external-files#amazon-s3--gcs--azure-blob-storage-references) vers un bucket externe, par exemple `s3://bucket/path`.
Veillez à remplacer les valeurs entre `<>` par les vôtres.
```python theme={"system"}
import wandb
# Initialiser un run W&B
with wandb.init(project="", entity="") as run:
# Journaliser le modèle
run.log_model(path="", name="")
```
Vous pouvez, si vous le souhaitez, fournir un nom pour l’artifact de modèle via le paramètre `name`. Si `name` n’est pas spécifié, W\&B utilise comme nom le nom de base (basename) du chemin d’entrée, précédé de l’ID du run.
Notez le `name` que vous attribuez au modèle, ou que W\&B lui attribue. Vous en aurez besoin pour récupérer le chemin du modèle avec la méthode [`wandb.Run.use_model()`](/fr/products/wandb/ref/python/experiments/run#use_model).
Consultez [`log_model`](/fr/products/wandb/ref/python/experiments/run#log_model) dans la Référence de l’API pour connaître les paramètres.
Exemple : journaliser un modèle dans un run
```python theme={"system"}
import os
import wandb
from tensorflow import keras
from tensorflow.keras import layers
config = {"optimizer": "adam", "loss": "categorical_crossentropy"}
# Initialiser un run W&B
with wandb.init(entity="charlie", project="mnist-experiments", config=config) as run:
# Hyperparamètres
loss = run.config["loss"]
optimizer = run.config["optimizer"]
metrics = ["accuracy"]
num_classes = 10
input_shape = (28, 28, 1)
# Algorithme d’entraînement
model = keras.Sequential(
[
layers.Input(shape=input_shape),
layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Flatten(),
layers.Dropout(0.5),
layers.Dense(num_classes, activation="softmax"),
]
)
# Configurer le modèle pour l’entraînement
model.compile(loss=loss, optimizer=optimizer, metrics=metrics)
# Enregistrer le modèle
model_filename = "model.h5"
local_filepath = "./"
full_path = os.path.join(local_filepath, model_filename)
model.save(filepath=full_path)
# Journaliser le modèle dans le run W&B
run.log_model(path=full_path, name="MNIST")
```
Lorsque vous appelez `wandb.Run.log_model()`, un artifact de modèle nommé `MNIST` est créé et le fichier `model.h5` y est ajouté. Votre terminal ou votre notebook indique ensuite où trouver des informations sur le run dans lequel le modèle a été journalisé.
```python theme={"system"}
View run different-surf-5 at: https://wandb.ai/charlie/mnist-experiments/runs/wlby6fuw
Synced 5 W&B file(s), 0 media file(s), 1 artifact file(s) and 0 other file(s)
Find logs at: ./wandb/run-20231206_103511-wlby6fuw/logs
```
Télécharger et utiliser un modèle journalisé
Utilisez la fonction [`use_model`](/fr/products/wandb/ref/python/experiments/run#use_model) pour accéder aux fichiers de modèle précédemment journalisés dans un run W\&B et les télécharger.
Indiquez le nom de l’artifact de modèle dans lequel sont stockés les fichiers de modèle à récupérer. Ce nom doit correspondre à celui d’un artifact de modèle journalisé existant.
Si vous n’avez pas défini `name` lors de la journalisation initiale des fichiers avec `log_model`, le nom attribué par défaut est le nom de base du chemin d’entrée, précédé de l’ID du run.
Veillez à remplacer les valeurs entre `<>` par les vôtres :
```python theme={"system"}
import wandb
# Initialiser un run
with wandb.init(project="", entity="") as run:
# Accéder au modèle et le télécharger. Renvoie le chemin de l’artifact téléchargé
downloaded_model_path = run.use_model(name="")
```
La fonction [use\_model](/fr/products/wandb/ref/python/experiments/run#use_model) renvoie le chemin des fichiers du modèle téléchargé. Conservez ce chemin si vous souhaitez lier ce modèle ultérieurement. Dans l’extrait de code précédent, le chemin renvoyé est stocké dans une variable nommée `downloaded_model_path`.
Exemple : télécharger et utiliser un modèle journalisé
Dans l’extrait de code suivant, par exemple, un utilisateur appelle l’API `use_model`. Il indique le nom de l’artifact de modèle à récupérer, ainsi qu’une version ou un alias. Il stocke ensuite le chemin renvoyé par l’API dans la variable `downloaded_model_path`.
```python theme={"system"}
import wandb
entity = "luka"
project = "NLP_Experiments"
alias = "latest" # surnom sémantique ou identifiant de la version du modèle
model_artifact_name = "fine-tuned-model"
# Initialiser un run
with wandb.init(project=project, entity=entity) as run:
# Accéder au modèle et le télécharger. Renvoie le chemin de l’artifact téléchargé
downloaded_model_path = run.use_model(name = f"{model_artifact_name}:{alias}")
```
Pour connaître les paramètres et le type de retour, consultez [`use_model`](/fr/products/wandb/ref/python/experiments/run#use_model) dans la référence de l’API.