Insurance Cost Prediction with Multivariable Linear Regression

Un projet de machine learning prédictant les coûts d'assurance médicale individuels basé sur plusieurs features comme l'âge, l'IMC, le nombre d'enfants, le statut de fumeur et la région.

Vue d'ensemble du projet

Ce projet implémente la régression linéaire multivariable à partir de zéro en utilisant la descente de gradient, ainsi qu'avec scikit-learn's LinearRegression pour comparaison. Le dataset inclut des informations démographiques, de style de vie et régionales sur les bénéficiaires d'assurance, avec 'charges' comme variable cible.

Le workflow couvre le prétraitement des données (encodage des variables catégorielles, mise à l'échelle des features), l'implémentation mathématique de la fonction de coût et de la descente de gradient, l'entraînement et l'évaluation du modèle, et la visualisation de la convergence du coût.

Ce projet construit une compréhension plus profonde de comment la régression linéaire s'étend à plusieurs variables. Il renforce les fondements mathématiques en codant l'algorithme à partir de zéro, tout en démontrant des workflows pratiques de machine learning utilisant scikit-learn.

Fonctionnalités clés

📊 Exploration des données : vérification des doublons, valeurs nulles et distributions des features

🔄 Prétraitement des features : encodage des variables catégorielles (sexe, fumeur, région) et mise à l'échelle des features numériques

🧮 Implémentation de la fonction de coût (MSE) et de la descente de gradient sous forme vectorisée

📉 Visualisation de la réduction du coût à travers les itérations

🤝 Comparaison de l'implémentation personnalisée avec scikit-learn LinearRegression

📈 Évaluation du modèle avec prédictions vs charges réelles

Implémentation du code

1. Import des bibliothèques

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.model_selection import train_test_split

2. Chargement et exploration des données

# Chargement du dataset
df = pd.read_csv("insurance.csv")

# Exploration des données
print("Shape:", df.shape)
print("\nInfo:")
print(df.info())
print("\nPremières lignes:")
print(df.head())
print("\nStatistiques descriptives:")
print(df.describe())

3. Prétraitement des données

# Encodage des variables catégorielles
le_sex = LabelEncoder()
le_smoker = LabelEncoder()
le_region = LabelEncoder()

df['sex_encoded'] = le_sex.fit_transform(df['sex'])
df['smoker_encoded'] = le_smoker.fit_transform(df['smoker'])
df['region_encoded'] = le_region.fit_transform(df['region'])

# Features et target
features = ['age', 'bmi', 'children', 'sex_encoded', 'smoker_encoded', 'region_encoded']
X = df[features]
y = df['charges']

# Mise à l'échelle des features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

4. Fonction de coût et descente de gradient

def compute_cost(X, y, theta):
    m = len(y)
    predictions = X.dot(theta)
    cost = (1/(2*m)) * np.sum((predictions - y)**2)
    return cost

def gradient_descent(X, y, theta, alpha, num_iters):
    m = len(y)
    cost_history = []
    
    for _ in range(num_iters):
        predictions = X.dot(theta)
        errors = predictions - y
        
        # Calcul des gradients
        gradients = (1/m) * X.T.dot(errors)
        
        # Mise à jour des paramètres
        theta = theta - alpha * gradients
        
        # Sauvegarde du coût
        cost_history.append(compute_cost(X, y, theta))
    
    return theta, cost_history

# Initialisation
theta = np.zeros(X_scaled.shape[1] + 1)  # +1 pour le biais
X_with_bias = np.column_stack([np.ones(len(X_scaled)), X_scaled])

# Entraînement
alpha = 0.01
num_iters = 1000
theta_final, cost_history = gradient_descent(X_with_bias, y, theta, alpha, num_iters)

5. Visualisation des résultats

# Visualisation de la convergence
plt.figure(figsize=(10, 6))
plt.plot(cost_history)
plt.xlabel('Itération')
plt.ylabel('Coût J')
plt.title('Convergence de la descente de gradient')
plt.grid(True)
plt.show()

# Prédictions vs valeurs réelles
predictions_custom = X_with_bias.dot(theta_final)
plt.figure(figsize=(10, 6))
plt.scatter(y, predictions_custom, alpha=0.6)
plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--', lw=2)
plt.xlabel('Valeurs réelles')
plt.ylabel('Prédictions')
plt.title('Prédictions vs Valeurs réelles (Implémentation personnalisée)')
plt.grid(True)
plt.show()

6. Comparaison avec scikit-learn

# Modèle scikit-learn
model = LinearRegression()
model.fit(X_scaled, y)

# Prédictions sklearn
predictions_sklearn = model.predict(X_scaled)

# Comparaison des coefficients
print("Coefficients personnalisés:")
print("Biais:", theta_final[0])
print("Features:", theta_final[1:])

print("\nCoefficients sklearn:")
print("Biais:", model.intercept_)
print("Features:", model.coef_)

# Visualisation comparative
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.scatter(y, predictions_custom, alpha=0.6, label='Personnalisé')
plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--', lw=2)
plt.xlabel('Valeurs réelles')
plt.ylabel('Prédictions')
plt.title('Implémentation personnalisée')
plt.legend()
plt.grid(True)

plt.subplot(1, 2, 2)
plt.scatter(y, predictions_sklearn, alpha=0.6, label='Sklearn')
plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--', lw=2)
plt.xlabel('Valeurs réelles')
plt.ylabel('Prédictions')
plt.title('Scikit-learn')
plt.legend()
plt.grid(True)

plt.tight_layout()
plt.show()