epi-modeling

name	epi-modeling
description	Compartmental epidemic modeling (SIR/SEIR/SEIHR) with parameter fitting, Rt estimation, age-structured models, and sensitivity analysis.
tags	["epidemiology","seir","compartmental-model","rt-estimation","public-health","scipy"]
version	1.0.0
authors	[{"name":"awesome-rosetta-skills contributors","github":"@awesome-rosetta-skills"}]
license	MIT
platforms	["claude-code","codex","gemini-cli","cursor"]
dependencies	["numpy>=1.24.0","scipy>=1.11.0","pandas>=2.0.0","matplotlib>=3.7.0","numba>=0.57.0"]
last_updated	2026-03-17

Epidemic Compartmental Modeling Skill

This skill covers the mathematical and computational workflow for building, fitting, and analysing compartmental epidemic models in Python. Starting from classic SIR and SEIR formulations, it extends to age-structured models, hospitalisation compartments (SEIHR), real-time reproduction number estimation, and global sensitivity analysis via Partial Rank Correlation Coefficients (PRCC).

All numerical integration is done with scipy.integrate.solve_ivp using the Radau solver, which handles stiff ODE systems arising from wide parameter ranges common in outbreak modeling.

---

Setup

pip install numpy scipy pandas matplotlib numba

---

Core Functions

"""
epi_modeling.py
---------------
Compartmental epidemic model utilities: SIR, SEIR, SEIHR, Rt estimation,
parameter fitting, age-structured models, and sensitivity analysis.
"""

from __future__ import annotations

import warnings
from typing import Callable, Dict, List, Optional, Tuple, Union

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from scipy.integrate import solve_ivp
from scipy.optimize import minimize, differential_evolution
from scipy.stats import pearsonr, spearmanr

warnings.filterwarnings("ignore", category=RuntimeWarning)


# ---------------------------------------------------------------------------
# 1. SEIR Model
# ---------------------------------------------------------------------------

