lossmodels 0.1.0__tar.gz

lossmodels-0.1.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: lossmodels
+Version: 0.1.0
+Summary: A Python library for actuarial loss modeling using frequency-severity methods.
+Author: Michael Bryant
+License: MIT
+Project-URL: Homepage, https://github.com/michaelabryant/lossmodels
+Project-URL: Repository, https://github.com/michaelabryant/lossmodels
+Project-URL: Issues, https://github.com/michaelabryant/lossmodels/issues
+Keywords: actuarial,insurance,risk,statistics,simulation,loss modeling,frequency severity
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.8
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+
+# lossmodels
+
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue)]()
+[![License](https://img.shields.io/badge/license-MIT-green)]()
+
+A Python library for actuarial loss modeling using frequency–severity methods.
+
+---
+
+## Overview
+
+`lossmodels` provides a clean, modular implementation of core actuarial techniques from *Loss Models: Data to Decisions* (Klugman, Panjer, Willmot), including:
+
+- frequency–severity modeling
+- aggregate loss modeling (simulation, Panjer recursion, FFT)
+- parameter estimation (MLE, method of moments)
+- credibility theory
+- risk measurement (VaR, TVaR, stop-loss)
+
+Designed for:
+- actuaries and actuarial analysts
+- quantitative developers
+- data scientists in insurance
+
+---
+
+## Quick Example
+
+```python
+from lossmodels.frequency import Poisson
+from lossmodels.severity import Lognormal
+from lossmodels.aggregate import CollectiveRiskModel
+
+freq = Poisson(lam=2.0)
+sev = Lognormal(mu=10.0, sigma=0.8)
+
+model = CollectiveRiskModel(freq, sev)
+
+print("Mean:", model.mean())
+print("VaR 95%:", model.var(0.95))
+print("TVaR 95%:", model.tvar(0.95))
+```
+
+---
+
+## Installation
+
+```bash
+pip install lossmodels
+```
+
+Or for development:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Core Features
+
+### Frequency Models
+- Poisson
+- Negative Binomial
+- Binomial
+- Geometric
+- Empirical frequency
+
+### Severity Models
+- Exponential
+- Gamma
+- Lognormal
+- Pareto
+- Weibull
+- Empirical severity
+
+### Aggregate Modeling
+- Monte Carlo simulation
+- Panjer recursion
+- FFT (Fast Fourier Transform)
+
+### Estimation
+- Maximum Likelihood Estimation (MLE)
+- Method of Moments
+- Generic numerical MLE
+
+### Model Selection
+- Best severity selection (AIC / BIC)
+- Best frequency selection (Poisson, Negative Binomial)
+
+### Credibility
+- Bühlmann
+- Bühlmann–Straub
+
+### Risk Measures
+- VaR
+- TVaR
+- Stop-loss
+- Limited Expected Value (LEV)
+- PMF-based VaR / TVaR / stop-loss
+
+---
+
+## Aggregate Methods
+
+### Simulation
+
+```python
+samples = model.sample(100_000)
+```
+
+### Panjer Recursion
+
+```python
+from lossmodels.aggregate import discretize_severity, panjer_recursion
+
+pmf = discretize_severity(sev, h=0.01, max_loss=20.0)
+agg = panjer_recursion(freq, pmf, n_steps=5000)
+```
+
+### FFT
+
+```python
+from lossmodels.aggregate import fft_aggregate_poisson
+
+agg = fft_aggregate_poisson(freq, pmf, n_steps=5000)
+```
+
+---
+
+## Risk Measures from PMF
+
+```python
+from lossmodels.aggregate import var_from_pmf, tvar_from_pmf
+
+var95 = var_from_pmf(agg, h=0.01, q=0.95)
+tvar95 = tvar_from_pmf(agg, h=0.01, q=0.95)
+```
+
+---
+
+## Parameter Estimation
+
+```python
+from lossmodels.estimation import fit_lognormal, fit_best_severity
+
+model = fit_lognormal(data)
+best = fit_best_severity(data)
+```
+
+---
+
+## Examples
+
+See the `examples/` directory:
+
+- `fit_and_compare_models.py`
+- `panjer_vs_simulation.py`
+- `panjer_vs_fft_vs_simulation.py`
+- `credibility_example.py`
+
+---
+
+## Testing
+
+```bash
+pytest -v
+```
+
+Fast tests only:
+
+```bash
+pytest -v -m "not slow"
+```
+
+---
+
+## Project Status
+
+Core *Loss Models* functionality is implemented.
+
+Planned improvements:
+- Extreme Value Theory (EVT)
+- Bootstrap methods
+- Performance optimization
+- Additional distributions
+- Documentation
+
+---
+
+## License
+
+MIT License

lossmodels-0.1.0/README.md

@@ -0,0 +1,193 @@
+# lossmodels
+
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue)]()
+[![License](https://img.shields.io/badge/license-MIT-green)]()
+
+A Python library for actuarial loss modeling using frequency–severity methods.
+
+---
+
+## Overview
+
+`lossmodels` provides a clean, modular implementation of core actuarial techniques from *Loss Models: Data to Decisions* (Klugman, Panjer, Willmot), including:
+
+- frequency–severity modeling
+- aggregate loss modeling (simulation, Panjer recursion, FFT)
+- parameter estimation (MLE, method of moments)
+- credibility theory
+- risk measurement (VaR, TVaR, stop-loss)
+
+Designed for:
+- actuaries and actuarial analysts
+- quantitative developers
+- data scientists in insurance
+
+---
+
+## Quick Example
+
+```python
+from lossmodels.frequency import Poisson
+from lossmodels.severity import Lognormal
+from lossmodels.aggregate import CollectiveRiskModel
+
+freq = Poisson(lam=2.0)
+sev = Lognormal(mu=10.0, sigma=0.8)
+
+model = CollectiveRiskModel(freq, sev)
+
+print("Mean:", model.mean())
+print("VaR 95%:", model.var(0.95))
+print("TVaR 95%:", model.tvar(0.95))
+```
+
+---
+
+## Installation
+
+```bash
+pip install lossmodels
+```
+
+Or for development:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Core Features
+
+### Frequency Models
+- Poisson
+- Negative Binomial
+- Binomial
+- Geometric
+- Empirical frequency
+
+### Severity Models
+- Exponential
+- Gamma
+- Lognormal
+- Pareto
+- Weibull
+- Empirical severity
+
+### Aggregate Modeling
+- Monte Carlo simulation
+- Panjer recursion
+- FFT (Fast Fourier Transform)
+
+### Estimation
+- Maximum Likelihood Estimation (MLE)
+- Method of Moments
+- Generic numerical MLE
+
+### Model Selection
+- Best severity selection (AIC / BIC)
+- Best frequency selection (Poisson, Negative Binomial)
+
+### Credibility
+- Bühlmann
+- Bühlmann–Straub
+
+### Risk Measures
+- VaR
+- TVaR
+- Stop-loss
+- Limited Expected Value (LEV)
+- PMF-based VaR / TVaR / stop-loss
+
+---
+
+## Aggregate Methods
+
+### Simulation
+
+```python
+samples = model.sample(100_000)
+```
+
+### Panjer Recursion
+
+```python
+from lossmodels.aggregate import discretize_severity, panjer_recursion
+
+pmf = discretize_severity(sev, h=0.01, max_loss=20.0)
+agg = panjer_recursion(freq, pmf, n_steps=5000)
+```
+
+### FFT
+
+```python
+from lossmodels.aggregate import fft_aggregate_poisson
+
+agg = fft_aggregate_poisson(freq, pmf, n_steps=5000)
+```
+
+---
+
+## Risk Measures from PMF
+
+```python
+from lossmodels.aggregate import var_from_pmf, tvar_from_pmf
+
+var95 = var_from_pmf(agg, h=0.01, q=0.95)
+tvar95 = tvar_from_pmf(agg, h=0.01, q=0.95)
+```
+
+---
+
+## Parameter Estimation
+
+```python
+from lossmodels.estimation import fit_lognormal, fit_best_severity
+
+model = fit_lognormal(data)
+best = fit_best_severity(data)
+```
+
+---
+
+## Examples
+
+See the `examples/` directory:
+
+- `fit_and_compare_models.py`
+- `panjer_vs_simulation.py`
+- `panjer_vs_fft_vs_simulation.py`
+- `credibility_example.py`
+
+---
+
+## Testing
+
+```bash
+pytest -v
+```
+
+Fast tests only:
+
+```bash
+pytest -v -m "not slow"
+```
+
+---
+
+## Project Status
+
+Core *Loss Models* functionality is implemented.
+
+Planned improvements:
+- Extreme Value Theory (EVT)
+- Bootstrap methods
+- Performance optimization
+- Additional distributions
+- Documentation
+
+---
+
+## License
+
+MIT License

lossmodels-0.1.0/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lossmodels"
+version = "0.1.0"
+description = "A Python library for actuarial loss modeling using frequency-severity methods."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "Michael Bryant" }
+]
+keywords = [
+    "actuarial",
+    "insurance",
+    "risk",
+    "statistics",
+    "simulation",
+    "loss modeling",
+    "frequency severity"
+]
+
+dependencies = [
+    "numpy>=1.22",
+    "scipy>=1.8"
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/michaelabryant/lossmodels"
+Repository = "https://github.com/michaelabryant/lossmodels"
+Issues = "https://github.com/michaelabryant/lossmodels/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+license-files = []
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+addopts = "-ra -q"
+testpaths = [
+    "tests"
+]
+markers = [
+    "slow: marks tests as slow",
+]

lossmodels-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lossmodels-0.1.0/src/lossmodels/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

lossmodels-0.1.0/src/lossmodels/aggregate/__init__.py

@@ -0,0 +1,48 @@
+from .base import AggregateModel
+from .collective import CollectiveRiskModel
+from .risk_measures import var, tvar, stop_loss, lev, exceedance_probability
+from .discretization import (
+    discretize_severity,
+    bucket_representatives,
+    mean_from_discretized_pmf,
+)
+from .panjer import (
+    panjer_recursion,
+    cdf_from_pmf,
+    mean_from_aggregate_pmf,
+)
+from .fft import (
+    fft_aggregate_poisson,
+    cdf_from_pmf_fft,
+    mean_from_aggregate_pmf_fft,
+)
+
+from .risk_measures_pmf import (
+    var_from_pmf,
+    tvar_from_pmf,
+    stop_loss_from_pmf,
+    mean_from_pmf,
+)
+
+__all__ = [
+    "AggregateModel",
+    "CollectiveRiskModel",
+    "var",
+    "tvar",
+    "stop_loss",
+    "lev",
+    "exceedance_probability",
+    "discretize_severity",
+    "bucket_representatives",
+    "mean_from_discretized_pmf",
+    "panjer_recursion",
+    "cdf_from_pmf",
+    "mean_from_aggregate_pmf",
+    "fft_aggregate_poisson",
+    "cdf_from_pmf_fft",
+    "mean_from_aggregate_pmf_fft",
+    "var_from_pmf",
+    "tvar_from_pmf",
+    "stop_loss_from_pmf",
+    "mean_from_pmf",
+]

lossmodels-0.1.0/src/lossmodels/aggregate/base.py

@@ -0,0 +1,89 @@
+import numpy as np
+from abc import ABC, abstractmethod
+
+
+class AggregateModel(ABC):
+    """
+    Base class for aggregate loss models.
+
+    All aggregate models must implement:
+    - sample
+    - mean
+    - variance
+    """
+
+    @abstractmethod
+    def sample(self, size: int = 1) -> np.ndarray:
+        """
+        Generate random samples of aggregate loss.
+        """
+        pass
+
+    @abstractmethod
+    def mean(self) -> float:
+        """
+        Expected aggregate loss.
+        """
+        pass
+
+    @abstractmethod
+    def variance(self) -> float:
+        """
+        Variance of aggregate loss.
+        """
+        pass
+
+    def std(self) -> float:
+        """
+        Standard deviation of aggregate loss.
+        """
+        return np.sqrt(self.variance())
+
+    def var(self, q: float, n_sim: int = 100_000) -> float:
+        """
+        Value-at-Risk at probability level q using simulation.
+        """
+        if not (0 < q < 1):
+            raise ValueError("q must be between 0 and 1")
+
+        samples = self.sample(n_sim)
+        return float(np.quantile(samples, q))
+
+    def tvar(self, q: float, n_sim: int = 100_000) -> float:
+        """
+        Tail Value-at-Risk at probability level q using simulation.
+        """
+        if not (0 < q < 1):
+            raise ValueError("q must be between 0 and 1")
+
+        samples = self.sample(n_sim)
+        var_q = np.quantile(samples, q)
+        tail = samples[samples > var_q]
+
+        if len(tail) == 0:
+            return float(var_q)
+
+        return float(np.mean(tail))
+
+    def stop_loss(self, d: float, n_sim: int = 100_000) -> float:
+        """
+        Expected stop-loss premium E[(S - d)+] using simulation.
+        """
+        if d < 0:
+            raise ValueError("d must be nonnegative")
+
+        samples = self.sample(n_sim)
+        return float(np.mean(np.maximum(samples - d, 0.0)))
+
+    def limited_expected_value(self, d: float, n_sim: int = 100_000) -> float:
+        """
+        Limited expected value E[min(S, d)] using simulation.
+        """
+        if d < 0:
+            raise ValueError("d must be nonnegative")
+
+        samples = self.sample(n_sim)
+        return float(np.mean(np.minimum(samples, d)))
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}()"

