MLRun

MLRun orchestrates end-to-end ML workflows as directed acyclic graphs (DAGs) executed on Kubernetes clusters, automatically managing resource allocation, job dependencies, and fault recovery. Jobs are containerized functions deployed to either native Kubernetes or the Nuclio serverless runtime, with built-in support for distributed training, data processing, and model serving stages. The orchestration engine handles job queuing, retry logic, and inter-job data passing through a unified execution context.

MLRun automatically captures experiment metadata (hyperparameters, metrics, training duration) and data lineage (input datasets, transformations, output models) without explicit logging code. The platform maintains a centralized metadata store that tracks relationships between data, code versions, and model artifacts, enabling reproducibility and audit trails. Auto-tracking integrates with the job execution context, intercepting function inputs/outputs and framework-specific metrics (TensorFlow, PyTorch, scikit-learn) without requiring instrumentation.

MLRun maintains a centralized model registry that tracks model versions, metadata (framework, training date, performance metrics), and deployment history. Models are versioned automatically with each training run, and the registry tracks which model version is deployed to which serving endpoint. The platform enables model promotion workflows (e.g., staging → production) with approval gates and automatic rollback if deployment fails or performance degrades.

MLRun deploys functions to the Nuclio serverless runtime, which automatically scales function instances based on request volume and queues excess requests during traffic spikes. Functions are defined as Python code with @handler decorators and automatically containerized and deployed to Kubernetes. Nuclio handles request routing, connection pooling, and resource cleanup without requiring users to manage Kubernetes services or deployments directly.

MLRun orchestrates distributed training across multiple GPUs and nodes using Kubernetes native distributed training patterns. The platform automatically configures distributed training frameworks (TensorFlow distributed strategy, PyTorch DistributedDataParallel, Horovod) based on the training function and cluster topology. Job scheduling handles GPU allocation, network configuration, and inter-node communication without requiring manual distributed training code.

MLRun provides a feature store that manages feature definitions, transformations, and storage with automatic generation of batch and real-time data pipelines. Features are defined as transformations on raw data sources (databases, data lakes, streaming sources) and materialized to offline storage (Parquet, Delta Lake) for training and online storage (Redis, DynamoDB) for real-time inference. The platform auto-generates ingestion pipelines that run on a schedule (batch) or continuously (streaming) and handles feature versioning, schema validation, and point-in-time joins for training data consistency.

MLRun deploys trained models as HTTP/gRPC endpoints on Kubernetes with automatic request routing, load balancing, and canary deployment support. Models are wrapped in serverless functions (via Nuclio) that handle inference requests, with built-in support for batching, request queuing, and auto-scaling based on CPU/memory/custom metrics. The platform enables traffic splitting between model versions (e.g., 90% to production, 10% to canary) for A/B testing and gradual rollouts without manual traffic management.

MLRun monitors deployed models for data drift (input feature distribution changes) and model performance degradation (prediction accuracy decline) in real-time, automatically triggering retraining pipelines when drift exceeds configured thresholds. The platform compares incoming inference request distributions against training data baselines using statistical tests (Kolmogorov-Smirnov, chi-square) and tracks prediction metrics (accuracy, latency) against SLOs. Drift detection runs continuously on inference request streams without requiring separate monitoring infrastructure.

MLRun provides distributed hyperparameter optimization that runs multiple training jobs in parallel across Kubernetes workers, supporting grid search (exhaustive parameter combinations), random search (random sampling), and Bayesian optimization (intelligent parameter exploration using past results). The tuning engine manages job scheduling, result aggregation, and early stopping (terminating unpromising runs) to reduce compute costs. Results are automatically tracked in the metadata store with full lineage to training data and model artifacts.

MLRun integrates with CI/CD systems to automate model testing, validation, and deployment workflows triggered by code commits or pull requests. When code changes are pushed, MLRun automatically runs training pipelines, validates model performance against baselines, executes unit/integration tests, and deploys approved models to serving endpoints. The platform provides hooks for GitHub Actions, GitLab CI, and Jenkins to trigger MLRun workflows and report results back to the VCS platform.

MLRun supports training and serving models built with popular ML frameworks (TensorFlow, PyTorch, scikit-learn, XGBoost, LightGBM) with automatic dependency resolution and containerization. When a training function is submitted, MLRun analyzes imports, installs required packages, and generates a Docker image without requiring manual Dockerfile creation. The platform handles framework-specific serialization (SavedModel for TensorFlow, pickle for scikit-learn) and provides unified inference interfaces across frameworks.

MLRun orchestrates large language model (LLM) fine-tuning workflows with built-in integration to NVIDIA NIM (NVIDIA Inference Microservices) for optimized inference. The platform automates data preparation, prompt engineering, parameter-efficient fine-tuning (LoRA, QLoRA), and evaluation against benchmarks. Fine-tuning jobs run distributed across GPUs on Kubernetes, with automatic checkpoint management and model versioning. Integration with Hugging Face model hub enables easy access to base models and community-contributed fine-tuned variants.

MLRun generates and orchestrates batch ETL pipelines that automatically parallelize data processing across Kubernetes workers. Data transformations are defined as Python functions and automatically distributed using Spark, Dask, or native Kubernetes parallelization depending on data size and cluster configuration. The platform handles data partitioning, shuffle operations, and result aggregation transparently, enabling data engineers to write single-machine code that scales to terabytes of data.