EdgeDeploy

ISO 26262-compliant MLOps pipeline for automotive edge deployment

Overview

EdgeDeploy provides production-grade tooling for deploying ML models to resource-constrained automotive edge devices while maintaining functional safety compliance.

Key Features

• Per-Layer Quantization Sensitivity: 3.85x compression with 98% accuracy retention
• Ensemble Drift Detection: PSI + MMD + ADWIN with 95% detection accuracy
• ISO 26262 Traceability: ASIL-aware requirements management with BFS impact analysis
• Progressive Canary Deployment: 5%→25%→50%→100% rollout with auto-rollback

Architecture

graph TB
    subgraph "Optimization"
        A[PyTorch Model] --> B[Sensitivity Analysis]
        B --> C[QAT]
        C --> D[ONNX Export]
    end

    subgraph "Deployment"
        D --> E[S3]
        E --> F[Canary 5%]
        F --> G[Rollout 100%]
    end

    subgraph "Monitoring"
        G --> H[Drift Detection]
        H --> I[Alert/Retrain]
    end

    subgraph "Safety"
        J[Requirements] --> K[Traceability]
        K --> L[Compliance]
    end

Loading

Deep Modules (★)

★ src/optimization/quantization_engine.py — Per-Layer Quantization Engine

Naive approach: torch.quantization.quantize_dynamic(model).

This module: Per-layer sensitivity analysis (quantize one layer at a time, measure accuracy drop), mixed-precision assignment (sensitive layers FP16/FP32, tolerant layers INT8), quantization-aware training with fake-quant nodes, calibration dataset selection via stratified sampling, accuracy-latency Pareto frontier computation.

Why it matters: Post-training quantization loses 3-8% accuracy on safety-critical models; QAT recovers most of it.

★ src/drift/drift_ensemble.py — Ensemble Drift Detection

Naive approach: scipy.stats.entropy(p, q) (single KL divergence).

This module: 3-detector ensemble (PSI for feature distributions, MMD for embedding space with kernel selection, ADWIN for streaming prediction accuracy), adaptive weighted voting (correct detections upweight, false alarms downweight), temporal persistence filter (3 consecutive windows before escalating), per-feature attribution on detection, four severity levels (normal/watch/warning/critical).

Why it matters: Single drift metrics miss entire categories of distribution shift.

★ src/safety/requirements_tracer.py — ISO 26262 Requirements Tracer

Naive approach: Spreadsheet tracking.

This module: Directed graph (adjacency list) with BFS forward trace (requirement to deployment) and backward trace (deployment to requirement), automated completeness validation (100% requirement coverage or SafetyTraceGapError blocks deployment), change impact propagation (modify a requirement, see all affected tests/models/deployments), evidence collection per trace link.

Why it matters: ISO 26262 requires bidirectional traceability; manual spreadsheets don't scale and can't block deployments.

Results

Metric	Value
Model Compression	3.85x
Accuracy Retention	98%
Drift Detection Accuracy	95%
Traceability Coverage	87%
Deployment Success Rate	99.9%

Quick Start

Installation

# Clone repository
git clone https://github.com/lAteralthInklAbs/edgedeploy.git
cd edgedeploy

# Install with dev dependencies
pip install -e ".[dev]"

Run Tests

make test

Run Evaluation

# Quantization evaluation
python scripts/run_qat_eval.py --epochs 3

# Drift detection evaluation
python scripts/run_drift_eval.py

Docker

# Build image
make docker

# Run container
docker run --rm edgedeploy:latest

API Reference

Method	Path	Description	Status Codes
POST	/api/v1/models/{ver}/optimize	Start quantization job	202
GET	/api/v1/models/{ver}/trace	Get traceability report	200 / 409
POST	/api/v1/deploy/{ver}	Start canary deployment	202 / 409
GET	/api/v1/drift/report	Get drift detection report	200
GET	/api/v1/safety/readiness/{ver}	Check deployment readiness	200

Usage

Quantization

from src.optimization import QuantizationEngine, QuantizationConfig

config = QuantizationConfig(
    qat_epochs=5,
    sensitivity_threshold=0.02,
    target_compression=4.0,
)
engine = QuantizationEngine(config=config)

# Analyze layer sensitivity
sensitivities = engine.analyze_layer_sensitivity(model, dataloader)

# Run full quantization pipeline
result = engine.quantize(model, train_loader, val_loader)
print(f"Compression: {result.compression_ratio:.2f}x")
print(f"Accuracy: {result.accuracy_retention:.1%}")

Drift Detection

from src.drift import DriftEnsemble, DriftConfig
import numpy as np

