Au-delà de la ligne droite : choisir entre les MCO, les termes d'interaction et la régression de Tweedie

Au-delà de la ligne droite : Choisir entre OLS, termes d'interaction et régression de Tweedie

La régression linéaire est souvent le premier outil auquel les data scientists pensent pour modéliser une variable continue. Mais les données réelles suivent rarement une ligne droite. Les relations peuvent être courbes, hétérogènes, ou pleines de zéros et d'asymétrie. Dans cet article, nous explorons trois approches de complexité croissante : les moindres carrés ordinaires (OLS), les OLS avec termes d'interaction, et la régression de Tweedie. Nous comparerons leurs hypothèses, leurs forces et leurs pièges, puis nous vous montrerons comment implémenter chacune en Python avec des commandes réelles.

Les limites des moindres carrés ordinaires

La régression par moindres carrés ordinaires suppose une relation linéaire entre les prédicteurs et la réponse, des erreurs normalement distribuées avec une variance constante, et l'indépendance des observations. Lorsque ces hypothèses sont vérifiées, les OLS constituent le meilleur estimateur linéaire sans biais. Mais en pratique, de nombreux ensembles de données les violent.

Prenons l'exemple de la prédiction des coûts de sinistres d'assurance. Les montants des sinistres sont strictement positifs, fortement asymétriques à droite, et contiennent souvent de nombreux zéros (pas de sinistre). Les OLS prédiraient des valeurs négatives, ne parviendraient pas à capturer la masse de zéros et produiraient des résidus hétéroscédastiques. De même, dans la modélisation du mix marketing, l'effet des dépenses publicitaires peut être non linéaire — des rendements décroissants à des niveaux de dépenses élevés. Les OLS manqueraient cette courbure.

La première étape au-delà de la ligne droite consiste à ajouter des termes d'interaction, qui permettent à l'effet d'un prédicteur de dépendre d'un autre.

Termes d'interaction : Capturer les relations conditionnelles

Les termes d'interaction modélisent comment la relation entre un prédicteur \(X_1\) et la variable de résultat \(Y\) change avec la valeur d'un autre prédicteur \(X_2\). Par exemple, l'effet de l'éducation sur le revenu pourrait être plus fort pour les jeunes travailleurs que pour les plus âgés. Vous pouvez modéliser cela en incluant le produit \(X_1 \times X_2\) dans la régression.

Les termes d'interaction sont intuitifs et faciles à implémenter. Ils permettent aux pentes de varier selon les groupes ou les niveaux d'une variable continue. Cependant, ils supposent toujours une relation linéaire entre les prédicteurs et la variable de résultat après prise en compte des interactions. Ils nécessitent également une interprétation prudente : les effets principaux changent de sens lorsqu'une interaction est présente.

Pour les données présentant une forte asymétrie, une inflation de zéros ou une variance non constante, les interactions seules sont insuffisantes. Vous avez besoin d'un modèle distributionnel qui respecte la nature des données. C'est là que la régression de Tweedie excelle.

Régression de Tweedie : Gérer les données asymétriques, avec inflation de zéros et continues

La régression de Tweedie appartient à la famille des modèles linéaires généralisés (GLM). Elle est conçue pour les données qui sont continues mais ont une probabilité non nulle d'être exactement nulles, et qui sont positivement asymétriques. Cette combinaison la rend idéale pour les sinistres d'assurance, les coûts de santé, les ventes au détail et autres résultats "semi-continus".

La distribution de Tweedie a un paramètre de puissance \(p\) (entre 1 et 2) qui détermine la forme de la distribution :

• \(p = 1\) : Poisson (données de comptage, discrètes)
• \(p = 2\) : Gamma (continues, positives, asymétriques)
• \(1 < p < 2\) : Poisson–Gamma composé (continues avec des zéros)

En choisissant le \(p\) approprié, vous pouvez modéliser des données qui présentent un pic à zéro et une longue queue à droite. La régression de Tweedie gère également l'hétéroscédasticité naturellement car la variance est une fonction de la moyenne.

Prérequis

