Statsmodels : Modélisation statistique et économétrie

Aperçu

Statsmodels est la bibliothèque premier choix de Python pour la modélisation statistique, offrant des outils pour l'estimation, l'inférence et les diagnostics sur une large gamme de méthodes statistiques. Utilisez cette compétence pour des analyses statistiques rigoureuses, allant de la régression linéaire simple aux modèles de séries temporelles complexes et aux analyses économétriques.

Quand utiliser cette compétence

Cette compétence doit être utilisée quand :

• Ajuster des modèles de régression (OLS, WLS, GLS, régression quantile)
• Effectuer une modélisation linéaire généralisée (logistique, Poisson, Gamma, etc.)
• Analyser des résultats discrets (binaire, multinomial, comptage, ordinal)
• Conduire une analyse de séries temporelles (ARIMA, SARIMAX, VAR, prévision)
• Exécuter des tests statistiques et diagnostics
• Tester les hypothèses du modèle (hétéroscédasticité, autocorrélation, normalité)
• Détecter les valeurs aberrantes et observations influentes
• Comparer des modèles (AIC/BIC, tests du rapport de vraisemblance)
• Estimer les effets causaux
• Générer des tableaux statistiques prêts pour la publication et des inférences

Guide de démarrage rapide

Régression linéaire (OLS)

import statsmodels.api as sm
import numpy as np
import pandas as pd

# Préparer les données - TOUJOURS ajouter une constante pour l'ordonnée à l'origine
X = sm.add_constant(X_data)

# Ajuster le modèle OLS
model = sm.OLS(y, X)
results = model.fit()

# Afficher les résultats complets
print(results.summary())

# Résultats clés
print(f"R-squared: {results.rsquared:.4f}")
print(f"Coefficients:\n{results.params}")
print(f"P-values:\n{results.pvalues}")

# Prédictions avec intervalles de confiance
predictions = results.get_prediction(X_new)
pred_summary = predictions.summary_frame()
print(pred_summary)  # inclut la moyenne, IC, intervalles de prédiction

# Diagnostics
from statsmodels.stats.diagnostic import het_breuschpagan
bp_test = het_breuschpagan(results.resid, X)
print(f"Breusch-Pagan p-value: {bp_test[1]:.4f}")

# Visualiser les résidus
import matplotlib.pyplot as plt
plt.scatter(results.fittedvalues, results.resid)
plt.axhline(y=0, color='r', linestyle='--')
plt.xlabel('Fitted values')
plt.ylabel('Residuals')
plt.show()

Régression logistique (résultats binaires)

from statsmodels.discrete.discrete_model import Logit

# Ajouter une constante
X = sm.add_constant(X_data)

# Ajuster le modèle logit
model = Logit(y_binary, X)
results = model.fit()

print(results.summary())

# Rapports de cotes
odds_ratios = np.exp(results.params)
print("Odds ratios:\n", odds_ratios)

# Probabilités prédites
probs = results.predict(X)

# Prédictions binaires (seuil 0,5)
predictions = (probs > 0.5).astype(int)

# Évaluation du modèle
from sklearn.metrics import classification_report, roc_auc_score

print(classification_report(y_binary, predictions))
print(f"AUC: {roc_auc_score(y_binary, probs):.4f}")

# Effets marginaux
marginal = results.get_margeff()
print(marginal.summary())

Séries temporelles (ARIMA)

from statsmodels.tsa.arima.model import ARIMA
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf

# Vérifier la stationnarité
from statsmodels.tsa.stattools import adfuller

adf_result = adfuller(y_series)
print(f"ADF p-value: {adf_result[1]:.4f}")

if adf_result[1] > 0.05:
    # La série est non-stationnaire, la différencier
    y_diff = y_series.diff().dropna()

# Tracer ACF/PACF pour identifier p, q
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
plot_acf(y_diff, lags=40, ax=ax1)
plot_pacf(y_diff, lags=40, ax=ax2)
plt.show()

# Ajuster ARIMA(p,d,q)
model = ARIMA(y_series, order=(1, 1, 1))
results = model.fit()

print(results.summary())

# Prévision
forecast = results.forecast(steps=10)
forecast_obj = results.get_forecast(steps=10)
forecast_df = forecast_obj.summary_frame()

print(forecast_df)  # inclut la moyenne et intervalles de confiance

# Diagnostics des résidus
results.plot_diagnostics(figsize=(12, 8))
plt.show()

Modèles linéaires généralisés (GLM)

import statsmodels.api as sm

# Régression de Poisson pour données de comptage
X = sm.add_constant(X_data)
model = sm.GLM(y_counts, X, family=sm.families.Poisson())
results = model.fit()

