Why This Guide Exists

Step 2: Feature Engineering — The Signal Kitchen Sink

Tier 1: Core Pricing Features

These are the GLM factors you’ll calibrate later. The ML part extracts signals from them.

• age, gender, marital_status
• zip3 (3-digit ZIP for territory granularity)
• vehicle_age, vehicle_value, vehicle_symbol
• limit_liability, limit_comp
• years_licensed, mvr_points
• credit_score_tier (FICO 8, VantageScore 4)

Tier 2: External Signals

These are the ML differentiators. Treat them as “feature candidates” until you prove lift.

• property_age (from public records)
• crime_score_zip3 (neighborhood risk)
• telematics_risk_score (aggregated from trip data)
• bureau_mvr_count_last3y
• iso_protection_class
• flood_zone (FEMA data)
• fire_district_score (ISO fire suppression)

Tier 3: Interaction & Derived Features

Build these in a feature store. Do not recalc on every model run.

• age_times_credit_score (nonlinear term)
• vehicle_value_over_limit (exposure signal)
• years_licensed_over_vehicle_age (young driver penalty attenuation)
• territory_crime_times_vehicle_symbol (high crime + flashy car interaction)

Temporal Features (The Silent Killer)

Your loss data is time-dependent. If you don’t encode time explicitly, your model will learn spurious trends.

• policy_effective_year (categorical)
• vintage_month (policy age in months)
• inflation_adj_factor (claims paid vs. CPI)
• cat_event_flag (CAT year dummy)

Code Snippet: Feature Store Ingestion (Python)

import pandas as pd
from feast import FeatureStore

# Load policy data with features
policy_df = pd.read_parquet("data/policy_master_clean.parquet")

# Define features
features = {
    "driver": ["age", "gender", "credit_score_tier"],
    "vehicle": ["vehicle_age", "vehicle_value", "vehicle_symbol"],
    "territory": ["zip3", "crime_score_zip3", "flood_zone"],
    "temporal": ["policy_effective_year", "vintage_month"]
}

# Initialize Feast and push to online store
fs = FeatureStore(repo_path="feature_repo")
fs.materialize_incremental("2024-01-01")

Resource estimate: 1 FTE data scientist + 0.5 FTE engineer for 6 weeks. Budget: $15k (Feast cloud tier).

Step 3: Target Construction — The Art of Defining “Good”

Option A: Pure Loss Ratio Target (Simple, Risky)

Target = incurred losses / earned premium. Problem: noisy at policy level, sensitive to reserve changes. Regulators hate it.

Option B: Loss Cost Plus LAE (Recommended)

Target = (incurred_loss + allocated_LAE) / on_level_exposure. Why?

• LAE is a real cost you can’t ignore.
• On-level exposure adjusts premium to current rates (removes rate change noise).
• Auditors prefer it because it’s close to the GLM target.

Option C: Pure Premium (Hybrid)

Target = (paid_loss + allocated_LAE) / earned_exposure. Use when you have lag in incurred data. Problem: understates tail risk.

Data Leakage Pitfall

Never include future claims in target construction. Even a 3-month lag can leak information if you’re not careful. In 2022, a carrier’s model leaked because they used “claims closed within 6 months” as target and trained on policies written 9 months ago. Their validation LR was 85%; production was 112%.

Step 4: Model Selection — GLM vs. Hybrid vs. Pure ML

3–5 hours (GLM) +

1–2 hours (ML)

My recommendation: start with a hybrid GLM-ML ensemble. Use GLM as the base, then train an XGBoost residual model on (actual LR - GLM predicted LR). At inference, clip residuals to ±20% to prevent wild swings. This keeps the model monotonic and auditable while extracting 3–5 points of lift.

Step 5: Training Pipeline — The Three-Bucket Split

Bucket 1: Training (70% of data)

Use policy data from 5+ years ago to capture claim development. Exclude the most recent 12 months (they’re still developing).