# Initialize with reference data
reference = np.random.normal(0, 1, size=(1000, 5))
ensemble = DriftEnsemble(reference)

# Detect drift in new data
new_data = np.random.normal(0.5, 1, size=(1000, 5))  # Shifted!
result = ensemble.detect(new_data)

if result.drift_detected:
    print(f"Drift detected: {result.level.value}")
    print(f"PSI: {result.psi_score:.3f}, MMD: {result.mmd_score:.3f}")

Requirements Tracing

from src.safety import RequirementsTracer, Requirement, ASILLevel

tracer = RequirementsTracer()

# Add requirements
tracer.add_requirement(Requirement(
    req_id="SYS-001",
    title="Perception System Safety",
    description="99.5% obstacle detection accuracy",
    asil_level=ASILLevel.ASIL_D,
))

# Analyze traceability
report = tracer.analyze_traceability()
print(f"Compliance Score: {report.compliance_score:.1%}")
print(f"Critical Gaps: {report.critical_gaps_count}")

Canary Deployment

import asyncio
from src.deployment import CanaryDeployment, DeploymentConfig

config = DeploymentConfig(model_version="v1.2.0")
deployment = CanaryDeployment(config=config)

async def health_check():
    # Return health metrics
    return HealthCheck(
        is_healthy=True,
        success_rate=0.99,
        latency_p99_ms=80.0,
        ...
    )

# Execute deployment
result = asyncio.run(deployment.execute(health_check))
print(f"Status: {result.final_status}")

Testing

make test          # All tests with coverage
make ci            # Full CI: lint + typecheck + test

Test suite includes:

• Quantization tests — sensitivity analysis, mixed-precision assignment
• Drift detection tests — PSI, MMD, ADWIN individual and ensemble
• Traceability tests — BFS traversal, gap detection, blocking behavior
• Canary deployment tests — stage progression, rollback triggers

Coverage target: ≥75% on src/optimization/ + src/drift/ + src/safety/

Deployment

Local

docker-compose up --build

AWS

cd infra
terraform init
terraform plan
terraform apply

Resources created:

• S3 buckets for models and drift data
• SageMaker endpoint for inference
• Lambda for drift detection
• CloudWatch dashboard
• SNS alerts

Design Decisions

All major decisions documented as ADRs in docs/adr/:

ADR	Decision	Rationale
001	Per-layer sensitivity over uniform	Safety-critical layers need higher precision
002	3-detector ensemble over single metric	Different drift types need different detectors
003	Progressive canary over blue-green	Gradual rollout catches edge cases
004	Graph-based over spreadsheet	Automated blocking, scalable analysis

Evaluation Metrics

Metric	Target	Status
Model Compression	≥ 3.5x	Pass 1
Accuracy Retention	≥ 97%	Pass 1
Drift Detection Accuracy	≥ 93%	Pass 1
Traceability Coverage	≥ 85%	Pass 1
Canary Success Rate	≥ 99%	Pass 1

Roadmap (Pass 2)

• Knowledge distillation (progressive layer matching, temperature annealing)
• ASIL-driven canary policies (per-ASIL bake times and health thresholds)
• V-model phase gates
• Ground truth feedback loop (prediction sampling, drift confirmation)

Project Structure

edgedeploy/
├── src/
│   ├── optimization/      # Quantization engine
│   ├── drift/             # Drift detection ensemble
│   ├── safety/            # Requirements tracing
│   ├── deployment/        # Canary deployment
│   └── export/            # ONNX export
├── tests/                 # Test suite
├── fixtures/              # Test data
├── scripts/               # Evaluation scripts
├── configs/               # Configuration files
├── infra/                 # Terraform (AWS)
├── docs/
│   └── adr/               # Architecture Decision Records
├── .github/workflows/     # CI/CD
├── Dockerfile
├── Makefile
└── pyproject.toml

Configuration

See configs/settings.yaml for all configuration options:

quantization:
  qat_epochs: 5
  sensitivity_threshold: 0.02
  target_compression: 4.0

drift:
  psi_threshold: 0.2
  mmd_threshold: 0.1
  persistence_required: 3

deployment:
  enable_auto_rollback: true
  stages:
    - name: canary
      traffic_percentage: 5.0

Tech Stack

• Language: Python 3.11+
• ML Framework: PyTorch 2.0+
• Export: ONNX/ONNXRuntime
• Cloud: AWS (S3, SageMaker, Lambda)
• IaC: Terraform
• Testing: pytest, Hypothesis
• Type Checking: mypy
• Linting: ruff

License

MIT — see LICENSE

---

Built for automotive ML deployment with safety in mind.