Les vecteurs et les matrices

Les maths du ML, en code · 50 min

Un objet décrit par une liste de nombres

Comment un ordinateur peut-il « comprendre » une maison ? Il ne la voit pas. On la lui décrit avec des nombres : sa surface, son nombre de chambres, sa distance au centre-ville.

maison A : [120, 3, 5]     120 m², 3 chambres, 5 km du centre
maison B : [80, 2, 12]

Tout devient vecteur :

• un élève : ses notes dans chaque matière ;
• une photo de 28 x 28 pixels en noir et blanc : 784 nombres, un par pixel ;
• un mot, dans les modèles de langage comme ChatGPT : des centaines de nombres qui résument son sens.

La distance entre deux vecteurs

Une maison de 120 m² à 5 km ressemble plus à une de 100 m² à 6 km qu'à une de 200 m² à 2 km. Pour mesurer cette ressemblance, on calcule une distance.

Entre [120, 3, 5] et [100, 3, 6] : différences 20, 0, -1, carrés 400, 0, 1, somme 401, racine environ 20,02.

a = np.array([120, 3, 5])
b = np.array([100, 3, 6])
np.sqrt(((a - b) ** 2).sum())      # 20.02...
np.linalg.norm(a - b)              # la même chose, en une fonction

C'est l'idée d'une des méthodes de machine learning les plus simples, les k plus proches voisins : pour estimer le prix d'une maison, on cherche les maisons les plus proches dont on connaît le prix.

import numpy as np

maisons = np.array([
    [120, 3, 5],
    [80, 2, 12],
    [200, 5, 2],
    [95, 3, 8],
])
prix = np.array([27500000, 17400000, 44400000, 22850000])
nouvelle = np.array([100, 3, 6])

distances = np.sqrt(((maisons - nouvelle) ** 2).sum(axis=1))
plus_proche = distances.argmin()
prix_estime = prix[plus_proche]
print(distances, plus_proche, prix_estime)

Le produit scalaire : une somme pondérée

Un agent immobilier a une règle pour estimer un prix :

prix = 5 000 000 + 150 000 x surface + 2 000 000 x chambres - 300 000 x distance

Chaque caractéristique est multipliée par un poids, puis on additionne. Pour la maison [120, 3, 5] : 5 000 000 + 18 000 000 + 6 000 000 - 1 500 000 = 27 500 000 FCFA.

maison = np.array([120, 3, 5])
poids = np.array([150000, 2000000, -300000])
prix = maison @ poids + 5000000     # 27500000

C'est exactement la forme d'un modèle linéaire, le modèle de machine learning le plus simple et l'un des plus utilisés :

prédiction = poids · caractéristiques + biais

Le nombre ajouté à la fin (5 000 000 ici) s'appelle le biais. « Apprendre », pour ce modèle, c'est trouver tout seul les bons poids et le bon biais à partir d'exemples dont on connaît le prix. C'est le sujet des deux prochaines leçons.

Les matrices

Avec une matrice de maisons (une maison par ligne), maisons @ poids calcule le produit scalaire de chaque ligne avec les poids : tous les prix d'un coup.

maisons @ poids + 5000000    # [27500000 17400000 44400000 22850000]

Un réseau de neurones comme ceux de ChatGPT fait surtout ça : des multiplications de matrices gigantesques, des milliards de fois. C'est pour ça que les GPU, très rapides pour ce calcul, sont au centre de l'IA.

import numpy as np


def predire(x, poids, biais):
    """Renvoie les prédictions d'un modèle linéaire pour chaque ligne de x."""
    return x @ poids + biais


maisons = np.array([[120, 3, 5], [80, 2, 12], [200, 5, 2], [95, 3, 8]])
vrais_prix = np.array([28000000, 16000000, 45000000, 23500000])
poids = np.array([150000, 2000000, -300000])

predictions = predire(maisons, poids, 5000000)
erreurs = predictions - vrais_prix
print(predictions)
print(erreurs)

Teste-toi