Machine Learning avec Python : Régression & Classification

Salut à toi, futur expert en Data Science ! Le Machine Learning (ML) est au cœur de l'innovation technologique actuelle. Comprendre ses mécanismes et savoir l'implémenter est une compétence indispensable.

Ce cours est conçu pour te guider pas à pas dans l'univers du ML avec Python. Nous allons explorer ensemble les concepts fondamentaux, de la préparation des données à la construction de modèles prédictifs.

Prépare-toi à coder et à expérimenter, car c'est en pratiquant que tu maîtriseras ces techniques. Attache ta ceinture, l'aventure commence maintenant !

I. Introduction au Machine Learning et à Python

I.1. Qu'est-ce que le Machine Learning ?

Le Machine Learning, ou apprentissage automatique, est une branche de l'intelligence artificielle. Il permet aux systèmes informatiques d'apprendre à partir de données sans être explicitement programmés pour chaque tâche.

L'objectif est de découvrir des patterns et des relations dans les données. Ces patterns sont ensuite utilisés pour faire des prédictions ou prendre des décisions.

Il existe principalement trois types d'apprentissage automatique : supervisé, non supervisé et par renforcement. Dans ce cours, nous nous concentrerons sur l'apprentissage supervisé.

L'apprentissage supervisé utilise des données étiquetées, c'est-à-dire des paires entrée-sortie. Le modèle apprend à mapper les entrées aux sorties souhaitées.

I.2. Pourquoi Python pour le Machine Learning ?

Python est devenu le langage de référence pour le Machine Learning et la Data Science. Sa popularité repose sur plusieurs atouts majeurs.

Il possède une syntaxe claire et facile à apprendre, ce qui rend le code lisible et maintenable. De plus, il dispose d'un écosystème riche de bibliothèques dédiées.

I.3. Vue d'ensemble des types de problèmes de ML

En apprentissage supervisé, on distingue principalement deux grandes catégories de problèmes : la régression et la classification.

Ces deux types de problèmes ont des objectifs et des types de sorties bien différents.

II. Préparation des Données : La Phase Cruciale

II.1. Collecte et exploration des données (Pandas)

Avant de construire un modèle, tu dois comprendre tes données. La collecte est la première étape, souvent suivie d'une phase d'exploration.

L'exploration des données (EDA) consiste à analyser les jeux de données pour en résumer les principales caractéristiques. Cela te permet de détecter des anomalies, de tester des hypothèses et de visualiser les distributions.

import pandas as pd
df = pd.read_csv('ventes.csv')

print(df.head())
print(df.info())
print(df.describe())

II.2. Nettoyage et prétraitement

Les données brutes sont rarement parfaites. Elles peuvent contenir des valeurs manquantes, des doublons, des erreurs ou des formats incohérents. Le nettoyage est essentiel.

Le prétraitement comprend la gestion des valeurs manquantes, l'encodage des variables catégorielles et la détection des valeurs aberrantes.

II.2.1. Gestion des valeurs manquantes

Les valeurs manquantes peuvent biaiser tes modèles ou les faire échouer. Tu as plusieurs options pour les gérer.

Tu peux les supprimer (lignes ou colonnes entières), les imputer avec une valeur (moyenne, médiane, mode) ou utiliser des méthodes plus avancées.

print(df.isnull().sum())

df['Prix'].fillna(df['Prix'].mean(), inplace=True)

II.2.2. Encodage des variables catégorielles

Les algorithmes de Machine Learning fonctionnent généralement avec des nombres. Les variables catégorielles (ex: "Rouge", "Vert", "Bleu") doivent être converties.

Deux méthodes courantes sont l'encodage ordinal (pour les catégories ordonnées) et l'encodage One-Hot (pour les catégories nominales).

II.3. Normalisation et standardisation

Ces techniques visent à transformer tes données numériques pour qu'elles aient une échelle similaire. Cela est crucial pour de nombreux algorithmes de ML sensibles à l'échelle des variables.

