Séance 1: Introduction IA et Machine Learning

Informations de la séance

Type: Cours
Durée: 2h
Objectifs: Obj1, Obj2, Obj3

1. Définition et Concepts de Base

1.1 Intelligence Artificielle (IA)

L’Intelligence Artificielle est un domaine de l’informatique qui vise à créer des systèmes capables d’effectuer des tâches nécessitant normalement l’intelligence humaine.

Exemples d’IA au quotidien

Assistants vocaux (Siri, Alexa, Google Assistant)
Recommandations Netflix/Spotify
Filtres anti-spam des emails
Reconnaissance faciale sur smartphones
Traduction automatique

1.2 Machine Learning (Apprentissage Automatique)

Le Machine Learning est une sous-discipline de l’IA qui permet aux ordinateurs d’apprendre à partir de données sans être explicitement programmés.

Différence clé:

Programmation traditionnelle: Humain écrit les règles → Ordinateur applique
Machine Learning: Ordinateur apprend les règles à partir des données

# Approche traditionnelle
def classifier_email(email):
    if "viagra" in email or "lottery" in email:
        return "spam"
    else:
        return "not spam"

# Approche Machine Learning
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)  # Apprend des exemples
prediction = model.predict(new_email)

1.3 Deep Learning

Le Deep Learning est une sous-catégorie du ML utilisant des réseaux de neurones artificiels profonds (plusieurs couches).

Diagramme mermaid:

graph TD
    A[Intelligence Artificielle] --> B[Machine Learning]
    B --> C[Deep Learning]
    A --> D[Systèmes experts]
    A --> E[Robotique]
    B --> F[Apprentissage supervisé]
    B --> G[Apprentissage non supervisé]
    B --> H[Apprentissage par renforcement]

2. Applications et Cas d’Utilisation

2.1 Vision par Ordinateur

Détection d’objets
Reconnaissance faciale
Diagnostic médical (imagerie)
Voitures autonomes

2.2 Traitement du Langage Naturel (NLP)

Chatbots et assistants virtuels
Traduction automatique
Analyse de sentiments
Résumé automatique de textes

2.3 Systèmes de Recommandation

E-commerce (Amazon, Alibaba)
Streaming (Netflix, YouTube)
Réseaux sociaux (Facebook, Instagram)

2.4 Finance

Détection de fraude
Trading algorithmique
Évaluation de risque de crédit

2.5 Santé

Diagnostic de maladies
Découverte de médicaments
Analyse d’imagerie médicale

3. Types d’Apprentissage

3.1 Apprentissage Supervisé

Le modèle apprend à partir de données étiquetées (avec réponses connues).

Exemple

Données d’entraînement: emails avec labels “spam” ou “non spam” Objectif: Prédire si un nouveau email est spam

Tâches principales:

Classification: prédire une catégorie (spam/non spam, chat/chien)
Régression: prédire une valeur continue (prix maison, température)

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestRegressor

# Classification
clf = LogisticRegression()
clf.fit(X_train, y_train)  # y_train contient les catégories
pred_class = clf.predict(X_test)

# Régression
reg = RandomForestRegressor()
reg.fit(X_train, y_train)  # y_train contient les valeurs continues
pred_value = reg.predict(X_test)

3.2 Apprentissage Non Supervisé

Le modèle apprend à partir de données non étiquetées (sans réponses).

Exemple

Données: comportements d’achat de clients Objectif: Identifier des groupes de clients similaires (segmentation)

Tâches principales:

Clustering: regrouper des données similaires
Réduction de dimension: simplifier les données
Détection d’anomalies: identifier des points inhabituels

from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

# Clustering
kmeans = KMeans(n_clusters=3)
clusters = kmeans.fit_predict(X)

# Réduction de dimension
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

3.3 Apprentissage Semi-Supervisé

Combine données étiquetées (peu) et non étiquetées (beaucoup).

Cas d’usage: Lorsque l’étiquetage est coûteux (imagerie médicale, reconnaissance vocale)

3.4 Apprentissage par Renforcement

L’agent apprend par essai-erreur en interagissant avec un environnement.

Exemple

Jeux vidéo (AlphaGo, Chess AI)
Robotique
Contrôle de systèmes complexes

Composants:

Agent: celui qui apprend
Environnement: le monde dans lequel l’agent évolue
Actions: ce que l’agent peut faire
Récompenses: feedback positif/négatif

4. Étapes de Conception d’un Modèle IA

4.1 Pipeline ML Standard

Diagramme mermaid:

graph TB
    A[1 Définir le problème] --> B[2 Collecter les données]
    B --> C[3 Explorer les données]
    C --> D[4 Préparer les données]
    D --> E[5 Choisir un modèle]
    E --> F[6 Entraîner le modèle]
    F --> G[7 Évaluer le modèle]
    G --> H{Performance OK?}
    H -->|Non| E
    H -->|Oui| I[8 Déployer]
    I --> J[9 Monitorer]

4.2 Détails des Étapes

Étape 1: Définir le Problème

Quel type de problème? (classification, régression, clustering)
Quelles sont les métriques de succès?
Quelles sont les contraintes?

Étape 2: Collecter les Données

Sources de données
Quantité nécessaire
Qualité des données

Étape 3: Explorer les Données (EDA)

Statistiques descriptives
Visualisations
Identifier les patterns, outliers, données manquantes

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Exemple EDA simple
df = pd.read_csv('data.csv')
print(df.info())
print(df.describe())

# Visualisation
sns.pairplot(df)
plt.show()

Étape 4: Préparer les Données

Nettoyage (valeurs manquantes, doublons)
Transformation (normalisation, encodage)
Feature engineering
Split train/test

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer

# Split des données
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Normalisation
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Gestion des valeurs manquantes
imputer = SimpleImputer(strategy='mean')
X_train_imputed = imputer.fit_transform(X_train)
X_test_imputed = imputer.transform(X_test)

Étape 5: Choisir un Modèle

Basé sur le type de problème
Complexité vs interprétabilité
Ressources disponibles

