💼 Insurance AI Applications

# Insurance Underwriting System - Neuro-Symbolic

import pandas as pd
import numpy as np

class InsuranceUnderwriter:
    def __init__(self):
        self.risk_model = self._load_neural_model()  # Pre-trained ML model
        self.underwriting_rules = self._define_rules()
        self.claims_knowledge_graph = self._build_kg()

    def _define_rules(self):
        """Define underwriting rules"""
        return {
            'max_age': 85,
            'min_age': 18,
            'excluded_conditions': ['stage_4_cancer', 'terminal_illness'],
            'premium_bounds': {'min': 50, 'max': 5000},
            'high_risk_factors': {
                'smoking': 1.5,      # 50% premium increase
                'diabetes': 1.3,
                'heart_disease': 2.0,  # 100% increase
                'prior_accidents': 1.2
            }
        }

    def evaluate_application(self, applicant):
        """
        Full underwriting pipeline:
        Neural risk prediction + Symbolic rule enforcement
        """
        # Step 1: Check hard constraints (symbols)
        if applicant['age'] > self.underwriting_rules['max_age']:
            return {
                'decision': 'DENY',
                'reason': 'Age exceeds maximum',
                'override': False
            }

        if applicant['condition'] in self.underwriting_rules['excluded_conditions']:
            return {
                'decision': 'DENY',
                'reason': 'Excluded medical condition',
                'override': False
            }

        # Step 2: Neural risk prediction
        features = self._extract_features(applicant)
        base_risk = self.risk_model.predict(features)[0]
        base_premium = self._risk_to_premium(base_risk)

        # Step 3: Apply risk adjustments (symbols)
        adjusted_premium = base_premium
        adjustments = []

        for condition, multiplier in self.underwriting_rules['high_risk_factors'].items():
            if applicant.get(condition, False):
                adjusted_premium *= multiplier
                adjustments.append(f'{condition}: {(multiplier-1)*100:.0f}% increase')

        # Step 4: Check premium bounds
        final_premium = max(
            self.underwriting_rules['premium_bounds']['min'],
            min(adjusted_premium, self.underwriting_rules['premium_bounds']['max'])
        )

        # Step 5: Decision
        return {
            'decision': 'APPROVE',
            'base_premium': base_premium,
            'adjusted_premium': adjusted_premium,
            'final_premium': final_premium,
            'adjustments': adjustments,
            'risk_level': self._categorize_risk(base_risk),
            'terms': self._generate_terms(applicant, final_premium)
        }

    def _generate_terms(self, applicant, premium):
        """Generate policy terms"""
        terms = {
            'coverage_type': 'standard',
            'deductible': 500,
            'co_insurance': 0.20
        }

        # High-risk customers get stricter terms
        if applicant.get('heart_disease'):
            terms['coverage_exclusions'] = ['cardiac procedures > $500k']

        return terms