print(results.summary())

# Rapports de taux (Poisson avec lien log)
rate_ratios = np.exp(results.params)
print("Rate ratios:\n", rate_ratios)

# Vérifier la surdispersion
overdispersion = results.pearson_chi2 / results.df_resid
print(f"Overdispersion: {overdispersion:.2f}")

if overdispersion > 1.5:
    # Utiliser Negative Binomial à la place
    from statsmodels.discrete.count_model import NegativeBinomial
    nb_model = NegativeBinomial(y_counts, X)
    nb_results = nb_model.fit()
    print(nb_results.summary())

Capacités principales de modélisation statistique

1. Modèles de régression linéaire

Suite complète de modèles linéaires pour résultats continus avec diverses structures d'erreur.

Modèles disponibles :

• OLS : Régression linéaire standard avec erreurs i.i.d.
• WLS : Moindres carrés pondérés pour erreurs hétéroscédastiques
• GLS : Moindres carrés généralisés pour structure de covariance arbitraire
• GLSAR : GLS avec erreurs autorégressives pour séries temporelles
• Quantile Regression : Quantiles conditionnels (robuste aux valeurs aberrantes)
• Mixed Effects : Modèles hiérarchiques/multiniveaux avec effets aléatoires
• Recursive/Rolling : Estimation de paramètres variant dans le temps

Caractéristiques clés :

• Tests de diagnostic complets
• Erreurs standard robustes (HC, HAC, cluster)
• Statistiques d'influence (distance de Cook, levier, DFFITS)
• Tests d'hypothèses (tests F, tests de Wald)
• Comparaison de modèles (AIC, BIC, tests du rapport de vraisemblance)
• Prédictions avec intervalles de confiance et de prédiction

Quand utiliser : Variable de résultat continue, inférence souhaitée sur les coefficients, diagnostics nécessaires

Référence : Voir references/linear_models.md pour des conseils détaillés sur la sélection du modèle, les diagnostics et les meilleures pratiques.

2. Modèles linéaires généralisés (GLM)

Cadre flexible étendant les modèles linéaires à des distributions non normales.

Familles de distributions :

• Binomial : Résultats binaires ou proportions (régression logistique)
• Poisson : Données de comptage
• Negative Binomial : Comptages surdispersés
• Gamma : Données continues positives, asymétriques à droite
• Inverse Gaussian : Continues positives avec structure de variance spécifique
• Gaussian : Équivalent à OLS
• Tweedie : Famille flexible pour données semi-continues

Fonctions de lien :

• Logit, Probit, Log, Identity, Inverse, Sqrt, CLogLog, Power
• Choisir selon les besoins d'interprétation et l'ajustement du modèle

Caractéristiques clés :

• Estimation par maximum de vraisemblance via IRLS
• Résidus de déviance et de Pearson
• Statistiques de qualité d'ajustement
• Mesures de pseudo R-carré
• Erreurs standard robustes

Quand utiliser : Résultats non normaux, besoin de spécifications flexibles de variance et de lien

Référence : Voir references/glm.md pour la sélection de famille, les fonctions de lien, l'interprétation et les diagnostics.

3. Modèles de choix discrets

Modèles pour résultats catégoriques et de comptage.

Modèles binaires :

• Logit : Régression logistique (rapports de cotes)
• Probit : Régression probit (distribution normale)

Modèles multinomiaux :

• MNLogit : Catégories non ordonnées (3+ niveaux)
• Conditional Logit : Modèles de choix avec variables spécifiques à l'alternative
• Ordered Model : Résultats ordinaux (catégories ordonnées)

Modèles de comptage :

• Poisson : Modèle de comptage standard
• Negative Binomial : Comptages surdispersés
• Zero-Inflated : Excès de zéros (ZIP, ZINB)
• Hurdle Models : Modèles en deux étapes pour données riches en zéros

Caractéristiques clés :

• Estimation par maximum de vraisemblance
• Effets marginaux à la moyenne ou effets marginaux moyens
• Comparaison de modèles via AIC/BIC
• Probabilités prédites et classification
• Tests de qualité d'ajustement

Quand utiliser : Résultats binaires, catégoriques ou de comptage

Référence : Voir references/discrete_choice.md pour la sélection de modèle, l'interprétation et l'évaluation.

4. Analyse de séries temporelles

Capacités complètes de modélisation et de prévision de séries temporelles.

Modèles univariés :

