Les Fondations du Machine Learning

Introduction et Régression : Prédire des Valeurs

Le Machine Learning (ML) n'est pas de la magie, c'est des mathématiques appliquées. Dans cette section, nous allons comprendre comment une machine "apprend" à prédire un chiffre (par exemple le prix d'un appartement).

Le Concept de l'Apprentissage Supervisé

Imaginez que vous apprenez à un enfant à reconnaître des fruits. Vous lui montrez une pomme et dites "Pomme". Vous lui montrez une banane et dites "Banane".

• Données (X) : L'image du fruit.
• Étiquette (y) : Le nom du fruit.
• But : Quand l'enfant voit un nouveau fruit sans étiquette, il devine le nom.

C'est l'essence de l'apprentissage supervisé : apprendre une fonction qui mappe X vers y.

La Régression Linéaire

C'est l'algorithme le plus simple pour prédire une valeur continue. Il cherche à tracer la "meilleure droite" qui passe à travers vos données.

Voici comment le processus fonctionne :

Micro-Exercice : Votre Première Prédiction

Nous allons utiliser scikit-learn, la bibliothèque standard en Python.

Objectif : Prédire le salaire en fonction des années d'expérience.

import numpy as np
from sklearn.linear_model import LinearRegression

# 1. Données (X=Années, y=Salaire)
X = np.array([[1], [2], [3], [4]])
y = np.array([25000, 35000, 45000, 55000])

# 2. Création et entraînement du modèle
model = LinearRegression()
model.fit(X, y)

# 3. Prédiction pour 5 ans d'expérience
prediction = model.predict([[5]])

print(f"Salaire prédit pour 5 ans : {prediction[0]:.0f}€")

Classification et Clustering : Trier les Données

Parfois, on ne veut pas prédire un chiffre, mais une catégorie (Oui/Non, Chat/Chien, Spam/Normal).

Classification : K-Nearest Neighbors (KNN)

L'algorithme des "K plus proches voisins" est très intuitif : "Dis-moi qui sont tes voisins, je te dirai qui tu es".

1. Pour classer un nouveau point, on regarde les K points les plus proches dans les données connues.
2. Si la majorité sont des "Triangles", le nouveau point devient un "Triangle".

Apprentissage Non-Supervisé : K-Means

Ici, pas d'étiquettes. On donne des données en vrac à l'algorithme et on lui dit : "Trouve des groupes (clusters) logiques".

Micro-Exercice : Classification de Fleurs

Utilisons le célèbre dataset Iris pour classer des fleurs selon leurs pétales.

from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

# 1. Charger les données
iris = load_iris()
X, y = iris.data, iris.target

# 2. Séparer pour tester honnêtement (80% entraînement, 20% test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 3. Entraîner le KNN (K=3)
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

# 4. Évaluer
accuracy = knn.score(X_test, y_test)
print(f"Précision du modèle : {accuracy * 100:.2f}%")

Méthodologie : Comment ne pas se tromper

Avoir un modèle qui marche, c'est bien. Savoir pourquoi il marche (ou pas), c'est mieux.

Le Danger de l'Overfitting (Sur-apprentissage)

C'est quand votre modèle apprend "par cœur" les données d'entraînement, y compris le bruit et les erreurs.

• Symptôme : 100% de réussite sur l'entraînement, mais 50% sur les nouvelles données.
• Solution : Simplifier le modèle ou ajouter plus de données.

Métriques d'Évaluation

Ne vous fiez pas juste à la "Précision" globale.

Micro-Exercice : Matrice de Confusion

Visualisez où votre modèle se trompe.

from sklearn.metrics import confusion_matrix

# Supposons ces prédictions (0=Chat, 1=Chien)
y_vrai = [0, 0, 1, 1, 0, 1]
y_pred = [0, 1, 1, 1, 0, 1]  # Le modèle s'est trompé sur le 2ème

cm = confusion_matrix(y_vrai, y_pred)
print("Matrice de Confusion :\n", cm)