mlflow

MLflow Tracking Server captures and persists experiment runs with hierarchical organization (experiments → runs → metrics/params/artifacts). Uses a backend store abstraction layer supporting local filesystem, SQL databases, and cloud object storage, enabling teams to log metrics, parameters, tags, and artifacts in real-time via REST API or Python SDK without managing infrastructure. Implements automatic run lifecycle management with start/end timestamps and status tracking.

MLflow Model Registry provides a centralized catalog for registered models with version control, stage management (Staging/Production/Archived), and metadata annotations. Uses a SQL-backed registry storing model URIs, version numbers, stage transitions with timestamps, and user-provided descriptions. Supports automatic model lineage tracking linking registered models back to source runs and enables stage-based deployment workflows through REST API and UI.

MLflow Tracking provides a query API supporting SQL-like filtering on metrics, parameters, and tags using a custom query language (e.g., 'metrics.accuracy > 0.9 AND params.learning_rate < 0.01'). Uses server-side filtering on the Tracking Server to reduce data transfer and enable efficient searches across large experiment datasets. Supports comparison operators (>, <, ==, !=), logical operators (AND, OR), and string matching for flexible run discovery.

MLflow automatically captures Python dependencies when logging models or projects using pip freeze or conda environment inspection, creating reproducible environment specifications (requirements.txt, environment.yml). Uses introspection on imported modules to identify dependencies and their versions, enabling models to be deployed with identical environments across machines. Supports both conda and pip-based environments with automatic environment creation during model serving.

MLflow Tracking supports arbitrary key-value tags on runs enabling custom metadata annotation beyond metrics and parameters. Uses a flexible tag storage system supporting string values with no schema enforcement, enabling teams to add custom labels (e.g., 'team:data-science', 'model-type:classification', 'status:approved'). Tags are indexed and searchable, enabling filtering and organization of runs by custom dimensions.

MLflow Models provides a standardized format (MLmodel YAML + flavor-specific serialization) for packaging trained models from diverse frameworks (scikit-learn, TensorFlow, PyTorch, XGBoost, Spark MLlib, etc.) with automatic dependency management. Uses a flavor-based architecture where each framework has a loader/saver implementation, enabling models to be deployed to any MLflow-compatible serving platform without framework-specific code. Includes automatic conda environment capture and Python dependency pinning.

MLflow Models Serving exposes registered models via REST endpoints (Flask-based local server or cloud deployments) supporting both single-record and batch prediction requests. Uses a standardized input/output schema derived from model flavor metadata, enabling clients to make predictions without framework knowledge. Supports multiple deployment targets (local, Docker, Kubernetes, cloud platforms) through a unified serving interface with automatic model loading and versioning.

MLflow integrates with hyperparameter optimization libraries (Optuna, Hyperopt, Ray Tune) through a callback/logging pattern, automatically capturing hyperparameter suggestions and corresponding metrics. Uses the experiment tracking backend to persist search history, enabling teams to analyze optimization trajectories and resume interrupted searches. Supports distributed hyperparameter search across multiple machines by coordinating runs through the Tracking Server.

MLflow Projects packages ML code with a project.yaml manifest specifying entry points, parameters, dependencies, and environment configuration. Uses parameter injection to override values at runtime without modifying source code, enabling reproducible execution across environments. Supports multiple entry points (training, evaluation, inference) and automatic environment setup via conda or Docker, allowing teams to version and execute ML workflows as atomic units.

MLflow Artifacts provides a pluggable storage backend abstraction supporting local filesystem, S3, GCS, Azure Blob Storage, HDFS, and HTTP endpoints. Uses a URI-based reference system (s3://bucket/path, gs://bucket/path, etc.) enabling seamless artifact migration between backends without code changes. Implements automatic artifact versioning through run-based directory structures and supports both synchronous uploads and asynchronous background persistence.

MLflow UI provides a web-based dashboard for visualizing experiment runs, comparing metrics across runs, and analyzing parameter-metric relationships. Uses interactive charts (line plots for metric trends, scatter plots for parameter correlation, parallel coordinates for multi-dimensional comparison) with filtering and sorting capabilities. Stores visualization state in browser local storage and supports exporting comparison data as CSV for external analysis.

MLflow Python SDK provides a high-level API using context managers (mlflow.start_run()) for automatic run lifecycle management, enabling developers to log metrics, parameters, and artifacts with minimal boilerplate. Uses a thread-local active run context enabling nested logging without explicit run references, and provides convenience functions (mlflow.log_metric, mlflow.log_param, mlflow.log_artifact) that automatically route to the active run. Supports both eager logging and batch operations through the same API.

MLflow Models automatically detects the framework of a trained model and applies the appropriate flavor-specific serialization logic without explicit configuration. Uses introspection on model objects (isinstance checks, module inspection) to identify frameworks and route to flavor handlers (sklearn, tensorflow, pytorch, xgboost, etc.). Enables seamless model logging from training scripts without requiring developers to specify framework or serialization format.