Analysis/docs/REGRESSION_GUIDE.md

# Guide Complet de la Régression

📈 **Maîtriser l'analyse de régression** pour modéliser, prédire et comprendre les relations entre variables.

---

## Table des Matières

1. [Concepts Fondamentaux](#concepts-fondamentaux)
2. [Types de Modèles](#types-de-modèles)
3. [Configuration du Modèle](#configuration-du-modèle)
4. [Interprétation des Résultats](#interprétation-des-résultats)
5. [Équations du Modèle](#équations-du-modèle)
6. [Diagnostics Graphiques](#diagnostics-graphiques)
7. [Bonnes Pratiques](#bonnes-pratiques)
8. [Exemples Détaillés](#exemples-détaillés)

---

## Concepts Fondamentaux

### Qu'est-ce que la Régression ?

La **régression** est une méthode statistique qui permet de :

✅ **Modéliser** la relation entre une variable cible (Y) et des prédicteurs (X)
✅ **Prédire** les valeurs de Y pour de nouvelles données
✅ **Comprendre** l'impact de chaque variable sur Y
✅ **Quantifier** l'incertitude des prédictions

### Notation Mathématique

```
Y = f(X) + ε

Où :
- Y = Variable cible (à expliquer/prédire)
- X = Variables explicatives (prédicteurs)
- f = Fonction du modèle
- ε = Erreur résiduelle (bruit)
```

### Terminologie

| Terme | Définition | Exemple |
|-------|------------|---------|
| **Variable cible (Y)** | Variable à expliquer/prédire | Prix, Ventes, Score |
| **Prédicteurs (X)** | Variables qui expliquent Y | Surface, Budget, Âge |
| **Coefficients** | Impact de chaque X sur Y | +2500 pour Surface |
| **Intercept** | Valeur de Y quand tous les X = 0 | Prix de base |
| **Résidus** | Différence entre réel et prédit | Erreur de prédiction |
| **R²** | Proportion de variance expliquée | 0.85 = 85% expliqué |

---

## Types de Modèles

L'application propose **4 types** de modèles de régression :

### 1. Régression Linéaire 📐

**Objectif** : Modéliser une relation **linéaire** entre X et Y.

**Équation** :
```
Y = β₀ + β₁X₁ + β₂X₂ + ... + βₙXₙ + ε
```

**Quand l'utiliser ?**
- ✅ Relation **linéaire** évidente (scatter plot en ligne droite)
- ✅ Cible **numérique continue**
- ✅ Résidus **normalement distribués**

**Hypothèses** :
- Linéarité de la relation
- Indépendance des erreurs
- Homoscédasticité (variance constante)
- Normalité des résidus

**Exemple** :
```python
# Prédire le prix immobilier
Prix = 50000 + 2500*Surface + 15000*Chambres

# Intercept : 50000€ (prix de base)
# Surface : +2500€ par m²
# Chambres : +15000€ par chambre
```

**Graphique typique** :
```
Prix
  │    •
  │   • •
  │  •   •
  │ •     •
  │•       •
  └─────────→ Surface
   (Ligne droite)
```

---

### 2. Régression Logistique 🎲

**Objectif** : Prédire la **probabilité** d'un événement binaire.

**Équation** :
```
P(Y=1) = 1 / (1 + e^-(β₀ + β₁X₁ + ... + βₙXₙ))
```

**Quand l'utiliser ?**
- ✅ Cible **binaire** (0/1, oui/non, vrai/faux)
- ✅ Cible **catégorique** (convertie en binaire)
- ✅ Intéressé par la **probabilité**, pas juste la classe

**Hypothèses** :
- Indépendance des observations
- Pas de multicolinéarité sévère
- Taille d'échantillon suffisante

**Exemple** :
```python
# Prédire si un client va acheter (1) ou non (0)
P(Achat) = f(Âge, Revenu, Historique)

# Résultat : Probabilité de 0 à 1
# Si P > 0.5 : Prédit "Achat"
# Si P ≤ 0.5 : Prédit "Pas d'achat"
```

**Graphique typique** :
```
P(Achat)
 1.0 ┤     ┌────────
     │    ┌
     │   ┌
     │  ┌
     │ ┌
 0.0 ┼─────┬─────→ Âge
         30
   (Courbe en S)
```

**Interprétation des coefficients** :
- **Odds Ratio** : e^coefficient
- Si coefficient = 0.5 → OR = 1.65 (65% plus de chances)
- Si coefficient = -0.5 → OR = 0.61 (39% moins de chances)

---

### 3. Régression Polynomial 📊

**Objectif** : Capturer des relations **non linéaires** (courbes).

**Équation** :
```
Y = β₀ + β₁X + β₂X² + β₃X³ + ... + ε
```

**Quand l'utiliser ?**
- ✅ Relation **courbe** évidente sur le scatter plot
- ✅ Résidus du modèle linéaire montrent un motif
- ✅ Relation quadratique (en U ou en cloche)

**Degré du polynôme** :
- **Degré 2** : Parabole (U ou ∩)
- **Degré 3** : Courbe en S
- **Degré 4-5** : Formes complexes (⚠️ sur-apprentissage)

**Exemple** :
```python
# Relation entre Budget_Publicité et Ventes
# (avec rendements décroissants)
Ventes = 1000 + 50*Budget - 0.1*Budget²

# Budget optimal : Budget* = 50 / (2*0.1) = 250€
# Ventes maximales : 1000 + 50*250 - 0.1*250² = 7250
```

**Graphique typique** :
```
Ventes
  │     •
  │    • •
  │   •   •
  │  •     •
  │ •       •
  └───────────→ Budget_Publicité
    (Courbe en ∩)
```

**⚠️ Risques** :
- **Sur-apprentissage** : Degré trop élevé s'adapte au bruit
- **Extrapolation** : Prédictions dangereuses hors des données
- **Interprétation** : Coefficients difficiles à expliquer

**Recommandation** : Commencer avec le degré 2, augmenter progressivement.

---

### 4. Régression Exponentielle 📈

**Objectif** : Modéliser une **croissance/décroissance exponentielle**.

**Équation** :
```
Y = e^(β₀ + β₁X + ε)
= e^β₀ × e^β₁X × e^ε
```

**Quand l'utiliser ?**
- ✅ Croissance **exponentielle** (population, virus, intérêts composés)
- ✅ Décroissance exponentielle (demi-vie, dépréciation)
- ✅ Y **toujours positif**

**Hypothèses** :
- Y > 0 (valeurs strictement positives)
- Relation logarithmique entre log(Y) et X

**Exemple** :
```python
# Croissance d'une population bactérienne
Population = e^(4.5 + 0.1*Temps)

# T0 : Population = e^4.5 = 90
# T10 : Population = e^5.5 = 245
# T20 : Population = e^6.5 = 665

# Temps de doublement : ln(2)/0.1 = 6.93 unités
```

**Graphique typique** :
```
Population
  │            •
  │         •
  │      •
  │   •
  │ •
  └───────────→ Temps
   (Courbe en J)
```

**⚠️ Limites** :
- Ne peut pas modéliser Y ≤ 0
- Très sensible aux outliers
- Difficile à interpréter directement

---

## Configuration du Modèle

### Étape 1 : Sélection de la Variable Cible (Y)

**Règles** :
- Pour **Linéaire/Polynomial/Exponentielle** : Y doit être **numérique continue**
  - ✅ Prix, Taille, Poids, Ventes, Temps
  - ❌ Catégorie, Couleur, Oui/Non

- Pour **Logistique** : Y doit être **catégorique ou binaire**
  - ✅ Achat (0/1), Spam (vrai/faux), Classe (A/B/C)
  - ❌ Prix continu, ID unique

**Dans l'application** :
1. Ouvrez le panneau "Configuration Avancée"
2. Sélectionnez votre cible dans le menu déroulant "Variable Cible (Y)"
3. Vérifiez les alertes de validation

**Exemple de validation** :
```
✅ Linéaire + Prix (numérique) → OK
❌ Linéaire + Catégorie (texte) → Erreur : "Ce modèle nécessite une cible numérique continue"
✅ Logistique + Catégorie (texte) → OK
✅ Logistique + Achat (0/1) → OK
```

---

### Étape 2 : Sélection des Prédicteurs (X)

**Automatique** : L'application recommande automatiquement les **5 meilleures variables** basées sur leur importance (Random Forest).

**Manuel** : Vous pouvez ajuster la sélection :
- ✅ Cochez : Inclure la variable
- ❌ Décochez : Exclure la variable

**Critères de sélection** :

1. **Corrélation avec Y** (via matrice de corrélation)
   - Privilégiez |r| > 0.5
   - Évitez |r| < 0.3 (trop faible)

2. **Multicolinéarité** entre X
   - ⚠️ Évitez |r| ≥ 0.7 entre prédicteurs
   - Choisissez la variable la plus corrélée avec Y

3. **Nombre de prédicteurs**
   - Règle : n/10 (n = taille échantillon)
   - Exemple : 100 observations → max 10 prédicteurs
   - Préférez **qualité > quantité**

**Exemple de workflow** :
```
1. Matrice de corrélation
   ├─ Prix vs Surface : r = 0.85 ✅
   ├─ Prix vs Chambres : r = 0.65 ✅
   ├─ Prix vs Jardin : r = 0.70 ✅
   └─ Prix vs Garage : r = 0.45 ⚠️ (faible)

2. Multicolinéarité
   ├─ Surface vs Chambres : r = 0.72 ⚠️ (problématique)
   └─ Surface vs Jardin : r = 0.50 ✅

3. Sélection finale
   ├─ Surface (meilleure corrélation avec Prix)
   ├─ Jardin (pas de multicolinéarité)
   └─ Exclure Chambres (multicolinéarité avec Surface)
```

---

### Étape 3 : Options Avancées

#### Pour Polynomial

**Degré du polynôme** (2 à 5) :
- **Degré 2** : Courbe simple (U ou ∩)
- **Degré 3** : Courbe en S
- **Degré 4-5** : Formes complexes (⚠️ risque de sur-apprentissage)

**Recommandation** :
```
1. Commencez avec le degré 2
2. Vérifiez le R² ajusté (doit augmenter)
3. Inspectez les résidus (pas de motif)
4. Si amélioration → essayez degré 3
5. Si dégradation → revenez au degré précédent
```

#### Pour Linéaire/Polynomial

**Inclure interactions** (x₁ × x₂) :
- Crée des termes croisés entre variables
- Exemple : Surface × Chambres, Âge × Revenu
- Utile pour capturer les **effets combinés**

**Quand l'utiliser ?**
- ✅ Effet d'une variable dépend d'une autre
- ✅ Interaction théorique justifiée
- ❌ Échantillon trop petit (< 50 observations)

**Exemple** :
```python
# Sans interaction
Salaire = 2000 + 50*Expérience + 100*Formation

# Avec interaction
Salaire = 2000 + 50*Expérience + 100*Formation + 5*(Expérience×Formation)

# Interprétation : L'effet de l'expérience est plus fort
# avec un niveau de formation élevé
```

---

## Interprétation des Résultats

### 1. Métriques de Qualité du Modèle

#### R-Squared (R² ou Coefficient de Détermination)

**Définition** : Proportion de la variance de Y expliquée par le modèle.

```
R² = 1 - (Variance résiduelle / Variance totale)
```

**Interprétation** :
| R² | Qualité | Signification |
|----|---------|--------------|
| **0.90 - 1.00** | Excellent | Le modèle explique 90-100% de la variance |
| **0.70 - 0.90** | Bon | Le modèle explique 70-90% de la variance |
| **0.50 - 0.70** | Modéré | Le modèle explique 50-70% de la variance |
| **0.30 - 0.50** | Faible | Le modèle explique 30-50% de la variance |
| **< 0.30** | Très faible | Le modèle est peu utile |

**Exemple** :
```python
# R² = 0.85
# Signification : 85% de la variation du Prix est expliquée par
# les variables Surface, Chambres, Jardin
# Les 15% restants sont dus à des facteurs non observés
```

⚠️ **Limites** :
- R² augmente **toujours** avec plus de variables
- Ne garantit pas la **causalité**
- Peut être **artificiellement élevé** avec outliers

---

#### Adjusted R-Squared (R² Ajusté)

**Définition** : R² corrigé pour pénaliser les variables inutiles.

```
R²_adj = 1 - (1 - R²) × (n - 1) / (n - p - 1)

Où :
- n = taille de l'échantillon
- p = nombre de prédicteurs
```

**Quand l'utiliser ?**
- Pour comparer des modèles avec **nombres de variables différents**
- Pour vérifier si une nouvelle variable **améliore vraiment** le modèle

**Règle** :
- Si R²_adj < R² → **Trop de variables inutiles**
- Si R²_augmente quand on ajoute une variable → **Variable utile**

**Exemple** :
```python
# Modèle 1 : R² = 0.85, R²_adj = 0.84, p = 5 variables
# Modèle 2 : R² = 0.86, R²_adj = 0.83, p = 10 variables

# Conclusion : Modèle 1 est meilleur (R²_adj plus élevé
# avec moins de variables)
```

---

#### AIC et BIC (Critères d'Information)

**Définition** : Mesurent la **qualité** du modèle avec **pénalité pour la complexité**.

```
AIC = 2k - 2ln(L)
BIC = k×ln(n) - 2ln(L)

Où :
- k = nombre de paramètres
- L = vraisemblance du modèle
- n = taille de l'échantillon
```

**Interprétation** :
- **Plus bas = meilleur**
- BIC pénalise plus fortement la complexité
- Utile pour comparer **modèles non emboîtés**

**Exemple** :
```python
# Modèle linéaire : AIC = 450, BIC = 460
# Modèle polynomial : AIC = 430, BIC = 455

# Conclusion : Polynomial est meilleur (AIC plus bas)
# Mais linéaire est plus simple (BIC proche)
```

---

### 2. Tableau des Coefficients

#### Structure

| Variable | Coefficient | P-Value | Fiabilité |
|----------|-------------|---------|-----------|
| const (Intercept) | 50000.00 | 0.001 | ✅ FIABLE |
| Surface | 2500.50 | 0.000 | ✅ FIABLE |
| Chambres | 12000.00 | 0.040 | ✅ FIABLE |
| Jardin | 8000.00 | 0.150 | ❌ INCERTAIN |

#### Coefficient

**Définition** : Changement moyen de Y quand X augmente de 1 unité.

**Interprétation** :
```python
# Y = 50000 + 2500*Surface + 12000*Chambres + 8000*Jardin

# Surface : coefficient = +2500
# → Si Surface augmente de 1 m², Prix augmente de 2500€

# Chambres : coefficient = +12000
# → Si Chambres augmente de 1, Prix augmente de 12000€

# Jardin : coefficient = +8000
# → Si Jardin passe de non à oui, Prix augmente de 8000€
```

**Signe du coefficient** :
- **Positif (+)** : X↑ ⇒ Y↑ (relation positive)
- **Négatif (-)** : X↑ ⇒ Y↓ (relation négative)
- **Proche de 0** : X a peu d'effet sur Y

---

#### P-Value

**Définition** : Probabilité que le coefficient soit dû au hasard.

**Règle** :
- **p < 0.05** : Coefficient **statistiquement significatif** (FIABLE)
- **p ≥ 0.05** : Coefficient **non significatif** (INCERTAIN)

**Exemple** :
```python
# Surface : p = 0.000 (< 0.05) → Fiable
# Jardin : p = 0.150 (≥ 0.05) → Incertain (pourrait être 0)

# Action : Retirer Jardin du modèle
```

**⚠️ Attention** :
- Une p-value > 0.05 ne signifie pas "pas d'effet"
- Elle signifie "pas assez de preuves" (échantillon trop petit)

---

#### Écart-Type (Std Error)

**Définition** : Incertitude sur l'estimation du coefficient.

**Intervalle de confiance à 95%** :
```
IC 95% = Coefficient ± 1.96 × Std_Error
```

**Exemple** :
```python
# Surface : coefficient = 2500, std_error = 200
# IC 95% = [2500 - 1.96×200, 2500 + 1.96×200]
#        = [2108, 2892]

# Interprétation : On est sûr à 95% que l'effet réel
# de la surface est entre 2108€ et 2892€ par m²
```

---

### 3. Diagnostic des Résidus

#### Résidus

**Définition** : Différence entre la valeur réelle et la prédite.

```
Résidu = Y_réel - Y_prédit
```

**Propriétés souhaitées** :
- ✅ **Moyenne = 0** : Pas de biais systématique
- ✅ **Distribution normale** : Pour les intervalles de confiance
- ✅ **Homoscédasticité** : Variance constante
- ✅ **Indépendance** : Pas d'autocorrélation

**Graphique Résidus vs Prédits** :

```
│    •    •
│  •   •   •
│ •    •    •   •  (Bien : dispersion aléatoire)
│•     •     •
└────────────────→ Prédits
```

```
│       •       •
│     •   •   •
│   •       •      (Mal : motif en U = relation non linéaire)
│ •           •
└────────────────→ Prédits
```

---

## Équations du Modèle

L'application génère automatiquement l'équation dans **3 formats** :

### 1. LaTeX (Mathématique)

**Usage** : Rapports, publications scientifiques, présentations.

**Exemple** :
```latex
$$y = 1.234567 + 2.345678x_{0} + 3.456789x_{0}^{2}$$
```

**Rendu** (dans un document LaTeX) :
```
y = 1.234567 + 2.345678x₀ + 3.456789x₀²
```

---

### 2. Python (Code)

**Usage** : Implémentation directe dans un script Python.

**Exemple** :
```python
y = 1.234567 + 2.345678*x0 + 3.456789*x0**2
```

**Utilisation** :
```python
# Fonction de prédiction
def predict(x0):
    return 1.234567 + 2.345678*x0 + 3.456789*x0**2

# Prédiction pour x0 = 5
resultat = predict(5)
print(resultat)  # 107.123457
```

---

### 3. Excel (Formule)

**Usage** : Utilisation directe dans une cellule Excel/Google Sheets.

**Exemple** :
```
=1.234567 + 2.345678*A1 + 3.456789*A1^2
```

**Correspondance des colonnes** :
- `x0` → Cellule `A1`
- `x1` → Cellule `B1`
- `x2` → Cellule `C1`
- etc.

**Utilisation** :
```
     A         B         C
1  [Surface]  [x0=50]   =1.234567 + 2.345678*B1 + 3.456789*B1^2
```

**Conversion automatique** :
- `x0^2` → `A1^2`
- `x0 x1` → `A1*B1`
- `x0^2 x1` → `(A1^2)*B1`

---

## Diagnostics Graphiques

### 1. Fit Plot (Régression Univariée)

**Objectif** : Vérifier visuellement l'ajustement du modèle aux données.

**Composants** :
- **Points gris** : Données réelles (X, Y_réel)
- **Ligne bleue** : Prédictions du modèle (X, Y_prédit)

**Interprétation** :
```
Bon ajustement :
  Y
  │    •
  │   •●  ← Ligne suit les points
  │  • ●
  │ •  ●
  │•   ●
  └─────────→ X

Mauvais ajustement :
  Y
  │    •
  │   ••
  │  •  ●  ← Ligne ne suit pas
  │ •   ●●
  │•    ●
  └─────────→ X
```

---

### 2. Partial Regression Plot (Régression Multivariée)

**Objectif** : Visualiser l'**effet isolé** de chaque variable, contrôlant les autres.

**Principe** :
- Montre la relation entre **X et Y**, après avoir retiré l'effet des autres variables
- La **pente** de la tendance = **coefficient** du modèle
- Utile pour comprendre la **contribution unique** de chaque prédicteur

**Interprétation** :
```
Y_résiduels
     │
   + │      •
     │    •  ●  ← Pente positive = coefficient positif
   0 │───●────●───
     │ •       •
   - │•
     └────────────→ X_résiduels
```

**Cas d'usage** :
- Identifier les variables avec **effet non linéaire**
- Détecter les **influences** (outliers sur une variable spécifique)
- Confirmer le **signe** des coefficients

---

### 3. Parity Plot (Validation)

**Objectif** : Vérifier la qualité des prédictions.

**Composants** :
- **Diagonale rouge** : Y = X (prédictions parfaites)
- **Points violets** : (Y_réel, Y_prédit)

**Interprétation** :
```
Y_prédit
  │
  │   •     •   (Bien : points près de la diagonale)
100├  •   •
  │ •     •
 50├•   •   •
  │
  └────────────→ Y_réel
    50   100

Y_prédit
  │
  │        •     (Mal : points loin de la diagonale)
100├    •
  │  •
 50├
  │•
  └────────────→ Y_réel
    50   100
```

**Métriques dérivées** :
- **MAE** (Mean Absolute Error) : |Y_réel - Y_prédit|
- **RMSE** (Root Mean Squared Error) : √(Σ(Y_réel - Y_prédit)²/n)
- **MAPE** (Mean Absolute Percentage Error) : 100×|Y_réel - Y_prédit|/Y_réel

---

## Bonnes Pratiques

### Workflow Recommencé

```
1. Exploration des données
   ├─ Vérifier les types (numérique, catégorique)
   ├─ Identifier les outliers
   └─ Statistiques descriptives

2. Matrice de corrélation
   ├─ Identifier les variables corrélées avec Y
   ├─ Repérer la multicolinéarité
   └─ Sélectionner les prédicteurs candidats

3. Régression simple
   ├─ Commencer avec 1-2 prédicteurs
   ├─ Utiliser le modèle linéaire
   └─ Vérifier les hypothèses (résidus)

4. Amélioration itérative
   ├─ Ajouter des variables (si pertinent)
   ├─ Tester polynomial (si relation courbe)
   ├─ Inclure interactions (si justifié)
   └─ Comparer les modèles (R²_adj, AIC, BIC)

5. Validation finale
   ├─ Parity Plot (qualité des prédictions)
   ├─ Diagnostic des résidus (pas de motif)
   ├─ Vérifier les p-values (< 0.05)
   └─ Interpréter les coefficients

6. Documentation
   ├─ Exporter l'équation
   ├─ Sauvegarder les graphiques
   └─ Noter les décisions (variables exclues, outliers retirés)
```

---

### Erreurs Courantes

❌ **Sur-apprentissage (Overfitting)**
```python
# Trop de variables par rapport à l'échantillon
n = 50 observations
p = 15 prédicteurs  # Trop !

# Signes :
# - R² très élevé (> 0.95)
# - R²_adj beaucoup plus bas que R²
# - Coefficients irréalistes

# Solution : Réduire le nombre de variables
```

❌ **Sous-apprentissage (Underfitting)**
```python
# Modèle trop simple pour la relation
# Relation courbe modélisée par linéaire

# Signes :
# - R² très faible (< 0.30)
# - Motif dans les résidus (forme en U)

# Solution : Essayer polynomial
```

❌ **Multicolinéarité ignorée**
```python
# Inclure des variables fortement corrélées
# Surface_m² (r=1.0) vs Surface_pieds²

# Signes :
# - Coefficients contre-intuitifs
# - p-values élevées malgré un bon R²
# - Coefficients instables (changent beaucoup si on retire une variable)

# Solution : Matrice de corrélation AVANT
```

❌ **Interprétation causale abusive**
```python
# Corrélation ≠ Causalité
# Y = 0.5*X ne signifie pas que X cause Y

# Exemple : Glace vs Requins
# Corrélation forte mais relation non causale
# (Facteur commun : Été)

# Solution : Expérience contrôlée ou avis d'expert
```

---

## Exemples Détaillés

### Exemple 1 : Prix Immobilier

**Données** (100 maisons) :
- Prix (€) : Cible
- Surface (m²)
- Chambres
- Jardin (0/1)
- Garage (0/1)
- Distance_Centre (km)

---

#### Étape 1 : Corrélation

```
                Prix   Surface Chambres Jardin Garage Distance
Prix           1.00    0.85    0.65    0.70   0.55  -0.75
Surface        0.85    1.00    0.72    0.60   0.50  -0.40
Chambres       0.65    0.72    1.00    0.45   0.35  -0.25
Jardin         0.70    0.60    0.45    1.00   0.30  -0.50
Garage         0.55    0.50    0.35    0.30   1.00  -0.20
Distance      -0.75   -0.40   -0.25   -0.50  -0.20   1.00
```

**Analyse** :
- **Meilleurs prédicteurs** : Surface (0.85), Distance (-0.75), Jardin (0.70)
- **Multicolinéarité** : Surface vs Chambres (0.72) ⚠️
- **Décision** : Garder Surface (meilleure corrélation), exclure Chambres

---

#### Étape 2 : Régression Linéaire

**Modèle** :
```python
Prix = β₀ + β₁×Surface + β₂×Distance + β₃×Jardin
```

**Résultats** :
```
R² = 0.87
R²_adj = 0.86
AIC = 1234
BIC = 1250
```

**Coefficients** :
```
Variable      Coefficient  P-Value  Fiabilité
const         50000.00     0.001    ✅ FIABLE
Surface        2500.50     0.000    ✅ FIABLE
Distance      -5000.00     0.002    ✅ FIABLE
Jardin         15000.00    0.030    ✅ FIABLE
```

---

#### Étape 3 : Interprétation

**Équation** :
```
Prix = 50000 + 2500×Surface - 5000×Distance + 15000×Jardin
```

**Signification** :
- **Prix de base** : 50000€ (pour Surface=0, Distance=0, Sans jardin)
- **Surface** : +2500€ par m²
- **Distance** : -5000€ par km du centre
- **Jardin** : +15000€ si jardin présent

**Exemple de prédiction** :
```python
# Maison : 80 m², 5 km du centre, avec jardin
Prix = 50000 + 2500×80 - 5000×5 + 15000×1
     = 50000 + 200000 - 25000 + 15000
     = 240000€
```

---

### Exemple 2 : Probabilité d'Achat

**Données** (500 clients) :
- Achat (0/1) : Cible
- Âge
- Revenu (€/mois)
- Historique (nombre d'achats précédents)

---

#### Régression Logistique

**Résultats** :
```
Pseudo R² = 0.35
AIC = 890
BIC = 910
```

**Coefficients** :
```
Variable      Coefficient  P-Value  Odds_Ratio  Fiabilité
const         -5.000       0.001    -           ✅ FIABLE
Âge            0.050       0.003    1.05        ✅ FIABLE
Revenu         0.0002      0.000    1.10        ✅ FIABLE
Historique     0.800       0.000    2.23        ✅ FIABLE
```

---

#### Interprétation

**Équation de probabilité** :
```python
P(Achat) = 1 / (1 + e^-(-5 + 0.05×Âge + 0.0002×Revenu + 0.8×Historique))
```

**Odds Ratios** :
- **Âge** : OR = 1.05 → Chaque année augmente la probabilité de 5%
- **Revenu** : OR = 1.10 → Chaque 1000€ augmente la probabilité de 10%
- **Historique** : OR = 2.23 → Chaque achat précédent double la probabilité

**Exemple de prédiction** :
```python
# Client : 45 ans, 3000€/mois, 3 achats précédents
z = -5 + 0.05×45 + 0.0002×3000 + 0.8×3
  = -5 + 2.25 + 0.6 + 2.4
  = 0.25

P(Achat) = 1 / (1 + e^-0.25)
        = 1 / (1 + 0.78)
        = 0.56

# Interprétation : 56% de probabilité d'achat
```

---

### Exemple 3 : Budget Publicité Optimal

**Données** (24 mois) :
- Ventes (k€)
- Budget_TV (k€)
- Budget_Radio (k€)

---

#### Régression Polynomial (Degré 2)

**Modèle** :
```python
Ventes = β₀ + β₁×Budget_TV + β₂×Budget_TV²
```

**Résultats** :
```
R² = 0.92
R²_adj = 0.91
```

**Coefficients** :
```
Variable      Coefficient  P-Value  Fiabilité
const         10.000       0.000    ✅ FIABLE
Budget_TV      5.000       0.000    ✅ FIABLE
Budget_TV²    -0.050       0.001    ✅ FIABLE
```

---

#### Interprétation

**Équation** :
```
Ventes = 10 + 5×Budget_TV - 0.05×Budget_TV²
```

**Budget optimal** :
```python
# Dérivée = 0
d(Ventes)/d(Budget) = 5 - 0.1×Budget = 0
Budget* = 5 / 0.1 = 50 k€

# Ventes maximales
Ventes_max = 10 + 5×50 - 0.05×50²
           = 10 + 250 - 125
           = 135 k€
```

**Graphique** :
```
Ventes
   │        •
135┤       • (Maximum)
   │      • •
100┤     •   •
   │    •     •
 50┤  •       •
   │ •         •
 10┼────────────────→ Budget_TV
    0    25    50    75
```

---

## 🎯 Conclusion

La régression est un outil puissant pour :

✅ **Comprendre** les relations entre variables
✅ **Prédire** des valeurs futures
✅ **Quantifier** l'impact de chaque facteur
✅ **Optimiser** les décisions (budget, prix, etc.)

**Points clés à retenir** :
- Toujours vérifier la **matrice de corrélation** avant
- Surveiller le **R² ajusté** (pas juste le R²)
- Respecter les **p-values** (< 0.05)
- Valider avec les **graphiques diagnostiques**
- Documenter vos **décisions**

---

**Version** : 1.0
**Projet** : Application d'Analyse de Données

🔗 **Voir aussi** : [Guide Corrélation](CORRELATION_GUIDE.md) | [Guide Outliers](OUTLIER_GUIDE.md)