## Stratégies de Régularisation et Généralisation La **régularisation** regroupe les techniques permettant d'empêcher un modèle de sur-apprendre (mémoriser le bruit), en agissant comme une contrainte ou une force externe qui le force à rester simple (comme un film plastique tendu sur le moule). Si le sur-apprentissage (une variance excessive) est la maladie, la régularisation en est le remède. La régularisation impose une contrainte mathématique de "lissage" pour favoriser la généralisation en pénalisant la complexité excessive du modèle [@wiki_early_stopping; @goyal_2021_overfitting]. Pour reprendre notre analogie du moulage : si notre matière est devenue trop liquide et commence à s'infiltrer dans les micro-rayures de la figurine, la régularisation consiste à appliquer une force de tension externe (comme un film plastique tendu par-dessus). Cette contrainte empêche la matière de capter les détails superflus (le bruit) et la force à se concentrer uniquement sur la structure globale et pertinente (le signal). ### Ridge, Lasso et Coefficients Pour garder le modèle simple, on punit les poids trop grands en ajoutant une amende à l'erreur globale. Le **Lasso (L1)** supprime complètement les variables inutiles en mettant leur poids à zéro (comme un tri sélectif strict), tandis que le **Ridge (L2)** réduit doucement tous les poids sans jamais en éliminer aucun (comme un amortisseur général). En apprentissage automatique, on applique cette contrainte en ajoutant une pénalité directement dans la fonction de perte. Cette pénalité sanctionne les paramètres (les poids ou coefficients) qui prennent trop d'importance. Deux approches géométriques s'opposent : * **Ridge (Régularisation L2) :** Cette méthode ajoute une pénalité proportionnelle au carré des coefficients. Géométriquement, cela agit comme une contrainte circulaire concentrique autour de l'origine. Ridge réduit la magnitude globale des coefficients pour stabiliser le modèle. L'effet visuel est un "amortissement" : les valeurs sont compressées doucement vers le centre, mais ne sont pratiquement jamais réduites à zéro [@shizuya_2024_l1l2; @dave_2020_linear]. * **Lasso (Régularisation L1) :** Cette méthode ajoute une pénalité proportionnelle à la valeur absolue des coefficients. Géométriquement, la zone de contrainte prend la forme d'un losange (ou d'un diamant). En raison de ses angles aigus, l'optimisation a tendance à rencontrer cette contrainte directement sur les axes du repère géométrique. Le résultat est radical : le Lasso force mathématiquement certains coefficients à valoir exactement zéro [@ibm_overfitting; @dev_lasso_ridge; @deepa_2025_regularization]. ::: {.card .card-window .mb-4 .regularization-simulator} :::: {.card-header} 🪄 Simulateur Interactif des Chemins de Régularisation :::: :::: {.panel-tabset .reg-type-tabset} ##### Lasso (L1) ##### Ridge (L2) ##### ElasticNet :::: :::: {.card-control-row .sim-controls-row} ```{ojs} //| echo: false mutable regType = "lasso" _regTypeWatcher = { const w = aptitek.createTabsetWatcher( ".reg-type-tabset", { "Lasso (L1)": "lasso", "Ridge (L2)": "ridge", "ElasticNet": "elastic" }, (val) => { mutable regType = val; } ); invalidation.then(() => w.destroy()); return aptitek.noop(); } viewof regLambda = Inputs.range([0, 100], { value: 15, step: 1, label: "⚡ Intensité (λ)" }) ``` :::: :::: {.row .g-3 .px-3 .pb-2} ::::: {.col-md-7} :::::: {.card .border .m-0} ::::::: {.card-header .font-monospace .text-uppercase .text-muted .py-2 .small} 🧪 Évolution des Coefficients Régressifs ::::::: ::::::: {#reg-svg-container .card-body .p-2 .reg-chart-wrapper} ::::::: :::::: ::::: ::::: {.col-md-5} :::::: {#reg-vars-container .list-group .m-0} :::::: ::::: :::: :::: {#reg-details-container .card .border-start .border-4 .bg-light .mx-3 .mb-3} ::::: {.card-body .p-3} [{{title}}]{.fw-bold .d-block .mb-2 .detail-title-color} {{body}} ::::: :::: :::: {#reg-details-data .d-none} | type | max_lambda | color | title | body | | :------ | :--------- | :----------------- | :------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | lasso | 0 | var(--sol-cyan) | 🟡 Lasso (λ = 0) : Régression standard (Moindres Carrés) | Sans aucune pénalité, le modèle garde toutes les variables, y compris la variable de Bruit (bruit purement aléatoire) avec un coefficient de +1.5. C'est la zone propice au surapprentissage (overfitting). | | lasso | 34 | var(--sol-green) | 🏆 Lasso (λ = {λ}) : Sélection intelligente active ! | La pénalité L1 a immédiatement annulé la variable de Bruit (w = 0) ! Elle a également fortement réduit le coefficient de la variable Garage (qui fait doublon avec la Taille). Le modèle se concentre sur les variables réellement importantes. | | lasso | 74 | var(--sol-yellow) | 🟡 Lasso (λ = {λ}) : Sélection sévère | La pénalité élimine maintenant l'Âge et le Garage. Seules les variables fondamentales Taille et Chambres survivent dans l'équation. C'est idéal pour obtenir un modèle très parcimonieux et simple. | | lasso | 100 | var(--sol-red) | ⚠️ Lasso (λ = {λ}) : Sous-apprentissage (Underfitting) | La pénalité L1 est trop agressive. Elle a tué quasiment tous les coefficients. Même la Taille (variable majeure) s'approche de zéro. Le modèle a perdu sa capacité prédictive. | | ridge | 0 | var(--sol-cyan) | 🟡 Ridge (λ = 0) : Aucune régularisation | Le modèle conserve tous les coefficients au maximum. La colinéarité entre Taille et Garage n'est pas traitée, ce qui gonfle artificiellement la variance du modèle. | | ridge | 100 | var(--sol-green) | 🏆 Ridge (λ = {λ}) : Réduction de la variance (L2) | Observez la différence avec Lasso ! La pénalité Ridge ne réduit jamais aucun coefficient à exactement zéro (toutes les variables restent actives). Elle courbe et atténue les poids de manière progressive pour stabiliser le modèle face au Bruit, ce qui est parfait pour gérer la colinéarité (les variables corrélées) sans jeter d'information. | | elastic | 100 | var(--sol-magenta) | 🏆 ElasticNet (λ = {λ}) : Le Compromis L1 + L2 | ElasticNet mélange le meilleur des deux mondes : il élimine complètement les variables de Bruit (comme Lasso) tout en conservant les variables corrélées ensemble avec des coefficients stables (effet de groupe Ridge), évitant le choix aléatoire d'une variable par rapport à une autre. | :::: :::: {#reg-variables .d-none} | id | name | w0 | color | desc | lassoThreshold | elasticThreshold | | :------- | :--------------- | :--- | :----------------- | :-------------------------------- | :------------- | :--------------- | | taille | Taille (m²) | 8.0 | var(--sol-cyan) | Variable majeure très prédictive. | 0.98 | 0.99 | | chambres | Chambres | 5.0 | var(--sol-green) | Variable importante modérée. | 0.72 | 0.85 | | garage | Garage | 3.5 | var(--sol-yellow) | Corrélée à Taille (Redondance). | 0.28 | 0.45 | | age | Âge | -4.0 | var(--sol-red) | Impact négatif sur le prix. | 0.48 | 0.68 | | bruit | Bruit dB (Bruit) | 1.5 | var(--sol-magenta) | Bruit aléatoire sans intérêt. | 0.12 | 0.20 | :::: ```{ojs} //| echo: false import { updateRegularization } from "../../assets/js/simulations/regularization.js" renderSimulator = { updateRegularization(regType, regLambda, { svgEl: document.getElementById("reg-svg-container"), varsEl: document.getElementById("reg-vars-container"), detailsEl: document.getElementById("reg-details-container") }); } ``` ### Elastic Net et Early Stopping Pour réguler le modèle, on peut combiner les forces de tri et d'amortissement (**ElasticNet**), ou simplement interrompre l'entraînement en direct dès que le modèle commence à faire moins bien sur de nouvelles données (**Early Stopping**). Face à des jeux de données complexes, d'autres stratégies complètent l'arsenal du Data Scientist : * **ElasticNet :** Dans les cas où les données présentent de nombreuses variables fortement corrélées entre elles, on utilise cet hybride. Il combine littéralement le meilleur des deux mondes en fusionnant la contrainte circulaire (L2) et la contrainte en losange (L1) [@hastie_elastic_net; @neena_2024_elastic]. * **Early Stopping (Arrêt prématuré) :** Il s'agit d'une régularisation purement temporelle. Au lieu de complexifier la fonction de perte, on observe la courbe d'apprentissage en direct. On interrompt l'entraînement au point critique exact où le modèle commence à mémoriser le bruit (c'est-à-dire le moment où l'erreur sur les données de validation commence à remonter, formant une courbe en U) [@wiki_early_stopping]. ### Le Lasso comme Gouvernance Utiliser le Lasso n'est pas qu'un choix technique, c'est aussi un choix stratégique : en éliminant les données inutiles, il permet de réduire les coûts opérationnels et de rendre les décisions de l'IA faciles à expliquer pour les régulateurs. L'impact d'une méthode comme le Lasso dépasse très largement la simple performance statistique. C'est un véritable outil de décision stratégique. En annulant purement et simplement les coefficients des variables non contributives, le Lasso réalise une sélection automatique de variables. Il permet d'identifier les leviers métier réels qui influencent une prédiction. Cela a des conséquences directes en entreprise : 1. **Réduction des coûts opérationnels :** On peut stopper la collecte, le traitement et le stockage de flux de données qui s'avèrent finalement inutiles. 2. **Auditabilité :** Il simplifie drastiquement l'interprétabilité du modèle pour les instances de gouvernance, rendant l'IA transparente et explicable ("*White Box*") [@oyegoke_2020_regularization]. :::