<div align="center">
    <img src="https://neptune.ai/wp-content/uploads/neptune-logo-less-margin-e1611939742683.png" width="300" /><br><br>
</div>

[![PyPI version](https://badge.fury.io/py/neptune-client.svg)](https://badge.fury.io/py/neptune-client)
[![Build Status](https://travis-ci.org/neptune-ai/neptune-client.svg?branch=master)](https://travis-ci.org/neptune-ai/neptune-client)
[![neptune-blog](https://img.shields.io/badge/Neptune-blog-informational?logo=data:image/png;base64, )](https://neptune.ai/blog)
[![twitter](https://img.shields.io/twitter/follow/neptune_ai.svg?label=Follow)](https://twitter.com/neptune_ai)
[![youtube](https://img.shields.io/youtube/views/9iX6DxcijO8?style=social)](https://www.youtube.com/channel/UCvOJU-ubyUqxGSDRN7xK4Ng)

## Flexible metadata store for MLOps, built for research and production teams that run a lot of experiments.
Neptune is a lightweight solution designed for:
* **Experiment tracking:** log, display, organize, and compare ML experiments in a single place.
* **Model registry:** version, store, manage, and query trained models, and model-building metadata.
* **Monitoring ML runs live:** record and monitor model training, evaluation, or production runs live.
&nbsp;


### Getting started

**Step 1:** Sign up for a **[free account](https://neptune.ai/register)**

**Step 2:** Install Neptune client library
```bash
pip install neptune-client
```
**Step 3:** Connect Neptune to your code
```python
import neptune.new as neptune

run = neptune.init(project="common/quickstarts",
                   api_token="ANONYMOUS")

run["parameters"] = {"batch_size": 64,
                     "dropout": 0.2,
                     "optim": {"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)

run["f1_score"] = 0.66
```
[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/neptune-ai/examples/blob/master/how-to-guides/hello-world/notebooks/Neptune_hello_world.ipynb)

<div align="center">
  <a href="https://youtu.be/15p-mAuIMlA" target="_blank">
    <img border="0" alt="W3Schools" src="https://neptune.ai/wp-content/uploads/manage-all-your-model-building-metadat-in-a-single-place.jpg" width="600">
  </a>
</div>
&nbsp;

Learn more in the [documentation](https://docs.neptune.ai/) or check our [video tutorials](https://www.youtube.com/c/NeptuneAI/) to find your specific use case.

### Features
***Log and display***

Neptune [supports log and display](https://docs.neptune.ai/you-should-know/what-can-you-log-and-display) for many different types of metadata generated during the ML model lifecycle:
* metrics and learning curves
* parameters, tags, and properties
* code, .git info, files, and jupyter notebooks
* hardware consumption (CPU, GPU, Memory)
* images, interactive charts, and HTML objects
* audio and video files
* tables and .csv files
* and [more](https://docs.neptune.ai/you-should-know/what-can-you-log-and-display)

<div align="center">
     <img border="0" alt="W3Schools" src="https://neptune.ai/wp-content/uploads/Log-and-display.gif" width="600">
</div>
&nbsp;


***Compare***

You can [compare model-building runs](https://docs.neptune.ai/you-should-know/comparing-runs) you log to Neptune using various comparison views:
* **Charts:** where you can compare learning curves for metrics or losses
* **Images:** where you can compare images across runs
* **Parallel coordinates:** where you can see parameters and metrics displayed on a parallel coordinates plot
* **Side-by-side:** which shows you the difference between runs in a table format
* **Artifacts:** where you can compare datasets, models, and other artifacts that you version in Neptune
* **Notebooks:** which shows you the difference between notebooks (or checkpoints of the same notebook) logged to the project

<div align="center">
     <img border="0" alt="W3Schools" src="https://neptune.ai/wp-content/uploads/Compare.gif" width="600">
</div>
&nbsp;


***Filter and organize***

As well as filter, sort, and group model training runs using [highly configurable dashboards](https://docs.neptune.ai/you-should-know/organizing-and-filtering-runs).

<div align="center">
     <img border="0" alt="W3Schools" src="https://neptune.ai/wp-content/uploads/Filter-and-organize-3688604602-1644927778194.png" width="600">
</div>
&nbsp;

***Collaborate***

And improve [team management and collaboration](https://docs.neptune.ai/you-should-know/collaboration-in-neptune) by grouping all experiments into projects and workspaces and quickly sharing any result or visualization within the team.

<div align="center">
     <img border="0" alt="W3Schools" src="https://neptune.ai/wp-content/uploads/Collaboration.gif" width="600">
</div>
&nbsp;

### Integrate with your favourite ML libraries
Neptune comes with **25+ integrations with Python libraries** popular in machine learning, deep learning and reinforcement learning.
Integrations available:
* PyTorch and PyTorch Lightning
* TensorFlow / Keras and TensorBoard
* Scikit-Learn, LightGBM, and XGBoost
* Optuna, Scikit Optimize, and Keras Tuner
* Bokeh, Altair, Plotly, and Matplotlib
* and [more](https://docs.neptune.ai/integrations-and-supported-tools/intro)

#### PyTorch Lightning

  <img src="https://neptune.ai/wp-content/uploads/PyTorch-Lightning.png" width="350" /><br><br>

Example:
```python
from pytorch_lightning import Trainer
from pytorch_lightning.loggers import NeptuneLogger

# create NeptuneLogger
neptune_logger = NeptuneLogger(
    api_key="ANONYMOUS",  # replace with your own
    project="common/pytorch-lightning-integration",  # "<WORKSPACE/PROJECT>"
    tags=["training", "resnet"],  # optional
)

# pass it to the Trainer
trainer = Trainer(max_epochs=10, logger=neptune_logger)

# run training
trainer.fit(my_model, my_dataloader)

```

[![neptune-pl](https://img.shields.io/badge/PytorchLightning-experiment-success?logo=data:image/png;base64, )](https://app.neptune.ai/common/pytorch-lightning-integration/experiments?split=tbl&dash=charts&viewId=faa75e77-5bd6-42b9-9379-863fe7a33227)
&nbsp;

[![github-code](https://img.shields.io/badge/GitHub-code-informational?logo=github)](https://github.com/neptune-ai/examples/tree/main/integrations-and-supported-tools/pytorch-lightning/scripts)
[![jupyter-code](https://img.shields.io/badge/Jupyter-code-informational?logo=jupyter)](https://github.com/neptune-ai/examples/blob/main/integrations-and-supported-tools/pytorch-lightning/notebooks/Neptune_PyTorch_Lightning.ipynb)
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/neptune-ai/examples/blob/main/integrations-and-supported-tools/pytorch-lightning/notebooks/Neptune_PyTorch_Lightning.ipynb)
[<img src="https://img.shields.io/badge/docs-PyTorch%20Lightning-yellow">](https://docs.neptune.ai/integrations-and-supported-tools/model-training/pytorch-lightning)

#### TensorFow/Keras

  <img src="https://neptune.ai/wp-content/uploads/TensorFowKeras.png" width="400" /><br><br>

Example:
```python
import tensorflow as tf
import neptune.new as neptune
from neptune.new.integrations.tensorflow_keras import NeptuneCallback

run = neptune.init(project="common/tf-keras-integration", api_token="ANONYMOUS")

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential(
    [
        tf.keras.layers.Flatten(),
        tf.keras.layers.Dense(256, activation=tf.keras.activations.relu),
        tf.keras.layers.Dropout(0.5),
        tf.keras.layers.Dense(10, activation=tf.keras.activations.softmax),
    ]
)

optimizer = tf.keras.optimizers.SGD(
    learning_rate=0.005,
    momentum=0.4,
)

model.compile(
    optimizer=optimizer, loss="sparse_categorical_crossentropy", metrics=["accuracy"]
)

neptune_cbk = NeptuneCallback(run=run, base_namespace="metrics")
model.fit(x_train, y_train, epochs=5, batch_size=64, callbacks=[neptune_cbk])

```

[![neptune-pl](https://img.shields.io/badge/TF/Keras-experiment-success?logo=data:image/png;base64, )](https://app.neptune.ai/common/tf-keras-integration/e/TFK-18/all)
&nbsp;

[![github-code](https://img.shields.io/badge/GitHub-code-informational?logo=github)](https://github.com/neptune-ai/examples/tree/main/integrations-and-supported-tools/tensorflow-keras/scripts)
[![jupyter-code](https://img.shields.io/badge/Jupyter-code-informational?logo=jupyter)](https://github.com/neptune-ai/examples/blob/main/integrations-and-supported-tools/tensorflow-keras/notebooks/Neptune_TensorFlow_Keras.ipynb)
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/neptune-ai/examples/blob/master/integrations-and-supported-tools/tensorflow-keras/notebooks/Neptune_TensorFlow_Keras.ipynb)
[<img src="https://img.shields.io/badge/docs-TensorFow%2FKeras-yellow">](https://docs.neptune.ai/integrations-and-supported-tools/model-training/tensorflow-keras)

#### Scikit-learn

  <img src="https://neptune.ai/wp-content/uploads/Scikit-learn.png" width="200" /><br><br>

Example:
```python
from sklearn.datasets import load_digits
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split
import neptune.new as neptune
import neptune.new.integrations.sklearn as npt_utils

run = neptune.init(
    project="common/sklearn-integration",
    api_token="ANONYMOUS",
    name="classification-example",
    tags=["GradientBoostingClassifier", "classification"],
)

parameters = {
    "n_estimators": 120,
    "learning_rate": 0.12,
    "min_samples_split": 3,
    "min_samples_leaf": 2,
}

gbc = GradientBoostingClassifier(**parameters)

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=28743
)

gbc.fit(X_train, y_train)

run["cls_summary"] = npt_utils.create_classifier_summary(
    gbc, X_train, X_test, y_train, y_test
)
```

[![neptune-pl](https://img.shields.io/badge/sklearn-experiment-success?logo=data:image/png;base64, )](https://app.neptune.ai/common/sklearn-integration/e/SKLEAR-97/all?path=rfr_summary%2Fdiagnostics_charts&attribute=feature_importance)
&nbsp;

[![github-code](https://img.shields.io/badge/GitHub-code-informational?logo=github)](https://github.com/neptune-ai/examples/tree/main/integrations-and-supported-tools/sklearn/scripts)
[![jupyter-code](https://img.shields.io/badge/Jupyter-code-informational?logo=jupyter)](https://github.com/neptune-ai/examples/blob/main/integrations-and-supported-tools/sklearn/notebooks/Neptune_Scikit_learn.ipynb)
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/neptune-ai/examples/blob/master/integrations-and-supported-tools/sklearn/notebooks/Neptune_Scikit_learn.ipynb)
[<img src="https://img.shields.io/badge/docs-Scikit--learn-yellow">](https://docs.neptune.ai/integrations-and-supported-tools/model-training/sklearn)

#### fastai

  <img src="https://neptune.ai/wp-content/uploads/fastai-1.png" width="150" /><br><br>

Example:
```python
import fastai
from neptune.new.integrations.fastai import NeptuneCallback
from fastai.vision.all import *
import neptune.new as neptune

run = neptune.init(
    project="common/fastai-integration", api_token="ANONYMOUS", tags="basic"
)

path = untar_data(URLs.MNIST_TINY)
dls = ImageDataLoaders.from_csv(path)

# Log all training phases of the learner
learn = cnn_learner(dls, resnet18, cbs=[NeptuneCallback(run=run, base_namespace="experiment")])
learn.fit_one_cycle(2)
learn.fit_one_cycle(1)

run.stop()
```

[![neptune-pl](https://img.shields.io/badge/fastai-experiment-success?logo=data:image/png;base64, )](https://app.neptune.ai/common/fastai-integration/e/FAS-61/dashboard/fastai-dashboard-1f456716-f509-4432-b8b3-a7f5242703b6)
&nbsp;

[![github-code](https://img.shields.io/badge/GitHub-code-informational?logo=github)](https://github.com/neptune-ai/examples/tree/main/integrations-and-supported-tools/fastai/scripts)
[![jupyter-code](https://img.shields.io/badge/Jupyter-code-informational?logo=jupyter)](https://github.com/neptune-ai/examples/blob/main/integrations-and-supported-tools/fastai/notebooks/Neptune_fastai.ipynb)
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/neptune-ai/examples/blob/main/integrations-and-supported-tools/fastai/notebooks/Neptune_fastai.ipynb)
[<img src="https://img.shields.io/badge/docs-fastai-yellow">](https://docs.neptune.ai/integrations-and-supported-tools/model-training/fastai)

#### Optuna

  <img src="https://neptune.ai/wp-content/uploads/Optuna-1.png" width="300" /><br><br>

Example:
```python
import lightgbm as lgb
import neptune.new as neptune
import neptune.new.integrations.optuna as optuna_utils
import optuna
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split


def objective(trial):
    data, target = load_breast_cancer(return_X_y=True)
    train_x, test_x, train_y, test_y = train_test_split(data, target, test_size=0.25)
    dtrain = lgb.Dataset(train_x, label=train_y)

    param = {
        "verbose": -1,
        "objective": "binary",
        "metric": "binary_logloss",
        "num_leaves": trial.suggest_int("num_leaves", 2, 256),
        "feature_fraction": trial.suggest_uniform("feature_fraction", 0.2, 1.0),
        "bagging_fraction": trial.suggest_uniform("bagging_fraction", 0.2, 1.0),
        "min_child_samples": trial.suggest_int("min_child_samples", 3, 100),
    }

    gbm = lgb.train(param, dtrain)
    preds = gbm.predict(test_x)
    accuracy = roc_auc_score(test_y, preds)

    return accuracy


# Create a Neptune Run
run = neptune.init(
    api_token="ANONYMOUS", project="common/optuna-integration"
)  # you can pass your credentials here

# Create a NeptuneCallback for Optuna
neptune_callback = optuna_utils.NeptuneCallback(run)

# Pass NeptuneCallback to Optuna Study .optimize()
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=20, callbacks=[neptune_callback])

# Stop logging to a Neptune Run
run.stop()
```

[![neptune-pl](https://img.shields.io/badge/Optuna-experiment-success?logo=data:image/png;base64, )](https://app.neptune.ai/common/optuna-integration/experiments?split=bth&dash=parallel-coordinates-plot&viewId=b6190a29-91be-4e64-880a-8f6085a6bb78)
&nbsp;

[![github-code](https://img.shields.io/badge/GitHub-code-informational?logo=github)](https://github.com/neptune-ai/examples/tree/main/integrations-and-supported-tools/optuna/scripts)
[![jupyter-code](https://img.shields.io/badge/Jupyter-code-informational?logo=jupyter)](https://github.com/neptune-ai/examples/blob/main/integrations-and-supported-tools/optuna/notebooks/Neptune_Optuna_integration.ipynb)
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/neptune-ai/examples/blob/master/integrations-and-supported-tools/optuna/notebooks/Neptune_Optuna_integration.ipynb)
[<img src="https://img.shields.io/badge/docs-Optuna-yellow">](https://docs.neptune.ai/integrations-and-supported-tools/hyperparameter-optimization/optuna)

### Neptune.ai is trusted by great companies
&nbsp;

<div align="center">
  <img src="https://neptune.ai/wp-content/uploads/Neptune-customers.png" width="900" />

</div>
&nbsp;

Read how various customers use Neptune to [improve their workflow](https://neptune.ai/customers).

### Support
If you got stuck or simply want to talk to us about something here are your options:
* Check our [FAQ page](https://docs.neptune.ai/getting-started/getting-help#frequently-asked-questions)
* Chat! When in application click on the [blue message icon](https://docs.neptune.ai/getting-started/getting-help#chat) in the bottom-right corner and send a message. A real person will talk to you ASAP (typically very ASAP),
* You can just shoot us an email at [support@neptune.ai](mailto:support@neptune.ai).

### People behind Neptune
Created with :heart: by the [Neptune.ai team](https://neptune.ai/about-us):

Piotr, Jakub, Paulina, Kamil, Magdalena, Małgorzata, Piotr, Aleksandra, Marcin, Hubert, Adam, Jakub, Paweł, Patrycja, Grzegorz, Paweł, Natalia, Marcin, Jakub, Prince, Piotr, Rafał, Sandra, Bartosz, Dominika, Karolina, Parth, Vovik, Rafał, Stephen and [you?](https://neptune.ai/jobs)
