Insurers pivot AI strategy toward core risk underwriting

Introduction

In the insurance industry, artificial intelligence (AI) is shifting from a flashy tool to a core business function. Insurance companies are now using AI not just to automate tasks, but to make smarter decisions about risk and capital allocation. In this tutorial, you'll learn how to use Python to build a simple AI model that can help assess risk for insurance underwriting. This is a foundational skill that insurers are using to make better decisions about who to insure and how much to charge.

Prerequisites

Before starting this tutorial, you should have:

• A basic understanding of Python programming
• Python installed on your computer (we recommend Python 3.8 or higher)
• Basic knowledge of data analysis concepts
• Access to a computer with internet connection

You will also need to install a few Python packages. Don't worry – we'll walk you through this step-by-step.

Step 1: Install Required Python Packages

First, we need to install the necessary Python libraries. These will help us work with data and build our AI model. Open your terminal or command prompt and run the following commands:

pip install pandas scikit-learn numpy matplotlib seaborn

Why: These packages are essential for data manipulation (pandas), machine learning (scikit-learn), and data visualization (matplotlib, seaborn). We'll use them to build our risk assessment model.

Step 2: Create a Sample Dataset

Before building a model, we need data to train it on. In this example, we'll create a simple dataset that simulates insurance applicants and their risk factors.

Let's create a Python script called insurance_data.py:

import pandas as pd
import numpy as np

# Create a sample dataset
np.random.seed(42)  # For reproducible results

# Generate 1000 sample applicants
n_applicants = 1000

# Create random data for different risk factors
age = np.random.randint(18, 80, n_applicants)
income = np.random.randint(20000, 150000, n_applicants)
credit_score = np.random.randint(300, 850, n_applicants)
years_driving = np.random.randint(0, 50, n_applicants)
num_claims = np.random.randint(0, 10, n_applicants)

# Create a DataFrame
insurance_data = pd.DataFrame({
    'age': age,
    'income': income,
    'credit_score': credit_score,
    'years_driving': years_driving,
    'num_claims': num_claims
})

# Add a risk_score column (this will be our target variable)
# Risk score is based on a combination of factors
insurance_data['risk_score'] = (
    (insurance_data['age'] / 80) * 0.1 +
    (insurance_data['income'] / 150000) * 0.2 +
    (insurance_data['credit_score'] / 850) * 0.3 +
    (insurance_data['years_driving'] / 50) * 0.1 +
    (insurance_data['num_claims'] / 10) * 0.3
)

# Save to CSV file
insurance_data.to_csv('insurance_applicants.csv', index=False)

print('Sample dataset created successfully!')
print(insurance_data.head())

Why: This script creates a realistic-looking dataset of insurance applicants with various risk factors. The risk score is calculated based on a weighted combination of these factors, simulating how an insurance company might assess risk.

Step 3: Load and Explore the Dataset

Now that we have our data, let's load it into our Python environment and explore it to understand what we're working with.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Load the dataset
insurance_data = pd.read_csv('insurance_applicants.csv')

# Display basic information about the dataset
print('Dataset Info:')
print(insurance_data.info())

# Display first few rows
print('\nFirst 5 rows:')
print(insurance_data.head())

# Display summary statistics
print('\nSummary Statistics:')
print(insurance_data.describe())

Why: Understanding your data is crucial before building a model. This step helps us see what variables we have, their types, and basic statistics to get a feel for the data.

Step 4: Visualize the Data

Data visualization helps us understand patterns and relationships in our data. Let's create a few plots to see how different risk factors relate to risk scores.

# Set up the plotting style
plt.style.use('seaborn-v0_8')

# Create a correlation heatmap
plt.figure(figsize=(10, 6))
sns.heatmap(insurance_data.corr(), annot=True, cmap='coolwarm', center=0)
plt.title('Correlation Matrix of Risk Factors')
plt.show()

# Plot risk score distribution
plt.figure(figsize=(10, 6))
sns.histplot(insurance_data['risk_score'], kde=True)
plt.title('Distribution of Risk Scores')
plt.xlabel('Risk Score')
plt.ylabel('Frequency')
plt.show()

Why: Visualizations help us quickly identify relationships between variables. For example, we can see how credit score or number of claims might influence risk score.

Step 5: Prepare Data for Machine Learning

Before building a machine learning model, we need to prepare our data. This includes separating features (inputs) from our target variable (risk score).

# Define features and target
features = ['age', 'income', 'credit_score', 'years_driving', 'num_claims']
target = 'risk_score'

# Create feature matrix and target vector
X = insurance_data[features]
y = insurance_data[target]

print('Features (X):')
print(X.head())

print('\nTarget (y):')
print(y.head())

Why: Machine learning models need data in a specific format. Features are the input variables, and the target is what we want to predict. Separating them is a standard practice in ML.

Step 6: Build a Simple AI Model

Now we'll create a basic machine learning model to predict risk scores based on our features. We'll use a simple regression model for this tutorial.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create and train the model
model = LinearRegression()
model.fit(X_train, y_train)

# Make predictions
y_pred = model.predict(X_test)

# Evaluate the model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f'Model Performance:')
print(f'Mean Squared Error: {mse:.2f}')
print(f'R-squared Score: {r2:.2f}')

Why: This step builds our AI model. We're using linear regression, a simple but effective method for predicting continuous values. The evaluation metrics help us understand how well our model performs.

Step 7: Use the Model to Make Predictions

Now that our model is trained, we can use it to predict risk scores for new applicants.

# Create a new applicant
new_applicant = [[30, 50000, 700, 5, 2]]

# Make a prediction
predicted_risk = model.predict(new_applicant)

print(f'Predicted Risk Score for New Applicant: {predicted_risk[0]:.2f}')

# Let's also try multiple applicants
new_applicants = [
    [25, 40000, 650, 3, 1],
    [45, 80000, 750, 15, 0],
    [60, 30000, 600, 20, 5]
]

print('\nPredictions for Multiple Applicants:')
for i, applicant in enumerate(new_applicants):
    pred = model.predict([applicant])[0]
    print(f'Applicant {i+1}: Predicted Risk Score = {pred:.2f}')

Why: This final step shows how the AI model can be used in practice. Insurance companies can input new applicant data into this model to quickly assess risk and make informed underwriting decisions.

Summary

In this tutorial, you've learned how to build a simple AI model for insurance underwriting. You've:

1. Installed the necessary Python packages
2. Created a sample dataset of insurance applicants
3. Explored and visualized the data
4. Prepared data for machine learning
5. Built and evaluated a linear regression model
6. Made predictions using the model

This is a basic example of how AI is being used in the insurance industry to assess risk more effectively. As insurers continue to invest in AI, these models are becoming more sophisticated, helping companies make better decisions about who to insure and how much to charge.

Remember, this is just the beginning. Real-world insurance AI models would include more features, use more advanced algorithms, and be trained on much larger datasets. But this foundation gives you a clear understanding of how AI is being applied in underwriting.