Étape 6: Entraîner le Modèle

Ajuster les paramètres
Optimisation

Étape 7: Évaluer le Modèle

Métriques appropriées
Validation croisée
Analyse des erreurs

Étape 8: Déployer

Mise en production
API, application web, etc.

Étape 9: Monitorer

Performances en production
Dérive des données (data drift)
Mise à jour du modèle

5. Concepts Clés

5.1 Overfitting vs Underfitting

Modèle trop simple
Ne capture pas les patterns dans les données
Biais élevé, variance faible
Mauvaise performance train ET test

Modèle trop complexe
Mémorise les données d’entraînement (bruit inclus)
Biais faible, variance élevée
Bonne performance train, mauvaise performance test

Modèle équilibré
Capture les vrais patterns
Biais et variance faibles
Bonne généralisation

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

# Génération de données
np.random.seed(42)
X = np.linspace(0, 10, 50)
y = 2*X + 1 + np.random.randn(50)*2

# Sous-ajustement (linear)
underfit_model = LinearRegression()
underfit_model.fit(X.reshape(-1, 1), y)
y_underfit = underfit_model.predict(X.reshape(-1, 1))

# Bon ajustement (polynomial degree 2)
goodfit_model = Pipeline([
    ('poly', PolynomialFeatures(degree=2)),
    ('linear', LinearRegression())
])
goodfit_model.fit(X.reshape(-1, 1), y)
y_goodfit = goodfit_model.predict(X.reshape(-1, 1))

# Surajustement (polynomial degree 15)
overfit_model = Pipeline([
    ('poly', PolynomialFeatures(degree=15)),
    ('linear', LinearRegression())
])
overfit_model.fit(X.reshape(-1, 1), y)
y_overfit = overfit_model.predict(X.reshape(-1, 1))

# Visualisation
fig, axes = plt.subplots(1, 3, figsize=(15, 4))

axes[0].scatter(X, y, alpha=0.5)
axes[0].plot(X, y_underfit, 'r-', linewidth=2)
axes[0].set_title('Underfitting (linéaire)')

axes[1].scatter(X, y, alpha=0.5)
axes[1].plot(X, y_goodfit, 'g-', linewidth=2)
axes[1].set_title('Good Fit (polynomial deg 2)')

axes[2].scatter(X, y, alpha=0.5)
axes[2].plot(X, y_overfit, 'b-', linewidth=2)
axes[2].set_title('Overfitting (polynomial deg 15)')

plt.tight_layout()
plt.show()

5.2 Compromis Biais-Variance

L’équilibre fondamental du Machine Learning

Le compromis biais-variance est un concept essentiel qui explique pourquoi certains modèles ne généralisent pas bien. Imaginez apprendre pour un examen :

Biais élevé = Vous survolez trop le cours (sous-apprentissage)
Variance élevée = Vous mémorisez par cœur sans comprendre (sur-apprentissage)

Formules Mathématiques Clés

Erreur totale du modèle : \[E_{\text{total}} = \underbrace{\text{Biais}^2}_{\text{simplicité}} + \underbrace{\text{Variance}}_{\text{complexité}} + \epsilon\]

Où :

$\text{Biais} = E[\hat{f}(x)] - f(x)$ (différence entre prédiction moyenne et vérité)
$\text{Variance} = E[(\hat{f}(x) - E[\hat{f}(x)])^2]$ (variabilité des prédictions)
$\epsilon$ = Bruit irréductible des données

Exemple Illustratif avec Python

Dans cet exemple ,nous allons explorer le compromis biais-variance à travers un cas concret :

Le Scénario

Imaginons que nous voulons prédire une variable y à partir d’une variable X. Nos données suivent une tendance sinusoïdale (comme une vague) avec du bruit aléatoire ajouté pour simuler des mesures réelles imparfaites.

Les Trois Types de Modèles Testés

Nous allons ajuster trois modèles polynomiaux de complexité croissante :

Degré 1 (Linéaire) :
- Modèle le plus simple : une ligne droite
- Problème attendu : Trop simple pour capturer la forme sinusoïdale → Biais élevé (sous-ajustement)
- La ligne droite ne peut pas suivre les courbes des données
Degré 3 (Cubique) :
- Complexité modérée : peut faire des courbes douces
- Résultat attendu : Bon équilibre entre simplicité et flexibilité
- Capture la tendance générale sans trop coller au bruit
Degré 9 (Polynôme de haut degré) :
- Modèle très complexe : peut faire des courbes très compliquées
- Problème attendu : Trop flexible, suit le bruit → Variance élevée (sur-ajustement)
- Passe par presque tous les points d’entraînement mais prédit mal sur de nouvelles données

Ce que Vous Allez Observer

Dans les onglets suivants, vous verrez :

Points bleus = Données d’entraînement (le modèle “voit” ces points)
Points rouges = Données de test (le modèle ne “voit” PAS ces points)
Ligne verte = Prédictions du modèle

Question clé à observer : Quel modèle prédit le mieux les points rouges (test) qu’il n’a jamais vus ?

Composition de l’Erreur Totale

Explication : L’erreur totale d’un modèle se décompose en trois parties :

Biais² : Erreur systématique due à la simplicité du modèle
Variance : Sensibilité du modèle aux variations dans les données
Bruit irréductible : Erreur aléatoire inhérente aux données

graph TD
    A["Erreur Totale"] --> B["Biais au carre<br/>Erreur due a la simplicite"]
    A --> C["Variance<br/>Erreur due a la complexite"]
    A --> D["Bruit irreductible<br/>Non controlable"]
    
    style A fill:#e1f5ff
    style B fill:#ffe1e1
    style C fill:#fff4e1
    style D fill:#f0f0f0

Impact de la Complexité sur le Modèle

Explication : Lorsqu’on augmente la complexité d’un modèle :

Le biais diminue : le modèle peut mieux capturer les patterns complexes
La variance augmente : le modèle devient plus sensible au bruit dans les données

C’est le cœur du compromis biais-variance !

