L'apprentissage supervisé est une méthode statistique pour modéliser la relation entre une variable `y` et une liste de variables `vec x = (x_1,x_2,x_3,...x_n)`. Elle ajuste une listes de paramètres `vec p = (p_1,p_2,p_3,...,p_d)` afin que le calcul `f(vec x,vec p)` produise une prédiction la plus proche de `y`. L'équation générale du modèle est donnée par :
`y = f(vec x,vec p) - epsilon`
où `f` est une fonction analytique quelconque permettant de définir toutes sortes d'apprentissages supervisés spécifiques, et où `epsilon` représente l'erreur de prédiction. La prédiction moins l'erreur de prédiction donne la valeur réelle.
La donnée d'entrée du modèle est appelée une observation. C'est la liste de `n` valeurs : `vec x = (x_1,x_2,x_3,...,x_n)`.
La donnée de sortie du modèle est appelée une observation cible. C'est la valeur `y`.
La mémoire d'apprentissage du modèle est une liste de paramètres qui s'ajustent : `vec p = (p_1,p_2,p_3,...,p_d)`
La fonction `f(vec x, vec p)` calcule la prédiction de `y` que l'on note `hat y= f(vec x, vec p)`
L'apprentissage automatique supervisé s'opère sur un jeux de `N` observations. Délors, lorsque l'on parle de la variable `vecx` et `y`, on désigne en fait `vecx_i` et `y_i`, pour un `i` donnée entre `1` et `N`, constituant la `i`ième observation. Les `n` composantes de `vecx_i` sont notées `x_(i,1),x_(i,2),...,x_(i,n)`. L'ensemble des données forme les matrices `X` et le vecteur `Y`. On note ainsi parfois simplement en majuscule les matrices et vecteurs. Le premier indice désigne le numéro de ligne. Le second indice désigne le numéro de colonne :
`AAi,AAj, X= [x_(i,j)]_(i,j)` `Y= [y_i]_i`
Par convention on utilise l'indice `i` pour parcourir les `N` observations. Et on utilise l'indice `j` pour parcourir les `n` composantes d'une observation. Chaque observation est un vecteur `vec(x_i) = (x_(i,1),x_(i,2),x_(i,3),...,x_(i,n))` et chaque observation cible est une valeur `y_i`. La valeur `x_(i,j)` représente la `j`ième composante de la `i`ième observation. La valeur `y_i` représente la `i`ième observation cible. La valeur `hat y_i` représente la `i`ième prédiction. L'erreur de prédiction `epsilon_i` représente l'écart entre la prédiction et la valeur réelle `epsilon_i = haty_i-y_i` pour la `i`ième observation. La prédiction à laquelle on enlève l'erreur de prédiction donne la valeur réelle.
On représente la liste des observations par la matrice `X`, et la liste des observations cibles par le vecteur `Y`, et la liste des prédictions par le vecteur `hat Y` , et la liste des erreurs de prédiction par le vecteur `E`. L'indice `i` indique le numéro de ligne (une observation par ligne). L'indice `j` indique le numéro de colonne.
`X= ((x_(1,1),x_(1,2),...,x_(1,n)),(x_(2,1),x_(2,2),...,x_(2,n)),(⫶,⫶,⋱,⫶),(x_(N,1),x_(N,2),...,x_(N,n)))` `Y=((y_1),(y_2),(⫶),(y_N))` `hat Y=((hat y_1),(hat y_2),(⫶),(hat y_N))` `E=hatY - Y`
L'apprentissage automatique supervisé va, à partir du jeu de données d'entrainement `X, Y`, ajuster les paramètres `vec p` pour obtenir une erreur `E` minimale. Mais, il faut définir ce qu'on entend par vecteur d'erreur `E` minimal. Il s'agit de comparer la variable statistique `epsilon` avec la valeur constante zéro. Dans le cas gaussien, l'indicateur de preformance est l'écart type, on minimise l'écart type de `epsilon` :
`sqrt(1/Nsum_i epsilon_i^2)` doit être minimal.
Cela revient à minimiser la somme des carrés, d'où le nom de "méthode des moindres carrés". L'apprentissage va alors ajuster les paramètres `vec p``=``(p_1,p_2,...,p_d)` afin que le vecteur `E``=``(epsilon_1,epsilon_2,...,epsilon_N)` définit par l'équation du modèle possède une somme de carré qui soit minimale.
`AAi, epsilon_i = F(x_(i,1),x_(i,2),...,x_(i,n),p_1,p_2,...,p_d)-y_i`
`sum_i epsilon_i^2` doit être minimal.
On garde néanmoins l'expression exacte de l'écart type sous la main, qui constitue une mesure intensive (et non extensive) de la performance gaussienne.
Pour maitriser facilement cette technique il faut avoir dans un premier temps une bonne représentation graphique de la façon dont sont rangées les données, sous forme de tableaux, de matrices et de vecteurs. Puis on donne des noms porteurs de sens intuitifs et on développer le langage mathématique pour pouvoir exprimer l'hypothèse par une simple formule sans ambiguité.
Récapitulons la disposition des données :
`x` Variable d'entrée, observation. `y` Variable de sortie, observation cible.
On considère `n` variables d'entrée comme autant de composantes de `x`. On ajoute donc une dimension représenté par l'indice `j` :
`n` Nombre de variables d'entrée. `j in {1,2,3,...,n}` Indice désignant la variable d'entrée. `x_1,x_2,x_3,...,x_n` Les `n` variables d'entrée. `vec(x)=(x_1,x_2,...x_n)` Forme vectorielle des variables d'entrée.
On considère `N` observations. On ajoute donc une dimension représenté par l'indice `i` :
`N` Nombre d'observations. `i in {1,2,3,...,N}` Indice désignant les observations. `vec(x_i) = ( x_(i,1),x_(i,2),x_(i,3), ... ,x_(i,n) )` `i`ième observation Les `N"×"n` données d'entrée. Le premier indice indique le numéro de l'observation.
Le second indice indique la variable d'entrée :
`(x_(1,1),x_(1,2),...,x_(1,n)),(x_(2,1),x_(2,2),...,x_(2,n)),...,(x_(N,1),x_(N,2),...,x_(N,n))``y_1,y_2,...,y_N` Les `N` données de sortie. Les observations cibles.
L'ensemble des données se mettent sous forme matricielle comme suit :
`X=[(x_(1,1),x_(1,2),...,x_(1,n)),(x_(2,1),x_(2,2),...,x_(2,n)),(⫶,⫶,⋱,⫶),(x_(N,1),x_(N,2),...,x_(N,n))]` `Y = [(y_1),(y_2),(⫶),(y_N)]`
Le premier indice est l'indice de ligne. Le second indice est l'indice de colonne.
Notez que cette disposition géométrique des matrices et vecteurs, transposées ou non, en lignes ou en colonnes, n'est qu'une convention. Ce qui compte dans la composition des matrices, c'est l'ordre des indices et le type de produit définit à l'aide de ces indices. D'une manière générale, à chaque fois que l'on ajoute une dimension en dézoomant l'échelle, on ajoute ici l'indice correspondant comme premier indice.
L'équation du modéle se décline pour chaque observation :
`y_1 = f(vec x_1,vec p) - epsilon_1`
`y_2 = f(vec x_2,vec p) - epsilon_2`
`y_3 = f(vec x_3,vec p) - epsilon_3`
`⫶`
`y_N = f(vec x_N,vec p) - epsilon_N`
Il convient donc d'adopter une notation pour pouvoir regrouper ces équations en une seule équation vectorielle :
`Y = F(X"|"vec p) - E`
Où, dans la liste des arguments d'une fonction, le symbôle `"|"` mis après le premier argument qui doit être une liste de listes, (ici, un vecteur colonne de vecteurs lignes, autrement dit, une matrice), indique que la fonction s'applique à chaque terme de la liste (ici à chaque terme du vecteur colonne) en complétant avec le même reste des arguments, pour produire le vecteur image :
`F(X"|"vec p) = ((f(vecx_1,vecp)),(f(vecx_2,vecp)),(⫶),(f(vecx_N,vecp)))` `X=((vecx_1),(vecx_2),(⫶),(vecx_N))` `AAi, vecx_i"="(x_(i,1),x_(i,2),...,x_(i,n))`
---- 17 novembre 2025 ----
La fonction `F(X"|"vecp)` étant analytique, au voisinage d'un `X`, elle se comporte linéairement selon `dvecp`. Cela signifie qu'une petite variation des paramètres `dvecp` va opérer linéairement une petite variation de `dF`. Il existe donc une matrice `M` telle que :
`dF = Mdvecp`
Par définition, cette matrice s'appelle la dérivé de `F` par `vecp`. On voit donc que le problème doit être traité d'abord dans le cas où les paramètres forment avec les variables d'entrée une combinaison linéaire.
---- 17 novembre 2025 ----
On choisit généralement comme métrique la norme des vecteurs qui correspond la distance de Pythagore. L'apprentissage automatique supervisé va, à partir du jeu de données d'entrainement `X, Y`, trouver les paramètres `vec p` pour obtenir un vecteur d'erreur `E` de norme minimale. Cela est la même chose que d'obtenir `E` de carré `E^2=E"·"E` minimum. Où l'opération `"·"` est le produit scalaire. Cela correspond la méthode des moindres carrés. La recherche d'un extrêmum revient à rechercher les valeurs de dérivée nulle :
`(d(E^2))/(dvecp) = vec 0`
Nous traiterons dans la partie suivante (Calcul différentiel vectoriel) comment développer cette dérivée et l'estimer empiriquement.
Les données de test servent à mesurer le taux d'erreur auquel on peut s'attendre en production sur les futures observations. Elles ne doivent pas faire parties des données d'entrainement. C'est un principe issu du principe de séparation des pouvoirs assez simple à comprendre. Sans cela, le test perd sa valeur de test.
Un modèle est en situation de surapprentissage lorsque ses performances sont très satisfaisantes sur les données d'entrainements, mais médiocre sur les données de test.
La validation croisée tente de mesurer ce niveau de surapprentissage. La méthode de base "Hold Out" sépare les données d'entrainements et les données de test, et compare les performances sur les deux groupes. La méthode "k-fold" consiste à partitionner les données en k jeux de données, puis à entrainer le modèle sur tous les jeux de données sauf un et de mesurer la performance des prédictions sur ce jeu de données, puis de refaire toute l'opération ainsi pour chaque jeux de données et de faire la moyenne des performances. La méthode "Leave One" consiste à entrainer le modèle sur toutes les données sauf une et de mesurer la performance de la prédiction sur cette donnée, puis de refaire toute l'opération ainsi pour chaque données et de faire la moyenne des performances.
Les hyperparamètres sont fixes lors d'un apprentissage et détermine l'évolution des paramètres lors de la phase d'apprentissage. Ils ne sont pas utilisés pour calculer un pronostique, qui est calculé à l'aide des seuls paramètres. Si on souhaite ajuster les hyperparamètres, alors selon un même principe de séparation des pouvoirs, il faut prévoir 3 jeux séparés de données ; un jeux de données d'entrainement, un jeux de données de validation, et un jeux de données de test. Les données d'entrainement permettent l'ajustement des paramètres du modèle. Les données de validation permettent de tester la performance de cet apprentissage pour un jeux d'hyperparamètres donné, et donc permettent l'ajustement des hyperparamètres du modèle. Et enfin les paramètres de teste servent a mesurer la performance finale sur les données de production.
Les premiers algorithmes d'apprentissages automatiques découlent de la nature mathématique des données traités. Il s'agit d'une construction quasi-canonique, l'essentiel des choix découlent de source et ne sont guidés par aucun arbitraire. Selon que les variables d'entrée ou de sortie sont de valeur discrète désignant une classe dans un ensemble de classes, ou de valeur continue ordonnée dans un corps, l'algorithme change de forme. Il y a donc 4 types d'algorithmes et qui peuvent se mixer.
Lorsque les valeurs d'entrée et de sortie sont continues, on parlera d'algorithme de regression.
Lorsque les valeurs d'entrée et de sortie sont discrètes et désigne des classes, on parlera d'algorithme de classification.
...
Cela se fait en définissant une métrique, telle que par exemple la norme cartésienne d'un vecteur.
Le pronostique est noté avec un chapeau `hat y_i "=" F(vec x_i, vec p)`. La performance est parfaite si `AAi, hat y_i "=" y_i`.
Par convention, la somme en `i` désigne la somme pour chaque donnée d'observation : `sum_i = sum_(i=1)^(i=N)`
La moyenne des observations cible se note `bar y` :
`bar y = 1/N sum_i y_i`
Voici les 5 mesures courantes de la performance du pronostic pour les algorithmes de regression :
Dans le cas simple d'une classification binaire `y "∈" {0,1}`, on utilise la matrice de confusion binaire définie comme suit :
`((V0,F1),(F0,V1)) = ( ( sum_i (y_i "=" 0 "et" hat y_i "=" 0), sum_i (y_i "=" 0 "et" hat y_i "=" 1)),(sum_i (y_i "=" 1 "et" hat y_i "=" 0),sum_i (y_i "=" 1 "et" hat y_i "=" 1))) `
où les proposition valent `0` si elle sont fausse, et valent `1` si elles sont vraies, d'où les appellations courantes suivantes :
Nombre d'observations où la prédiction est bonne `hat y"="y` et où `y"="0`. Nombre d'observations où la prédiction est bonne `hat y"="y` et où `y"="1`. Nombre d'observations où la prédiction est fausse `hat y"≠"y` et où `y"="0`. Nombre d'observations où la prédiction est fausse `hat y"≠"y` et où `y"="1`.
Voici quelques mesures de la performance de la prédiction pour les algorithmes de classification binaire :
Dans le cas générale d'une classification `y "∈" {1,2,3,...,c}`, on utilise la matrice de confusion de dimension `c` définie comme suit :
où `Q_(a,b)` est le nombre d'observations ou `y"="a` et `hat y "="b` :`( (Q_(1,1),Q_(1,2),Q_(1,3),...,Q_(1,c)), (Q_(2,1),Q_(2,2),Q_(2,3),...,Q_(2,c)), (Q_(3,1),Q_(3,2),Q_(3,3),...,Q_(3,c)),(⫶,⫶,⫶,⋱,⫶),(Q_(c,1),Q_(c,2),Q_(c,3),...,Q_(c,c)))`
`Q_(a,b) = sum_i (y_i "=" a "et" hat y_i "=" b)`
Voici quelques mesures de la performance de la prédiction pour les algorithmes de classification multiple :
Le taux de réussite du modèle est définie par `(Q_(1,1)"+"Q_(2,2)"+"..."+"Q_(c,c))/N`. C'est la probabilité de réussite, notée `sf"P"(hat y"="y)`.
`sf"P"(hat y"="y) = 1/N sum_i (hat y_i"="y_i) = (Q_(1,1)"+"Q_(2,2)"+"..."+"Q_(c,c))/N`
Le Recall de la classe `a`. C'est la probabilité conditionnelle de réussite sachant `y"="a`, notée `sf"P"(hat y"="y | y"="a)`
`sf"P"(hat y"="y | y"="a) = (sum_i (hat y_i"="y_i "et" y_i"="a))/(sum_i y_i"="a) = (Q_(a,a))/(Q_(a,1)"+"Q_(a,2)"+"..."+"Q_(a,c))`
Lien Calcul différentiel :
.