> ## 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.
# Log models
> Log model artifacts to a W&B run and retrieve them later using the log_model and use_model SDK methods.
export const ColabLink = ({url}) =>
Try in Colab
;
# Log models
The following guide describes how to log models to a W\&B run and interact with them.
The following APIs are useful for tracking models as a part of your experiment tracking workflow. Use the APIs listed on this page to log models to a run, and to access metrics, tables, media, and other objects.
W\&B suggests that you use [W\&B Artifacts](/models/artifacts/) if you want to:
* Create and keep track of different versions of serialized data besides models, such as datasets, prompts, and more.
* Explore [lineage graphs](/models/artifacts/explore-and-traverse-an-artifact-graph/) of a model or any other objects tracked in W\&B.
* Interact with the model artifacts these methods created, such as [updating properties](/models/artifacts/update-an-artifact/) (metadata, aliases, and descriptions)
For more information on W\&B Artifacts and advanced versioning use cases, see the [Artifacts](/models/artifacts/) documentation.
## Log a model to a run
Use the [`log_model`](/models/ref/python/experiments/run#log_model) to log a model artifact that contains content within a directory you specify. The [`log_model`](/models/ref/python/experiments/run#log_model) method also marks the resulting model artifact as an output of the W\&B run.
You can track a model's dependencies and the model's associations if you mark the model as the input or output of a W\&B run. View the lineage of the model within the W\&B App UI. See the [Explore and traverse artifact graphs](/models/artifacts/explore-and-traverse-an-artifact-graph/) page within the [Artifacts](/models/artifacts/) chapter for more information.
Provide the path where your model files are saved to the `path` parameter. The path can be a local file, directory, or [reference URI](/models/artifacts/track-external-files/#amazon-s3--gcs--azure-blob-storage-references) to an external bucket such as `s3://bucket/path`.
Ensure to replace values enclosed in `<>` with your own.
```python theme={null}
import wandb
# Initialize a W&B run
with wandb.init(project="", entity="") as run:
# Log the model
run.log_model(path="", name="")
```
Optionally provide a name for the model artifact for the `name` parameter. If `name` is not specified, W\&B will use the basename of the input path prepended with the run ID as the name.
Keep track of the `name` that you, or W\&B assigns, to the model. You will need the name of the model to retrieve the model path with the [`wandb.Run.use_model()`](/models/ref/python/experiments/run#use_model) method.
See [`log_model`](/models/ref/python/experiments/run#log_model) in the API Reference for parameters.
Example: Log a model to a run
```python theme={null}
import os
import wandb
from tensorflow import keras
from tensorflow.keras import layers
config = {"optimizer": "adam", "loss": "categorical_crossentropy"}
# Initialize a W&B run
with wandb.init(entity="charlie", project="mnist-experiments", config=config) as run:
# Hyperparameters
loss = run.config["loss"]
optimizer = run.config["optimizer"]
metrics = ["accuracy"]
num_classes = 10
input_shape = (28, 28, 1)
# Training algorithm
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"),
]
)
# Configure the model for training
model.compile(loss=loss, optimizer=optimizer, metrics=metrics)
# Save model
model_filename = "model.h5"
local_filepath = "./"
full_path = os.path.join(local_filepath, model_filename)
model.save(filepath=full_path)
# Log the model to the W&B run
run.log_model(path=full_path, name="MNIST")
```
When you call `wandb.Run.log_model()`, a model artifact named `MNIST` is created and the file `model.h5` is added to the model artifact. Your terminal or notebook will print information of where to find information about the run the model was logged to.
```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
```
## Download and use a logged model
Use the [`use_model`](/models/ref/python/experiments/run#use_model) function to access and download models files previously logged to a W\&B run.
Provide the name of the model artifact where the model files you want to retrieve are stored. The name you provide must match the name of an existing logged model artifact.
If you did not define `name` when you originally logged the files with `log_model`, the default name assigned is the basename of the input path, prepended with the run ID.
Ensure to replace the values enclosed in `<>` with your own:
```python theme={null}
import wandb
# Initialize a run
with wandb.init(project="", entity="") as run:
# Access and download model. Returns path to downloaded artifact
downloaded_model_path = run.use_model(name="")
```
The [use\_model](/models/ref/python/experiments/run#use_model) function returns the path of downloaded model files. Keep track of this path if you want to link this model later. In the preceding code snippet, the returned path is stored in a variable called `downloaded_model_path`.
Example: Download and use a logged model
For example, in the following code snippet a user called the `use_model` API. They specified the name of the model artifact they want to fetch and they also provided a version/alias. They then stored the path that is returned from the API to the `downloaded_model_path` variable.
```python theme={null}
import wandb
entity = "luka"
project = "NLP_Experiments"
alias = "latest" # semantic nickname or identifier for the model version
model_artifact_name = "fine-tuned-model"
# Initialize a run
with wandb.init(project=project, entity=entity) as run:
# Access and download model. Returns path to downloaded artifact
downloaded_model_path = run.use_model(name = f"{model_artifact_name}:{alias}")
```
See [`use_model`](/models/ref/python/experiments/run#use_model) in the API Reference for parameters and return type.