Machine Learning 1 — Starter

:::tip Notebook Kaggle Le code complet et exécutable de ce chapitre est sur Kaggle : Ouvrir →

Versions anglaise et chinoise disponibles depuis la page d'accueil. :::

Premier chapitre du cours. Nous y revisitons les outils Python que nous allons utiliser tout au long du parcours, et nous terminons sur la programmation orientée objet — un détour important parce qu'au prochain chapitre, nous coderons une régression linéaire à la main, sous forme d'une classe.

Pourquoi ce chapitre ?

En Machine Learning, nous passons 80 % du temps à manipuler des données et 20 % à entraîner des modèles. Ce premier chapitre donne les briques de cette manipulation :

• NumPy pour les calculs numériques (vecteurs, matrices, opérations vectorisées) ;
• pandas pour la lecture des fichiers CSV et la manipulation tabulaire ;
• Seaborn et Plotly pour visualiser ;
• les classes Python pour structurer les modèles.

NumPy : le calcul numérique vectorisé

Un tableau NumPy est l'équivalent d'une liste Python, mais beaucoup plus rapide pour les calculs numériques car il s'appuie sur du code C optimisé.

import numpy as np

x = np.array([1, 2, 3, 4])           # vecteur 1D, shape (4,)
X = np.array([[1, 2], [3, 4]])       # matrice 2D, shape (2, 2)

L'attribut .shape donne les dimensions. C'est la première chose à regarder quand vous prenez en main un tableau.

Opérations vectorisées

NumPy applique les opérations élément par élément, sans boucle Python :

x + 1     # ajoute 1 à chaque élément
x * 2     # multiplie chaque élément par 2
x ** 2    # met chaque élément au carré
np.sum(x), np.mean(x), np.std(x)

C'est plus court à écrire et bien plus rapide qu'une boucle for.

Produit matriciel et opérateur @

Le produit matriciel — que l'on retrouve partout en ML — utilise l'opérateur @ :

$\hat{y} = X w$

X = np.array([[1, 2], [3, 4], [5, 6]])   # (3, 2)
w = np.array([0.5, 1.0])                  # (2,)
X @ w                                     # (3,) — produit matriciel

:::warning Piège classique X * w fait un produit élément par élément (avec broadcast), pas un produit matriciel. Toujours préférer @ quand on veut $X w$. :::

pandas : manipulation tabulaire

pandas, c'est le pont entre les fichiers de données (CSV, Excel) et le code Python. La structure centrale est le DataFrame, l'équivalent en code d'une feuille Excel.

import pandas as pd

df = pd.read_csv('data.csv')
df.head()         # premières lignes
df.shape          # (n_lignes, n_colonnes)
df.info()         # types, valeurs manquantes, mémoire
df.describe()     # min, max, moyenne, écart-type par colonne

Sélectionner des colonnes

df['co2']                    # une colonne → Series (1D)
df[['co2']]                  # même colonne, mais DataFrame (2D)
df[['consumption', 'co2']]   # plusieurs colonnes

La distinction Series vs DataFrame est importante : scikit-learn attend souvent du 2D pour les variables explicatives, d'où le [[...]] que vous rencontrerez souvent.

Statistiques rapides

df['co2'].mean()             # ou np.mean(df['co2'])
df['co2'].std()              # écart-type
df['co2'].min(), df['co2'].max()
df['co2'].describe()         # tout d'un coup

Visualiser : Seaborn et Plotly

Deux bibliothèques complémentaires :

• Seaborn : graphiques statistiques en une ligne (boxplot, scatter, KDE), syntaxe orientée DataFrame, sortie en image fixe.
• Plotly Express : graphiques interactifs (zoom, hover, déplacement), idéal pour explorer.

import seaborn as sns
import plotly.express as px

sns.boxplot(y=df['co2'])             # statique
px.scatter(df, x='consumption', y='co2', trendline='ols')   # interactif

Le boxplot résume une distribution en 5 nombres : minimum, $Q_1$ (25 %), médiane, $Q_3$ (75 %), maximum. La boîte va de $Q_1$ à $Q_3$ — l'intervalle interquartile $IQR = Q_3 - Q_1$ qui contient 50 % des valeurs. Les points isolés sont les outliers (au-delà de $Q_1 - 1.5 \cdot IQR$ ou $Q_3 + 1.5 \cdot IQR$).

Classes Python — la POO

Avant la fin du chapitre, nous revoyons la programmation orientée objet. Pourquoi ? Parce qu'au chapitre suivant, nous allons coder un neurone linéaire sous forme d'une classe avec fit, predict, history — exactement comme le fait scikit-learn.

class Calculatrice:
    def __init__(self):
        self.memoire = 10        # attribut d'instance

    def add(self, x):
        self.memoire = self.memoire + x   # méthode qui modifie l'état

calc = Calculatrice()
calc.add(5)
print(calc.memoire)              # 15

Trois choses à retenir :

• __init__ est le constructeur, appelé automatiquement à la création d'un objet.
• self représente l'instance courante. Toujours premier paramètre des méthodes.
• Les attributs (self.memoire) gardent l'état de l'objet entre les appels.

Cette structure va devenir le patron standard des modèles que nous allons coder : __init__ pour initialiser, fit pour apprendre, predict pour prédire.

---

Notebook complet sur Kaggle (forkable) →