def train(frame, holdout_year=2025):
    check = PurePremiumModel().fit(
        frame[frame.policy_year < holdout_year])
    hold = frame[frame.policy_year == holdout_year]
    pp = check.pure_premium(hold)
    metrics = {
        "holdout_actual_to_expected":
            hold.inc_liab.sum() / (pp * hold.exposure).sum(),
        "holdout_gini": gini(hold.inc_liab, pp, hold.exposure)}
    model = PurePremiumModel().fit(frame)     # all five years
    return model, metrics

saved glm-dcbe5b5dbb to models/champion
  holdout_year: 2025
  holdout_actual_to_expected: 1.0143
  holdout_gini: 0.2753
  trained_rows: 84346
  trained_car_years: 72,780.5092
  trained_claims: 4565

{
  "name": "motor-liability-glm",
  "version": "glm-dcbe5b5dbb",
  "sha256": "dcbe5b5dbbc32b2e72874ee7c05421e6...",
  "created_at": "2026-09-30T14:54:51+00:00",
  "sklearn_version": "1.9.1",
  "features": ["vehicle_style", "driver_age",
               "urban", "annual_mileage"],
  "metrics": {
    "holdout_year": 2025,
    "holdout_actual_to_expected": 1.0143,
    "holdout_gini": 0.2753,
    "trained_rows": 84346,
    "trained_claims": 4565
  }
}

def load(directory):
    manifest = json.loads((directory / "manifest.json").read_text())
    if sha256(directory / "model.joblib") != manifest["sha256"]:
        raise ModelIntegrityError("does not match its manifest "
                                  "checksum: refusing to load")
    if sklearn_major_minor() != manifest_major_minor(manifest):
        raise ModelIntegrityError("model trained with "
                                  "scikit-learn 0.24.2, ...")
    return joblib.load(directory / "model.joblib"), manifest

def promote(champion, challenger) -> bool:
    return (0.95 <= challenger["ae"] <= 1.05
            and challenger["gini"] >= champion["gini"] + 0.005
            and challenger["tests_passed"])

jobs:
  checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: astral-sh/setup-uv@v10
      - run: uv sync --locked
      - run: uv run ruff check . && uv run mypy src tests
      - run: uv run pytest --cov
  images:
    needs: checks
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: docker/setup-buildx-action@v4
      - uses: docker/build-push-action@v7
        with: {target: api, tags: "rating-api:ci", load: true,
               cache-from: type=gha, cache-to: "type=gha,mode=max"}
      - uses: docker/build-push-action@v7
        with: {target: portal, tags: "rating-portal:ci"}
      - name: Smoke test the API container
        run: |
          docker run -d -p 8000:8000 -e RP_API_KEY=ci-key \
            -e RP_DATABASE_URL=sqlite:////tmp/ci.db rating-api:ci
          # wait for /health, POST a quote, check the user is "app"

BINS = {"driver_age": [16, 25, 30, 65, 75, 121],   # manual bands
        "annual_mileage": [0, 7_500, 15_000, float("inf")],
        "vehicle_style": None, "urban": None}      # categories

def psi(reference, current, floor=1e-4):
    ref, cur = reference.align(current, fill_value=0.0)
    ref, cur = ref.clip(lower=floor), cur.clip(lower=floor)
    return float(((cur - ref) * np.log(cur / ref)).sum())

@app.get("/monitoring/drift")
def drift(s: Db, last: int = 1_000):
    """PSI of the last `last` quote requests against the
    in-force book."""

• My model is an artifact with a checksum and a manifest
• The service refuses a model it can’t verify
• Promotion follows a written rule
• Images are built only from code that passed its checks

• A smoke test runs the real image
• Every quote records the model version
• Input drift is measured and alerted on
• I can roll back, and know what each version priced