Add predict interval and tests, add files for CI/CD

Author: OpenActuarial

.github/workflows/ci.yml

@@ -0,0 +1,53 @@
+# Generated from the shared OpenActuarial CI template -- keep the five
+# package repos' copies identical (edit the template, regenerate, commit).
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+      - name: Test
+        run: pytest -q
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: python -m pip install ruff
+      - run: ruff check src tests examples
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build sdist and wheel
+        run: |
+          python -m pip install --upgrade pip build twine
+          python -m build
+          twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

.github/workflows/release.yml

@@ -0,0 +1,56 @@
+# Tag-driven release via PyPI Trusted Publishing (no tokens, no twine
+# passwords). One-time setup per package:
+#   1. On PyPI: project -> Publishing -> add a Trusted Publisher:
+#      owner OpenActuarial, repository ratingmodels, workflow release.yml,
+#      environment pypi.
+#   2. On GitHub: repo Settings -> Environments -> create "pypi".
+# Then:  git tag v{version} && git push --tags
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: |
+          python -m pip install --upgrade pip build twine
+          python -m build
+          twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    needs: publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Extract latest changelog section
+        run: |
+          awk '/^## /{n++} n==1' CHANGELOG.md > release_notes.md
+      - uses: softprops/action-gh-release@v2
+        with:
+          body_path: release_notes.md

CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.7.0 - 2026-07-05
+
+Frequency-severity parity with the GLM layer's uncertainty surface.
+
+### Added
+- **Frequency-severity prediction intervals.**
+  `FrequencySeverityModel.predict_interval` -- the same delta-method
+  interval `GLMRelativities` has, for the composite: log-scale variances
+  of the two component linear predictors add, under the stated (and it
+  is an assumption, stated as such) independence of the frequency and
+  severity coefficient estimates. `predicted` equals
+  `pure_premium_prediction` exactly; switching from a GLM to a
+  frequency-severity model no longer silently loses uncertainty.
+## 0.6.1 - 2026-07-04
+
+### Added
+- **Frequency-severity interactions.** `FrequencySeverityModel.fit`
+  gains `frequency_interactions` / `severity_interactions` (severity
+  defaults to the frequency list, mirroring the predictor convention),
+  threading straight through to the component GLMs. Categorical x
+  categorical cells surface in `combined_relativities()` under an
+  `"a:b"` key with a MultiIndex of level pairs (`combined` = frequency x
+  severity per cell; a component without the interaction contributes
+  1.0); `to_factor_tables()` excludes interactions like the GLM does, and
+  `RatingPlan.from_model` warns accordingly.
 ## 0.6.0 - 2026-07-04
 
 Validation and implementation release: a fitted model is now inspectable,

README.md

@@ -1,5 +1,7 @@
 # ratingmodels
 
