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.
The system namespace is special in a couple of ways:
- You cannot create new "sys" fields.
- Edits to "sys" fields are excluded from monitoring time.
The below table lists the fields in the system namespace. For more details on a field, refer to the respective section.
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 model version
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 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:
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:
- In the single run view, by clicking Details in the left pane
- Directly in runs table, by adding the
sys/description
field as a column
- Models: In the Models view, by selecting the model name and clicking Details next to the model name
- Model versions:
- In the single model version view, by clicking Details in the left pane
- Directly in the Versions view, by adding the
sys/description
field as a column
- 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#
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 Adding 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 Managing 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 Stopping or aborting a run remotely.