Neptune API

Logs experiment metadata (metrics, configs, artifacts) from multiple concurrent processes using a context manager pattern (`with Run()`) that handles async writes to Neptune's backend. Supports step-indexed metrics, configuration snapshots, and binary artifacts (images, audio, video, files) with implicit serialization. Designed for distributed training environments where multiple workers log simultaneously without blocking.

Queries logged experiment runs using the `neptune-query` package with support for filtering across metrics, configs, and run metadata using extended regex syntax. Enables cross-project searches and retrieval of experiment metadata without requiring web UI navigation. Returns structured run objects with access to all logged artifacts and metrics.

Manages experiment run lifecycle using Python context manager (with statement) pattern, automatically initializing run state on entry and flushing/closing on exit. Context manager ensures proper resource cleanup and backend synchronization even if training code raises exceptions, preventing data loss and orphaned connections.

Exports metric charts and dashboards as PNG images with embedded metadata, enabling offline sharing via email, Slack, or documentation without requiring Neptune account access. Export preserves chart styling, legends, and multi-run overlays, generating publication-ready visualizations.

Web-based visualization dashboard that renders logged metrics as interactive charts, with side-by-side comparison view showing metric deltas between selected runs in diff format. Supports custom views with filtered run tables, persistent shareable links for charts/dashboards, and PNG export of visualizations. Built on Neptune's web app (version 3.20251215).

Captures experiment configurations (hyperparameters, model architecture details, dataset paths) as immutable snapshots via `log_configs()` method, storing them alongside metrics for reproducibility. Configurations are queryable and comparable across runs, enabling hyperparameter sensitivity analysis and reproducibility audits without manual parameter logging.

Creates shareable dashboards combining multiple charts, filtered run tables, and custom widgets. Generates collaborative reports with persistent URLs that can be shared with team members without requiring them to have Neptune accounts. Supports real-time updates as new experiments are logged, enabling live monitoring of ongoing training jobs.

Stores binary artifacts (model checkpoints, images, audio, video, files) alongside experiment metadata with implicit versioning by run and step. Artifacts are queryable and retrievable via the neptune-query API, enabling model registry functionality without requiring separate artifact storage systems. Supports arbitrary file types with automatic serialization.

Creates filtered views of experiment runs using metadata-based filters (metrics, configs, run names) with persistent storage of filter definitions. Custom views appear as tabs in the runs table, enabling teams to organize experiments by project, model type, or performance tier without duplicating data. Filters support regex matching and multi-criteria AND/OR logic.

Logs metrics with explicit step indices (epoch, iteration, batch number) enabling automatic time-series construction without manual timestamp management. Supports logging multiple metrics per step, NaN and infinity values, and implicit metric aggregation across distributed processes. Step indices enable metric alignment across runs with different training lengths.

Enables multiple team members to view and interact with shared experiments simultaneously with role-based access control (RBAC) determining read/write/admin permissions. Supports real-time updates as new metrics are logged, allowing team members to monitor ongoing training jobs without polling. Persistent sharing links enable asynchronous collaboration across time zones.

Manages isolated run contexts for each training process using the context manager pattern (`with Run()`), preventing metric/config collisions when multiple processes log simultaneously. Each process gets a unique run ID, and Neptune handles async writes without requiring explicit process synchronization or queue management. Supports both single-process and multi-GPU/multi-node training.