graph TD
    E1["Complexite croissante"] --> F1["Impact sur Biais"]
    E1 --> G1["Impact sur Variance"]
    
    F1 --> H1["Modele simple: Biais eleve"]
    F1 --> I1["Modele complexe: Biais faible"]
    
    G1 --> J1["Modele simple: Variance faible"]
    G1 --> K1["Modele complexe: Variance elevee"]
    
    style E1 fill:#e1f5ff
    style F1 fill:#fff4e1
    style G1 fill:#fff4e1
    style H1 fill:#f8d7da
    style I1 fill:#d4edda
    style J1 fill:#d4edda
    style K1 fill:#f8d7da

Recherche de la Zone Optimale

Explication : L’objectif est de trouver le point d’équilibre où :

Le biais n’est pas trop élevé (modèle pas trop simple)
La variance n’est pas trop élevée (modèle pas trop complexe)
Le modèle généralise bien sur de nouvelles données

graph TD
    L2["Recherche de l equilibre"] --> M2["Zone optimale<br/>Biais carre proche Variance"]
    M2 --> N2["Modele generalise bien"]
    
    style L2 fill:#fff3cd
    style M2 fill:#d1ecf1
    style N2 fill:#d4edda

A Retenir

Biais élevé = Modèle trop simple = Sous-ajustement (underfitting)
Variance élevée = Modèle trop complexe = Sur-ajustement (overfitting)
Objectif = Trouver le juste milieu pour une bonne généralisation
Erreur de test = Indicateur principal de la performance réelle du modèle

Comment Trouver l’Équilibre ?

Commencez simple (régression linéaire comme baseline)
Augmentez progressivement la complexité
Surveillez l’écart entre performance d’entraînement et de test
Arrêtez quand l’erreur de test commence à augmenter

Formule à retenir : \[E_{\text{test}} = \text{Biais}^2 + \text{Variance} + \epsilon\]

Le succès = trouver le point où cette somme est minimale !

Règle d’or : Visez l’équilibre où votre modèle est assez complexe pour apprendre les patterns importants, mais assez simple pour ignorer le bruit aléatoire.

Cette compréhension est cruciale pour choisir et ajuster vos modèles. L’objectif n’est pas d’éliminer le biais ou la variance, mais de trouver l’équilibre optimal pour votre problème spécifique !

Exercice Pratique : Diagnostic et Correction

from sklearn.datasets import make_moons
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