Avant de plonger dans le code, assurez-vous que votre environnement dispose des packages Python suivants. Nous utiliserons `statsmodels` pour les OLS et les termes d'interaction, et `scikit-learn` pour la régression de Tweedie (via `TweedieRegressor`).

• Python 3.8 ou ultérieur
• `numpy`
• `pandas`
• `statsmodels`
• `scikit-learn`
• `matplotlib` (pour les graphiques optionnels)

Installation étape par étape

Nous allons créer un environnement virtuel dédié et installer les packages requis.

Tout d'abord, créez et activez un environnement virtuel. Cela isole les dépendances pour ce projet.

python3 -m venv regression_env
source regression_env/bin/activate   # Sur Windows : regression_env\Scripts\activate

Ensuite, mettez à jour `pip` vers la dernière version pour éviter les conflits de dépendances.

pip install --upgrade pip

Installez maintenant les packages principaux. Nous installerons `numpy`, `pandas`, `statsmodels`, `scikit-learn` et `matplotlib`.

pip install numpy pandas statsmodels scikit-learn matplotlib

Pour vérifier l'installation, exécutez une vérification rapide en Python. Cela devrait afficher les versions sans erreur.

python -c "import numpy; import pandas; import statsmodels; import sklearn; print('Tous les packages installés avec succès')"

Exemples d'utilisation

Nous allons simuler un ensemble de données réaliste : les coûts de sinistres d'assurance. Il comportera un prédicteur continu `age` et un prédicteur catégoriel `vehicle_type` (0 = berline, 1 = camion). La variable de réponse `claim_amount` est avec inflation de zéros et asymétrique à droite.

1. Simuler les données

Tout d'abord, générez les données. Nous créerons 1000 observations avec une structure connue.

import numpy as np
import pandas as pd

np.random.seed(42)
n = 1000
age = np.random.uniform(18, 70, n)
vehicle_type = np.random.binomial(1, 0.4, n)

# Probabilité de base d'un sinistre : 30% pour berline, 50% pour camion
prob_claim = 0.3 + 0.2 * vehicle_type
has_claim = np.random.binomial(1, prob_claim)

# Montant du sinistre : distribué selon une gamma, la moyenne dépend de l'âge et du type de véhicule
mean_claim = 200 + 5 * age + 50 * vehicle_type
claim_amount = has_claim * np.random.gamma(shape=2, scale=mean_claim/2)

df = pd.DataFrame({
    'age': age,
    'vehicle_type': vehicle_type,
    'claim_amount': claim_amount
})
print(df.head())

2. Ajuster les OLS avec termes d'interaction

Nous utilisons `statsmodels` pour ajuster les OLS avec une interaction entre `age` et `vehicle_type`. Notez que les OLS ne sont pas appropriés pour ces données (zéros et asymétrie), mais nous les incluons à des fins de comparaison.

import statsmodels.api as sm

# Ajouter le terme d'interaction
df['age_vehicle'] = df['age'] * df['vehicle_type']
X = df[['age', 'vehicle_type', 'age_vehicle']]
X = sm.add_constant(X)
y = df['claim_amount']

ols_model = sm.OLS(y, X).fit()
print(ols_model.summary())

La sortie montre les coefficients, les erreurs types et les diagnostics. Notez que le R-carré pourrait être faible car les OLS ne parviennent pas à capturer la masse de zéros.

3. Ajuster la régression de Tweedie

