Initial ML platform implementation

Author: ShaheemShaik26

.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: ci
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .[dev]
+      - name: Lint
+        run: ruff check src tests
+      - name: Test
+        run: pytest
+      - name: Training sanity check
+        run: python -m mlplatform.scripts.training_sanity_check
+      - name: Build Docker image
+        run: docker build -t mlplatform:ci .
+      - name: Simulate deployment
+        run: python -m mlplatform.scripts.simulate_deploy

.gitignore

@@ -0,0 +1,9 @@
+.pytest_cache/
+.testdata/
+__pycache__/
+*.pyc
+.venv/
+venv/
+dist/
+build/
+*.egg-info/

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+WORKDIR /app
+
+RUN addgroup --system app && adduser --system --ingroup app app
+
+COPY pyproject.toml README.md /app/
+COPY src /app/src
+
+RUN pip install --upgrade pip && pip install .
+
+USER app
+
+EXPOSE 8000
+
+CMD ["uvicorn", "mlplatform.api.app:create_app", "--factory", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,97 @@
+# MLPlatform
+
+MLPlatform is a production-style machine learning platform simulation that covers the full model lifecycle:
+training orchestration, experiment tracking, model registry, automated promotion, inference serving, and observability.
+
+## Architecture
+
+```text
+                 +--------------------+
+                 |   CLI / FastAPI     |
+                 +---------+----------+
+                           |
+                           v
+                 +--------------------+
+                 | Job Queue + Worker  |
+                 | async training exec |
+                 +---------+----------+
+                           |
+        +------------------+-------------------+
+        |                  |                   |
+        v                  v                   v
++---------------+  +----------------+  +---------------------+
+| Experiment DB |  | Model Registry |  | Observability Store  |
+| SQLite/Postgres|  | version/stage  |  | latency/drift/usage  |
++-------+-------+  +--------+-------+  +----------+----------+
+        |                   |                     |
+        v                   v                     v
++---------------+   +------------------+   +------------------+
+| Run metadata  |   | Artifact store   |   | Monitoring APIs  |
++---------------+   +------------------+   +------------------+
+                           |
+                           v
+                 +--------------------+
+                 | FastAPI Serving    |
+                 | multi-version load |
+                 +--------------------+
+```
+
+## Folder Structure
+
+```text
+src/mlplatform/
+  api/              FastAPI REST surface
+  serving/          online inference service
+  training/         config-driven training and queueing
+  *.py              database, registry, tracking, promotion, observability
+
+tests/
+  end-to-end and component tests
+
+.github/workflows/
+  CI pipeline
+```
+
+## Core Capabilities
+
+- Async training submission through CLI and REST API.
+- YAML-driven experiments with reproducible seeding.
+- Persistent experiment tracking in SQLite or Postgres via SQLAlchemy.
+- Automatic model versioning and stage management.
+- Rule-based promotion checks using accuracy gain and latency thresholds.
+- FastAPI inference service with multiple model versions loaded simultaneously.
+- Basic observability for latency, request volume, and drift signals.
+
+## Local Usage
+
+```bash
+pip install -e .[dev]
+mlplatform init-db
+uvicorn mlplatform.api.app:create_app --factory --reload
+```
+
+Run the training sanity check:
+
+```bash
+python -m mlplatform.scripts.training_sanity_check
+```
+
+Run tests:
+
+```bash
+pytest
+```
+
+## Design Decisions
+
+- SQLAlchemy + SQLite by default for portability; the schema is compatible with Postgres.
+- Queueing is simulated with a durable job table plus an in-process worker so the system behaves like an internal platform without needing Redis.
+- The trainer supports PyTorch when available, but the platform remains operable in minimal environments through a deterministic fallback trainer.
+- Model artifacts are versioned on disk with registry metadata in the database, which keeps deployment simple and rollback explicit.
+
+## Failure Handling
+
+- Training failures are persisted with stack traces and the run status is marked failed.
+- Promotion is blocked when safety checks fail, including missing metrics or latency regressions.
+- Serving returns structured errors for unknown model versions or missing artifacts.
+- Observability ingestion is non-blocking and never takes down the serving path.

pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mlplatform"
+version = "0.1.0"
+description = "Production-grade ML platform simulation with training, tracking, registry, serving, and observability"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "fastapi>=0.110",
+  "uvicorn[standard]>=0.27",
+  "pydantic>=2.6",
+  "PyYAML>=6.0",
+  "SQLAlchemy>=2.0",
+  "httpx>=0.26",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+  "ruff>=0.6",
+]
+torch = [
+  "torch>=2.2",
+]
+
+[project.scripts]
+mlplatform = "mlplatform.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]
+
+[tool.pytest.ini_options]
+addopts = "-q"
+testpaths = ["tests"]
+pythonpath = ["src"]

src/mlplatform/__init__.py

@@ -0,0 +1,6 @@
+"""MLPlatform package."""
+
+from mlplatform.config import Settings
+from mlplatform.db import init_db
+
+__all__ = ["Settings", "init_db"]

src/mlplatform/api/__init__.py

@@ -0,0 +1 @@
+"""API package."""

src/mlplatform/api/app.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from fastapi import FastAPI
+
+from mlplatform.db import init_db
+from mlplatform.api.routes import router
+from mlplatform.queue import AsyncJobQueue
+from mlplatform.training.service import TrainingService
+from mlplatform.serving.service import ServingService
+
+
+def create_app() -> FastAPI:
+    init_db()
+    app = FastAPI(title="MLPlatform", version="0.1.0")
+    training_service = TrainingService()
+    serving_service = ServingService()
+    job_queue = AsyncJobQueue()
+
+    def handle_job(job_id: str, payload: dict[str, object]) -> dict[str, object]:
+        return training_service.run_job(job_id, payload)
+
+    job_queue.start(handle_job)
+    app.state.training_service = training_service
+    app.state.serving_service = serving_service
+    app.state.job_queue = job_queue
+    app.include_router(router)
+
+    @app.on_event("shutdown")
+    def shutdown_queue() -> None:
+        job_queue.stop()
+
+    return app