Core concepts

Core concepts in Neptune
​Neptune Client Library (API): The suite of libraries to help you log, query, and download model-building metadata. You can use Neptune client for Python, R, and one of many integrations with ML tools.
​Neptune Web Interface (app): The visual interface where you can display, filter, compare, and organize ML runs and model building metadata.
​Workspace: The space inside Neptune where you can manage projects, people, and your subscription. When you create an account, you are assigned an individual workspace. You can belong to many team workspaces at the same time.
​Project: The space inside a workspace where you put all the metadata generated while working on a machine learning task. You can assign different people from your workspace to different projects.
​Run: A namespace inside a project where you log model building metadata. Typically, you create a run every time you execute a script that does model training, re-training, or inference.
​Field: A place inside the run namespace where you log various types of model building metadata.  
​Metadata: Metrics and losses, hyperparameters, figures, image predictions, hardware consumption logs, code snapshots, and any other information you need to feel in control of your model building.
Client library (Neptune API)
​Neptune client is an open-source Python library that helps you do two things:
​Log model building metadata to Neptune​
​Query and download model building metadata from Neptune​
It is designed to be:
lightweight: easy connect to your workflow and integrate with other tools in your MLOps tech stack,
flexible: capable of logging any kind of ML metadata in any structure you need,
straightforward: you define what you want to log for each ML run.
Neptune API in 30 seconds
Step 1: Install the neptune-client library
Depending on your operating system, open a terminal or CMD and run this command:
pip
conda
pip install neptune-client
conda install -c conda-forge neptune-client
For more help, see installing neptune-client.
Step 2: Add logging into your model training script
train.py
import neptune.new as neptune
​
run = neptune.init(
    project="YOUR_WORKSPACE/YOUR_PROJECT",  # your project
    api_token="YOUR_API_TOKEN",  # your api token
)
​
# Track metadata and hyperparameters of your run
run["JIRA"] = "NPT-952"
​
params = {
    "batch_size": 64,
    "dropout": 0.2,
    "optimizer": {"learning_rate": 0.001, "optimizer": "Adam"},
}
run["parameters"] = params
​
# Track the training process by logging your training metrics
for epoch in range(100):
    run["train/accuracy"].log(epoch * 0.6)
    run["train/loss"].log(epoch * 0.4)
​
# Log the final results
run["f1_score"] = 0.66
Step 3: Run model training
python train.py
Step 4: Query whatever model building metadata you need
import neptune.new as neptune
​
run = neptune.init(
    project="YOUR_WORKSPACE/YOUR_PROJECT",  # your project
    api_token="YOUR_API_TOKEN",  # your api token
    run="YOUR_RUN_ID",  # id of the run you want to access
)
​
params = run["parameters"].fetch()
Installation and setup
Quickstart
Logging metadata
What can you log and display?
API reference
Web Interface (Neptune app) 
Neptune comes with a Web Interface designed for working with ML model building metadata. 
It makes it easy to:
​Organize and filter model training runs​
​Compare models and experiments​
​Display all model building metadata types like metrics, hyperparameters, images, or video​
​Present all metadata in a folder-like structure ​
There are a few essential components of the Neptune app:
Projects: where you can create and manage all your projects,
Runs Table: where you can compare, filter, and organize your runs,
Single run: where you can explore and display rich metadata,
People: where you can deal with user access control (ACL),
Subscription: where you can manage your plan and see current usage.
Neptune UI Tour
Examples of Neptune UI in action
​
Example in Neptune
Runs table
​​
​​
Comparison of runs
​​
​​
Logged learning curves
​​
​​
Logged hardware consumption
​​
​​
Logged interactive charts
​​
​​
Logged images
​​
​​
Custom Dashboard
​​
​​
Displaying metadata
What can you log and display?
Comparing runs
Organizing and filtering Runs
Workspace
A workspace is a space inside Neptune where you can manage projects, people, and your subscription. 
There are two types of workspaces:
Individual
When you create an account you are assigned an individual workspace called your username,
You can create an unlimited number of public and private projects, 
You cannot invite other people to this workspace. 
Team
Comes in handy when you want to collaborate on projects with other people,
You can invite as many people as you want to your team workspace,
You can belong to many team workspaces, 
Team workspace is paid but you can try it for free, for details check our pricing page, 
For academic purposes or Kaggle, you can use the team workspace for free. Create a team workspace and claim non-profit/educational type of organization in the setup process. We suggest you use your .edu/non-profit email for this type of account. 
You can be a member of multiple workspaces. For example, you can have: 
your individual workspace, 
a team workspace at work, 
a team workspace at the university.  
Workspaces
Project
A project is a collection of runs, models, and other metadata created by project members. Typically you should create one project per machine learning task, to make it easy to compare runs that are connected to building certain kinds of ML model.
There are two types of projects:
Private projects: Only people assigned to the project can see it,
Public projects: freely available to view by everyone who has access to the Internet.
You can assign different people from your workspace to different projects.
To log to a project via Neptune API, you need a full project name of the format workspace_name/project_name:
run = neptune.init(project="YOUR_WORKSPACE/YOUR_PROJECT")
 See how to find it in the Neptune UI and set it in your logging code.​