• AutoReg (AR) : Modèles autorégressifs
• ARIMA : Moyenne mobile intégrée autorégressive
• SARIMAX : ARIMA saisonnier avec variables exogènes
• Exponential Smoothing : Lissage simple, Holt, Holt-Winters
• ETS : Modèles en espace d'états d'innovations

Modèles multivariés :

• VAR : Autorégression vectorielle
• VARMAX : VAR avec MA et variables exogènes
• Dynamic Factor Models : Extraire les facteurs communs
• VECM : Modèles de correction d'erreur vectorielle (cointégration)

Modèles avancés :

• State Space : Filtrage de Kalman, spécifications personnalisées
• Regime Switching : Modèles à changement de régime Markovien
• ARDL : Lag autorégressif distribué

Caractéristiques clés :

• Analyse ACF/PACF pour identification de modèle
• Tests de stationnarité (ADF, KPSS)
• Prévisions avec intervalles de prédiction
• Diagnostics des résidus (Ljung-Box, hétéroscédasticité)
• Test de causalité de Granger
• Fonctions de réponse aux impulsions (IRF)
• Décomposition de variance d'erreur de prévision (FEVD)

Quand utiliser : Données temporelles, prévision, compréhension de la dynamique temporelle

Référence : Voir references/time_series.md pour la sélection de modèle, les diagnostics et les méthodes de prévision.

5. Tests statistiques et diagnostics

Capacités étendues de test et de diagnostic pour la validation du modèle.

Diagnostics des résidus :

• Tests d'autocorrélation (Ljung-Box, Durbin-Watson, Breusch-Godfrey)
• Tests d'hétéroscédasticité (Breusch-Pagan, White, ARCH)
• Tests de normalité (Jarque-Bera, Omnibus, Anderson-Darling, Lilliefors)
• Tests de spécification (RESET, Harvey-Collier)

Influence et valeurs aberrantes :

• Levier (valeurs chapeau)
• Distance de Cook
• DFFITS et DFBETAs
• Résidus studentisés
• Graphiques d'influence

Tests d'hypothèses :

• Tests t (un échantillon, deux échantillons, appariés)
• Tests de proportion
• Tests du chi-carré
• Tests non paramétriques (Mann-Whitney, Wilcoxon, Kruskal-Wallis)
• ANOVA (unidirectionnel, bidirectionnel, mesures répétées)

Comparaisons multiples :

• HSD de Tukey
• Correction de Bonferroni
• Taux de faux positifs (FDR)

Tailles d'effet et puissance :

• d de Cohen, êta-carré
• Analyse de puissance pour tests t, proportions
• Calculs de taille d'échantillon

Inférence robuste :

• ES hétéroscédasticité-consistantes (HC0-HC3)
• ES HAC (Newey-West)
• Erreurs standard robustes aux groupes

Quand utiliser : Validation des hypothèses, détection de problèmes, assurance d'inférence robuste

Référence : Voir references/stats_diagnostics.md pour des procédures complètes de test et diagnostic.

API de formule (style R)

Statsmodels supporte les formules de style R pour une spécification de modèle intuitive :

import statsmodels.formula.api as smf

# OLS avec formule
results = smf.ols('y ~ x1 + x2 + x1:x2', data=df).fit()

# Variables catégoriques (codage factice automatique)
results = smf.ols('y ~ x1 + C(category)', data=df).fit()

# Interactions
results = smf.ols('y ~ x1 * x2', data=df).fit()  # x1 + x2 + x1:x2

# Termes polynomiaux
results = smf.ols('y ~ x + I(x**2)', data=df).fit()

# Logit
results = smf.logit('y ~ x1 + x2 + C(group)', data=df).fit()

# Poisson
results = smf.poisson('count ~ x1 + x2', data=df).fit()

# ARIMA (non disponible via formule, utiliser l'API ordinaire)

Sélection et comparaison de modèles

Critères d'information

# Comparer les modèles avec AIC/BIC
models = {
    'Model 1': model1_results,
    'Model 2': model2_results,
    'Model 3': model3_results
}

comparison = pd.DataFrame({
    'AIC': {name: res.aic for name, res in models.items()},
    'BIC': {name: res.bic for name, res in models.items()},
    'Log-Likelihood': {name: res.llf for name, res in models.items()}
})

print(comparison.sort_values('AIC'))
# AIC/BIC inférieur indique un meilleur modèle

Test du rapport de vraisemblance (modèles imbriqués)

# Pour modèles imbriqués (l'un est subset de l'autre)
from scipy import stats

lr_stat = 2 * (full_model.llf - reduced_model.llf)
df = full_model.df_model - reduced_model.df_model
p_value = 1 - stats.chi2.cdf(lr_stat, df)