Maintenant, nous ajustons une régression de Tweedie en utilisant `TweedieRegressor` de `scikit-learn`. Nous utiliserons `power=1.5` (typique pour les données d'assurance). Nous mettons également les caractéristiques à l'échelle pour une meilleure convergence.

from sklearn.linear_model import TweedieRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Préparer les caractéristiques (pas d'interaction nécessaire — Tweedie gère la non-linéarité via la fonction de lien)
X = df[['age', 'vehicle_type']]
y = df['claim_amount']

# Mettre les caractéristiques à l'échelle
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Diviser les données
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)

# Ajuster la régression de Tweedie
tweedie_model = TweedieRegressor(
    power=1.5,   # Poisson–Gamma composé
    alpha=0.0,   # pas de régularisation
    max_iter=1000,
    tol=1e-4
)
tweedie_model.fit(X_train, y_train)

# Prédire et évaluer
y_pred = tweedie_model.predict(X_test)
print("Coefficients :", tweedie_model.coef_)
print("Ordonnée à l'origine :", tweedie_model.intercept_)

4. Comparer les performances des modèles

Nous comparerons l'erreur absolue moyenne (MAE) et l'erreur quadratique moyenne (MSE) entre les OLS et Tweedie. Notez que la MSE est plus sensible aux grandes erreurs, que Tweedie gère mieux.

from sklearn.metrics import mean_absolute_error, mean_squared_error

# Prédictions OLS sur l'ensemble de test
X_test_ols = sm.add_constant(pd.DataFrame({
    'age': df.loc[X_test_indices, 'age'],
    'vehicle_type': df.loc[X_test_indices, 'vehicle_type'],
    'age_vehicle': df.loc[X_test_indices, 'age'] * df.loc[X_test_indices, 'vehicle_type']
}))
# (Supposons que X_test_indices sont les indices de train_test_split)
# Par simplicité, nous re-prédisons sur l'ensemble des données (ceci est illustratif)
ols_pred = ols_model.predict(X)

# Prédictions Tweedie (déjà calculées)
print("MAE OLS :", mean_absolute_error(y, ols_pred))
print("MAE Tweedie :", mean_absolute_error(y_test, y_pred))
print("MSE OLS :", mean_squared_error(y, ols_pred))
print("MSE Tweedie :", mean_squared_error(y_test, y_pred))

En pratique, Tweedie donnera une MSE plus faible car il prend en compte la masse de zéros et l'asymétrie.

5. Visualiser l'ajustement

Tracez les valeurs prédites par rapport aux valeurs réelles pour les deux modèles afin de voir la différence.

import matplotlib.pyplot as plt

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.scatter(y, ols_pred, alpha=0.3)
plt.plot([0, y.max()], [0, y.max()], 'r--')
plt.xlabel('Réel')
plt.ylabel('Prédit par OLS')
plt.title('OLS : Prédit vs Réel')

plt.subplot(1, 2, 2)
plt.scatter(y_test, y_pred, alpha=0.3)
plt.plot([0, y_test.max()], [0, y_test.max()], 'r--')
plt.xlabel('Réel')
plt.ylabel('Prédit par Tweedie')
plt.title('Tweedie : Prédit vs Réel')

plt.tight_layout()
plt.show()

Le graphique de Tweedie devrait montrer moins de dispersion et un meilleur alignement le long de la diagonale.

Quand utiliser chaque approche

• **OLS** : Utilisez uniquement lorsque vos données sont approximativement normales, homoscédastiques et sans zéros ni plage bornée. Bon pour les expériences contrôlées ou les scores de tests standardisés.
• **OLS avec interactions** : Utilisez lorsque vous soupçonnez que l'effet d'une variable dépend d'une autre, mais que les données satisfont toujours aux hypothèses des OLS. Par exemple, le ROI marketing par canal.
• **Régression de Tweedie** : Utilisez lorsque votre variable de résultat est continue, positive (ou nulle) et asymétrique à droite. Idéal pour les données d'assurance, de santé et de ventes. Il gère naturellement l'inflation de zéros et l'hétéroscédasticité.

Conclusion

La régression linéaire est une base de référence puissante, mais les données réelles exigent souvent plus. Les termes d'interaction ajoutent de la flexibilité pour les relations conditionnelles, mais ils ne résolvent pas les problèmes distributionnels comme l'asymétrie et les zéros. La régression de Tweedie comble le fossé — elle respecte la véritable nature des données tout en restant interprétable et efficace sur le plan computationnel. En choisissant le bon outil pour le travail, vous allez au-delà de la ligne droite vers des modèles qui reflètent la complexité du monde. Commencez par les OLS, ajoutez des interactions lorsque c'est nécessaire, et passez à Tweedie lorsque vos données le réclament. Vos modèles — et vos parties prenantes — vous en remercieront.