Tejas_Bajaj_Simulation_Q3_Q4-b.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.stats import norm, poisson, gamma\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       IDpol  ClaimNb  Exposure Area  VehPower  VehAge  DrivAge  BonusMalus   \n",
      "0  2271893.0      0.0      0.83    E       5.0    17.0     53.0        64.0  \\\n",
      "1  1111864.0      0.0      0.24    E       5.0     2.0     27.0        64.0   \n",
      "2    72908.0      0.0      0.50    E       7.0    11.0     67.0        50.0   \n",
      "3  2283027.0      0.0      0.08    B       5.0     8.0     28.0        60.0   \n",
      "4  1123838.0      0.0      0.03    A      11.0     1.0     38.0        50.0   \n",
      "\n",
      "  VehBrand   VehGas  Density Region  ClaimAmount  \n",
      "0       B2   Diesel   3317.0    R93          0.0  \n",
      "1       B3   Diesel   2740.0    R22          0.0  \n",
      "2       B3  Regular   4762.0    R93          0.0  \n",
      "3       B1   Diesel     64.0    R91          0.0  \n",
      "4       B2  Regular     16.0    R24          0.0  \n"
     ]
    }
   ],
   "source": [
    "\n",
    "data = pd.read_csv('claim_data_group5_2024.csv')\n",
    "\n",
    "\n",
    "print(data.head())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['IDpol', 'ClaimNb', 'Exposure', 'Area', 'VehPower', 'VehAge', 'DrivAge',\n",
      "       'BonusMalus', 'VehBrand', 'VehGas', 'Density', 'Region', 'ClaimAmount',\n",
      "       'RiskGroup'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Print the column names to verify them\n",
    "print(data.columns)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Group: Young, Frequency (Lambda): 0.06827379904979765, Severity Params (Alpha, Beta): 0.01964747952012325, 6207.896245220362\n",
      "Group: Young Adult, Frequency (Lambda): 0.033688506007708, Severity Params (Alpha, Beta): 0.004919542888139972, 12511.368333019273\n",
      "Group: Adult, Frequency (Lambda): 0.03744802635131487, Severity Params (Alpha, Beta): 0.0037408291068754844, 17187.687515738457\n",
      "Group: Senior, Frequency (Lambda): 0.03854398221657669, Severity Params (Alpha, Beta): 0.003988534291448176, 18055.872228309032\n",
      "Group: Elder, Frequency (Lambda): 0.04106133979015335, Severity Params (Alpha, Beta): 0.0014624172389984653, 82906.65829033543\n"
     ]
    }
   ],
   "source": [
    "\n",
    "data['RiskGroup'] = pd.cut(data['DrivAge'], bins=[18, 25, 35, 50, 65, 100], labels=['Young', 'Young Adult', 'Adult', 'Senior', 'Elder'])\n",
    "\n",
    "# frequency and severity distributions per group\n",
    "frequency_params = {}\n",
    "severity_params = {}\n",
    "\n",
    "for group, group_data in data.groupby('RiskGroup'):\n",
    "    \n",
    "    lambda_freq = group_data['ClaimNb'].mean()\n",
    "    frequency_params[group] = lambda_freq\n",
    "    \n",
    "    \n",
    "    mean_severity = group_data['ClaimAmount'].mean()\n",
    "    var_severity = group_data['ClaimAmount'].var()\n",
    "\n",
    "    \n",
    "    alpha = mean_severity**2 / var_severity\n",
    "    beta = var_severity / mean_severity\n",
    "    severity_params[group] = (alpha, beta)\n",
    "    \n",
    "    print(f\"Group: {group}, Frequency (Lambda): {lambda_freq}, Severity Params (Alpha, Beta): {alpha}, {beta}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "simulated_losses = {}\n",
    "\n",
    "for group in frequency_params.keys():\n",
    "    lambda_freq = frequency_params[group]\n",
    "    alpha, beta = severity_params[group]\n",
    "    \n",
    "    # number of claims using Poisson\n",
    "    num_claims = poisson.rvs(mu=lambda_freq, size=10000)  # Adjust the size if needed\n",
    "    \n",
    "    # Sclaim severity using Gamma\n",
    "    claim_severity = gamma.rvs(a=alpha, scale=beta, size=num_claims.sum())\n",
    "    \n",
    "    # total losses for each simulation\n",
    "    total_losses = [sum(claim_severity[i:i + n]) for i, n in enumerate(num_claims) if n > 0]\n",
    "    simulated_losses[group] = total_losses\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Expected Loss across all groups: $5.75\n",
      "Buffered Minimum Premium (10% above average expected loss): $6.33\n",
      "Risk Group: Young, Expected Loss: 1.9320508347486918, Premium: 108.6900622190589\n",
      "Risk Group: Young Adult, Expected Loss: 7.025776242479371e-06, Premium: 6.3269253554300935\n",
      "Risk Group: Adult, Expected Loss: 4.99660653802954e-27, Premium: 6.3269253554300935\n",
      "Risk Group: Senior, Expected Loss: 26.825504043565612, Premium: 1371.0392818740702\n",
      "Risk Group: Elder, Expected Loss: 0.0011897115007840772, Premium: 6.3269253554300935\n"
     ]
    }
   ],
   "source": [
    "# expected losses for each group \n",
    "expected_losses = {}\n",
    "\n",
    "for group, losses in simulated_losses.items():\n",
    "    expected_loss = np.mean(losses)\n",
    "    expected_losses[group] = expected_loss\n",
    "\n",
    "# average expected loss across all groups\n",
    "average_expected_loss = np.mean(list(expected_losses.values()))\n",
    "buffered_minimum_premium = average_expected_loss * 1.1  # Setting a 10% buffer\n",
    "\n",
    "print(f\"Average Expected Loss across all groups: ${average_expected_loss:.2f}\")\n",
    "print(f\"Buffered Minimum Premium (10% above average expected loss): ${buffered_minimum_premium:.2f}\")\n",
    "\n",
    "# premiums with buffered minimum premium for each group\n",
    "for group, losses in simulated_losses.items():\n",
    "    expected_loss = np.mean(losses)\n",
    "    std_dev = np.std(losses)\n",
    "    \n",
    "    # Calculate premium based on confidence level\n",
    "    z_score = norm.ppf(confidence_level)  # 99.5% confidence level\n",
    "    premium = expected_loss + z_score * std_dev\n",
    "    \n",
    "    \n",
    "    premium = max(premium, buffered_minimum_premium)\n",
    "    premiums[group] = premium\n",
    "    \n",
    "    print(f\"Risk Group: {group}, Expected Loss: {expected_loss}, Premium: {premium}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Premiums by Risk Group:\n",
      "Young: $108.69\n",
      "Young Adult: $6.33\n",
      "Adult: $6.33\n",
      "Senior: $1371.04\n",
      "Elder: $6.33\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nPremiums by Risk Group:\")\n",
    "for group, premium in premiums.items():\n",
    "    print(f\"{group}: ${premium:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss Ratios by Risk Group:\n",
      "             TotalPremiums  TotalClaims  LossRatio\n",
      "RiskGroup                                         \n",
      "Adult         1.262204e+06   2992640.26   2.370964\n",
      "Elder         6.854603e+05    955935.16   1.394589\n",
      "Senior        9.695206e+05   1762008.03   1.817401\n",
      "Young         5.100968e+05    608750.50   1.193402\n",
      "Young Adult   6.852904e+05   1894313.39   2.764249\n",
      "nan           7.596000e+02      6754.78   8.892549\n",
      "\n",
      "Average Loss Ratio: 3.07\n",
      "Variance in Loss Ratios: 8.48\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "data_2025 = pd.read_csv('claim_data_group5_2025.csv')\n",
    "\n",
    "\n",
    "data_2025['RiskGroup'] = pd.cut(data_2025['DrivAge'], bins=[18, 25, 35, 50, 65, 100], labels=['Young', 'Young Adult', 'Adult', 'Senior', 'Elder'])\n",
    "\n",
    "\n",
    "data_2025['RiskGroup'] = data_2025['RiskGroup'].astype(str)\n",
    "\n",
    "# Updated parameters from previous outputs\n",
    "frequency_params = {'Young': 0.0683, 'Young Adult': 0.0337, 'Adult': 0.0374, 'Senior': 0.0385, 'Elder': 0.0411}\n",
    "severity_params = {\n",
    "    'Young': (0.0196, 6207.90),\n",
    "    'Young Adult': (0.0049, 12511.37),\n",
    "    'Adult': (0.0037, 17187.69),\n",
    "    'Senior': (0.0039, 18055.87),\n",
    "    'Elder': (0.0015, 82906.66)\n",
    "}\n",
    "buffered_minimum_premium = 6.33  # Buffered minimum premium from previous output\n",
    "confidence_level = 0.995\n",
    "z_score = norm.ppf(confidence_level)\n",
    "\n",
    "# Calculate premiums for each policy in 2025 data using updated parameters\n",
    "def calculate_premium(risk_group):\n",
    "    lambda_freq = frequency_params.get(risk_group, 0)\n",
    "    alpha, beta = severity_params.get(risk_group, (1, 1))\n",
    "    \n",
    "    # Expected loss and standard deviation\n",
    "    expected_loss = lambda_freq * alpha * beta\n",
    "    std_dev = np.sqrt(lambda_freq) * alpha * beta\n",
    "    \n",
    "    \n",
    "    premium = expected_loss + z_score * std_dev\n",
    "    \n",
    "    \n",
    "    return max(premium, buffered_minimum_premium)\n",
    "\n",
    "\n",
    "data_2025['PremiumCharged'] = data_2025['RiskGroup'].apply(calculate_premium)\n",
    "\n",
    "\n",
    "data_2025['PremiumCharged'] = pd.to_numeric(data_2025['PremiumCharged'], errors='coerce')\n",
    "data_2025['ClaimAmount'] = pd.to_numeric(data_2025['ClaimAmount'], errors='coerce')\n",
    "\n",
    "# Group by RiskGroup and sum up total premiums and total claims\n",
    "grouped_data = data_2025.groupby('RiskGroup').agg({\n",
    "    'PremiumCharged': 'sum',\n",
    "    'ClaimAmount': 'sum'\n",
    "}).rename(columns={'PremiumCharged': 'TotalPremiums', 'ClaimAmount': 'TotalClaims'})\n",
    "\n",
    "# Calculate loss ratio for each group\n",
    "grouped_data['LossRatio'] = grouped_data['TotalClaims'] / grouped_data['TotalPremiums']\n",
    "\n",
    "\n",
    "print(\"Loss Ratios by Risk Group:\")\n",
    "print(grouped_data[['TotalPremiums', 'TotalClaims', 'LossRatio']])\n",
    "\n",
    "\n",
    "average_loss_ratio = grouped_data['LossRatio'].mean()\n",
    "loss_ratio_variance = grouped_data['LossRatio'].var()\n",
    "\n",
    "print(f\"\\nAverage Loss Ratio: {average_loss_ratio:.2f}\")\n",
    "print(f\"Variance in Loss Ratios: {loss_ratio_variance:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}