La normalisation (Min-Max Scaling) met les données entre 0 et 1. La standardisation (Z-score normalization) les transforme pour avoir une moyenne de 0 et un écart-type de 1.

II.4. Séparation des jeux de données (entraînement, validation, test)

Pour évaluer la performance de ton modèle de manière fiable, tu dois séparer tes données en plusieurs sous-ensembles. C'est une étape fondamentale du processus de ML.

Le jeu d'entraînement est utilisé pour que le modèle "apprenne". Le jeu de test évalue la performance du modèle sur des données qu'il n'a jamais vues.

from sklearn.model_selection import train_test_split
X = df[['Feature1', 'Feature2']] # Tes variables explicatives
y = df['Target'] # Ta variable cible

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

III. Régression Linéaire : Le Fondement de la Prédiction Continue

III.1. Principe de la régression linéaire simple

La régression linéaire est l'un des algorithmes de Machine Learning les plus basiques. Elle permet de modéliser la relation linéaire entre une variable dépendante continue et une ou plusieurs variables indépendantes.

Dans sa forme simple, elle cherche à ajuster la "meilleure" droite à un ensemble de points de données. Cette droite minimise la somme des carrés des erreurs entre les valeurs prédites et les valeurs réelles.

III.2. Modèle de régression linéaire multiple

Lorsque tu as plusieurs variables indépendantes pour prédire ta variable cible, tu utilises la régression linéaire multiple. Le principe reste le même.

Tu cherches à trouver les coefficients qui, combinés linéairement avec tes variables d'entrée, prédisent au mieux la variable cible. Le modèle s'étend simplement à plus de dimensions.

III.3. Fonction de coût et descente de gradient

Comment le modèle trouve-t-il la "meilleure" droite ou hyperplan ? Il utilise une fonction de coût (ou de perte) pour mesurer l'erreur de ses prédictions.

Pour la régression linéaire, la fonction de coût la plus courante est l'erreur quadratique moyenne (Mean Squared Error - MSE). L'algorithme cherche à minimiser cette fonction de coût.

La descente de gradient est l'algorithme d'optimisation souvent utilisé pour minimiser la fonction de coût. Il ajuste itérativement les coefficients du modèle dans la direction où la fonction de coût diminue le plus rapidement.

III.4. Implémentation avec Scikit-learn

Scikit-learn est la bibliothèque incontournable pour le Machine Learning en Python. Elle offre une interface simple et cohérente pour de nombreux modèles.

L'implémentation d'une régression linéaire est très concise et suit un schéma classique en Scikit-learn : instancier le modèle, l'entraîner, puis faire des prédictions.

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Créer des données d'exemple
np.random.seed(0)
heures_etude = np.random.rand(100, 1) * 10 # Entre 0 et 10 heures
score_examen = 2 * heures_etude + np.random.randn(100, 1) * 2 + 30 # Score = 2*heures + bruit + 30
df_etude = pd.DataFrame({'HeuresEtude': heures_etude.flatten(), 'ScoreExamen': score_examen.flatten()})

X = df_etude[['HeuresEtude']]
y = df_etude['ScoreExamen']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model_lr = LinearRegression()
model_lr.fit(X_train, y_train)

y_pred = model_lr.predict(X_test)

III.5. Évaluation des modèles de régression

Une fois ton modèle entraîné, tu dois évaluer sa performance. Pour la régression, plusieurs métriques sont couramment utilisées.

Les métriques les plus importantes sont l'erreur quadratique moyenne (MSE), l'erreur absolue moyenne (MAE) et le coefficient de détermination ($R^2$).

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"MSE sur le jeu de test : {mse:.2f}")
print(f"R² sur le jeu de test : {r2:.2f}")
print(f"Coefficient (pente) : {model_lr.coef_[0]:.2f}")
print(f"Ordonnée à l'origine : {model_lr.intercept_:.2f}")

IV. Régression Logistique : La Classification Binaire en Action

IV.1. Pourquoi la régression linéaire n'est pas adaptée à la classification