+[![CI](https://github.com/OpenActuarial/ratingmodels/actions/workflows/ci.yml/badge.svg)](https://github.com/OpenActuarial/ratingmodels/actions/workflows/ci.yml) [![PyPI](https://img.shields.io/pypi/v/ratingmodels)](https://pypi.org/project/ratingmodels/)
+
 **Actuarial pricing and rate-indication tools for experience-rated insurance portfolios.**
 
 `ratingmodels` covers the group rating workflow — the step that turns experience

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ratingmodels"
-version = "0.6.1"
+version = "0.7.0"
 description = "Rating and pricing models: manual and experience rate build-up, credibility blending, rate indications and decomposition, GLM relativities and evaluation, and pricing scenarios."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -38,7 +38,7 @@ classifiers = [
 dependencies = [
     "numpy>=1.22",
     "pandas>=1.4",
-    "actuarialpy~=0.39.0",
+    "actuarialpy~=0.40.0",
     "statsmodels>=0.14",
 ]
 

src/ratingmodels/freqsev.py

@@ -199,6 +199,65 @@ def pure_premium_prediction(
         """
         return self.frequency_prediction(data, exposure=exposure) * self.severity_prediction(data)
 
+    def predict_interval(
+        self,
+        data: pd.DataFrame,
+        confidence_level: float = 0.95,
+        exposure: str | None = None,
+    ) -> pd.DataFrame:
+        r"""Predicted pure premium with its confidence interval, per row.
+
+        The pure premium is :math:`\exp(\eta_f + \eta_s)`; on the log
+        scale the variances of the two component linear predictors add,
+        *assuming the frequency and severity coefficient estimates are
+        independent* -- the standard frequency-severity assumption (the
+        two GLMs are fit to different responses), stated here because it
+        is an assumption, not a theorem. The interval is for the *mean*
+        pure premium of a cell, not for an individual outcome; individual
+        losses vary enormously more than their expectation.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Index-aligned with ``data``; columns ``predicted``, ``ci_low``,
+            ``ci_high``. With ``exposure``, all three are on the total
+            scale. ``predicted`` equals :meth:`pure_premium_prediction`
+            exactly.
+        """
+        self._check_fit()
+        from statistics import NormalDist
+
+        for name, model in (("frequency", self.frequency),
+                            ("severity", self.severity)):
+            if model.cov_params_ is None:
+                raise RuntimeError(
+                    f"{name} model has no coefficient covariance "
+                    "(rank-deficient design); no interval is available"
+                )
+        if not 0 < confidence_level < 1:
+            raise ValueError("confidence_level must be in (0, 1)")
+        z = NormalDist().inv_cdf(0.5 + confidence_level / 2.0)
+        eta = np.zeros(len(data))
+        var = np.zeros(len(data))
+        for model in (self.frequency, self.severity):
+            x = model._design_matrix_from_info(data)
+            eta += x @ model.coefficients_.to_numpy()
+            var += np.einsum("ij,jk,ik->i", x, model.cov_params_.to_numpy(), x)
+        se = np.sqrt(np.maximum(var, 0.0))
+        out = pd.DataFrame(
+            {
+                "predicted": np.exp(np.clip(eta, -30, 30)),
+                "ci_low": np.exp(np.clip(eta - z * se, -30, 30)),
+                "ci_high": np.exp(np.clip(eta + z * se, -30, 30)),
+            },
+            index=data.index,
+        )
+        if exposure is not None:
+            expo = data[exposure].to_numpy(dtype=float)
+            for col in out.columns:
+                out[col] = out[col] * expo
+        return out
+
     # ----- combined structure ----- #
     @property
     def base_value_(self) -> float:

tests/test_freqsev_interactions.py

@@ -80,3 +80,35 @@ def test_to_factor_tables_excludes_interactions_and_plan_warns(fitted):
     assert set(model.to_factor_tables()) == {"area", "ind"}
     with pytest.warns(UserWarning, match="interaction terms"):
         rm.RatingPlan.from_model(model)
+
+
+def test_predict_interval_identities(fitted):
+    df, model = fitted
+    head = df.head(40)
+    pi = model.predict_interval(head, exposure="exposure")
+    np.testing.assert_allclose(
+        pi["predicted"],
+        model.pure_premium_prediction(head, exposure="exposure"),
+        rtol=1e-12,
+    )
+    assert (pi["ci_low"] < pi["predicted"]).all()
+    assert (pi["predicted"] < pi["ci_high"]).all()
+    # log-scale variance is exactly the sum of the component variances:
+    # reconstruct from the two submodel intervals
+    z = 1.959963984540054
+    hf = np.log(model.frequency.predict_interval(head)["ci_high"]
+                / model.frequency.predict_interval(head)["predicted"]) / z
+    hs = np.log(model.severity.predict_interval(head)["ci_high"]
+                / model.severity.predict_interval(head)["predicted"]) / z
+    combined = np.log(pi["ci_high"] / pi["predicted"]) / z
+    np.testing.assert_allclose(combined, np.sqrt(hf**2 + hs**2), rtol=1e-10)
+    # exposure scales all three columns linearly
+    per_unit = model.predict_interval(head)
+    np.testing.assert_allclose(
+        pi["ci_low"], per_unit["ci_low"] * head["exposure"], rtol=1e-12)
+
+
+def test_predict_interval_guards(fitted):
+    df, model = fitted
+    with pytest.raises(ValueError, match="confidence_level"):
+        model.predict_interval(df.head(), confidence_level=1.5)