print(f"LR statistic: {lr_stat:.4f}")
print(f"p-value: {p_value:.4f}")

if p_value < 0.05:
    print("Full model significantly better")
else:
    print("Reduced model preferred (parsimony)")

Validation croisée

from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error

kf = KFold(n_splits=5, shuffle=True, random_state=42)
cv_scores = []

for train_idx, val_idx in kf.split(X):
    X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]
    y_train, y_val = y.iloc[train_idx], y.iloc[val_idx]

    # Ajuster le modèle
    model = sm.OLS(y_train, X_train).fit()

    # Prédire
    y_pred = model.predict(X_val)

    # Évaluer
    rmse = np.sqrt(mean_squared_error(y_val, y_pred))
    cv_scores.append(rmse)

print(f"CV RMSE: {np.mean(cv_scores):.4f} ± {np.std(cv_scores):.4f}")

Meilleures pratiques

Préparation des données

1. Toujours ajouter une constante : Utiliser sm.add_constant() sauf si pas d'ordonnée à l'origine souhaitée
2. Vérifier les valeurs manquantes : Traiter ou imputer avant d'ajuster
3. Mettre à l'échelle si nécessaire : Améliore la convergence, l'interprétation (mais non requis pour modèles arbre)
4. Encoder les catégories : Utiliser l'API de formule ou codage factice manuel

Construction de modèle

1. Commencer simple : Débuter avec un modèle basique, ajouter de la complexité selon les besoins
2. Vérifier les hypothèses : Tester les résidus, hétéroscédasticité, autocorrélation
3. Utiliser le modèle approprié : Adapter le modèle au type de résultat (binaire→Logit, comptage→Poisson)
4. Considérer les alternatives : Si hypothèses violées, utiliser méthodes robustes ou modèle différent

Inférence

1. Rapporter les tailles d'effet : Pas seulement les p-valeurs
2. Utiliser des ES robustes : Quand hétéroscédasticité ou groupement présent
3. Comparaisons multiples : Corriger quand tester beaucoup d'hypothèses
4. Intervalles de confiance : Toujours rapporter avec les estimations ponctuelles

Évaluation du modèle

1. Vérifier les résidus : Tracer résidus vs ajustés, graphique Q-Q
2. Diagnostics d'influence : Identifier et enquêter sur observations influentes
3. Validation hors échantillon : Tester sur ensemble de rétention ou valider par CV
4. Comparer les modèles : Utiliser AIC/BIC pour non imbriqués, test LR pour imbriqués

Rapportage

1. Résumé complet : Utiliser .summary() pour résultats détaillés
2. Documenter les décisions : Noter les transformations, observations exclues
3. Interpréter avec soin : Tenir compte des fonctions de lien (p. ex. exp(β) pour lien log)
4. Visualiser : Tracer prédictions, intervalles de confiance, diagnostics

Flux de travail courants

Flux de travail 1 : Analyse de régression linéaire

1. Explorer les données (graphiques, descriptives)
2. Ajuster le modèle OLS initial
3. Vérifier les diagnostics des résidus
4. Tester l'hétéroscédasticité, autocorrélation
5. Vérifier la multicolinéarité (VIF)
6. Identifier les observations influentes
7. Réajuster avec ES robustes si nécessaire
8. Interpréter coefficients et inférence
9. Valider sur rétention ou via CV

Flux de travail 2 : Classification binaire

1. Ajuster la régression logistique (Logit)
2. Vérifier les problèmes de convergence
3. Interpréter les rapports de cotes
4. Calculer les effets marginaux
5. Évaluer la performance de classification (AUC, matrice de confusion)
6. Vérifier les observations influentes
7. Comparer avec modèles alternatifs (Probit)
8. Valider prédictions sur ensemble de test

Flux de travail 3 : Analyse de données de comptage

1. Ajuster la régression de Poisson
2. Vérifier la surdispersion
3. Si surdispersée, ajuster Negative Binomial
4. Vérifier les zéros excédentaires (considérer ZIP/ZINB)
5. Interpréter les rapports de taux
6. Évaluer la qualité d'ajustement
7. Comparer les modèles via AIC
8. Valider les prédictions

Flux de travail 4 : Prévision de séries temporelles

1. Tracer la série, vérifier tendance/saisonnalité
2. Tester la stationnarité (ADF, KPSS)
3. Différencier si non-stationnaire
4. Identifier p, q à partir ACF/PACF
5. Ajuster ARIMA ou SARIMAX
6. Vérifier diagnostics des résidus (Ljung-Box)
7. Générer prévisions avec intervalles de confiance
8. Évaluer la précision de prévision sur ensemble de test