Tu pourrais être tenté d'utiliser la régression linéaire pour la classification en associant des nombres à tes catégories (ex: 0 pour "non-spam", 1 pour "spam"). Cependant, ce n'est pas une bonne idée.

La régression linéaire prédit des valeurs continues, ce qui signifie que ses sorties peuvent être inférieures à 0 ou supérieures à 1. Ces valeurs n'ont pas de sens pour des probabilités de classe.

De plus, la régression linéaire est sensible aux valeurs aberrantes, ce qui peut fausser la ligne de décision pour la classification. Elle n'est pas conçue pour modéliser des probabilités.

IV.2. Le rôle de la fonction Sigmoïde

La régression logistique résout ce problème en utilisant une fonction Sigmoïde (aussi appelée fonction logistique). Cette fonction "écrase" n'importe quelle valeur réelle entre 0 et 1.

Elle prend en entrée la sortie linéaire du modèle et la transforme en une probabilité. C'est ce qui permet à la régression logistique de prédire des probabilités d'appartenance à une classe.

Si la probabilité calculée est supérieure à un certain seuil (généralement 0.5), la classe est prédite comme positive (1). Sinon, elle est prédite comme négative (0).

IV.3. Interprétation des probabilités

La sortie de la fonction Sigmoïde est une probabilité. Par exemple, si le modèle prédit 0.7 pour une observation, cela signifie qu'il y a 70% de chances qu'elle appartienne à la classe positive.

Cette interprétation probabiliste est très utile et permet d'aller au-delà d'une simple classification binaire. Tu peux ajuster le seuil de décision en fonction de tes besoins métiers.

IV.4. Implémentation avec Scikit-learn

Comme pour la régression linéaire, Scikit-learn simplifie grandement l'implémentation de la régression logistique. Le processus reste le même : instancier, entraîner et prédire.

La classe LogisticRegression est robuste et efficace pour la classification binaire et multi-classe.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification # Pour générer des données de classification
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

X, y = make_classification(n_samples=100, n_features=2, n_informative=2,
                           n_redundant=0, n_clusters_per_class=1, random_state=42)
# X sont les caractéristiques, y est la variable cible (0 ou 1)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model_lr_clf = LogisticRegression(random_state=42)
model_lr_clf.fit(X_train, y_train)

y_pred_clf = model_lr_clf.predict(X_test)
y_pred_proba = model_lr_clf.predict_proba(X_test)[:, 1] # Probabilités de la classe positive

IV.5. Évaluation des modèles de classification

L'évaluation des modèles de classification est différente de celle des modèles de régression. L'accuracy (précision globale) est un bon début, mais elle n'est pas toujours suffisante, surtout avec des classes déséquilibrées.

La matrice de confusion est un outil essentiel pour comprendre les performances de ton classifieur. Elle décompose les prédictions en quatre catégories : Vrais Positifs (VP), Vrais Négatifs (VN), Faux Positifs (FP) et Faux Négatifs (FN).

À partir de la matrice de confusion, tu peux calculer d'autres métriques clés comme la précision (Precision), le rappel (Recall), et le F1-score.

accuracy = accuracy_score(y_test, y_pred_clf)
conf_matrix = confusion_matrix(y_test, y_pred_clf)
class_report = classification_report(y_test, y_pred_clf)

print(f"Accuracy : {accuracy:.2f}")
print("Matrice de confusion :\n", conf_matrix)
print("Rapport de classification :\n", class_report)

V. Arbres de Décision et Forêts Aléatoires : Modèles Puissants et Interprétables

V.1. Fonctionnement d'un arbre de décision

Les arbres de décision sont des algorithmes polyvalents qui peuvent être utilisés pour la régression et la classification. Ils modélisent les décisions comme un arbre.

Chaque nœud de l'arbre représente un test sur une caractéristique. Chaque branche représente le résultat de ce test et chaque feuille représente une décision finale ou une valeur prédite.

