From c091b11dd5869641cff6fba5f029afa0a69d5a34 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Mon, 4 Dec 2023 13:56:42 -0800
Subject: [PATCH 01/16] first draft

---
 docs/guides/track/log/intro.md      |  2 +-
 docs/guides/track/log/log-models.md | 89 +++++++++++++++++++++++++++++
 sidebars.js                         |  1 +
 3 files changed, 91 insertions(+), 1 deletion(-)
 create mode 100644 docs/guides/track/log/log-models.md

diff --git a/docs/guides/track/log/intro.md b/docs/guides/track/log/intro.md
index c44749a1ea..87008354a0 100644
--- a/docs/guides/track/log/intro.md
+++ b/docs/guides/track/log/intro.md
@@ -28,7 +28,7 @@ wandb.log({'loss': 0.2}, step=step)
 <!-- [INSERT EXAMPLE] -->
 
 :::caution
-Use `wandb.log()` to log consecutive values for each `step`: 0, 1, 2, ..... It is not possible to write to a specific history step. W&B only writes to the "current" and "next" step.
+Use `wandb.log()` to log consecutive values for each `step`: 0, 1, 2, and so on. It is not possible to write to a specific history step. W&B only writes to the "current" and "next" step.
 :::
 
 <!-- You can set `commit=False` in `wandb.log` to accumulate metrics, just be sure to eventually call `wandb.log` with `commit=True` (the default) to persist the metrics.
diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
new file mode 100644
index 0000000000..43ec2f4bfd
--- /dev/null
+++ b/docs/guides/track/log/log-models.md
@@ -0,0 +1,89 @@
+---
+displayed_sidebar: default
+---
+
+# Log models
+
+Use W&B to log models that are created from W&B runs.
+
+The following guide describes how to log and interact with models logged to a W&B run. 
+
+:::tip
+The following APIs are useful for early model exploration and experiment tracking. Use the APIs listed on this page to quickly log models to a run, in addition to metrics, tables, media and other objects.
+
+The APIs listed on this page are not intended for [INSERT].
+
+
+W&B suggests that you use W&B Artifacts if you want to:
+- Create and keep track of different versions of serialized data such as models, datasets, prompts, and more.
+- Create lineage graphs of a model or any other objects tracked in W&B.
+- How to interact with the model artifacts these methods created, such as updating properties (metadata, aliases, and descriptions) 
+:::
+
+
+## Log a model to a W&B run
+Declare a model artifact as an output of a run with the [`log_model`](../../../ref/python/run.md#logmodel) method. To do so, provide a name for your model artifact and the path where your model is saved to for the `model_name` and `path` parameters, respectively.
+
+```python
+import wandb
+
+project="<your-project-name>"
+entity="<your-entity>"
+path="/local/dir/70154.h5"
+model_artifact_name="model.h5"
+
+# Initialize a W&B run
+run = wandb.init(project=project, entity=entity)
+
+# Log the model
+run.log_model(model_name=model_artifact_name, path=path)
+run.finish()
+```
+
+In the preceding code snippet, the model originally had a file name of `70154.h5` and was locally stored in the user's `/local/dir/` directory. When the user logged the model with `log_model`, they gave the model artifact a name of `model.h5`. 
+
+
+## Download and use a logged model
+Use the [`use_model`](../../../ref/python/run.md#usemodel) function to access and download models files previously logged to a W&B run. 
+
+Provide the name of your model artifact to the `model_name` field in `use_model`. 
+
+:::tip
+W&B suggests that you prepend the entity and name of the project your model was saved to.
+:::
+
+The proceeding code snippet shows how to download a logged model. The code snippet uses the same variables declared in the [Log a model to a W&B run](#log-a-model-to-a-wb-run).
+
+```python
+import wandb
+
+alias = "v0"
+model_name=f'{entity}/{project}/{model_artifact_name}:{alias}'
+
+# Initialize a run
+run = wandb.init(project=project, entity=entity)
+
+# Access and download model. Returns path to downloaded artifact
+downloaded_model_path = run.use_model(model_name=model_name)
+```
+
+The `use_model` function returns the path of downloaded artifact file(s). Keep track of this path, as you will need to have this path to link a model. In the preceeding code snippet, we stored the file path in a variable called `downloaded_model_path`.
+
+
+## Log and link a model to the W&B Model Registry
+Use the `link_model` method to log model file(s) as a model [artifact](../../artifacts/intro.md) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). 
+
+When you link a model artifact to the registry, this creates a new version of that registered model. The new version is a pointer to the artifact version that exists in that project.
+
+The following code snippet is a continuation of the code snippet in [Download and use a logged model](#download-and-use-a-logged-model). The code snippet uses the 
+
+The proceeding code snippet shows how to link a model with the `link_model` API. The code snippet uses the `downloaded_model_path` variable defined in the [Download and use a logged model](#download-and-use-a-logged-model) section to provide the path of the model.
+
+```python
+run.link_model(path=downloaded_model_path,
+                 registered_model_name="Industrial ViT",
+                 linked_model_name=f"model_vit-{wandb.run.id}",
+                 aliases=["staging", "QA"])
+
+run.finish()
+```
\ No newline at end of file
diff --git a/sidebars.js b/sidebars.js
index 1382e49418..563417cff0 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -49,6 +49,7 @@ const sidebars = {
               link: { type: 'doc', id: 'guides/track/log/intro' },
               items: [
                 // 'guides/track/log/intro',
+                'guides/track/log/log-models',
                 'guides/track/log/plots',
                 'guides/track/log/log-tables',
                 'guides/track/log/log-summary',

From 7b6acab0324057bafe9890dcca56f39d5266d9aa Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Mon, 4 Dec 2023 13:59:43 -0800
Subject: [PATCH 02/16] Added it to JA

---
 .../current/guides/track/log/log-models.md    | 89 +++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 i18n/ja/docusaurus-plugin-content-docs/current/guides/track/log/log-models.md

diff --git a/i18n/ja/docusaurus-plugin-content-docs/current/guides/track/log/log-models.md b/i18n/ja/docusaurus-plugin-content-docs/current/guides/track/log/log-models.md
new file mode 100644
index 0000000000..43ec2f4bfd
--- /dev/null
+++ b/i18n/ja/docusaurus-plugin-content-docs/current/guides/track/log/log-models.md
@@ -0,0 +1,89 @@
+---
+displayed_sidebar: default
+---
+
+# Log models
+
+Use W&B to log models that are created from W&B runs.
+
+The following guide describes how to log and interact with models logged to a W&B run. 
+
+:::tip
+The following APIs are useful for early model exploration and experiment tracking. Use the APIs listed on this page to quickly log models to a run, in addition to metrics, tables, media and other objects.
+
+The APIs listed on this page are not intended for [INSERT].
+
+
+W&B suggests that you use W&B Artifacts if you want to:
+- Create and keep track of different versions of serialized data such as models, datasets, prompts, and more.
+- Create lineage graphs of a model or any other objects tracked in W&B.
+- How to interact with the model artifacts these methods created, such as updating properties (metadata, aliases, and descriptions) 
+:::
+
+
+## Log a model to a W&B run
+Declare a model artifact as an output of a run with the [`log_model`](../../../ref/python/run.md#logmodel) method. To do so, provide a name for your model artifact and the path where your model is saved to for the `model_name` and `path` parameters, respectively.
+
+```python
+import wandb
+
+project="<your-project-name>"
+entity="<your-entity>"
+path="/local/dir/70154.h5"
+model_artifact_name="model.h5"
+
+# Initialize a W&B run
+run = wandb.init(project=project, entity=entity)
+
+# Log the model
+run.log_model(model_name=model_artifact_name, path=path)
+run.finish()
+```
+
+In the preceding code snippet, the model originally had a file name of `70154.h5` and was locally stored in the user's `/local/dir/` directory. When the user logged the model with `log_model`, they gave the model artifact a name of `model.h5`. 
+
+
+## Download and use a logged model
+Use the [`use_model`](../../../ref/python/run.md#usemodel) function to access and download models files previously logged to a W&B run. 
+
+Provide the name of your model artifact to the `model_name` field in `use_model`. 
+
+:::tip
+W&B suggests that you prepend the entity and name of the project your model was saved to.
+:::
+
+The proceeding code snippet shows how to download a logged model. The code snippet uses the same variables declared in the [Log a model to a W&B run](#log-a-model-to-a-wb-run).
+
+```python
+import wandb
+
+alias = "v0"
+model_name=f'{entity}/{project}/{model_artifact_name}:{alias}'
+
+# Initialize a run
+run = wandb.init(project=project, entity=entity)
+
+# Access and download model. Returns path to downloaded artifact
+downloaded_model_path = run.use_model(model_name=model_name)
+```
+
+The `use_model` function returns the path of downloaded artifact file(s). Keep track of this path, as you will need to have this path to link a model. In the preceeding code snippet, we stored the file path in a variable called `downloaded_model_path`.
+
+
+## Log and link a model to the W&B Model Registry
+Use the `link_model` method to log model file(s) as a model [artifact](../../artifacts/intro.md) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). 
+
+When you link a model artifact to the registry, this creates a new version of that registered model. The new version is a pointer to the artifact version that exists in that project.
+
+The following code snippet is a continuation of the code snippet in [Download and use a logged model](#download-and-use-a-logged-model). The code snippet uses the 
+
+The proceeding code snippet shows how to link a model with the `link_model` API. The code snippet uses the `downloaded_model_path` variable defined in the [Download and use a logged model](#download-and-use-a-logged-model) section to provide the path of the model.
+
+```python
+run.link_model(path=downloaded_model_path,
+                 registered_model_name="Industrial ViT",
+                 linked_model_name=f"model_vit-{wandb.run.id}",
+                 aliases=["staging", "QA"])
+
+run.finish()
+```
\ No newline at end of file

From cef52b4e89d8bd218947af15162e76434dca03bd Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Mon, 4 Dec 2023 16:17:49 -0800
Subject: [PATCH 03/16] Added dropdown examples with more info

---
 docs/guides/track/log/log-models.md | 98 ++++++++++++++++++++++++-----
 1 file changed, 81 insertions(+), 17 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 43ec2f4bfd..b2a8c8f186 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -4,25 +4,43 @@ displayed_sidebar: default
 
 # Log models
 
-Use W&B to log models that are created from W&B runs.
+Use W&B to log models to your experiment.
 
 The following guide describes how to log and interact with models logged to a W&B run. 
 
 :::tip
-The following APIs are useful for early model exploration and experiment tracking. Use the APIs listed on this page to quickly log models to a run, in addition to metrics, tables, media and other objects.
+The following APIs are useful for tracking models as a part of your experiment tracking workflow. Use the APIs listed on this page to quickly log models to a run, in addition to metrics, tables, media and other objects.
 
-The APIs listed on this page are not intended for [INSERT].
+W&B suggests that you use [W&B Artifacts](../../artifacts/intro.md) 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](../../artifacts/explore-and-traverse-an-artifact-graph.md) of a model or any other objects tracked in W&B.
+- How to interact with the model artifacts these methods created, such as [updating properties](../../artifacts/update-an-artifact.md) (metadata, aliases, and descriptions) 
 
-
-W&B suggests that you use W&B Artifacts if you want to:
-- Create and keep track of different versions of serialized data such as models, datasets, prompts, and more.
-- Create lineage graphs of a model or any other objects tracked in W&B.
-- How to interact with the model artifacts these methods created, such as updating properties (metadata, aliases, and descriptions) 
+For more information on W&B Artifacts and for more information on advanced versioning use cases, see the [Artifacts](../../artifacts/intro.md) documentation.
 :::
 
 
 ## Log a model to a W&B run
-Declare a model artifact as an output of a run with the [`log_model`](../../../ref/python/run.md#logmodel) method. To do so, provide a name for your model artifact and the path where your model is saved to for the `model_name` and `path` parameters, respectively.
+Use the [`log_model`](../../../ref/python/run.md#logmodel) method to log a model artifact. The `log_model` methods also marks the model artifact as an output of the run. Associating a model to a run (with log_model, for example), enables you to track the lineage of the model. View the lineage of the model, such as the inputs and outputs of a run, within the W&B App UI. See the [Explore and traverse artifact graphs](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.
+
+Provide a name for your model artifact and the path where your model is saved to for the `model_name` and `path` parameters, respectively. Ensure to replace values enclosed in `<>` with your own.
+
+```python
+import wandb
+
+# Initialize a W&B run
+run = wandb.init(project='<your-project>', entity='<your-entity>')
+
+# Log the model
+run.log_model(model_name='<model_artifact_name>', path='<path-to-model>')
+run.finish()
+```
+
+<details>
+
+<summary>Example: Log a model to a run</summary>
+
+For example, in the proceeding code snippet, the model originally had a file name of `70154.h5` and was locally stored in the user's `/local/dir/` directory. When the user logged the model with `log_model`, they gave the model artifact a name of `model.h5`. 
 
 ```python
 import wandb
@@ -39,8 +57,7 @@ run = wandb.init(project=project, entity=entity)
 run.log_model(model_name=model_artifact_name, path=path)
 run.finish()
 ```
-
-In the preceding code snippet, the model originally had a file name of `70154.h5` and was locally stored in the user's `/local/dir/` directory. When the user logged the model with `log_model`, they gave the model artifact a name of `model.h5`. 
+</details>
 
 
 ## Download and use a logged model
@@ -52,7 +69,26 @@ Provide the name of your model artifact to the `model_name` field in `use_model`
 W&B suggests that you prepend the entity and name of the project your model was saved to.
 :::
 
-The proceeding code snippet shows how to download a logged model. The code snippet uses the same variables declared in the [Log a model to a W&B run](#log-a-model-to-a-wb-run).
+The proceeding code snippet shows how to download a logged model. Replace the values enclosed in `<>` with your own:
+
+```python
+import wandb
+
+# Initialize a run
+run = wandb.init(project='<your-project>', entity='<your-entity>')
+
+# Access and download model. Returns path to downloaded artifact
+downloaded_model_path = run.use_model(model_name="<your-model-name>")
+```
+
+The `use_model` function returns the path of downloaded artifact file(s). Keep track of this path, as you will need to have this path to link a model. In the preceeding code snippet, we stored the file path in a variable called `downloaded_model_path`.
+
+<details>
+
+<summary>Example: Download and use a logged model</summary>
+
+For example, the proceeding code snippet shows how to log a model with `log_model` method. First, the user defines a `model_name` variable that contains the full name of the model artifact. Then the user called the use_model API to access and download the model. They then stored the path that is returned from the API to the `downloaded_model_path` variable.
+
 
 ```python
 import wandb
@@ -67,7 +103,11 @@ run = wandb.init(project=project, entity=entity)
 downloaded_model_path = run.use_model(model_name=model_name)
 ```
 
-The `use_model` function returns the path of downloaded artifact file(s). Keep track of this path, as you will need to have this path to link a model. In the preceeding code snippet, we stored the file path in a variable called `downloaded_model_path`.
+:::note
+The code shown in this example is a continuation of the code example shown in the dropdown of the [Log a model to a W&B run](#log-a-model-to-a-wb-run) section. The code in this example uses the same `entity`, `project`, and `model_artifact_name` variables declared.
+:::
+
+</details>
 
 
 ## Log and link a model to the W&B Model Registry
@@ -75,9 +115,7 @@ Use the `link_model` method to log model file(s) as a model [artifact](../../art
 
 When you link a model artifact to the registry, this creates a new version of that registered model. The new version is a pointer to the artifact version that exists in that project.
 
-The following code snippet is a continuation of the code snippet in [Download and use a logged model](#download-and-use-a-logged-model). The code snippet uses the 
-
-The proceeding code snippet shows how to link a model with the `link_model` API. The code snippet uses the `downloaded_model_path` variable defined in the [Download and use a logged model](#download-and-use-a-logged-model) section to provide the path of the model.
+The proceeding code snippet shows how to link a model with the `link_model` API. 
 
 ```python
 run.link_model(path=downloaded_model_path,
@@ -86,4 +124,30 @@ run.link_model(path=downloaded_model_path,
                  aliases=["staging", "QA"])
 
 run.finish()
-```
\ No newline at end of file
+```
+
+<details>
+
+<summary>Example: Log and link a model to the W&B Model Registry</summary>
+
+For example, the proceeding code snippet links the model created in previous code snippets to a W&B Model Registry called `"MNIST"`. To do this, the user called the `link_model` API and provided the path of the downloaded model artifact, the name of the model registry the user wanted to link the model to, the name of the model, and an alias `"best"` for the `path`, `linked_model_name`, `model_name`, and `aliases` parameters, respectively. 
+
+```python
+registered_model_name="MNIST"
+
+run.link_model(
+    path=downloaded_model_path, 
+    linked_model_name=registered_model_name,
+    model_name=model_artifact_name, 
+    aliases=['best'])
+```
+
+:::note
+The code shown in this example is a continuation of the code example shown in the dropdown of the [Download and use a logged model](#download-and-use-a-logged-model) section. The code in this example uses the same `downloaded_model_path` and `model_artifact_name` variables declared.
+:::
+
+:::tip
+W&B will create a model registry with the name you provide for `linked_model_name` parameter if you do not already have a registry with that name.
+:::
+
+</details>
\ No newline at end of file

From 8998e4a6aa5c892af7c7debc6ca1352bd5410f33 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Mon, 4 Dec 2023 16:19:25 -0800
Subject: [PATCH 04/16] Added noa s better wording

---
 docs/guides/track/log/log-models.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index b2a8c8f186..6f3340cbd5 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -40,7 +40,7 @@ run.finish()
 
 <summary>Example: Log a model to a run</summary>
 
-For example, in the proceeding code snippet, the model originally had a file name of `70154.h5` and was locally stored in the user's `/local/dir/` directory. When the user logged the model with `log_model`, they gave the model artifact a name of `model.h5`. 
+In the proceeding code snippet, a path to the model file(s) `/local/dir/70154.h5` is passed in.  When the user logged the model with `log_model`, they gave the model artifact a name of `model.h5`. 
 
 ```python
 import wandb

From 6baee2ad696e8e0b046926a2fbda24eb69f1dc6b Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Mon, 4 Dec 2023 16:40:16 -0800
Subject: [PATCH 05/16] More word smithing

---
 docs/guides/track/log/log-models.md | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 6f3340cbd5..e01b5194fa 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -36,6 +36,8 @@ run.log_model(model_name='<model_artifact_name>', path='<path-to-model>')
 run.finish()
 ```
 
+The path can be a local file, directory, or [reference URI](../../artifacts/track-external-files.md#amazon-s3--gcs--azure-blob-storage-references) to an external bucket such as `s3://bucket/path`. 
+
 <details>
 
 <summary>Example: Log a model to a run</summary>
@@ -63,14 +65,13 @@ run.finish()
 ## Download and use a logged model
 Use the [`use_model`](../../../ref/python/run.md#usemodel) function to access and download models files previously logged to a W&B run. 
 
-Provide the name of your model artifact to the `model_name` field in `use_model`. 
+Provide the name of your model artifact to the `model_name` field for the `use_model` parameter. Ensure to replace other the values enclosed in `<>` with your own:
 
 :::tip
 W&B suggests that you prepend the entity and name of the project your model was saved to.
 :::
 
-The proceeding code snippet shows how to download a logged model. Replace the values enclosed in `<>` with your own:
-
+ 
 ```python
 import wandb
 
@@ -113,19 +114,26 @@ The code shown in this example is a continuation of the code example shown in th
 ## Log and link a model to the W&B Model Registry
 Use the `link_model` method to log model file(s) as a model [artifact](../../artifacts/intro.md) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). 
 
-When you link a model artifact to the registry, this creates a new version of that registered model. The new version is a pointer to the artifact version that exists in that project.
-
-The proceeding code snippet shows how to link a model with the `link_model` API. 
+The proceeding code snippet shows how to link a model with the `link_model` API. Ensure to replace other the values enclosed in `<>` with your own:
 
 ```python
 run.link_model(path=downloaded_model_path,
-                 registered_model_name="Industrial ViT",
-                 linked_model_name=f"model_vit-{wandb.run.id}",
-                 aliases=["staging", "QA"])
+                 registered_model_name="<model-registry-name>",
+                 linked_model_name="<linked-model=name>",
+                 aliases=["<aliases>"])
 
 run.finish()
 ```
 
+:::tip
+W&B will create a model registry with the name you provide for `linked_model_name` parameter if you do not already have a registry with that name.
+:::
+
+
+A new version of a registered model is created when you link a model artifact to a model registry that already exists within that model registry.
+
+For example, suppose you have a  model artifact named "mnist-testing" that exists within a model registry called "MNIST". And suppose that within the W&B App UI you see that the model artifact is marked as **Version 1**.  W&B will automatically create a **Version 2** of your model if you link a new model with the same name ("mnist-testing") to the same registry ("MNIST").
+
 <details>
 
 <summary>Example: Log and link a model to the W&B Model Registry</summary>
@@ -146,8 +154,5 @@ run.link_model(
 The code shown in this example is a continuation of the code example shown in the dropdown of the [Download and use a logged model](#download-and-use-a-logged-model) section. The code in this example uses the same `downloaded_model_path` and `model_artifact_name` variables declared.
 :::
 
-:::tip
-W&B will create a model registry with the name you provide for `linked_model_name` parameter if you do not already have a registry with that name.
-:::
 
 </details>
\ No newline at end of file

From cc6d935fdb5e03a2b952e59aba1b33dca8f0038d Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Mon, 4 Dec 2023 16:59:55 -0800
Subject: [PATCH 06/16] Added link to colab

---
 docs/guides/track/log/log-models.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index e01b5194fa..3a54501029 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -19,6 +19,9 @@ W&B suggests that you use [W&B Artifacts](../../artifacts/intro.md) if you want
 For more information on W&B Artifacts and for more information on advanced versioning use cases, see the [Artifacts](../../artifacts/intro.md) documentation.
 :::
 
+:::info
+See this [Colab notebook](https://colab.research.google.com/drive/1Nvgz4VQHMbr4hoVGeUdDVfHE2lHFpvbs) for an end-to-end example of how to use the APIs described on this page.
+:::
 
 ## Log a model to a W&B run
 Use the [`log_model`](../../../ref/python/run.md#logmodel) method to log a model artifact. The `log_model` methods also marks the model artifact as an output of the run. Associating a model to a run (with log_model, for example), enables you to track the lineage of the model. View the lineage of the model, such as the inputs and outputs of a run, within the W&B App UI. See the [Explore and traverse artifact graphs](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.

From 82e905dd0585e045d509bfb924bed4856026ca07 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Mon, 4 Dec 2023 17:01:35 -0800
Subject: [PATCH 07/16] lint checker

---
 docs/guides/track/log/log-models.md | 35 ++++++++++++++++-------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 3a54501029..66448a6b06 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -32,10 +32,10 @@ Provide a name for your model artifact and the path where your model is saved to
 import wandb
 
 # Initialize a W&B run
-run = wandb.init(project='<your-project>', entity='<your-entity>')
+run = wandb.init(project="<your-project>", entity="<your-entity>")
 
 # Log the model
-run.log_model(model_name='<model_artifact_name>', path='<path-to-model>')
+run.log_model(model_name="<model_artifact_name>", path="<path-to-model>")
 run.finish()
 ```
 
@@ -50,10 +50,10 @@ In the proceeding code snippet, a path to the model file(s) `/local/dir/70154.h5
 ```python
 import wandb
 
-project="<your-project-name>"
-entity="<your-entity>"
-path="/local/dir/70154.h5"
-model_artifact_name="model.h5"
+project = "<your-project-name>"
+entity = "<your-entity>"
+path = "/local/dir/70154.h5"
+model_artifact_name = "model.h5"
 
 # Initialize a W&B run
 run = wandb.init(project=project, entity=entity)
@@ -79,7 +79,7 @@ W&B suggests that you prepend the entity and name of the project your model was
 import wandb
 
 # Initialize a run
-run = wandb.init(project='<your-project>', entity='<your-entity>')
+run = wandb.init(project="<your-project>", entity="<your-entity>")
 
 # Access and download model. Returns path to downloaded artifact
 downloaded_model_path = run.use_model(model_name="<your-model-name>")
@@ -98,7 +98,7 @@ For example, the proceeding code snippet shows how to log a model with `log_mode
 import wandb
 
 alias = "v0"
-model_name=f'{entity}/{project}/{model_artifact_name}:{alias}'
+model_name = f"{entity}/{project}/{model_artifact_name}:{alias}"
 
 # Initialize a run
 run = wandb.init(project=project, entity=entity)
@@ -120,10 +120,12 @@ Use the `link_model` method to log model file(s) as a model [artifact](../../art
 The proceeding code snippet shows how to link a model with the `link_model` API. Ensure to replace other the values enclosed in `<>` with your own:
 
 ```python
-run.link_model(path=downloaded_model_path,
-                 registered_model_name="<model-registry-name>",
-                 linked_model_name="<linked-model=name>",
-                 aliases=["<aliases>"])
+run.link_model(
+    path=downloaded_model_path,
+    registered_model_name="<model-registry-name>",
+    linked_model_name="<linked-model=name>",
+    aliases=["<aliases>"],
+)
 
 run.finish()
 ```
@@ -144,13 +146,14 @@ For example, suppose you have a  model artifact named "mnist-testing" that exist
 For example, the proceeding code snippet links the model created in previous code snippets to a W&B Model Registry called `"MNIST"`. To do this, the user called the `link_model` API and provided the path of the downloaded model artifact, the name of the model registry the user wanted to link the model to, the name of the model, and an alias `"best"` for the `path`, `linked_model_name`, `model_name`, and `aliases` parameters, respectively. 
 
 ```python
-registered_model_name="MNIST"
+registered_model_name = "MNIST"
 
 run.link_model(
-    path=downloaded_model_path, 
+    path=downloaded_model_path,
     linked_model_name=registered_model_name,
-    model_name=model_artifact_name, 
-    aliases=['best'])
+    model_name=model_artifact_name,
+    aliases=["best"],
+)
 ```
 
 :::note

From 0ac7f52742df15a8ecbcf8ec687d8a2ac0a539e0 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Mon, 4 Dec 2023 17:36:27 -0800
Subject: [PATCH 08/16] More stuff

---
 docs/guides/track/log/log-models.md | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 66448a6b06..814c576e0e 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -4,8 +4,6 @@ displayed_sidebar: default
 
 # Log models
 
-Use W&B to log models to your experiment.
-
 The following guide describes how to log and interact with models logged to a W&B run. 
 
 :::tip
@@ -41,6 +39,8 @@ run.finish()
 
 The path can be a local file, directory, or [reference URI](../../artifacts/track-external-files.md#amazon-s3--gcs--azure-blob-storage-references) to an external bucket such as `s3://bucket/path`. 
 
+See [`log_model`](../../../ref/python/run.md#logmodel) in the API Reference guide for more information on possible parameters and return type.
+
 <details>
 
 <summary>Example: Log a model to a run</summary>
@@ -69,11 +69,6 @@ run.finish()
 Use the [`use_model`](../../../ref/python/run.md#usemodel) function to access and download models files previously logged to a W&B run. 
 
 Provide the name of your model artifact to the `model_name` field for the `use_model` parameter. Ensure to replace other the values enclosed in `<>` with your own:
-
-:::tip
-W&B suggests that you prepend the entity and name of the project your model was saved to.
-:::
-
  
 ```python
 import wandb
@@ -85,7 +80,7 @@ run = wandb.init(project="<your-project>", entity="<your-entity>")
 downloaded_model_path = run.use_model(model_name="<your-model-name>")
 ```
 
-The `use_model` function returns the path of downloaded artifact file(s). Keep track of this path, as you will need to have this path to link a model. In the preceeding code snippet, we stored the file path in a variable called `downloaded_model_path`.
+The `use_model` function returns the path of downloaded artifact file(s). Keep track of this path, as you will need to have this path to link a model. In the preceding code snippet, we stored the file path in a variable called `downloaded_model_path`.
 
 <details>
 
@@ -113,15 +108,22 @@ The code shown in this example is a continuation of the code example shown in th
 
 </details>
 
+See [`use_model`](../../../ref/python/run.md#usemodel) in the API Reference guide for more information on possible parameters and return type.
 
 ## Log and link a model to the W&B Model Registry
-Use the `link_model` method to log model file(s) as a model [artifact](../../artifacts/intro.md) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). 
+Use the [`link_model`](../../../ref/python/run.md#linkmodel) method to log model file(s) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). If no registered model exists, W&B will create a new for you with the name you provide for the `linked_model_name` parameter. 
+
+:::tip
+You can think of linking a model similar to 'bookmarking' or 'publishing' a model that others members of your team can view.
+:::
+
+A *Registered Model* is a collection or folder of linked model versions in the W&B Model Registry. Registered models typically represent a team’s ML task. 
 
 The proceeding code snippet shows how to link a model with the `link_model` API. Ensure to replace other the values enclosed in `<>` with your own:
 
 ```python
 run.link_model(
-    path=downloaded_model_path,
+    path="<path-to-model>",
     registered_model_name="<model-registry-name>",
     linked_model_name="<linked-model=name>",
     aliases=["<aliases>"],
@@ -130,15 +132,12 @@ run.link_model(
 run.finish()
 ```
 
-:::tip
-W&B will create a model registry with the name you provide for `linked_model_name` parameter if you do not already have a registry with that name.
-:::
-
-
 A new version of a registered model is created when you link a model artifact to a model registry that already exists within that model registry.
 
 For example, suppose you have a  model artifact named "mnist-testing" that exists within a model registry called "MNIST". And suppose that within the W&B App UI you see that the model artifact is marked as **Version 1**.  W&B will automatically create a **Version 2** of your model if you link a new model with the same name ("mnist-testing") to the same registry ("MNIST").
 
+See [`link_model`](../../../ref/python/run.md#linkmodel) in the API Reference guide for more information on possible parameters and return type.
+
 <details>
 
 <summary>Example: Log and link a model to the W&B Model Registry</summary>

From 0c8379e560399af3d63d45e65031fc21d510a35f Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Tue, 5 Dec 2023 11:23:37 -0800
Subject: [PATCH 09/16] WIP

---
 docs/guides/track/log/log-models.md | 46 +++++++++++++++++++++--------
 1 file changed, 34 insertions(+), 12 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 814c576e0e..14dbc5994e 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -4,7 +4,7 @@ displayed_sidebar: default
 
 # Log models
 
-The following guide describes how to log and interact with models logged to a W&B run. 
+The following guide describes how to log models to a W&B run and interact with them. 
 
 :::tip
 The following APIs are useful for tracking models as a part of your experiment tracking workflow. Use the APIs listed on this page to quickly log models to a run, in addition to metrics, tables, media and other objects.
@@ -22,9 +22,13 @@ See this [Colab notebook](https://colab.research.google.com/drive/1Nvgz4VQHMbr4h
 :::
 
 ## Log a model to a W&B run
-Use the [`log_model`](../../../ref/python/run.md#logmodel) method to log a model artifact. The `log_model` methods also marks the model artifact as an output of the run. Associating a model to a run (with log_model, for example), enables you to track the lineage of the model. View the lineage of the model, such as the inputs and outputs of a run, within the W&B App UI. See the [Explore and traverse artifact graphs](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.
+Use the [`log_model`](../../../ref/python/run.md#logmodel) to log a model artifact that contains content within a directory you specify. The `log_model` methods also marks the resulting model artifact as an output of the W&B run. 
 
-Provide a name for your model artifact and the path where your model is saved to for the `model_name` and `path` parameters, respectively. Ensure to replace values enclosed in `<>` with your own.
+Models that are associated to a W&B run enable you to track the lineage of that model. You can view the lineage of the model, such as the inputs and outputs of a run, within the W&B App UI. See the [Explore and traverse artifact graphs](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.
+
+Provide the path where your model file(s) are saved to the `path` parameter. The path can be a local file, directory, or [reference URI](../../artifacts/track-external-files.md#amazon-s3--gcs--azure-blob-storage-references) to an external bucket such as `s3://bucket/path`. 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. 
+
+Ensure to replace values enclosed in `<>` with your own.
 
 ```python
 import wandb
@@ -33,19 +37,17 @@ import wandb
 run = wandb.init(project="<your-project>", entity="<your-entity>")
 
 # Log the model
-run.log_model(model_name="<model_artifact_name>", path="<path-to-model>")
+run.log_model(name="<model_artifact_name>", path="<path-to-model>")
 run.finish()
 ```
 
-The path can be a local file, directory, or [reference URI](../../artifacts/track-external-files.md#amazon-s3--gcs--azure-blob-storage-references) to an external bucket such as `s3://bucket/path`. 
-
 See [`log_model`](../../../ref/python/run.md#logmodel) in the API Reference guide for more information on possible parameters and return type.
 
 <details>
 
 <summary>Example: Log a model to a run</summary>
 
-In the proceeding code snippet, a path to the model file(s) `/local/dir/70154.h5` is passed in.  When the user logged the model with `log_model`, they gave the model artifact a name of `model.h5`. 
+In the proceeding code snippet, a path to the model file `/local/dir/70154.h5` is provided to the `path` parameter.
 
 ```python
 import wandb
@@ -53,22 +55,42 @@ import wandb
 project = "<your-project-name>"
 entity = "<your-entity>"
 path = "/local/dir/70154.h5"
-model_artifact_name = "model.h5"
+model_artifact_name = "fine-tuned-model"
 
 # Initialize a W&B run
 run = wandb.init(project=project, entity=entity)
 
 # Log the model
-run.log_model(model_name=model_artifact_name, path=path)
+run.log_model(name=model_artifact_name, path=path)
 run.finish()
 ```
+
+When the user called `log_model`, a model artifact with name `fine-tuned-model` was created and the file `70154.h5` was added to the model artifact.
+
 </details>
 
 
 ## Download and use a logged model
 Use the [`use_model`](../../../ref/python/run.md#usemodel) function to access and download models files previously logged to a W&B run. 
 
-Provide the name of your model artifact to the `model_name` field for the `use_model` parameter. Ensure to replace other the values enclosed in `<>` with your own:
+Provide the name of your model artifact to the `name` field. The name you provide must match the name of an existing logged model artifact. The name must adhere to one of the following schemas: 
+
+* `model_artifact_name:version`
+* `model_artifact_name:alias`
+* `model_artifact_name:digest`
+
+:::info
+You can optionally prepend the the W&B entity and project to the name. For example, the following is valid:
+
+```python
+run.use_model(
+            name="my_entity/my_project/my_model_artifact:<digest>",
+        )
+```
+
+:::
+
+Ensure to replace other the values enclosed in `<>` with your own:
  
 ```python
 import wandb
@@ -77,7 +99,7 @@ import wandb
 run = wandb.init(project="<your-project>", entity="<your-entity>")
 
 # Access and download model. Returns path to downloaded artifact
-downloaded_model_path = run.use_model(model_name="<your-model-name>")
+downloaded_model_path = run.use_model(name="<your-model-name>")
 ```
 
 The `use_model` function returns the path of downloaded artifact file(s). Keep track of this path, as you will need to have this path to link a model. In the preceding code snippet, we stored the file path in a variable called `downloaded_model_path`.
@@ -99,7 +121,7 @@ model_name = f"{entity}/{project}/{model_artifact_name}:{alias}"
 run = wandb.init(project=project, entity=entity)
 
 # Access and download model. Returns path to downloaded artifact
-downloaded_model_path = run.use_model(model_name=model_name)
+downloaded_model_path = run.use_model(name=model_name)
 ```
 
 :::note

From 7f4d176d114602089a71220ad1a7a17f8065a2a1 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Tue, 5 Dec 2023 11:31:37 -0800
Subject: [PATCH 10/16] Added info about name

---
 docs/guides/track/log/log-models.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 14dbc5994e..26533c39f4 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -73,7 +73,7 @@ When the user called `log_model`, a model artifact with name `fine-tuned-model`
 ## Download and use a logged model
 Use the [`use_model`](../../../ref/python/run.md#usemodel) function to access and download models files previously logged to a W&B run. 
 
-Provide the name of your model artifact to the `name` field. The name you provide must match the name of an existing logged model artifact. The name must adhere to one of the following schemas: 
+Provide the name of the model artifact where the model file(s) you are looking to retrieve are stored for the `name` parameter. The name you provide must match the name of an existing logged model artifact. The name must adhere to one of the following schemas: 
 
 * `model_artifact_name:version`
 * `model_artifact_name:alias`
@@ -87,9 +87,10 @@ run.use_model(
             name="my_entity/my_project/my_model_artifact:<digest>",
         )
 ```
-
 :::
 
+If you did not define `name` when originally logged the file(s) with `log_model`, the default name assigned is the basename of the input path, prepended with the run ID.
+
 Ensure to replace other the values enclosed in `<>` with your own:
  
 ```python

From 995e6b81f293414508df33c390e5fa9745365b99 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Tue, 5 Dec 2023 16:53:09 -0800
Subject: [PATCH 11/16] Changed parameter names, more edits

---
 docs/guides/track/log/log-models.md | 62 +++++++++++++----------------
 1 file changed, 28 insertions(+), 34 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 26533c39f4..0dfb1e4a24 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -37,11 +37,10 @@ import wandb
 run = wandb.init(project="<your-project>", entity="<your-entity>")
 
 # Log the model
-run.log_model(name="<model_artifact_name>", path="<path-to-model>")
-run.finish()
+run.log_model(path="<path-to-model>")
 ```
 
-See [`log_model`](../../../ref/python/run.md#logmodel) in the API Reference guide for more information on possible parameters and return type.
+See [`log_model`](../../../ref/python/run.md#logmodel) in the API Reference guide for more information on possible parameters.
 
 <details>
 
@@ -52,16 +51,14 @@ In the proceeding code snippet, a path to the model file `/local/dir/70154.h5` i
 ```python
 import wandb
 
-project = "<your-project-name>"
-entity = "<your-entity>"
 path = "/local/dir/70154.h5"
 model_artifact_name = "fine-tuned-model"
 
 # Initialize a W&B run
-run = wandb.init(project=project, entity=entity)
+run = wandb.init(project="MNIST_Exploration", entity="charlie")
 
 # Log the model
-run.log_model(name=model_artifact_name, path=path)
+run.log_model(path=path, name=model_artifact_name)
 run.finish()
 ```
 
@@ -84,7 +81,7 @@ You can optionally prepend the the W&B entity and project to the name. For examp
 
 ```python
 run.use_model(
-            name="my_entity/my_project/my_model_artifact:<digest>",
+            name="<entity>/<project>/<model_artifact_name>:<digest>",
         )
 ```
 :::
@@ -103,19 +100,21 @@ run = wandb.init(project="<your-project>", entity="<your-entity>")
 downloaded_model_path = run.use_model(name="<your-model-name>")
 ```
 
-The `use_model` function returns the path of downloaded artifact file(s). Keep track of this path, as you will need to have this path to link a model. In the preceding code snippet, we stored the file path in a variable called `downloaded_model_path`.
+The `use_model` function returns the path of downloaded artifact file(s). 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`.
 
 <details>
 
 <summary>Example: Download and use a logged model</summary>
 
-For example, the proceeding code snippet shows how to log a model with `log_model` method. First, the user defines a `model_name` variable that contains the full name of the model artifact. Then the user called the use_model API to access and download the model. They then stored the path that is returned from the API to the `downloaded_model_path` variable.
-
+For example, the proceeding code snippet shows how to log a model with `log_model` method. First, the user defines a `model_name` variable that contains the full name of the model artifact. Then the user called the `use_model` API to access and download the model. They then stored the path that is returned from the API to the `downloaded_model_path` variable.
 
 ```python
 import wandb
 
-alias = "v0"
+entity="luka"
+project="NLP_Experiments"
+alias="latest"
+model_artifact_name = "fine-tuned-model"
 model_name = f"{entity}/{project}/{model_artifact_name}:{alias}"
 
 # Initialize a run
@@ -124,11 +123,6 @@ run = wandb.init(project=project, entity=entity)
 # Access and download model. Returns path to downloaded artifact
 downloaded_model_path = run.use_model(name=model_name)
 ```
-
-:::note
-The code shown in this example is a continuation of the code example shown in the dropdown of the [Log a model to a W&B run](#log-a-model-to-a-wb-run) section. The code in this example uses the same `entity`, `project`, and `model_artifact_name` variables declared.
-:::
-
 </details>
 
 See [`use_model`](../../../ref/python/run.md#usemodel) in the API Reference guide for more information on possible parameters and return type.
@@ -145,42 +139,42 @@ A *Registered Model* is a collection or folder of linked model versions in the W
 The proceeding code snippet shows how to link a model with the `link_model` API. Ensure to replace other the values enclosed in `<>` with your own:
 
 ```python
+import wandb
+
+run = wandb.init(entity="<your-entity>", project="<your-project>")
+
 run.link_model(
     path="<path-to-model>",
-    registered_model_name="<model-registry-name>",
-    linked_model_name="<linked-model=name>",
-    aliases=["<aliases>"],
+    registered_model_name="<model-registry-name>"
 )
-
-run.finish()
 ```
 
+See [`link_model`](../../../ref/python/run.md#linkmodel) in the API Reference guide for more information on optional parameters.
+
 A new version of a registered model is created when you link a model artifact to a model registry that already exists within that model registry.
 
 For example, suppose you have a  model artifact named "mnist-testing" that exists within a model registry called "MNIST". And suppose that within the W&B App UI you see that the model artifact is marked as **Version 1**.  W&B will automatically create a **Version 2** of your model if you link a new model with the same name ("mnist-testing") to the same registry ("MNIST").
 
-See [`link_model`](../../../ref/python/run.md#linkmodel) in the API Reference guide for more information on possible parameters and return type.
-
 <details>
 
 <summary>Example: Log and link a model to the W&B Model Registry</summary>
 
-For example, the proceeding code snippet links the model created in previous code snippets to a W&B Model Registry called `"MNIST"`. To do this, the user called the `link_model` API and provided the path of the downloaded model artifact, the name of the model registry the user wanted to link the model to, the name of the model, and an alias `"best"` for the `path`, `linked_model_name`, `model_name`, and `aliases` parameters, respectively. 
+For example, the proceeding code snippet logs model files and links the model model to a model registry called `"MNIST"`. 
+
+To do this, a user calls the `link_model` API. When they call the API, they provide a local filepath that points the content of the model (`path`) and they provide a name for the model registry (`registered_model_name`). 
 
 ```python
+import wandb
+
+path = "/local/dir/model.pt"
 registered_model_name = "MNIST"
 
+run = wandb.init(project="<your-project>", entity="<your-entity>")
+
 run.link_model(
-    path=downloaded_model_path,
-    linked_model_name=registered_model_name,
-    model_name=model_artifact_name,
-    aliases=["best"],
+    path=path,
+    registered_model_name=registered_model_name
 )
 ```
 
-:::note
-The code shown in this example is a continuation of the code example shown in the dropdown of the [Download and use a logged model](#download-and-use-a-logged-model) section. The code in this example uses the same `downloaded_model_path` and `model_artifact_name` variables declared.
-:::
-
-
 </details>
\ No newline at end of file

From 50788d9b08d014edf3cbbf17faaf0503edcf5551 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Wed, 6 Dec 2023 11:30:30 -0800
Subject: [PATCH 12/16] Vsomething

---
 docs/guides/track/log/log-models.md | 134 +++++++++++++++++-----------
 1 file changed, 84 insertions(+), 50 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 0dfb1e4a24..029375740f 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -22,11 +22,11 @@ See this [Colab notebook](https://colab.research.google.com/drive/1Nvgz4VQHMbr4h
 :::
 
 ## Log a model to a W&B run
-Use the [`log_model`](../../../ref/python/run.md#logmodel) to log a model artifact that contains content within a directory you specify. The `log_model` methods also marks the resulting model artifact as an output of the W&B run. 
+Use the [`log_model`](../../../ref/python/run.md#log_model) to log a model artifact that contains content within a directory you specify. The `log_model` methods also marks the resulting model artifact as an output of the W&B run. 
 
 Models that are associated to a W&B run enable you to track the lineage of that model. You can view the lineage of the model, such as the inputs and outputs of a run, within the W&B App UI. See the [Explore and traverse artifact graphs](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.
 
-Provide the path where your model file(s) are saved to the `path` parameter. The path can be a local file, directory, or [reference URI](../../artifacts/track-external-files.md#amazon-s3--gcs--azure-blob-storage-references) to an external bucket such as `s3://bucket/path`. 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. 
+Provide the path where your model file(s) are saved to the `path` parameter. The path can be a local file, directory, or [reference URI](../../artifacts/track-external-files.md#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.
 
@@ -37,54 +37,82 @@ import wandb
 run = wandb.init(project="<your-project>", entity="<your-entity>")
 
 # Log the model
-run.log_model(path="<path-to-model>")
+run.log_model(path="<path-to-model>", name="<name>")
 ```
 
-See [`log_model`](../../../ref/python/run.md#logmodel) in the API Reference guide for more information on possible parameters.
+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. 
+
+:::tip
+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 [`use_model`](https://docs.wandb.ai/ref/python/run#use_model) method. 
+:::
+
+See [`log_model`](../../../ref/python/run.md#log_model) in the API Reference guide for more information on possible parameters.
 
 <details>
 
 <summary>Example: Log a model to a run</summary>
 
-In the proceeding code snippet, a path to the model file `/local/dir/70154.h5` is provided to the `path` parameter.
-
 ```python
+import os
 import wandb
+from tensorflow import keras
+from tensorflow.keras import layers
 
-path = "/local/dir/70154.h5"
-model_artifact_name = "fine-tuned-model"
+config = {"optimizer": "adam", "loss": "categorical_crossentropy"}
 
 # Initialize a W&B run
-run = wandb.init(project="MNIST_Exploration", entity="charlie")
+run = wandb.init(entity="charlie", project="mnist-experiments", config=config)
+
+# 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"),
+    ]
+)
 
-# Log the model
-run.log_model(path=path, name=model_artifact_name)
+# 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")
 run.finish()
 ```
 
-When the user called `log_model`, a model artifact with name `fine-tuned-model` was created and the file `70154.h5` was added to the model artifact.
+When the user called `log_model`, a model artifact named `MNIST` was created and the file `model.h5` was 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
+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
+```
 
 </details>
 
 
 ## Download and use a logged model
-Use the [`use_model`](../../../ref/python/run.md#usemodel) function to access and download models files previously logged to a W&B run. 
+Use the [`use_model`](../../../ref/python/run.md#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 file(s) you are looking to retrieve are stored for the `name` parameter. The name you provide must match the name of an existing logged model artifact. The name must adhere to one of the following schemas: 
-
-* `model_artifact_name:version`
-* `model_artifact_name:alias`
-* `model_artifact_name:digest`
-
-:::info
-You can optionally prepend the the W&B entity and project to the name. For example, the following is valid:
-
-```python
-run.use_model(
-            name="<entity>/<project>/<model_artifact_name>:<digest>",
-        )
-```
-:::
+Provide the name of the model artifact where the model file(s) you are looking to retrieve are stored for the `name` parameter. The name you provide must match the name of an existing logged model artifact.
 
 If you did not define `name` when originally logged the file(s) with `log_model`, the default name assigned is the basename of the input path, prepended with the run ID.
 
@@ -100,7 +128,7 @@ run = wandb.init(project="<your-project>", entity="<your-entity>")
 downloaded_model_path = run.use_model(name="<your-model-name>")
 ```
 
-The `use_model` function returns the path of downloaded artifact file(s). 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`.
+The `use_model` function returns the path of downloaded model file(s). 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`.
 
 <details>
 
@@ -111,9 +139,9 @@ For example, the proceeding code snippet shows how to log a model with `log_mode
 ```python
 import wandb
 
-entity="luka"
-project="NLP_Experiments"
-alias="latest"
+entity = "luka"
+project = "NLP_Experiments"
+alias = "latest"
 model_artifact_name = "fine-tuned-model"
 model_name = f"{entity}/{project}/{model_artifact_name}:{alias}"
 
@@ -125,16 +153,18 @@ downloaded_model_path = run.use_model(name=model_name)
 ```
 </details>
 
-See [`use_model`](../../../ref/python/run.md#usemodel) in the API Reference guide for more information on possible parameters and return type.
+See [`use_model`](../../../ref/python/run.md#use_model) in the API Reference guide for more information on possible parameters and return type.
 
 ## Log and link a model to the W&B Model Registry
-Use the [`link_model`](../../../ref/python/run.md#linkmodel) method to log model file(s) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). If no registered model exists, W&B will create a new for you with the name you provide for the `linked_model_name` parameter. 
+Use the [`link_model`](../../../ref/python/run.md#link_model) method to log model file(s) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). If no registered model exists, W&B will create a new for you with the name you provide for the `linked_model_name` parameter. 
 
 :::tip
-You can think of linking a model similar to 'bookmarking' or 'publishing' a model that others members of your team can view.
+You can think of linking a model similar to 'bookmarking' or 'publishing' a model to a centralized team repository of models that others members of your team can view and consume. 
+
+Note that when you link a model, that model is not duplicated in the Model Registry. That model is also not moved out of the project and intro the registry. A linked model is a pointer to the original model in your project.
 :::
 
-A *Registered Model* is a collection or folder of linked model versions in the W&B Model Registry. Registered models typically represent a team’s ML task. 
+A *Registered Model* is a collection or folder of linked model versions in the W&B Model Registry. Registered Models typically represent candidate models for a single modeling use case or task. 
 
 The proceeding code snippet shows how to link a model with the `link_model` API. Ensure to replace other the values enclosed in `<>` with your own:
 
@@ -143,23 +173,24 @@ import wandb
 
 run = wandb.init(entity="<your-entity>", project="<your-project>")
 
-run.link_model(
-    path="<path-to-model>",
-    registered_model_name="<model-registry-name>"
-)
+run.link_model(path="<path-to-model>", registered_model_name="<registered-model-name>")
+
+run.finish()
 ```
 
-See [`link_model`](../../../ref/python/run.md#linkmodel) in the API Reference guide for more information on optional parameters.
+See [`link_model`](../../../ref/python/run.md#link_model) in the API Reference guide for more information on optional parameters.
+
+If the `'registered-model-name'` matches the name of a registered model that already exists within the Model Registry, the model will be linked to that registered model. If no such registered model exists, a new one will be created and the model will be the first one linked. 
+
+For example, suppose you have an existing registered model named "Fine-Tuned Review Autocompletion" in your Model Registry (see example [here](https://wandb.ai/reviewco/registry/model?selectionPath=reviewco%2Fmodel-registry%2FFinetuned-Review-Autocompletion&view=all-models)). And suppose that a few model versions have already been linked to it: v0, v1, v2. If you call `link_model` with `registered-model-name="Fine-Tuned Review Autocompletion"`, the new model will be linked to this existing Registered Model as v4. If no Registered Model with this name exists, a new one will be created and the new model will be linked as v0. 
 
-A new version of a registered model is created when you link a model artifact to a model registry that already exists within that model registry.
 
-For example, suppose you have a  model artifact named "mnist-testing" that exists within a model registry called "MNIST". And suppose that within the W&B App UI you see that the model artifact is marked as **Version 1**.  W&B will automatically create a **Version 2** of your model if you link a new model with the same name ("mnist-testing") to the same registry ("MNIST").
 
 <details>
 
 <summary>Example: Log and link a model to the W&B Model Registry</summary>
 
-For example, the proceeding code snippet logs model files and links the model model to a model registry called `"MNIST"`. 
+For example, the proceeding code snippet logs model files and links the model model to a registered model name `"Fine-Tuned Review Autocompletion"`. 
 
 To do this, a user calls the `link_model` API. When they call the API, they provide a local filepath that points the content of the model (`path`) and they provide a name for the model registry (`registered_model_name`). 
 
@@ -167,14 +198,17 @@ To do this, a user calls the `link_model` API. When they call the API, they prov
 import wandb
 
 path = "/local/dir/model.pt"
-registered_model_name = "MNIST"
+registered_model_name = "Fine-Tuned Review Autocompletion"
 
-run = wandb.init(project="<your-project>", entity="<your-entity>")
+run = wandb.init(project="llm-evaluation", entity="noa")
 
-run.link_model(
-    path=path,
-    registered_model_name=registered_model_name
-)
+run.link_model(path=path, registered_model_name=registered_model_name)
+
+run.finish()
 ```
 
+:::info
+As a quick reminder, registered model houses a collection of bookmarked model versions. 
+:::
+
 </details>
\ No newline at end of file

From 8e5aca70ba420893c0cda8bca28a170c74565c51 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Wed, 6 Dec 2023 11:42:55 -0800
Subject: [PATCH 13/16] Updated notebook example

---
 docs/guides/track/log/log-models.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 029375740f..72fc58b9e8 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -18,7 +18,7 @@ For more information on W&B Artifacts and for more information on advanced versi
 :::
 
 :::info
-See this [Colab notebook](https://colab.research.google.com/drive/1Nvgz4VQHMbr4hoVGeUdDVfHE2lHFpvbs) for an end-to-end example of how to use the APIs described on this page.
+See this [Colab notebook](https://colab.research.google.com/github/wandb/examples/blob/ken-add-new-model-reg-api/colabs/wandb-model-registry/New_Model_Logging_in_W&B.ipynb) for an end-to-end example of how to use the APIs described on this page.
 :::
 
 ## Log a model to a W&B run
@@ -208,7 +208,7 @@ run.finish()
 ```
 
 :::info
-As a quick reminder, registered model houses a collection of bookmarked model versions. 
+As a quick reminder, registered model house a collection of bookmarked model versions. 
 :::
 
 </details>
\ No newline at end of file

From 79625234b828085bf3a0945bd718e1379793a03b Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Wed, 6 Dec 2023 12:08:16 -0800
Subject: [PATCH 14/16] V something +1

---
 docs/guides/track/log/log-models.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 72fc58b9e8..63eb8f1a6c 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -22,9 +22,9 @@ See this [Colab notebook](https://colab.research.google.com/github/wandb/example
 :::
 
 ## Log a model to a W&B run
-Use the [`log_model`](../../../ref/python/run.md#log_model) to log a model artifact that contains content within a directory you specify. The `log_model` methods also marks the resulting model artifact as an output of the W&B run. 
+Use the [`log_model`](../../../ref/python/run.md#log_model) to log a model artifact that contains content within a directory you specify. The [`log_model`](../../../ref/python/run.md#log_model) method also marks the resulting model artifact as an output of the W&B run. 
 
-Models that are associated to a W&B run enable you to track the lineage of that model. You can view the lineage of the model, such as the inputs and outputs of a run, within the W&B App UI. See the [Explore and traverse artifact graphs](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.
+Models that are marked as the input or output to a run to track the lineage of that model. A model's lineage graph shows the model's dependencies and the model's associations. You can view the lineage of the model within the W&B App UI. See the [Explore and traverse artifact graphs](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.
 
 Provide the path where your model file(s) are saved to the `path` parameter. The path can be a local file, directory, or [reference URI](../../artifacts/track-external-files.md#amazon-s3--gcs--azure-blob-storage-references) to an external bucket such as `s3://bucket/path`. 
 
@@ -112,7 +112,7 @@ Find logs at: ./wandb/run-20231206_103511-wlby6fuw/logs
 ## Download and use a logged model
 Use the [`use_model`](../../../ref/python/run.md#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 file(s) you are looking to retrieve are stored for the `name` parameter. The name you provide must match the name of an existing logged model artifact.
+Provide the name of the model artifact where the model file(s) you are 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 originally logged the file(s) with `log_model`, the default name assigned is the basename of the input path, prepended with the run ID.
 
@@ -156,7 +156,7 @@ downloaded_model_path = run.use_model(name=model_name)
 See [`use_model`](../../../ref/python/run.md#use_model) in the API Reference guide for more information on possible parameters and return type.
 
 ## Log and link a model to the W&B Model Registry
-Use the [`link_model`](../../../ref/python/run.md#link_model) method to log model file(s) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). If no registered model exists, W&B will create a new for you with the name you provide for the `linked_model_name` parameter. 
+Use the [`link_model`](../../../ref/python/run.md#link_model) method to log model file(s) to a W&B run and link it to the [W&B Model Registry](../../model_registry/intro.md). If no registered model exists, W&B will create a new for you with the name you provide for the `registered_model_name` parameter. 
 
 :::tip
 You can think of linking a model similar to 'bookmarking' or 'publishing' a model to a centralized team repository of models that others members of your team can view and consume. 
@@ -164,9 +164,9 @@ You can think of linking a model similar to 'bookmarking' or 'publishing' a mode
 Note that when you link a model, that model is not duplicated in the Model Registry. That model is also not moved out of the project and intro the registry. A linked model is a pointer to the original model in your project.
 :::
 
-A *Registered Model* is a collection or folder of linked model versions in the W&B Model Registry. Registered Models typically represent candidate models for a single modeling use case or task. 
+A *Registered Model* is a collection or folder of linked model versions in the [W&B Model Registry](../../model_registry/intro.md). Registered models typically represent candidate models for a single modeling use case or task. 
 
-The proceeding code snippet shows how to link a model with the `link_model` API. Ensure to replace other the values enclosed in `<>` with your own:
+The proceeding code snippet shows how to link a model with the [`link_model`](../../../ref/python/run.md#link_model) API. Ensure to replace other the values enclosed in `<>` with your own:
 
 ```python
 import wandb
@@ -208,7 +208,7 @@ run.finish()
 ```
 
 :::info
-As a quick reminder, registered model house a collection of bookmarked model versions. 
+Reminder: A registered model houses a collection of bookmarked model versions. 
 :::
 
 </details>
\ No newline at end of file

From fb48697b6536d4222e8e10ed92b58b74f5188f41 Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Wed, 6 Dec 2023 12:23:17 -0800
Subject: [PATCH 15/16] Version something + 1 + 1

---
 docs/guides/track/log/log-models.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 63eb8f1a6c..188be9268c 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -161,7 +161,9 @@ Use the [`link_model`](../../../ref/python/run.md#link_model) method to log mode
 :::tip
 You can think of linking a model similar to 'bookmarking' or 'publishing' a model to a centralized team repository of models that others members of your team can view and consume. 
 
-Note that when you link a model, that model is not duplicated in the Model Registry. That model is also not moved out of the project and intro the registry. A linked model is a pointer to the original model in your project.
+Note that when you link a model, that model is not duplicated in the [Model Registry](../../model_registry/intro.md). That model is also not moved out of the project and intro the registry. A linked model is a pointer to the original model in your project.
+
+Use the [Model Registry](../../model_registry/intro.md)to organize your best models by task, manage model lifecycle, facilitate easy tracking and auditing throughout the ML lifecyle, and [automate](../../model_registry/automation.md) downstream actions with webhooks or jobs.
 :::
 
 A *Registered Model* is a collection or folder of linked model versions in the [W&B Model Registry](../../model_registry/intro.md). Registered models typically represent candidate models for a single modeling use case or task. 
@@ -182,15 +184,14 @@ See [`link_model`](../../../ref/python/run.md#link_model) in the API Reference g
 
 If the `'registered-model-name'` matches the name of a registered model that already exists within the Model Registry, the model will be linked to that registered model. If no such registered model exists, a new one will be created and the model will be the first one linked. 
 
-For example, suppose you have an existing registered model named "Fine-Tuned Review Autocompletion" in your Model Registry (see example [here](https://wandb.ai/reviewco/registry/model?selectionPath=reviewco%2Fmodel-registry%2FFinetuned-Review-Autocompletion&view=all-models)). And suppose that a few model versions have already been linked to it: v0, v1, v2. If you call `link_model` with `registered-model-name="Fine-Tuned Review Autocompletion"`, the new model will be linked to this existing Registered Model as v4. If no Registered Model with this name exists, a new one will be created and the new model will be linked as v0. 
-
+For example, suppose you have an existing registered model named "Fine-Tuned-Review-Autocompletion" in your Model Registry (see example [here](https://wandb.ai/reviewco/registry/model?selectionPath=reviewco%2Fmodel-registry%2FFinetuned-Review-Autocompletion&view=all-models)). And suppose that a few model versions are already linked to it: v0, v1, v2. If you call `link_model` with `registered-model-name="Fine-Tuned-Review-Autocompletion"`, the new model will be linked to this existing registered model as v4. If no registered model with this name exists, a new one will be created and the new model will be linked as v0. 
 
 
 <details>
 
 <summary>Example: Log and link a model to the W&B Model Registry</summary>
 
-For example, the proceeding code snippet logs model files and links the model model to a registered model name `"Fine-Tuned Review Autocompletion"`. 
+For example, the proceeding code snippet logs model files and links the model model to a registered model name `"Fine-Tuned-Review-Autocompletion"`. 
 
 To do this, a user calls the `link_model` API. When they call the API, they provide a local filepath that points the content of the model (`path`) and they provide a name for the model registry (`registered_model_name`). 
 
@@ -198,7 +199,7 @@ To do this, a user calls the `link_model` API. When they call the API, they prov
 import wandb
 
 path = "/local/dir/model.pt"
-registered_model_name = "Fine-Tuned Review Autocompletion"
+registered_model_name = "Fine-Tuned-Review-Autocompletion"
 
 run = wandb.init(project="llm-evaluation", entity="noa")
 

From c41a91d876e80a0c91d4e6662edd98fe986b189d Mon Sep 17 00:00:00 2001
From: Noah Luna <15202580+ngrayluna@users.noreply.github.com>
Date: Wed, 6 Dec 2023 14:18:46 -0800
Subject: [PATCH 16/16] last edits

---
 docs/guides/track/log/log-models.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/guides/track/log/log-models.md b/docs/guides/track/log/log-models.md
index 188be9268c..f46124ff24 100644
--- a/docs/guides/track/log/log-models.md
+++ b/docs/guides/track/log/log-models.md
@@ -24,7 +24,7 @@ See this [Colab notebook](https://colab.research.google.com/github/wandb/example
 ## Log a model to a W&B run
 Use the [`log_model`](../../../ref/python/run.md#log_model) to log a model artifact that contains content within a directory you specify. The [`log_model`](../../../ref/python/run.md#log_model) method also marks the resulting model artifact as an output of the W&B run. 
 
-Models that are marked as the input or output to a run to track the lineage of that model. A model's lineage graph shows the model's dependencies and the model's associations. You can view the lineage of the model within the W&B App UI. See the [Explore and traverse artifact graphs](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.
+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](../../artifacts/explore-and-traverse-an-artifact-graph.md) page within the [Artifacts](../../artifacts/intro.md) chapter for more information.
 
 Provide the path where your model file(s) are saved to the `path` parameter. The path can be a local file, directory, or [reference URI](../../artifacts/track-external-files.md#amazon-s3--gcs--azure-blob-storage-references) to an external bucket such as `s3://bucket/path`.