Bucket 2: Validation (15%)

Use data from 24–12 months ago. This is your “as if” period—you’ll compare model predictions to actual loss costs in this window.

Bucket 3: Holdout (15%)

Use the most recent 12 months. This is your bleeding edge—your model should not overfit to recent CAT activity.

Code Snippet: Splitting Logic

from sklearn.model_selection import train_test_split

# Define time split
train_end = pd.Timestamp("2021-12-31")
val_end = pd.Timestamp("2022-12-31")

train = policy_df[policy_df["policy_effective_date"] <= train_end]
val = policy_df[(policy_df["policy_effective_date"] > train_end) &
                (policy_df["policy_effective_date"] <= val_end)]
test = policy_df[policy_df["policy_effective_date"] > val_end]

# Stratify by state and coverage to avoid skew
train, _ = train_test_split(train, test_size=0.3, stratify=train[["state", "coverage"]])

Step 6: GLM Baseline — The “Nothing Breaks” Model

Before touching ML, build a GLM that matches your current rate manual. This is your baseline and your rollback plan.

Steps

1. Start with Poisson GLM with log link.
2. Use statsmodels for interpretability. Later, port to scikit-learn for pipeline consistency.
3. Enforce monotonicity on key factors: age, credit_score_tier, vehicle_age.
4. Fit on loss cost + LAE / on-level exposure.
5. Compare actual vs. predicted LR by state-coverage. If any cell deviates >15%, investigate (data error, filing error, or missing factor).

Code Snippet: GLM Monotonic Constraints

import statsmodels.api as sm
import statsmodels.formula.api as smf

# Define formula with monotonic terms
formula = (
    "loss_cost ~ age + C(gender) + credit_score_tier + "
    "vehicle_age + vehicle_value + zip3 + "
    "C(coverage) + C(state)"
)

# Fit with constraints
mod = smf.glm(
    formula,
    data=train,
    family=sm.families.Poisson(),
    var_weights=train["on_level_exposure"]
)
result = mod.fit_constrained({
    "age": "age >= 0",  # Implicit monotonic
    "credit_score_tier": "credit_score_tier >= 0",
    "vehicle_age": "vehicle_age >= 0"
})

Resource estimate: 1 FTE actuary for 2 weeks. Budget: $5k.

Step 7: Hybrid Ensemble — The ML Lift Layer

Step 7.1: Residual Target

Compute residual = actual_loss_ratio - glmm_predicted_loss_ratio.

Truncate residuals to [-0.2, 0.2] to prevent wild swings in rating.

Step 7.2: Feature Selection

Use SHAP to rank features. Keep only those with SHAP importance >0.01. In practice, this reduces feature count from 45 to 12–15.

Step 7.3: Model Training

Train XGBoost on residuals with:

• Objective: reg:squarederror
• Max depth: 6
• Learning rate: 0.05
• Subsample: 0.8
• Early stopping on validation set (patience=10)

Step 7.4: Calibration

Scale predictions to match the GLM’s expected loss ratio. Formula:

final_prediction = glmm_prediction * (1 + residual_prediction)

Code Snippet: Hybrid Inference

import xgboost as xgb
import joblib

# Load models
glmm = joblib.load("models/glmm_baseline.joblib")
xgb_model = xgb.Booster()
xgb_model.load_model("models/residual_xgb.json")

def predict_hybrid(policy_data):
    # GLM prediction (in log space)
    glmm_pred = glmm.predict(policy_data)

    # ML residual prediction
    ml_features = policy_data[ml_feature_list]
    dmatrix = xgb.DMatrix(ml_features)
    residual_pred = xgb_model.predict(dmatrix)

    # Clip residual to prevent wild swings
    residual_pred = np.clip(residual_pred, -0.2, 0.2)

    # Final prediction
    final_pred = glmm_pred * (1 + residual_pred)
    return final_pred

Step