Le processus de construction d'un arbre de décision implique de choisir la meilleure caractéristique pour diviser les données à chaque étape. Des critères comme l'impureté de Gini ou l'entropie sont utilisés pour cela.

V.2. Avantages et inconvénients des arbres

Les arbres de décision offrent plusieurs avantages. Ils sont faciles à comprendre et à interpréter, et leur visualisation est intuitive.

Ils peuvent gérer à la fois des données numériques et catégorielles sans nécessiter d'encodage complexe. Ils ne nécessitent pas de normalisation ou de standardisation des caractéristiques.

Cependant, les arbres de décision peuvent être sujets au surapprentissage (overfitting) s'ils sont trop profonds. Ils peuvent également être instables, de petites variations dans les données d'entraînement pouvant entraîner des arbres très différents.

V.3. Concept de l'ensemble learning : Forêts Aléatoires (Random Forest)

Pour pallier les inconvénients des arbres de décision uniques, l'approche de l'apprentissage d'ensemble (Ensemble Learning) a été développée. La Forêt Aléatoire (Random Forest) en est un excellent exemple.

Une Forêt Aléatoire construit un grand nombre d'arbres de décision indépendants. Pour la classification, la prédiction finale est la classe majoritaire votée par les arbres. Pour la régression, c'est la moyenne des prédictions des arbres.

Deux mécanismes clés contribuent à la performance des Forêts Aléatoires : le "bagging" (bootstrap aggregating) et la sélection aléatoire des caractéristiques à chaque division. Cela réduit le surapprentissage et la variance.

V.4. Implémentation et hyperparamètres

L'implémentation des arbres de décision et des Forêts Aléatoires avec Scikit-learn est aussi simple que pour les modèles précédents.

Ces modèles ont de nombreux hyperparamètres que tu peux ajuster pour optimiser leurs performances. Par exemple, la profondeur maximale de l'arbre (max_depth) ou le nombre d'arbres dans une forêt (n_estimators).

from sklearn.ensemble import RandomForestClassifier

# Utiliser X_train, X_test, y_train, y_test des exemples précédents

model_rf_clf = RandomForestClassifier(n_estimators=100, random_state=42)
model_rf_clf.fit(X_train, y_train)

y_pred_rf = model_rf_clf.predict(X_test)
accuracy_rf = accuracy_score(y_test, y_pred_rf)
print(f"Accuracy de la Forêt Aléatoire : {accuracy_rf:.2f}")
print("Rapport de classification Forêt Aléatoire :\n", classification_report(y_test, y_pred_rf))

VI. Cas Pratiques et Bonnes Pratiques en ML

VI.1. Gestion du surapprentissage (overfitting) et sous-apprentissage (underfitting)

Comprendre et gérer le surapprentissage et le sous-apprentissage est fondamental en Machine Learning. Ces deux phénomènes représentent un équilibre délicat.

Le sous-apprentissage (underfitting) se produit lorsque ton modèle est trop simple pour capturer la complexité des données. Il a de mauvaises performances sur l'entraînement et le test.

Le surapprentissage (overfitting) arrive quand ton modèle est trop complexe et a mémorisé les données d'entraînement, y compris le bruit. Il aura une excellente performance sur l'entraînement, mais une mauvaise sur le test.

