Skip to content

Evidence

This section collects tangible proof that the system works as described. It is the verification layer — where architecture claims are backed by artifacts.

What is proved by this project

Claim Proof
Pipeline is reproducible dvc repro from clean checkout produces same model; DVC lock + MLflow run IDs.
Validation is leakage-safe Property tests with hypothesis verify rolling features don't see future data.
Inference API is live curl POST /predict returns probabilities with latency ~20ms p50.
Model is tracked and versioned MLflow run IDs, parameter logs, and registry aliases in mlruns/.
Tests cover behaviour contracts pytest tests/ — 316 tests: unit / property / service / contract / load.
Infrastructure is code Docker, K8s manifests, Helm charts, GitLab CI pipeline — all in repo.
Secrets are encrypted SOPS + age; encrypted files committed to repo; no plaintext credentials.

Evidence map by competency

Competency Evidence page Key artifact
Reproducibility MLflow Evidence MLflow run IDs; dvc status output
Validation rigor System Proofs pytest tests/property/ output; DVC split artifacts
Serving design Serving Evidence Live API responses; GET /metrics output
Deployment readiness System Proofs kubectl get pods output; Helm release
Observability thinking Monitoring Evidence Prometheus metrics; runbook links
Operational maturity System Proofs Test output; CI pipeline pass
System thinking Architecture docs C4 diagrams; ADRs; layer contracts

Strongest artifacts

  1. dvc dag + dvc status — proves pipeline is defined and reproducible
  2. MLflow experiment UI — shows tracked runs, parameters, metrics, model versions
  3. POST /predict response — proves model is loaded and serving
  4. pytest tests/ -q output — proves 316 tests pass
  5. kubectl get pods -n soccer — proves deployment is live
  6. GET /metrics response — proves Prometheus instrumentation is active

For a quick proof check (5 min): 1. Implementation Status — what exists vs. what's planned 2. MLflow Evidence — experiment runs and model registry 3. Serving Evidence — live API call example

For a complete review (20 min): 1. System Proofs — infrastructure and pipeline running 2. MLflow Evidence — training discipline 3. Serving Evidence — API contract and behaviour 4. Monitoring Evidence — observability coverage 5. Lessons Learned — retrospective and honest limitations

How to verify locally

# Reproduce the ML pipeline from scratch
git clone <repo> && cd soccer
dvc pull
dvc repro
mlflow ui --backend-store-uri ./mlruns --port 5001

# Run all tests
pytest tests/ -q

# Check serving (if API is running)
curl http://api.time2bet.ru/healthcheck/
curl -X POST http://api.time2bet.ru/v1/predict \
  -H "Content-Type: application/json" \
  -d '{"home_team":"Arsenal","away_team":"Chelsea","match_date":"2025-05-10","league":"premier_league"}'

Evidence pages

Page Contents
System Proofs K8s pods, DVC dag, pipeline state, test output
MLflow Evidence Experiment runs, metrics, model registry screenshots
Serving Evidence API responses, latency, endpoint behaviour
Monitoring Evidence Prometheus metrics, coverage gaps
Lessons Learned Retrospective: what was hard, what I'd change
Evaluation Reports Quarto-rendered EDA, model comparison, ablation