def () -> :
    
     () -> []:
        S, E, I, R = y
        force_of_infection = beta * S * I / N
        dS = mu * (N - S) - force_of_infection
        dE = force_of_infection - (sigma + mu) * E
        dI = sigma * E - (gamma + mu) * I
        dR = gamma * I - mu * R
         [dS, dE, dI, dR]

    seir_ode.__doc__ = (
                        )
     seir_ode


 () -> :
    
     ():
        S, I, R = y
        foi = beta * S * I / N
         [-foi, foi - gamma * I, gamma * I]

     sir_ode


 () -> :
    
     ():
        S, E, I, H, R = y
        foi = beta * S * I / N
        dS = -foi
        dE = foi - sigma * E
        dI = sigma * E - gamma * I
        dH = hosp_rate * gamma * I - gamma_h * H
        dR = ( - hosp_rate) * gamma * I + gamma_h * H
         [dS, dE, dI, dH, dR]

     seihr_ode






 () -> :
    
    T = (incidence)
    t_eval = np.arange(T)

    
    I0 = 
    S0 = N - I0 - initial_exposed
    param_names = (param_bounds.keys())
    bounds_list = [param_bounds[k]  k  param_names]

     ():
        kwargs = ((param_names, params_vec))
        kwargs[] = N
        :
            ode = model_func(**kwargs)
         TypeError:
             

        y0_len = ode.__code__.co_varcount -   
        
        n_states =     (ode, , ).lower()  
           (model_func, , ).lower():
            n_states = 

        y0_map = {
            : [S0,             I0, ],
            : [S0, initial_exposed, I0, ],
            : [S0, initial_exposed, I0, , ],
        }
        y0 = y0_map.get(n_states, [S0, initial_exposed, I0, ])

        :
            sol = solve_ivp(
                ode, [, T - ], y0,
                t_eval=t_eval, method=,
                max_step=, dense_output=,
            )
              sol.success:
                 
            
            cumulative = sol.y[compartment_idx - ] + sol.y[compartment_idx]
            modelled = np.maximum(np.diff(cumulative, prepend=cumulative[]), )
             (np.sqrt(np.mean((modelled - incidence) ** )))
         Exception:
             

     method == :
        result = differential_evolution(
            _residuals, bounds_list,
            maxiter=, tol=, seed=,
            workers=, polish=,
        )
    :
        x0 = [(lo + hi) /   lo, hi  bounds_list]
        result = minimize(_residuals, x0, method=,
                          options={: , : })

    fitted_params = ((param_names, result.x))
    fitted_params[] = N
    ode_fitted = model_func(**fitted_params)

    n_states_f = 
    y0_final = [S0, initial_exposed, I0, ]
    sol_final = solve_ivp(
        ode_fitted, [, T - ], y0_final,
        t_eval=t_eval, method=, max_step=,
    )
    cumulative_f = sol_final.y[compartment_idx - ] + sol_final.y[compartment_idx]
    fitted_inc = np.maximum(np.diff(cumulative_f, prepend=cumulative_f[]), )

    R0 = 
       fitted_params    fitted_params:
        R0 = fitted_params[] / fitted_params[]

     {
        : {k: v  k, v  fitted_params.items()  k != },
        : sol_final,
        : fitted_inc,
        : result.fun,
        : R0,
    }






 () -> pd.DataFrame:
    
     scipy.stats  gamma  gamma_dist

    T = (incidence)
    
    cv2 = (si_sd / si_mean) ** 
    k =  / cv2          
    theta = si_mean * cv2  

    rt_vals   = np.full(T, np.nan)
    rt_lower  = np.full(T, np.nan)
    rt_upper  = np.full(T, np.nan)
    r_vals    = np.full(T, np.nan)

    inc_smooth = pd.Series(incidence).rolling(window, center=,
                                               min_periods=).mean().values

     t  (window, T - window):
        segment = inc_smooth[t - window:t + window + ]
         np.(segment <= )  np.(np.isnan(segment)):
            
        
        log_inc = np.log(segment + )
        time_idx = np.arange((segment)) - window
        slope, intercept = np.polyfit(time_idx, log_inc, )
        r = slope

        
        rt = ( + r * theta) ** k
        
        boot_rt = []
        rng = np.random.default_rng(t)
         _  ():
            noise = rng.normal(,  * np.(r) + , (segment))
            log_b = log_inc + noise
            b_slope, _ = np.polyfit(time_idx, log_b, )
            boot_rt.append(( + b_slope * theta) ** k)
        rt_lower[t] = (, np.quantile(boot_rt, quantiles[]))
        rt_upper[t] = np.quantile(boot_rt, quantiles[])
        rt_vals[t]  = rt
        r_vals[t]   = r

    df = pd.DataFrame({
        : rt_vals,
        : rt_lower,
        : rt_upper,
        : r_vals,
        : ~np.isnan(rt_vals),
    })
     df






 () -> plt.Figure:
    
    n_panels =   rt_df     
    fig, axes = plt.subplots(n_panels, , figsize=(,  * n_panels),
                             sharex=)
     n_panels == :
        axes = [axes]

    ax = axes[]
    ax.bar(dates, cases, color=, alpha=, label=, width=)
     model_output   :
        ax.plot(dates, model_output, color=, linewidth=,
                label=)
    ax.set_ylabel()
    ax.set_title(title, fontsize=)
    ax.legend()
    ax.xaxis.set_major_formatter(mdates.DateFormatter())
    ax.xaxis.set_major_locator(mdates.MonthLocator())

     rt_df   :
        ax2 = axes[]
        valid = rt_df[]
        ax2.plot(np.array(dates)[valid], rt_df.loc[valid, ],
                 color=, linewidth=, label=)
        ax2.fill_between(
            np.array(dates)[valid],
            rt_df.loc[valid, ],
            rt_df.loc[valid, ],
            color=, alpha=, label=,
        )
        ax2.axhline(, color=, linewidth=, linestyle=)
        ax2.set_ylabel()
        ax2.set_ylim(, (, rt_df[].quantile() * ))
        ax2.legend()

    fig.autofmt_xdate()
    fig.tight_layout()

     output_path:
        fig.savefig(output_path, dpi=, bbox_inches=)
        ()

     fig






 () -> :
    
    n = (N_by_age)
    N_total = N_by_age.()

     ():
        y = np.reshape(y, (, n))
        S, E, I, R = y

        
        foi = beta * (contact_matrix @ (I / N_by_age))

        dS = -foi * S
        dE =  foi * S - sigma * E
        dI =  sigma * E - gamma * I
        dR =  gamma * I
         np.concatenate([dS, dE, dI, dR])

     ode