Model

Model
A Model object can be used to store and retrieve general metadata about the model, such as validation datasets or the model signature. It can also be used to list model versions of that model.
[] (field lookup)
You can access any model's field through a dict-like field lookup model[field_path].
This way you can both store metadata:
1
model["model/signature"].upload("model_signature.json")
2
​
3
model["validation/dataset/v0.1"].track_files("s3://datasets/validation")
4
model.wait()
5
model["validation/dataset/latest"] = model["validation/dataset/v0.1"].fetch()
Copied!
as well as fetch already tracked metadata -- for example, to have the single source of truth when evaluating a new model version:
1
model_version = neptune.init_model_version(model="PROJ-MOD")
2
model_version["validation/dataset"] = model["validation/dataset/latest"].fetch()
3
model["validation/dataset/latest"].download()
Copied!
Returns
The returned type depends on the field's type and whether a field is stored under the given path.
Field
Returns
The field exists.
The returned type matches type of the field.
The field does not exist
​Handler object
The path is a namespace e.g. model when a field model/signature exists.
​Namespace handler object
=
Convenience alias for .assign().
.assign()
Assign values to multiple fields from a dictionary. You can use this method to store multiple pieces of metadata with a single command.
Parameters
Text
value
(dict ) - A dictionary with values to assign, where keys become the paths of the fields.
The dictionary can be nested, in which case the path will be a combination of all keys.
wait
(Boolean, optional, default is False) - If True the client will wait before sending all tracked metadata to the server. This makes the call synchronous. For details, see the Connection modes guide.
Examples
1
import neptune.new as neptune
2
model = neptune.init_model(key="MOD")
3
​
4
# Assign multiple fields from a dictionary
5
model_info = {"size_limit": 50.0, "size_units": "MB"}
6
model["model"] = model_info
7
​
8
# You can always explicitly store metadata piece by piece
9
model["model/size_limit"] = 50.0
10
model["model/size_units"] = "MB"
11
​
12
# Dictionaries can be nested
13
model_info = {"size": {"limit": 50.0}}
14
model["model"] = model_info
15
# This will store the number 50.0 under path "model/size/limit"
Copied!
.print_structure()
Pretty prints the structure of the model's metadata. Paths are ordered lexicographically and the whole structure is neatly colored.
See also: .get_structure().
.get_structure()
Returns a model's metadata structure in the form of a dictionary.
This method can be used to traverse the model's metadata structure programmatically when using Neptune in automated workflows.
See also: .print_structure().
The returned object is a shallow copy of the internal structure. Any modifications to it may result in tracking malfunction.
Returns
dict with the model's metadata structure.
del
Completely removes the field or whole namespace stored under the path and all data associated with them. See also .pop().
Examples
1
import neptune.new as neptune
2
model = neptune.init_model(model="PROJ-MOD")
3
​
4
# Delete the field with the path "datasets/v0.4"
5
del model["datasets/v0.4"]
6
​
7
# You can also delete the whole namespace
8
del model["datasets"]
Copied!
.pop()
Removes the field or whole namespace stored under the path completely and all data associated with them. See also .del().
Parameters
Text
path
(str ) - Path of the field or namespace to be removed.
wait
(Boolean, optional, default is False) - If True the client will first wait to send all tracked metadata to the server. This makes the call synchronous, see Connection modes guide.
Examples
1
import neptune.new as neptune
2
model = neptune.init_model(model="PROJ-MOD")
3
​
4
# Delete a field along with its data
5
model.pop("datasets/v0.4")
6
​
7
# .pop() can be invoked directly on fields and namespaces
8
​
9
# The following line
10
model.pop("datasets/v0.4")
11
# is equiavlent to the line
12
model["datasets/v0.4"].pop()
13
# and this line
14
model["datasets"].pop("v0.4")
15
​
16
# You can also delete the whole namespace as a batch
17
model["datasets"].pop()
Copied!
.exists()
Checks if there is a field or namespace under the specified path.
Note that this method checks the local representation of the model. The field may have been created by another process (use .sync() to synchronize local representation) or the metadata may have not reached the Neptune servers, so it may be impossible to fetch (use .wait() to wait for all tracking calls to finish).
Parameters
Text
path
(str) - The path to check for the existence of a field or a namespace
Examples
1
import neptune.new as neptune
2
model = neptune.init_model(model="PROJ-MOD")
3
​
4
# If an old dataset exists remove it
5
if model.exists("dataset/v0.4"):
6
    del model["dataset/v0.4"]