Installation and setup
Projects
Run
A run is a namespace inside a project where you log model building metadata. Typically, you create a run every time you execute a script that does model training, re-training, or inference.   
It has a dictionary-like structure with fields to which any type of ML metadata can be logged.
You can create a nested structure in your Runs to organize your parameters, metrics, or other metadata.
You start a run with neptune.init():
import neptune.new as neptune
​
run = neptune.init(
    project="YOUR_WORKSPACE/YOUR_PROJECT", api_token="YOUR_API_TOKEN"
)  # your credentials
Log model building metadata to various fields of the run:
run["JIRA"] = "NPT-952"
​
run["parameters"] = {
    "batch_size": 64,
    "dropout": 0.2,
    "optimizer": {"learning_rate": 0.001, "optimizer": "Adam"},
}
​
for epoch in range(100):
    run["train/accuracy"].log(epoch * 0.6)
    run["train/loss"].log(epoch * 0.4)
​
# Log the final results
run["f1_score"] = 0.66
Explore your run in the app:
Run in the Neptune UI
Access the run programmatically (after it has finished) :
run = neptune.init(
    project="YOUR_WORKSPACE/YOUR_PROJECT",
    api_token="YOUR_API_TOKEN",  # pass credentials
    run="YOUR_RUN_ID",
)  # pass a run ID
​
# update with new data
run["test_accuracy"] = 0.42
​
# fetch metadata
run["parameters/batch_size"].fetch()
The run stops when the script finishes or when you explicitly call. Explicitly stopping the run is mandatory for notebooks and interactive environments.
run.stop()
Quickstart
Core concepts
Logging metadata
What can you log and display?
Run
Field
A field of a run is a namespace to which various types of model building metadata can be logged.
A run field can be flat or nested:
# flat
run["f1_score"] = 0.66
run["model"].upload("model.pkl")
​
# nested
run["parameters/batch_size"] = 64
run["parameters/optimizer/learning_rate"] = 0.001
run["parameters/optimizer/optimizer"] = "Adam"
You can also assign values to a Field of a Run with a dictionary:
run["parameters"] = {
    "batch_size": 64,
    "optimizer": {"learning_rate": 0.001, "optimizer": "Adam"},
}
Neptune field types and logging methods
Model building metadata are displayed in the Neptune UI based on the type you choose to assign to your field. 
Depending on what metadata you want to log and how you wish to display it you should use different Neptune field types and methods:
Metadata 
Field Type
Logging Method
Example
Single metric
​Float​
​=, assign()​
run["f1_score"] = 0.66
Series of loss values
​FloatSeries​
​.log()​
for epoch in range(100):
    run["loss"].log(loss_value)
Hyperparameters
​Float, String​
​=, assign()​
run["learning_rate"] = 0.001
run["optimizer"] = "Adam"
Image predictions
​FileSeries​
​.log()​
for epoch in range(100):
    run["preds"].log(image)
Charts
​File​
​.upload() , .as_html(), .as_image()​
run["results"].upload(File.as_image(fig))
Model weights
​File​
​.upload() 
run["model"].upload("model.pkl")
Field types
Query and download metadata from the Field 
You can access information from the field of a run programmatically with the .fetch() and .download() methods.
Field type
Method
What it does
Example
​Float, String 
​.fetch()​
get value from the field
run["train/epoch"].fetch()
​File, FileSeries​
​.download()​
download file from the field
run["predictions/img2"].download()
​FloatSeries​
​.fetch_values()​
get all values from a series field
run["train/loss"].fetch_values()
​FileSeries​
​.download_last()​
download the last file from a series field
run["predictions"].download_last()
Field types
System ("sys") namespace
Metadata
When we talk about metadata in the context of Neptune we usually mean model building metadata. 
There are three main types of ML metadata that you can log and display in Neptune.
Experiment and model training metadata
Metrics
Hyperparameters
Learning curves
Training code and configuration files
Predictions (images, tables, etc.)
Diagnostic charts (Confusion matrix, ROC curve, etc.)
Console logs
Hardware logs
And more
Artifact (datasets, predictions, and models) metadata
Paths to the dataset or model (s3 bucket, filesystem, etc.)
Dataset hash
Dataset/prediction preview (head of the table, snapshot of the image folder, etc.)
Description
Feature column names (for tabular data)
Who created/modified 
When last modified
Size of the dataset
And more
(Trained) Model metadata
Model binary or location to your model asset
Dataset versions 
Links to recorded model training runs and experiments 
Who trained the model
Model descriptions and notes
Links to observability dashboards (like Grafana)
And more
Most model building metadata types can be easily logged and nicely displayed in the Neptune app: 
Have a look at the complete list of metadata types you can log.​
Displaying metadata
What can you log and display?
What's next?
What can you log and display?
Examples
Quickstart
How-to guides
Integrations and Supported Tools
​

Getting Started - Previous

Getting help

Next - You should know

Logging metadata

Last modified 1mo ago

Export as PDF

Copy link

Outline

Client library (Neptune API)

Web Interface (Neptune app)