Documentation de référence

Cette compétence inclut des fichiers de référence complets pour des conseils détaillés :

references/linear_models.md

Couverture détaillée des modèles de régression linéaire incluant :

• OLS, WLS, GLS, GLSAR, Quantile Regression
• Modèles à effets mixtes
• Régression récursive et sur fenêtres
• Diagnostics complets (hétéroscédasticité, autocorrélation, multicolinéarité)
• Statistiques d'influence et détection de valeurs aberrantes
• Erreurs standard robustes (HC, HAC, cluster)
• Tests d'hypothèses et comparaison de modèles

references/glm.md

Guide complet des modèles linéaires généralisés :

• Toutes les familles de distributions (Binomial, Poisson, Gamma, etc.)
• Fonctions de lien et quand utiliser chacune
• Ajustement et interprétation de modèle
• Pseudo R-carré et qualité d'ajustement
• Diagnostics et analyse des résidus
• Applications (régression logistique, Poisson, Gamma)

references/discrete_choice.md

Guide complet des modèles de résultats discrets :

• Modèles binaires (Logit, Probit)
• Modèles multinomiaux (MNLogit, Conditional Logit)
• Modèles de comptage (Poisson, Negative Binomial, Zero-Inflated, Hurdle)
• Modèles ordinaux
• Effets marginaux et interprétation
• Diagnostics et comparaison de modèles

references/time_series.md

Conseils approfondie pour analyse de séries temporelles :

• Modèles univariés (AR, ARIMA, SARIMAX, Exponential Smoothing)
• Modèles multivariés (VAR, VARMAX, Dynamic Factor)
• Modèles en espace d'états
• Tests de stationnarité et diagnostics
• Méthodes de prévision et évaluation
• Causalité de Granger, IRF, FEVD

references/stats_diagnostics.md

Tests statistiques et diagnostics complets :

• Diagnostics des résidus (autocorrélation, hétéroscédasticité, normalité)
• Détection d'influence et de valeurs aberrantes
• Tests d'hypothèses (paramétriques et non paramétriques)
• ANOVA et tests post-hoc
• Correction des comparaisons multiples
• Matrices de covariance robustes
• Analyse de puissance et tailles d'effet

Quand faire référence :

• Besoin d'explications détaillées de paramètres
• Choisir entre modèles similaires
• Dépanner problèmes de convergence ou diagnostics
• Comprendre des statistiques de test spécifiques
• Chercher des exemples de code pour fonctionnalités avancées

Modèles de recherche :

# Trouver des informations sur modèles spécifiques
grep -r "Quantile Regression" references/

# Trouver des tests de diagnostic
grep -r "Breusch-Pagan" references/stats_diagnostics.md

# Trouver des conseils de séries temporelles
grep -r "SARIMAX" references/time_series.md

Pièges courants à éviter

1. Oublier le terme constant : Toujours utiliser sm.add_constant() sauf pas d'ordonnée à l'origine souhaitée
2. Ignorer les hypothèses : Vérifier les résidus, hétéroscédasticité, autocorrélation
3. Mauvais modèle pour type de résultat : Binaire→Logit/Probit, Comptage→Poisson/NB, pas OLS
4. Ne pas vérifier la convergence : Chercher les avertissements d'optimisation
5. Mal interpréter les coefficients : Se souvenir des fonctions de lien (log, logit, etc.)
6. Utiliser Poisson avec surdispersion : Vérifier la dispersion, utiliser Negative Binomial si nécessaire
7. Ne pas utiliser des ES robustes : Quand hétéroscédasticité ou groupement présent
8. Surapprentissage : Trop de paramètres relatif à la taille d'échantillon
9. Fuite de données : Ajuster sur données de test ou utiliser informations futures
10. Ne pas valider les prédictions : Toujours vérifier la performance hors échantillon
11. Comparer modèles non imbriqués : Utiliser AIC/BIC, pas test LR
12. Ignorer les observations influentes : Vérifier la distance de Cook et levier
13. Tests multiples : Corriger les p-valeurs quand tester beaucoup d'hypothèses
14. Ne pas différencier les séries temporelles : Ajuster ARIMA sur données non-stationnaires
15. Confondre intervalle de prédiction vs confiance : Les intervalles de prédiction sont plus larges

Obtenir de l'aide

Pour la documentation détaillée et des exemples :

• Documentation officielle : https://www.statsmodels.org/stable/
• Guide utilisateur : https://www.statsmodels.org/stable/user-guide.html
• Exemples : https://www.statsmodels.org/stable/examples/index.html
• Référence API : https://www.statsmodels.org/stable/api.html