Pour lutter contre le surapprentissage, tu peux réduire la complexité du modèle (moins de caractéristiques, profondeur d'arbre limitée), utiliser plus de données, ou appliquer des techniques de régularisation. Pour le sous-apprentissage, tu dois augmenter la complexité du modèle ou ajouter des caractéristiques pertinentes.

VI.2. Validation croisée (Cross-validation)

La validation croisée est une technique robuste pour évaluer la performance de ton modèle et réduire la variance de l'estimation.

Au lieu de diviser tes données une seule fois en entraînement/test, la validation croisée divise les données en plusieurs sous-ensembles. Le modèle est entraîné et évalué plusieurs fois sur différentes combinaisons de ces sous-ensembles.

Cette méthode donne une estimation plus fiable de la performance généralisée de ton modèle. Elle est particulièrement utile pour le réglage des hyperparamètres.

VI.3. Pipeline de Machine Learning

Lorsque tu construis un modèle de Machine Learning, plusieurs étapes se succèdent : prétraitement, sélection de caractéristiques, entraînement du modèle, etc.

Les Pipelines Scikit-learn te permettent de chaîner ces étapes de manière organisée. Cela rend ton code plus propre, plus lisible et moins sujet aux erreurs.

VI.4. Interprétabilité et explicabilité des modèles

Dans de nombreux domaines, il ne suffit pas que le modèle soit performant ; il doit aussi être compréhensible. L'interprétabilité est la capacité à expliquer les prédictions du modèle.

Pourquoi le modèle a-t-il prédit un certain prix ? Quelles caractéristiques ont été les plus importantes pour classer un e-mail comme spam ? Ces questions sont essentielles.

Certains modèles, comme la régression linéaire ou les arbres de décision simples, sont intrinsèquement plus interprétables. Pour les modèles plus complexes (comme les forêts aléatoires), des techniques d'explicabilité (ex: SHAP, LIME) sont nécessaires.

Récapitulatif Final

Félicitations ! Tu as parcouru les fondamentaux du Machine Learning, de la préparation des données aux modèles de régression et de classification. Voici un tableau synthétique pour fixer les idées :

Exercices d'Application Rapides

1. Nettoyage de données : Tu as un DataFrame Pandas df_clients avec une colonne 'Âge' contenant des valeurs manquantes. Propose une ligne de code Python pour remplacer ces valeurs manquantes par la médiane de la colonne 'Âge'.

   Correction :

   df_clients['Âge'].fillna(df_clients['Âge'].median(), inplace=True)

2. Régression Linéaire : Si un modèle de régression linéaire a un $R^2$ de 0.95 sur son jeu d'entraînement et un $R^2$ de 0.10 sur son jeu de test, quelle conclusion peux-tu en tirer ?

   Correction :

   Cela indique un fort surapprentissage (overfitting). Le modèle a parfaitement mémorisé les données d'entraînement mais ne généralise pas du tout aux nouvelles données.

3. Classification : Dans un problème de classification binaire, ton modèle prédit 10 Vrais Positifs, 5 Faux Positifs, 3 Faux Négatifs et 80 Vrais Négatifs. Calcule la Précision et le Rappel de ce modèle.

   Correction :

   Précision = $VP / (VP + FP) = 10 / (10 + 5) = 10 / 15 \approx 0.67$

   Rappel = $VP / (VP + FN) = 10 / (10 + 3) = 10 / 13 \approx 0.77$

4. Type de Modèle : Pour prédire si un étudiant réussira ou échouera à un examen, quel type d'algorithme de Machine Learning (régression ou classification) devrais-tu utiliser et pourquoi ?

   Correction :

   Tu devrais utiliser un algorithme de classification. La variable cible ("réussira" ou "échouera") est une catégorie discrète, pas une valeur continue.

Comment ORBITECH Peut T'aider

Chez ORBITECH AI Academy, nous sommes là pour faciliter ton parcours en Machine Learning. Nos outils sont conçus pour te donner les clés de la réussite et t'aider à maîtriser chaque concept, de la théorie à la pratique. Nous t'accompagnons dans la structuration de tes révisions et la mise en application de tes connaissances en Data Science.

• Générateur d'Exercices : Crée des exercices sur mesure pour pratiquer la régression, la classification, ou la préparation des données avec des données variées.
• Générateur de Flashcards : Mémorise les définitions et les formules clés du Machine Learning de manière efficace et ludique.
• Générateur de Résumés : Obtiens des synthèses claires des concepts complexes comme la descente de gradient ou les métriques d'évaluation.
• Bloc-Notes : Organise tes codes Python, tes notes de cours et tes réflexions pour garder une trace structurée de ton apprentissage en ML.