lossmodels-0.1.0/src/lossmodels/aggregate/collective.py

@@ -0,0 +1,85 @@
+import numpy as np
+
+from .base import AggregateModel
+from ..frequency.base import FrequencyModel
+from ..severity.base import SeverityModel
+
+
+class CollectiveRiskModel(AggregateModel):
+    """
+    Collective risk model for aggregate loss:
+
+        S = X1 + X2 + ... + XN
+
+    where:
+    - N is the claim count random variable (frequency)
+    - Xi are iid claim severities
+
+    Assumes:
+    - severities are iid
+    - N is independent of severities
+    """
+
+    def __init__(self, frequency: FrequencyModel, severity: SeverityModel):
+        self.frequency = frequency
+        self.severity = severity
+
+    def sample(self, size: int = 1) -> np.ndarray:
+        """
+        Generate random samples of aggregate loss.
+        """
+        if size <= 0:
+            raise ValueError("size must be positive")
+
+        counts = self.frequency.sample(size=size)
+        aggregate_losses = np.zeros(size, dtype=float)
+
+        for i, n_claims in enumerate(counts):
+            if n_claims > 0:
+                aggregate_losses[i] = np.sum(self.severity.sample(size=int(n_claims)))
+
+        return aggregate_losses
+
+    def mean(self) -> float:
+        """
+        E[S] = E[N] * E[X]
+        """
+        return self.frequency.mean() * self.severity.mean()
+
+    def variance(self) -> float:
+        """
+        Var(S) = E[N] Var(X) + Var(N) (E[X])^2
+        """
+        en = self.frequency.mean()
+        vn = self.frequency.variance()
+        ex = self.severity.mean()
+        vx = self.severity.variance()
+
+        return en * vx + vn * (ex ** 2)
+
+    def frequency_mean(self) -> float:
+        return self.frequency.mean()
+
+    def severity_mean(self) -> float:
+        return self.severity.mean()
+
+    def summary(self) -> dict:
+        """
+        Return a small summary of the model.
+        """
+        return {
+            "frequency_model": repr(self.frequency),
+            "severity_model": repr(self.severity),
+            "frequency_mean": self.frequency.mean(),
+            "severity_mean": self.severity.mean(),
+            "aggregate_mean": self.mean(),
+            "aggregate_variance": self.variance(),
+            "aggregate_std": self.std(),
+        }
+
+    def __repr__(self):
+        return (
+            f"CollectiveRiskModel("
+            f"frequency={repr(self.frequency)}, "
+            f"severity={repr(self.severity)})"
+        )