Have your model development under control.
Version, store, organize, and query models, and model development metadata including:
Neptune lets you version, display, and query most metadata generated during model building:
You connect Neptune to your model training from your code via neptune-client library.
neptune.init() # credentials go here
neptune.create_experiment(
params={'lr': 0.21,
'batch_size': 128},
upload_source_files=['**.*.py', # scripts
'env.yaml']) # environment
log_data_version('data/train.csv') # data versions
neptune.log_metric('acc', 0.92) # metrics
neptune.log_artifact('model.pkl') # model binaries
Neptune works with any ML framework in Python and R via the official client libraries (but you can record model training from other languages).
To make things easier Neptune has integrations with over 25 major ML frameworks and libraries including:
#Tensorflow/Keras
model.fit(..., callbacks=[NeptuneMonitor()])
# PyTorch lightning
trainer = pl.Trainer(..., logger=NeptuneLogger())
# lightGBM
gbm = lgb.train(... callbacks = [neptune_monitor()])
# XGBoost
xgb.train(..., callbacks=[neptune_callback()])
# Optuna
study.optimize(…, callbacks=[NeptuneCallback()])
You can download model information directly from the UI or use the client library.
Whatever you logged to Neptune can be accessed and queried programmatically.
project = neptune.init('Project')
exp = project.get_experiments(id='Proj-123')[0]
exp.get_parameters()
exp.download_artifact('model.pkl')
Have data, code, parameters, and model binary versioned for every model training run.
Run model training jobs in every environment (cloud, local, notebooks, you name it) and log whatever information you care about to Neptune.
Your team can organize, display, compare and query it easily.
Find model training runs you care about quickly:
Neptune experiment dashboard is fully customizable.
You can download all model information that you logged, including:
It is as simple as pointing Neptune to the experiment run that you want in your Python code.
import neptune
project = neptune.init('Project')
exp = project.get_experiments(id='Proj-123')[0]
exp.get_parameters()
exp.download_artifact('model.pkl')
Automatically record the code, environment, parameters, model binaries, and evaluation metrics every time you run an experiment. You will not forget to commit your changes because it just happens.
neptune.create_experiment(
params={'lr':0.21,
'data_version': sha('data/train.csv')},
upload_source_files=['**.*.py',
'requirements.yaml')
...
neptune.log_metric('acc', 0.92)
neptune.log_artifact('model.pkl')
Find and access information from your past runs whenever you need them.
No worries about losing your work or not knowing which model is running in production.
Everything is stored, backed up, and ready for you.
Do you need to re-run a model training job from the past?
Query all the pieces you need from Neptune.
Your code, environment files, data versions, and parameters can be attached to every model training job you run. You can access it programmatically or find it in the UI.
Do you want to know who created the model that is running in production?
Neptune automatically records that info for every experiment that is run.
Just find that run, send an experiment link to your colleague, and talk.
Your production model is behaving unexpectedly, and you are wondering what it was trained on?
Neptune lets you record data versions and locations for every experiment training run so that when you need it, you can find it in a second.
You can even record a data snapshot to understand it better.
Have every artifact of every model your team builds in a central model registry.
Avoid duplicating expensive jobs.
Everything backed-up, secure, and ready to be accessed at any time.
Want to discuss what you see right now in the application?
Just share a link. It’s that simple.
Experiment details, comparisons, dashboard views, or anything else get persistent links that you can paste or send!
You can have all experiments and models your team runs in a single place.
Code, parameters, and model binaries are logged for every training job so that you can re-produce, re-train, and deploy them in production.
Everything that your team logs to Neptune is automatically accessible to every team member.
You can access model training run information like the code, parameters, model binary, or other objects via an API.
project = neptune.init('MyProject')
experiment = project.get_experiments(id='PRO-332')[0]
experiment.get_parameters()
experiment.download_artifact('model.pkl')
experiment.download_source()
pip install neptune-client
import neptune
neptune.init('Me/MyProject')
neptune.create_experiment(params={'lr':0.1, 'dropout':0.4})
# training and evaluation logic
neptune.log_metric('test_accuracy', 0.84)
Try live notebook
