> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Journaliser les modèles
> Journalisez des Artifacts de modèle dans un run W&B, puis récupérez-les ultérieurement à l’aide des méthodes SDK log_model et use_model.
export const ColabLink = ({url}) =>
Essayer sur Colab
;
# Journaliser les modèles
Le guide suivant explique comment journaliser des modèles dans un run W\&B et interagir avec ceux-ci.
Les API suivantes sont utiles pour suivre les modèles dans le cadre de votre flux de travail de suivi des expériences. Utilisez les API répertoriées sur cette page pour journaliser des modèles dans un run et accéder aux métriques, tableaux, médias et autres objets.
W\&B vous recommande d'utiliser [W\&B Artifacts](/fr/models/artifacts/) si vous souhaitez :
* Créer et suivre différentes versions de données sérialisées autres que les modèles, comme des jeux de données, des prompts, etc.
* Explorer les [graphes de lignage](/fr/models/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/models/artifacts/update-an-artifact/) (métadonnées, alias et descriptions)
Pour en savoir plus sur W\&B Artifacts et les cas d'usage avancés de gestion des versions, consultez la documentation [Artifacts](/fr/models/artifacts/).
## Journaliser un modèle dans un run
Utilisez [`log_model`](/fr/models/ref/python/experiments/run#log_model) pour journaliser un artifact de modèle contenant le contenu du répertoire que vous spécifiez. La méthode [`log_model`](/fr/models/ref/python/experiments/run#log_model) marque également l'artifact de modèle obtenu comme sortie du run W\&B.
Vous pouvez suivre les dépendances d'un modèle et les relations qui lui sont associées si vous le marquez comme entrée ou sortie d'un run W\&B. Consultez la traçabilité du modèle dans l'interface de l'application W\&B. Voir la page [Explorer et parcourir les graphes d'artifacts](/fr/models/artifacts/explore-and-traverse-an-artifact-graph/) du chapitre [Artifacts](/fr/models/artifacts/) pour plus d'informations.
Indiquez dans le paramètre `path` le chemin où vos fichiers de modèle sont enregistrés. Le chemin peut correspondre à un fichier local, à un répertoire ou à une [URI de référence](/fr/models/artifacts/track-external-files/#amazon-s3--gcs--azure-blob-storage-references) pointant vers un bucket externe, par exemple `s3://bucket/path`.
Veillez à remplacer les valeurs entre `<>` par les vôtres.
```python theme={null}
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 facultativement fournir un nom pour l'artifact de modèle via le paramètre `name`. Si `name` n'est pas spécifié, W\&B utilisera le nom de base du chemin d'entrée, précédé de l'ID du run, comme nom.
Notez le `name` que vous, ou W\&B, attribuez au modèle. Vous aurez besoin du nom du modèle pour récupérer son chemin avec la
méthode [`wandb.Run.use_model()`](/fr/models/ref/python/experiments/run#use_model).
Voir [`log_model`](/fr/models/ref/python/experiments/run#log_model) dans la Référence de l'API pour les paramètres.
Exemple : journaliser un modèle dans un run
```python theme={null}
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 notebook affichera des informations indiquant où trouver des informations sur le run auquel le modèle a été enregistré.
```python theme={null}
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 enregistré
Utilisez la fonction [`use_model`](/fr/models/ref/python/experiments/run#use_model) pour accéder aux fichiers de modèle et les télécharger s’ils ont été enregistrés auparavant dans un run W\&B.
Indiquez le nom de l’artifact de modèle dans lequel sont stockés les fichiers de modèle que vous souhaitez récupérer. Le nom que vous indiquez doit correspondre à celui d’un artifact de modèle enregistré existant.
Si vous n’avez pas défini `name` lorsque vous avez enregistré les 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={null}
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 vers l'artifact téléchargé
downloaded_model_path = run.use_model(name="")
```
La fonction [use\_model](/fr/models/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 plus tard. Dans l’extrait de code précédent, le chemin renvoyé est stocké dans une variable appelée `downloaded_model_path`.
Exemple : Télécharger et utiliser un modèle enregistré
Par exemple, dans l’extrait de code suivant, un utilisateur a appelé l’API `use_model`. Il a indiqué le nom de l’artifact de modèle à récupérer, ainsi qu’une version/un alias. Il a ensuite stocké dans la variable `downloaded_model_path` le chemin renvoyé par l’API.
```python theme={null}
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 vers l’artifact téléchargé
downloaded_model_path = run.use_model(name = f"{model_artifact_name}:{alias}")
```
Voir [`use_model`](/fr/models/ref/python/experiments/run#use_model) dans la Référence de l’API pour les paramètres et le type de retour.