# Données non-linéaires
X, y = make_moons(n_samples=1000, noise=0.3, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Test de différents modèles
models = {
    'Arbre Profond (Variance)': DecisionTreeClassifier(max_depth=20),
    'Arbre Simple (Biais)': DecisionTreeClassifier(max_depth=2),
    'Arbre Optimisé': DecisionTreeClassifier(max_depth=5, min_samples_split=10),
    'Random Forest': RandomForestClassifier(n_estimators=100, max_depth=5),
    'SVM Linéaire (Biais)': SVC(kernel='linear', C=1),
    'SVM RBF (Variance)': SVC(kernel='rbf', C=10, gamma=10)
}

print("🧪 TEST DU COMPROMIS BIAS-VARIANCE")
print("=" * 50)

for name, model in models.items():
    diagnose_bias_variance(model, X_train, X_test, y_train, y_test)
    print("-" * 40)

Cliquez ici pour révéler/masquer la solution interactive

Conclusion et Bonnes Pratiques

Checklist de Validation

Biais élevé suspecté → Essayer modèles plus complexes
Variance élevée suspectée → Ajouter régularisation
Données limitées → Privilégier modèles simples
Données abondantes → Modèles complexes possibles
Toujours utiliser validation croisée

Règles Empiriques

Commencez simple : Linéaire/logistique comme baseline
Augmentez progressivement la complexité
Surveillez l’écart entre train et validation
Utilisez l’ensemble de test UNE SEULE FOIS à la fin
Documentez vos choix d’hyperparamètres

Formule à Retenir

Modèle Idéal = Biais² + Variance + Bruit
→ Minimiser la somme, pas individuellement

Le compromis biais-variance n’est pas un problème à éliminer mais un équilibre à maîtriser. La clé réside dans la compréhension des besoins de votre problème spécifique et l’ajustement continu de votre approche.

6. Exercices de Réflexion

Question 1

Pour chacun des problèmes suivants, identifiez le type d’apprentissage approprié (supervisé, non supervisé, renforcement):

Prédire si un patient a une maladie cardiaque
Regrouper des articles de presse par thème
Apprendre à un robot à marcher
Prédire le prix d’une maison
Détecter des transactions frauduleuses inhabituelles

Réponse 1

Apprentissage supervisé (Classification) : On prédit une étiquette binaire (malade ou non).
Apprentissage non supervisé (Clustering) : On regroupe des données sans étiquettes préalables.
Apprentissage par renforcement : Le robot apprend par essais et erreurs avec un système de récompenses.
Apprentissage supervisé (Régression) : On prédit une valeur numérique continue.
Apprentissage non supervisé (Détection d’anomalies) : On cherche des comportements qui s’écartent de la norme.

Question 2

Expliquez pourquoi un modèle avec 100% de précision sur les données d’entraînement peut être problématique.

Réponse 2

Une précision de 100 % sur les données d’entraînement est souvent le signe d’un surapprentissage (overfitting). Le modèle a “mémorisé” le bruit et les particularités des données d’entraînement au lieu d’apprendre les tendances générales. Par conséquent, il risque d’avoir de très mauvaises performances sur de nouvelles données (faible capacité de généralisation).

Question 3

Donnez 3 exemples d’applications ML dans votre domaine d’intérêt et identifiez le type de problème (classification, régression, clustering).

Réponse 3

Exemples dans le domaine du commerce électronique :

Système de recommandation de produits : Identifier des groupes de clients aux comportements similaires (Clustering).
Prévision de la demande (stocks) : Prédire le nombre d’unités qui seront vendues le mois prochain (Régression).
Filtrage de commentaires abusifs : Identifier si un avis client est conforme ou non aux règles de la plateforme (Classification).

Résumé de la Séance

Points clés à retenir

ML = apprentissage à partir de données sans programmation explicite
Trois types principaux: supervisé, non supervisé, renforcement
Pipeline ML: Problème → Données → Exploration → Préparation → Modèle → Évaluation → Déploiement
Overfitting vs Underfitting: équilibre crucial pour la généralisation
Applications diverses: vision, NLP, recommandations, finance, santé

Lectures Complémentaires

Géron, A. (2019) - Chapitre 1: The Machine Learning Landscape
Google’s Machine Learning Crash Course
Andrew Ng - What is Machine Learning?

# Séance 1: Introduction IA et Machine Learning ::: {.callout-note icon=false} ## Informations de la séance - **Type**: Cours - **Durée**: 2h - **Objectifs**: Obj1, Obj2, Obj3 ::: ## 1. Définition et Concepts de Base ### 1.1 Intelligence Artificielle (IA) L'**Intelligence Artificielle** est un domaine de l'informatique qui vise à créer des systèmes capables d'effectuer des tâches nécessitant normalement l'intelligence humaine. ::: {.callout-tip} ## Exemples d'IA au quotidien - Assistants vocaux (Siri, Alexa, Google Assistant) - Recommandations Netflix/Spotify - Filtres anti-spam des emails - Reconnaissance faciale sur smartphones - Traduction automatique ::: ### 1.2 Machine Learning (Apprentissage Automatique) Le **Machine Learning** est une sous-discipline de l'IA qui permet aux ordinateurs d'apprendre à partir de données sans être explicitement programmés. **Différence clé**: - **Programmation traditionnelle**: Humain écrit les règles → Ordinateur applique - **Machine Learning**: Ordinateur apprend les règles à partir des données ```python # Approche traditionnelle def classifier_email(email): if "viagra" in email or "lottery" in email: return "spam" else: return "not spam" # Approche Machine Learning from sklearn.linear_model import LogisticRegression model = LogisticRegression() model.fit(X_train, y_train) # Apprend des exemples prediction = model.predict(new_email) ``` ### 1.3 Deep Learning Le **Deep Learning** est une sous-catégorie du ML utilisant des réseaux de neurones artificiels profonds (plusieurs couches). **Diagramme mermaid:** ```{mermaid} graph TD A[Intelligence Artificielle] --> B[Machine Learning] B --> C[Deep Learning] A --> D[Systèmes experts] A --> E[Robotique] B --> F[Apprentissage supervisé] B --> G[Apprentissage non supervisé] B --> H[Apprentissage par renforcement] ``` ## 2. Applications et Cas d'Utilisation ### 2.1 Vision par Ordinateur - Détection d'objets - Reconnaissance faciale - Diagnostic médical (imagerie) - Voitures autonomes ### 2.2 Traitement du Langage Naturel (NLP) - Chatbots et assistants virtuels - Traduction automatique - Analyse de sentiments - Résumé automatique de textes ### 2.3 Systèmes de Recommandation - E-commerce (Amazon, Alibaba) - Streaming (Netflix, YouTube) - Réseaux sociaux (Facebook, Instagram) ### 2.4 Finance - Détection de fraude - Trading algorithmique - Évaluation de risque de crédit ### 2.5 Santé - Diagnostic de maladies - Découverte de médicaments - Analyse d'imagerie médicale ## 3. Types d'Apprentissage ### 3.1 Apprentissage Supervisé Le modèle apprend à partir de **données étiquetées** (avec réponses connues). ::: {.callout-note} ## Exemple **Données d'entraînement**: emails avec labels "spam" ou "non spam" **Objectif**: Prédire si un nouveau email est spam ::: **Tâches principales**: - **Classification**: prédire une catégorie (spam/non spam, chat/chien) - **Régression**: prédire une valeur continue (prix maison, température) ```python from sklearn.linear_model import LogisticRegression from sklearn.ensemble import RandomForestRegressor # Classification clf = LogisticRegression() clf.fit(X_train, y_train) # y_train contient les catégories pred_class = clf.predict(X_test) # Régression reg = RandomForestRegressor() reg.fit(X_train, y_train) # y_train contient les valeurs continues pred_value = reg.predict(X_test) ``` ### 3.2 Apprentissage Non Supervisé Le modèle apprend à partir de **données non étiquetées** (sans réponses). ::: {.callout-note} ## Exemple **Données**: comportements d'achat de clients **Objectif**: Identifier des groupes de clients similaires (segmentation) ::: **Tâches principales**: - **Clustering**: regrouper des données similaires - **Réduction de dimension**: simplifier les données - **Détection d'anomalies**: identifier des points inhabituels ```python from sklearn.cluster import KMeans from sklearn.decomposition import PCA # Clustering kmeans = KMeans(n_clusters=3) clusters = kmeans.fit_predict(X) # Réduction de dimension pca = PCA(n_components=2) X_reduced = pca.fit_transform(X) ``` ### 3.3 Apprentissage Semi-Supervisé Combine données étiquetées (peu) et non étiquetées (beaucoup). **Cas d'usage**: Lorsque l'étiquetage est coûteux (imagerie médicale, reconnaissance vocale) ### 3.4 Apprentissage par Renforcement L'agent apprend par **essai-erreur** en interagissant avec un environnement. ::: {.callout-note} ## Exemple - Jeux vidéo (AlphaGo, Chess AI) - Robotique - Contrôle de systèmes complexes ::: **Composants**: - **Agent**: celui qui apprend - **Environnement**: le monde dans lequel l'agent évolue - **Actions**: ce que l'agent peut faire - **Récompenses**: feedback positif/négatif ## 4. Étapes de Conception d'un Modèle IA ### 4.1 Pipeline ML Standard **Diagramme mermaid:** ```{mermaid} graph TB A[1 Définir le problème] --> B[2 Collecter les données] B --> C[3 Explorer les données] C --> D[4 Préparer les données] D --> E[5 Choisir un modèle] E --> F[6 Entraîner le modèle] F --> G[7 Évaluer le modèle] G --> H{Performance OK?} H -->|Non| E H -->|Oui| I[8 Déployer] I --> J[9 Monitorer] ``` ### 4.2 Détails des Étapes #### Étape 1: Définir le Problème - Quel type de problème? (classification, régression, clustering) - Quelles sont les métriques de succès? - Quelles sont les contraintes? #### Étape 2: Collecter les Données - Sources de données - Quantité nécessaire - Qualité des données #### Étape 3: Explorer les Données (EDA) - Statistiques descriptives - Visualisations - Identifier les patterns, outliers, données manquantes ```python import pandas as pd import seaborn as sns import matplotlib.pyplot as plt # Exemple EDA simple df = pd.read_csv('data.csv') print(df.info()) print(df.describe()) # Visualisation sns.pairplot(df) plt.show() ``` #### Étape 4: Préparer les Données - Nettoyage (valeurs manquantes, doublons) - Transformation (normalisation, encodage) - Feature engineering - Split train/test ```python from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.impute import SimpleImputer # Split des données X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42 ) # Normalisation scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) # Gestion des valeurs manquantes imputer = SimpleImputer(strategy='mean') X_train_imputed = imputer.fit_transform(X_train) X_test_imputed = imputer.transform(X_test) ``` #### Étape 5: Choisir un Modèle - Basé sur le type de problème - Complexité vs interprétabilité - Ressources disponibles #### Étape 6: Entraîner le Modèle - Ajuster les paramètres - Optimisation #### Étape 7: Évaluer le Modèle - Métriques appropriées - Validation croisée - Analyse des erreurs #### Étape 8: Déployer - Mise en production - API, application web, etc. #### Étape 9: Monitorer - Performances en production - Dérive des données (data drift) - Mise à jour du modèle ## 5. Concepts Clés ### 5.1 Overfitting vs Underfitting ::: {.panel-tabset} ## Underfitting - Modèle **trop simple** - Ne capture pas les patterns dans les données - **Biais élevé**, variance faible - Mauvaise performance train ET test ## Overfitting - Modèle **trop complexe** - Mémorise les données d'entraînement (bruit inclus) - Biais faible, **variance élevée** - Bonne performance train, **mauvaise** performance test ## Juste bien (Good fit) - Modèle équilibré - Capture les vrais patterns - Biais et variance faibles - Bonne généralisation ::: ```python import numpy as np import matplotlib.pyplot as plt from sklearn.pipeline import Pipeline from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_model import LinearRegression # Génération de données np.random.seed(42) X = np.linspace(0, 10, 50) y = 2*X + 1 + np.random.randn(50)*2 # Sous-ajustement (linear) underfit_model = LinearRegression() underfit_model.fit(X.reshape(-1, 1), y) y_underfit = underfit_model.predict(X.reshape(-1, 1)) # Bon ajustement (polynomial degree 2) goodfit_model = Pipeline([ ('poly', PolynomialFeatures(degree=2)), ('linear', LinearRegression()) ]) goodfit_model.fit(X.reshape(-1, 1), y) y_goodfit = goodfit_model.predict(X.reshape(-1, 1)) # Surajustement (polynomial degree 15) overfit_model = Pipeline([ ('poly', PolynomialFeatures(degree=15)), ('linear', LinearRegression()) ]) overfit_model.fit(X.reshape(-1, 1), y) y_overfit = overfit_model.predict(X.reshape(-1, 1)) # Visualisation fig, axes = plt.subplots(1, 3, figsize=(15, 4)) axes[0].scatter(X, y, alpha=0.5) axes[0].plot(X, y_underfit, 'r-', linewidth=2) axes[0].set_title('Underfitting (linéaire)') axes[1].scatter(X, y, alpha=0.5) axes[1].plot(X, y_goodfit, 'g-', linewidth=2) axes[1].set_title('Good Fit (polynomial deg 2)') axes[2].scatter(X, y, alpha=0.5) axes[2].plot(X, y_overfit, 'b-', linewidth=2) axes[2].set_title('Overfitting (polynomial deg 15)') plt.tight_layout() plt.show() ``` ### 5.2 Compromis Biais-Variance #### **L'équilibre fondamental du Machine Learning** Le **compromis biais-variance** est un concept essentiel qui explique pourquoi certains modèles ne généralisent pas bien. Imaginez apprendre pour un examen : - **Biais élevé** = Vous survolez trop le cours (sous-apprentissage) - **Variance élevée** = Vous mémorisez par cœur sans comprendre (sur-apprentissage) #### **Formules Mathématiques Clés** **Erreur totale du modèle :** $$E_{\text{total}} = \underbrace{\text{Biais}^2}_{\text{simplicité}} + \underbrace{\text{Variance}}_{\text{complexité}} + \epsilon$$ **Où :** - $\text{Biais} = E[\hat{f}(x)] - f(x)$ (différence entre prédiction moyenne et vérité) - $\text{Variance} = E[(\hat{f}(x) - E[\hat{f}(x)])^2]$ (variabilité des prédictions) - $\epsilon$ = Bruit irréductible des données #### **Exemple Illustratif avec Python** Dans cet exemple ,nous allons explorer le **compromis biais-variance** à travers un cas concret : ##### **Le Scénario** Imaginons que nous voulons prédire une variable `y` à partir d'une variable `X`. Nos données suivent une **tendance sinusoïdale** (comme une vague) avec du **bruit aléatoire** ajouté pour simuler des mesures réelles imparfaites. ##### **Les Trois Types de Modèles Testés** Nous allons ajuster trois modèles polynomiaux de complexité croissante : 1. **Degré 1 (Linéaire)** : - Modèle le plus simple : une ligne droite - **Problème attendu** : Trop simple pour capturer la forme sinusoïdale → **Biais élevé** (sous-ajustement) - La ligne droite ne peut pas suivre les courbes des données 2. **Degré 3 (Cubique)** : - Complexité modérée : peut faire des courbes douces - **Résultat attendu** : Bon équilibre entre simplicité et flexibilité - Capture la tendance générale sans trop coller au bruit 3. **Degré 9 (Polynôme de haut degré)** : - Modèle très complexe : peut faire des courbes très compliquées - **Problème attendu** : Trop flexible, suit le bruit → **Variance élevée** (sur-ajustement) - Passe par presque tous les points d'entraînement mais prédit mal sur de nouvelles données #### **Ce que Vous Allez Observer** Dans les onglets suivants, vous verrez : - **Points bleus** = Données d'entraînement (le modèle "voit" ces points) - **Points rouges** = Données de test (le modèle ne "voit" PAS ces points) - **Ligne verte** = Prédictions du modèle **Question clé à observer** : Quel modèle prédit le mieux les points rouges (test) qu'il n'a jamais vus ? --- ```{python} #| echo: false #| eval: true #| warning: false # ============================================================================ # IMPORTATION DES BIBLIOTHÈQUES # ============================================================================ import numpy as np import matplotlib.pyplot as plt import ipywidgets as widgets from IPython.display import display from sklearn.pipeline import Pipeline from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_model import LinearRegression from sklearn.model_selection import train_test_split # ============================================================================ # GÉNÉRATION DES DONNÉES SYNTHÉTIQUES # ============================================================================ # Fixation de la graine aléatoire pour la reproductibilité des résultats np.random.seed(42) # Création de 50 points équidistants entre 0 et 10 X = np.linspace(0, 10, 50) # Génération de la variable cible : fonction sinusoïdale avec bruit gaussien # y = 2*sin(X) + bruit aléatoire # Cela simule des données réelles avec une tendance non-linéaire et du bruit y = 2*np.sin(X) + np.random.randn(50) # Séparation des données en ensembles d'entraînement (70%) et de test (30%) # - X_train, y_train : pour entraîner les modèles # - X_test, y_test : pour évaluer la performance et la généralisation X_train, X_test, y_train, y_test = train_test_split( X.reshape(-1, 1), # reshape nécessaire pour sklearn (format 2D) y, test_size=0.3, # 30% des données pour le test random_state=42 # pour des résultats reproductibles ) # ============================================================================ # FONCTION : CRÉATION D'UN GRAPHIQUE POUR UN DEGRÉ POLYNOMIAL SPÉCIFIQUE # ============================================================================ def create_model_plot(degree): """ Crée un graphique montrant l'ajustement d'un modèle polynomial. Paramètres: ----------- degree : int Degré du polynôme (1=linéaire, 3=cubique, 9=très complexe) Retourne: --------- fig : matplotlib.figure.Figure La figure contenant le graphique Concepts illustrés: ------------------- - Degré faible (1) : sous-ajustement (underfitting), biais élevé - Degré moyen (3) : bon équilibre - Degré élevé (9) : sur-ajustement (overfitting), variance élevée """ fig, ax = plt.subplots(figsize=(7, 5)) # Création d'un pipeline sklearn : # 1. PolynomialFeatures : transforme X en [X, X^2, X^3, ..., X^degree] # 2. LinearRegression : ajuste un modèle linéaire sur ces features polynomiales model = Pipeline([ ('poly', PolynomialFeatures(degree=degree)), ('linear', LinearRegression()) ]) # Entraînement du modèle sur les données d'entraînement model.fit(X_train, y_train) # Création de points pour tracer une courbe lisse de prédiction X_plot = np.linspace(0, 10, 100).reshape(-1, 1) y_plot = model.predict(X_plot) # Visualisation : # - Points bleus : données d'entraînement # - Points rouges : données de test # - Ligne verte : prédictions du modèle ax.scatter(X_train, y_train, alpha=0.5, s=30, label='Train') ax.scatter(X_test, y_test, alpha=0.5, s=30, color='red', label='Test') ax.plot(X_plot, y_plot, 'g-', linewidth=2, label='Prédiction') ax.set_title(f'Modèle polynomial de degré {degree}') ax.set_xlabel('X') ax.set_ylabel('y') ax.legend() ax.grid(True, alpha=0.3) plt.tight_layout() return fig # ============================================================================ # FONCTION : COURBE DU COMPROMIS BIAIS-VARIANCE # ============================================================================ def create_bias_variance_curve(): """ Crée un graphique montrant l'évolution des erreurs en fonction de la complexité. Concepts illustrés: ------------------- - Erreur d'entraînement (bleue) : diminue toujours avec la complexité - Erreur de test (rouge) : forme en U caractéristique * Début élevé : sous-ajustement (biais élevé) * Minimum : zone optimale (bon équilibre) * Fin élevé : sur-ajustement (variance élevée) """ fig, ax = plt.subplots(figsize=(7, 5)) # Test de modèles avec des degrés polynomiaux de 1 à 14 degrees_range = range(1, 15) train_errs, test_errs = [], [] # Pour chaque degré, on calcule l'erreur quadratique moyenne (MSE) for d in degrees_range: model = Pipeline([ ('poly', PolynomialFeatures(degree=d)), ('linear', LinearRegression()) ]) model.fit(X_train, y_train) # Erreur sur l'entraînement : mesure le biais # Une erreur élevée indique un modèle trop simple train_errs.append(np.mean((model.predict(X_train) - y_train) ** 2)) # Erreur sur le test : mesure la capacité de généralisation # Une erreur élevée indique soit du biais soit de la variance test_errs.append(np.mean((model.predict(X_test) - y_test) ** 2)) # Traçage des courbes ax.plot(degrees_range, train_errs, 'b-', label='Erreur Train', linewidth=2) ax.plot(degrees_range, test_errs, 'r-', label='Erreur Test', linewidth=2) ax.set_xlabel('Degré du polynôme (Complexité)') ax.set_ylabel('Erreur Quadratique Moyenne') ax.set_title('Courbe du compromis Biais-Variance') ax.legend() ax.grid(True, alpha=0.3) plt.tight_layout() return fig # ============================================================================ # FONCTION : AFFICHAGE DES FORMULES MATHÉMATIQUES # ============================================================================ def create_formulas(): """ Affiche les formules mathématiques du compromis biais-variance. Formules: --------- 1. Erreur totale = Biais² + Variance + Bruit irréductible 2. Biais = Différence entre prédiction moyenne et vraie valeur 3. Variance = Variabilité des prédictions pour différents ensembles """ fig, ax = plt.subplots(figsize=(7, 5)) ax.axis('off') # Pas d'axes pour ce graphique # Formules en LaTeX (notation mathématique) formules = r"""$E_{\mathrm{total}} = \mathrm{Biais}^2 + \mathrm{Variance} + \epsilon$ $\mathrm{Biais} = E[\hat{f}(x)] - f(x)$ $\mathrm{Variance} = E[(\hat{f}(x) - E[\hat{f}(x)])^2]$""" ax.text(0.5, 0.5, formules, fontsize=16, ha='center', va='center') plt.tight_layout() return fig # ============================================================================ # CRÉATION DES WIDGETS INTERACTIFS (ONGLETS) # ============================================================================ # Création de conteneurs pour chaque graphique # widgets.Output() permet de capturer et afficher les sorties matplotlib out_degree1 = widgets.Output() out_degree3 = widgets.Output() out_degree9 = widgets.Output() out_curve = widgets.Output() out_formulas = widgets.Output() # Génération et affichage de chaque graphique dans son conteneur # Degré 1 : Modèle linéaire simple (sous-ajustement probable) with out_degree1: fig1 = create_model_plot(1) plt.show() # Degré 3 : Modèle cubique (souvent un bon équilibre) with out_degree3: fig3 = create_model_plot(3) plt.show() # Degré 9 : Modèle très complexe (sur-ajustement probable) with out_degree9: fig9 = create_model_plot(9) plt.show() # Courbe montrant l'évolution des erreurs with out_curve: fig_curve = create_bias_variance_curve() plt.show() # Formules mathématiques with out_formulas: fig_formulas = create_formulas() plt.show() # ============================================================================ # ASSEMBLAGE DES ONGLETS ET AFFICHAGE FINAL # ============================================================================ # Création d'une interface à onglets contenant tous les graphiques tabs = widgets.Tab(children=[out_degree1, out_degree3, out_degree9, out_curve]) # Attribution des titres pour chaque onglet tabs.set_title(0, 'Degré 1') # Modèle simple tabs.set_title(1, 'Degré 3') # Modèle équilibré tabs.set_title(2, 'Degré 9') # Modèle complexe tabs.set_title(3, 'Courbe Biais-Variance') # Vue d'ensemble #tabs.set_title(4, 'Formules') # Théorie mathématique # Affichage de l'interface interactive display(tabs) ``` --- #### **Composition de l'Erreur Totale** **Explication :** L'erreur totale d'un modèle se décompose en trois parties : - **Biais²** : Erreur systématique due à la simplicité du modèle - **Variance** : Sensibilité du modèle aux variations dans les données - **Bruit irréductible** : Erreur aléatoire inhérente aux données ```{mermaid} graph TD A["Erreur Totale"] --> B["Biais au carre<br/>Erreur due a la simplicite"] A --> C["Variance<br/>Erreur due a la complexite"] A --> D["Bruit irreductible<br/>Non controlable"] style A fill:#e1f5ff style B fill:#ffe1e1 style C fill:#fff4e1 style D fill:#f0f0f0 ``` --- ##### Impact de la Complexité sur le Modèle **Explication :** Lorsqu'on augmente la complexité d'un modèle : - Le **biais diminue** : le modèle peut mieux capturer les patterns complexes - La **variance augmente** : le modèle devient plus sensible au bruit dans les données C'est le cœur du compromis biais-variance ! ```{mermaid} graph TD E1["Complexite croissante"] --> F1["Impact sur Biais"] E1 --> G1["Impact sur Variance"] F1 --> H1["Modele simple: Biais eleve"] F1 --> I1["Modele complexe: Biais faible"] G1 --> J1["Modele simple: Variance faible"] G1 --> K1["Modele complexe: Variance elevee"] style E1 fill:#e1f5ff style F1 fill:#fff4e1 style G1 fill:#fff4e1 style H1 fill:#f8d7da style I1 fill:#d4edda style J1 fill:#d4edda style K1 fill:#f8d7da ``` --- ##### Recherche de la Zone Optimale **Explication :** L'objectif est de trouver le point d'équilibre où : - Le biais n'est pas trop élevé (modèle pas trop simple) - La variance n'est pas trop élevée (modèle pas trop complexe) - Le modèle **généralise bien** sur de nouvelles données ```{mermaid} graph TD L2["Recherche de l equilibre"] --> M2["Zone optimale<br/>Biais carre proche Variance"] M2 --> N2["Modele generalise bien"] style L2 fill:#fff3cd style M2 fill:#d1ecf1 style N2 fill:#d4edda ``` --- #### A Retenir 1. **Biais élevé** = Modèle trop simple = Sous-ajustement (underfitting) 2. **Variance élevée** = Modèle trop complexe = Sur-ajustement (overfitting) 3. **Objectif** = Trouver le juste milieu pour une bonne généralisation 4. **Erreur de test** = Indicateur principal de la performance réelle du modèle #### **Comment Trouver l'Équilibre ?** 1. **Commencez simple** (régression linéaire comme baseline) 2. **Augmentez progressivement** la complexité 3. **Surveillez l'écart** entre performance d'entraînement et de test 4. **Arrêtez quand** l'erreur de test commence à augmenter **Formule à retenir** : $$E_{\text{test}} = \text{Biais}^2 + \text{Variance} + \epsilon$$ **Le succès** = trouver le point où cette somme est minimale ! > **Règle d'or** : Visez l'équilibre où votre modèle est assez complexe pour apprendre les patterns importants, mais assez simple pour ignorer le bruit aléatoire. Cette compréhension est cruciale pour choisir et ajuster vos modèles. L'objectif n'est pas d'éliminer le biais ou la variance, mais de trouver l'équilibre optimal pour votre problème spécifique ! #### Exercice Pratique : Diagnostic et Correction ```python from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier from sklearn.ensemble import RandomForestClassifier from sklearn.svm import SVC from sklearn.model_selection import train_test_split # Données non-linéaires X, y = make_moons(n_samples=1000, noise=0.3, random_state=42) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) # Test de différents modèles models = { 'Arbre Profond (Variance)': DecisionTreeClassifier(max_depth=20), 'Arbre Simple (Biais)': DecisionTreeClassifier(max_depth=2), 'Arbre Optimisé': DecisionTreeClassifier(max_depth=5, min_samples_split=10), 'Random Forest': RandomForestClassifier(n_estimators=100, max_depth=5), 'SVM Linéaire (Biais)': SVC(kernel='linear', C=1), 'SVM RBF (Variance)': SVC(kernel='rbf', C=10, gamma=10) } print("🧪 TEST DU COMPROMIS BIAS-VARIANCE") print("=" * 50) for name, model in models.items(): diagnose_bias_variance(model, X_train, X_test, y_train, y_test) print("-" * 40) ``` :::{.callout-tip} ## Cliquez ici pour révéler/masquer la solution interactive ::: ```{=html} <div id="jupyterlite-container" style="display: none; width: 100%; height: 600px; margin-top: 20px;"> <iframe src="https://nevermind78.github.io/datailabproject/notebooks/index.html?path=correction_Diagnostic.ipynb" width="100%" height="600px" frameborder="0" allowfullscreen> </iframe> </div> <button onclick="toggleJupyterLite()" class="btn btn-primary"> Afficher/Masquer l'exercice interactif </button> <script> function toggleJupyterLite() { var container = document.getElementById('jupyterlite-container'); var button = document.querySelector('button.btn-primary'); if (container.style.display === 'none') { container.style.display = 'block'; button.textContent = 'Masquer l\'exercice interactif'; } else { container.style.display = 'none'; button.textContent = 'Afficher l\'exercice interactif'; } } </script> #### Conclusion et Bonnes Pratiques **Checklist de Validation** - [ ] **Biais élevé suspecté** → Essayer modèles plus complexes - [ ] **Variance élevée suspectée** → Ajouter régularisation - [ ] **Données limitées** → Privilégier modèles simples - [ ] **Données abondantes** → Modèles complexes possibles - [ ] **Toujours** utiliser validation croisée **Règles Empiriques** 1. **Commencez simple** : Linéaire/logistique comme baseline 2. **Augmentez progressivement** la complexité 3. **Surveillez l'écart** entre train et validation 4. **Utilisez l'ensemble de test** UNE SEULE FOIS à la fin 5. **Documentez** vos choix d'hyperparamètres **Formule à Retenir** > **Modèle Idéal = Biais² + Variance + Bruit** > → Minimiser la somme, pas individuellement Le compromis biais-variance n'est pas un problème à éliminer mais un équilibre à maîtriser. La clé réside dans la compréhension des besoins de votre problème spécifique et l'ajustement continu de votre approche. ## 6. Exercices de Réflexion ::: {.callout-warning icon=false} ## Question 1 Pour chacun des problèmes suivants, identifiez le type d'apprentissage approprié (supervisé, non supervisé, renforcement): a) Prédire si un patient a une maladie cardiaque b) Regrouper des articles de presse par thème c) Apprendre à un robot à marcher d) Prédire le prix d'une maison e) Détecter des transactions frauduleuses inhabituelles ::: ::: {.callout-note collapse="true"} ## Réponse 1 a) **Apprentissage supervisé** (Classification) : On prédit une étiquette binaire (malade ou non). b) **Apprentissage non supervisé** (Clustering) : On regroupe des données sans étiquettes préalables. c) **Apprentissage par renforcement** : Le robot apprend par essais et erreurs avec un système de récompenses. d) **Apprentissage supervisé** (Régression) : On prédit une valeur numérique continue. e) **Apprentissage non supervisé** (Détection d'anomalies) : On cherche des comportements qui s'écartent de la norme. ::: ::: {.callout-warning icon=false} ## Question 2 Expliquez pourquoi un modèle avec 100% de précision sur les données d'entraînement peut être problématique. ::: ::: {.callout-note collapse="true"} ## Réponse 2 Une précision de 100 % sur les données d'entraînement est souvent le signe d'un **surapprentissage (overfitting)**. Le modèle a "mémorisé" le bruit et les particularités des données d'entraînement au lieu d'apprendre les tendances générales. Par conséquent, il risque d'avoir de très mauvaises performances sur de nouvelles données (faible capacité de généralisation). ::: ::: {.callout-warning icon=false} ## Question 3 Donnez 3 exemples d'applications ML dans votre domaine d'intérêt et identifiez le type de problème (classification, régression, clustering). ::: ::: {.callout-note collapse="true"} ## Réponse 3 *Exemples dans le domaine du commerce électronique :* 1. **Système de recommandation de produits** : Identifier des groupes de clients aux comportements similaires (**Clustering**). 2. **Prévision de la demande (stocks)** : Prédire le nombre d'unités qui seront vendues le mois prochain (**Régression**). 3. **Filtrage de commentaires abusifs** : Identifier si un avis client est conforme ou non aux règles de la plateforme (**Classification**). ::: ## Résumé de la Séance ::: {.callout-important icon=false} ## Points clés à retenir 1. **ML** = apprentissage à partir de données sans programmation explicite 2. **Trois types principaux**: supervisé, non supervisé, renforcement 3. **Pipeline ML**: Problème → Données → Exploration → Préparation → Modèle → Évaluation → Déploiement 4. **Overfitting vs Underfitting**: équilibre crucial pour la généralisation 5. **Applications diverses**: vision, NLP, recommandations, finance, santé ::: ## Lectures Complémentaires 1. Géron, A. (2019) - Chapitre 1: The Machine Learning Landscape 2. [Google's Machine Learning Crash Course](https://developers.google.com/machine-learning/crash-course) 3. [Andrew Ng - What is Machine Learning?](https://www.coursera.org/learn/machine-learning)