Copied!
When working in the asynchronous (default) mode remember that metadata you track may not be available immediately to fetch from the server, even if it appears in the local representation. To circumvent that, you can use .wait().
1
import neptune.new as neptune
2
model = neptune.init_model(model="PROJ-MOD")
3
​
4
model["model/signature"].upload("model_signature.json")
5
​
6
# The path exists in the local representation
7
if model.exists("model/signature"):
8
    # However, the tracking call may have not reached Neptune servers yet
9
    model["model/signature"].download() # Error - the field does not exist
Copied!
.stop()
Stops the connection to the model and kills the synchronization thread. .stop() will be automatically called when a script that initialized the connection finishes or when exiting Neptune context.
When using Neptune with Jupyter notebooks, it's a good practice to stop the connection manually as it will be stopped automatically only when the Jupyter kernel stops.
Parameters
Text
seconds
(int or float, optional, default is None) - The method will wait for the specified time for all tracking calls to finish, before stopping the connection. If None, it will wait for all tracking calls to finish.
Example
If you are initializing the connection from a script, you don't need to call .stop():
1
import neptune.new as neptune
2
model = neptune.init_model(key="MOD")
3
​
4
[...] # Your code
5
​
6
# If you are executing Python script, then .stop()
7
# is automatically called at the end for every Neptune object
Copied!
If you are initializing multiple connections from one script it is a good practice to call .stop() for any unneeded connections. You can also use Context Managers -- Neptune will automatically call .stop() when exiting the Model context:
1
import neptune.new as neptune
2
​
3
# If you are initializing multiple connections from the same script,
4
# stop the connection manually once not needed
5
for model_identifier in models:
6
  model = neptune.init_model(model=model_identifier)
7
  [...] # Your code
8
  model.stop()
9
​
10
# You can also use a "with" statement and context manager
11
for model_identifier in models:
12
  with neptune.init_model(model=model_identifier) as model:
13
    [...] # Your code
14
    # .stop() is automatically called
15
    # when code execution exits the with statement
Copied!
If you are using Jupyter notebooks for connecting to a model, you need to manually invoke .stop() once the connection is not needed.
.fetch()
Fetch values of all non-File Atom fields as a dictionary.
The result will preserve the hierarchical structure of the model's metadata but will contain only non-File Atom fields.
Returns
dict containing all non-File Atom fields values.
Examples
1
import neptune.new as neptune
2
model = neptune.init_model(model="PROJ-MOD")
3
​
4
# Fetch all the model metrics
5
model_metrics = model["metrics"].fetch()
Copied!
.get_url()
Returns the URL of the model in Neptune.
returns
str with the URL of the model in Neptune
.fetch_model_versions_table()
List the versions of the model.
The first 10,000 runs matching the criteria are fetched.
Returns
An interim Table object containing a list of model versions. Use .to_pandas()to convert it to a Pandas DataFrame.
Examples
1
import neptune.new as neptune
2
model = neptune.init_model(model="PROJ-MOD")
3
​
4
# Fetch list of all version of the model as Pandas DataFrame
5
model_versions_df = model.fetch_model_versions_table().to_pandas()
Copied!
.wait()
Wait for all the tracking calls to finish.
Parameters
Text
disk_only
(Boolean, optional, default is False) - If True the process will only wait for data to be saved locally from memory, but will not wait for them to reach Neptune servers.
.sync()
Synchronizes local representation of the model with Neptune servers.
Parameters
Text
wait
(Boolean, optional, default is True) - If True the client will wait before sending all tracked metadata to the server. This makes the call synchronous, see Connection modes guide.
Table
An interim object containing model versions. To access the data, you need to convert it to a pandas DataFrame by invoking to_pandas().
.to_pandas()
Converts Table data to a pandas DataFrame object.
Returns
Table data in the form of pandas.DataFrame.
Examples
1
import neptune.new as neptune
2
model = neptune.init_model(model="PROJ-MOD")
3
​
4
# Fetch list of all version of the model as Pandas DataFrame
5
model_versions_df = model.fetch_model_versions_table().to_pandas()
Copied!