System namespace ("sys")#
The system namespace ("sys"
) contains system information and some basic data about logged Neptune objects. Most of this data is logged automatically.
You cannot create new fields in the "sys"
namespace, but some of their values can be edited manually (marked with *
in the table below).
Field | Description | Example |
---|---|---|
id |
Neptune identifier |
|
custom_run_id |
Custom run identifier | "my custom ID" |
name * |
Name of the object | "First PyTorch run" |
running_time |
Total running time of the object in seconds | 1.822 |
monitoring_time |
Total monitoring time used by the object in seconds | 2 |
ping_time |
Time of the last interaction with the Neptune client library | 2022-05-03 06:45:23.452364+00:00 |
owner |
Username of the user who created the object | neptuner |
creation_time |
Time the object was created | 2022-04-25 07:08:05.023000+00:00 |
modification_time |
Time the object was last modified | 2022-05-03 06:45:23.452364+00:00 |
tags * |
Tags applied to the object | "maskRCNN" , "finetune" , "v2.0.1" |
state |
Whether the object is active or inactive | "inactive" |
size |
Size of the object in bytes | 6973.0 |
failed * |
(Runs only) Whether the run was marked as "failed" | False |
description * |
Description of the object | "New test data" |
hostname |
(Runs only) System host where the run was created | LAPTOP-EX1000 |
model_id |
(Model versions only) Identifier of the model | CLS-FOREST |
stage * |
(Model versions only) Stage of the model version | production |
* The field can be manually edited, either through the app or the API.
Identifier#
Field | Type |
---|---|
sys/id |
String |
Each Run
, Model
, and ModelVersion
object has a unique string identifier within the project.
The project key is always the first part of an object ID.
- Run ID = project key + high water counter
- Example: In a project called "Classification" with project key
CLS
, the third run will have the identifierCLS-3
.
- Example: In a project called "Classification" with project key
- Model ID = project key + model key.
- In a project called "Classification" with project key
CLS
, a model with keyFOREST
will have the identifierCLS-FOREST
.
- In a project called "Classification" with project key
- Model version ID = project key + model key + high water counter.
- For a model with identifier
CLS-FOREST
, the third model version will have the identifierCLS-FOREST-3
.
- For a model with identifier
You can access the ID of your active object programmatically with the fetch()
method:
>>> import neptune
>>> run = neptune.init_run(project="ml-team/classification")
>>> run_id = run["sys/id"].fetch()
>>> print(run_id)
CLS-23
You can use the ID to resume logging to the object later, or connect to it from multiple processes.
Custom run identifier#
Field | Type |
---|---|
sys/custom_run_id |
String |
The custom run identifier, if one was supplied when the run was created.
Note that it's not possible to use a custom run ID in offline mode.
Related
Name#
Field | Type |
---|---|
sys/name |
String |
Editable name of an object.
The name should capture the essence of the object in a one-sentence summary. It does not need to be unique.
You can set it in the following ways:
- During initialization through the
name
parameter of theinit
function - In the app, by navigating to the object's details
- Directly in the code:
import neptune
run = neptune.init_run(project="ml-team/classification")
run["sys/name"] = "Testing new approach"
Description#
Field | Type |
---|---|
sys/description |
String |
Editable description of an object.
The description field can store a longer description or free-form note about the object.
You can edit the description
-
in the code, through the API:
-
through the Neptune app:
- Runs:
- Click the run menu () next to the run ID → Show run information
- Directly in runs table, by adding the
sys/description
field as a column
- Models: In the Models section, by selecting the model name and clicking Model information next to the model name
- Model versions:
- Directly in the Versions tab, by adding the
sys/description
field as a column - In the model version view, by clicking Model version information
- Directly in the Versions tab, by adding the
- Runs:
Tip
For runs, you can also enter a description during initialization, through the description
parameter of init_run()
.
Running time#
Field | Type |
---|---|
sys/running_time |
Float |
Total running time of the object in seconds.
This number takes into account any additional resumes of the object.
Monitoring time#
Deprecated feature
Monitoring time was the basis for neptune.ai's previous pricing model. It has no function in the current model, which is based on the number of active projects.
You can still access the field and display it in the runs table.
Field | Type |
---|---|
sys/monitoring_time |
Integer |
Total monitoring time (logging hours) used by the object in seconds.
This number takes into account any additional resumes of the object.
Owner#
Neptune username of the user that created the object.
Field | Type |
---|---|
sys/owner |
String |
Creation time#
Field | Type |
---|---|
sys/creation_time |
Datetime |
Creation time of the object.
Includes date, time of day, and information about the time zone.
Modification time#
Field | Type |
---|---|
sys/modification_time |
Datetime |
Time that the object was last modified.
Includes date, time of day, and information about the time zone.
Tags#
Field | Type |
---|---|
sys/tags |
StringSet |
The tags assigned to the object.
You can assign tags in the following ways:
- (Runs only) During initialization, pass them as arguments for the
tags
parameter of theinit_run()
function - After initialization, with the
add()
method:run["sys/tags"].add("best")
- Through the Neptune app
For more, see Add tags.
State#
See also
Field | Type |
---|---|
sys/state |
RunState |
An object can be in one of two states:
Active
Inactive
Active means that at least one process is connected to the object. This may be a process that is logging training metrics, monitoring performance, or fetching metadata to perform further analysis.
The object automatically transitions to an Inactive state once there has been no activity for 20 seconds, typically after the script ended or you invoked stop()
.
Info
"Active/inactive" does not correspond to "success/failure". The connection to a Neptune object can be paused and resumed multiple times, so Neptune does not know when the logging was a success.
Example: In the case of a run, an inactive state can mean that the run did not start, that the training or monitoring was paused, or that it did in fact finish training with a success.
When fetching the runs table programmatically, you can filter the returned table by passing values of sys/state
to the state
argument of the fetch_runs_table()
method:
import neptune
project = neptune.init_project(project="workspace-name/project-name")
runs_table_df = project.fetch_runs_table(state="active").to_pandas()
Tip
To make the states match your workflow better, you can set a custom status for each run. For example: run["info/state"] = "Success"
or run["info/state"] = "Queued"
.
Stage#
Field | Type |
---|---|
sys/stage |
ModelVersionStage |
A model version object can be in one of four lifecycle stages:
none
(default)staging
production
archived
You can manage the stage either through the app or programmatically with the change_stage()
method.
For more, see Manage model stage.
Failed#
See also
Field | Type |
---|---|
sys/failed |
Boolean |
Whether the run failed. You can set it manually to mark a run as failed, or reset it to False
in case of resuming a failed run.
If there is a crash during monitoring, Neptune automatically sets the Failed
status to True
. You can override this behavior by setting the fail_on_exception
parameter in init_run()
to False
.
In both cases, the traceback is captured and appended to the "monitoring/traceback"
field. (If you provided a custom monitoring namespace for init_run()
, the "traceback"
field goes under that custom namespace.)
If you performed a remote abort, the Failed
status will also be set to True
. To learn more, see Stop or abort a run remotely.