Skip to content

System namespace ("sys")#

The system namespace (sys) contains auto-logged system information and basic metadata on the run object. This includes the ID, name, timestamps, and status information.

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 Auto-created Neptune identifier (PROJKEY-#) NLI-18
custom_run_id Custom run identifier hashlib.md5(str(time.time()).encode()).hexdigest()
name * Name of the run "mellow-panda"
creation_time When the run was created 2022-04-25 07:08:05.023000+00:00
owner Name of the account that created the run jackie
tags * Tags applied to the run "maskRCNN", "finetune", "v2.0.1"
group_tags * Group tags applied to the run "high-lr", "low-lr"
description * Description of the run "New test data"
running_time Total running time of the run in seconds 1.822
modification_time When the run was last modified 2022-05-03 06:45:23.452364+00:00
ping_time Last interaction with the Neptune client 2022-05-04 11:20:01.763951+00:00
state Whether the run is active or inactive "inactive"
failed * (Runs only) Whether the run is marked as "failed" False
size Size of the run in bytes 6973.0
hostname (Runs only) System host where the run was created LAPTOP-EX1000

* Editable field

Deprecated system fields
Field         Description Example
model_id (Model versions only) Identifier of the parent model NLI-PRETRAINED
stage * (Model versions only) Stage of the model version production
monitoring_time Total monitoring time used by the run in seconds 182

Identifier (ID)#

Field Type
sys/id String

Each Run object has a unique string identifier within the project.

The project key is always the first part of a run ID.

Example: In a project called "Classification" with project key CLS, the third run will have the identifier CLS-3.

You can access the ID of your active run programmatically with the fetch() method:

>>> run = neptune.init_run(project="ml-team/classification")
>>> run["sys/id"].fetch()
CLS-23

You can use the ID to resume logging later, access the metadata in read-only mode, or trash the run.

Custom run identifier#

Field Type
sys/custom_run_id String

The custom run identifier, if one was supplied to the custom_run_id argument when the run was created.

Example
import hashlib
import time

run = neptune.init_run(
    custom_run_id=hashlib.md5(str(time.time()).encode()).hexdigest(),
)

Note that it's not possible to use a custom run ID in offline mode.

Related

Set custom run ID

Name#

Field Type
sys/name String

Editable name of a run.

It doesn't need to be unique, but you can use it as a human-friendly ID.

You can set it in the following ways:

  • During initialization, pass the name to the name parameter of the init_run() function:

    run = neptune.init_run(name="mellow-panda")

    If you don't set a name at initialization, once the run is synchronized with the server, Neptune sets the auto-generated identifier (sys/id) as the name.

  • Any time the run is active in your code, assign a string to the sys/name field:

    >>> run = neptune.init_run(with_id=...)
>>> run["sys/name"] = "sleepy-swallow"

  • In the app, hover over the run, then click → Run information. You can edit the name in the modal that opens.

Related

Set custom run name

Description#

Field Type
sys/description String

Editable description of a run.

The description field can store a longer description or free-form note about the run.

You can add a description with the description parameter of init_run():

run = neptune.init_run(description="My longer description of the run")

You can also add or edit descriptions through the web app:

  • Click the run menu ( ) next to the run ID → Run information.
  • In experiments table, add the sys/description field as a column. You can then edit the contents of the cell.

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 run.

Monitoring time#

Deprecated feature

Monitoring time was the basis for neptune.ai's previous pricing model.

You can still access the field and display it in the experiments table.

Field Type
sys/monitoring_time Integer

Total monitoring time (logging hours) used by the run in seconds.

This number takes into account any additional resumes of the run.

Ping time#

Field Type
sys/ping_time Datetime

Time of the last interaction with the Neptune client library. That is, when something was last logged by the API.

Includes date, time of day, and information about the time zone.

Owner#

Field Type
sys/owner String

Neptune username of the user or service account that created the run.

Creation time#

Field Type
sys/creation_time Datetime

Creation time of the run.

Includes date, time of day, and information about the time zone.

Modification time#

Field Type
sys/modification_time Datetime

Time that the run was last modified. This could be any kind of edit, such as setting a description or removing a tag through the app.

Includes date, time of day, and information about the time zone.

Tags#

Field Type
sys/tags StringSet

The tags assigned to the run.

You can assign tags in the following ways:

  • During initialization, pass them as as list to the tags argument of the init_run() function:

    run = neptune.init_run(tags=["maskRCNN", "finetune"])

  • After creating the run, with the add() method: run["sys/tags"].add("best")

  • Through the Neptune app, in the Experiments tab

For more, see Add tags.

Group tags#

Field Type
sys/group_tags StringSet

Group tags assigned to the run.

You can assign group tags in the following ways:

  • After creating the run, with the add() method: run["sys/group_tags"].add("high lr")
  • Through the Neptune app, in the Experiments tab

For more, see Groups.

State#

See also

sys/failed

Field Type
sys/state RunState

A run object can be in one of two states:

  • Active
  • Inactive

Active means that at least one process is connected to the run. This may be a process that is logging training metrics or monitoring performance.

The run automatically transitions to an Inactive state once there's been no activity for 20 seconds, typically after the script ended or you invoked stop().

Connecting to an inactive run in read-only mode doesn't change the state to active.

Info

"Active/inactive" doesn't correspond to "success/failure". The connection to a run can be paused and resumed multiple times, so Neptune doesn't know when the logging was a success.

Example: An inactive state can mean that the run didn't start, that the training or monitoring was paused, or that it did in fact finish training with a success.

When fetching the experiments table programmatically, you can filter the returned table by passing values of sys/state to the state argument of the fetch_runs_table() method:

Fetch active runs from a project
import neptune

project = neptune.init_project(project="workspace-name/project-name")
runs_table_df = project.fetch_runs_table(state="active").to_pandas()

Customization tip

To make the states match your workflow better, you can set a custom status for each run. For example:

  • run["info/state"] = "Success"
  • run["info/state"] = "Queued"

You can also define Boolean fields:

  • run["info/success"] = True
  • run["info/queued"] = False

Size#

Field Type
sys/size Float

Size of the run object in bytes.

Fetch all runs and sort by size (space taken up in Neptune)
>>> project = neptune.init_project(project="ml-team/nlu", mode="read-only")
>>> large_runs_df = project.fetch_runs_table(sort_by="sys/size").to_pandas()

Stage#

Model registry is deprecated

The model registry feature is deprecated. This includes:

  • The Models section in the web app.
  • The Model and ModelVersion objects of the API.

The feature will be deactivated on 2025-04-01.

For examples of model lifecycle management using experiments, see:

For how to migrate your models, see Migrate from model registry to experiments.

Field Type
sys/stage ModelVersionStage

A model version object can be in one of four lifecycle stages:

  • none (default)
  • staging
  • production
  • archived

Failed#

See also

sys/state

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.