Utilisez des modèles supervisés non linéaires

Il n'y a pas qu'aux SVM que l'on peut appliquer l'astuce du noyau ! Elle marche avec un certain nombre d'algorithmes linéaires, par exemple, la régression ridge régularisée.

Prenons n points en p dimensions, décrits par la matrice X (de taille n x p), et leurs étiquettes, décrites par le vecteur y (de taille n).

Pour une nouvelle observation x, la prédiction de la régression ridge est :

$\$\backslash (f(x)\; =\; x\; \backslash beta\backslash )\$$

où $\$\backslash (\backslash beta\; \backslash )\$$ est un vecteur colonne de taille p, donné par $\$\backslash (\backslash beta\; =\; (\; \backslash lambda\; I\_p\; +\; X^\backslash top\; X)^\{-1\}\; X^\backslash top\; y\backslash )\$$ . Je note $\$\backslash (I\_p\backslash )\$$ la matrice identité de taille p x p.

Ainsi donc

$\$\backslash (f(x)\; =\; x\; (\; \backslash lambda\; I\_p\; +\; X^\backslash top\; X)^\{-1\}\; X^\backslash top\; y.\backslash )\$$

Cette équation peut se réécrire sous la forme

$\$\backslash (f(x)\; =\; x\; X^\backslash top\; (\; \backslash lambda\; I\_n\; +\; X\; X^\backslash top)^\{-1\}\; y\backslash )\$$

Cela nécessite quelques manipulations mathématiques, que vous trouverez ci-dessous mais qui ne sont pas essentielles à la compréhension, si vous admettez cette réécriture...

En effet, en multipliant à gauche l'expression qui définit $\$\backslash (\backslash beta\backslash )\$$ par  $\$\backslash ((\; \backslash lambda\; I\_p\; +\; X^\backslash top\; X)\backslash )\$$ , on obtient : $\$\backslash ((\; \backslash lambda\; I\_p\; +\; X^\backslash top\; X)\; \backslash beta\; =\; X^\backslash top\; y\backslash )\$$ et donc $\$\backslash (\backslash beta\; =\; X^\backslash top\; \backslash alpha\backslash )\$$ où $\$\backslash (\backslash alpha\; =\; \backslash frac\{1\}\{\backslash lambda\}\; \backslash left(y\; -\; X\backslash beta\; \backslash right).\backslash )\$$

En remplaçant $\$\backslash (\; \backslash beta\; \backslash )\$$ par $\$\backslash (\; X^\backslash top\; \backslash alpha\; \backslash )\$$ dans la définition de $\$\backslash (\; \backslash alpha,\; \backslash )\$$ on obtient $\$\backslash (\backslash lambda\; \backslash alpha\; =\; y\; -\; X\; X^\backslash top\; \backslash alpha\backslash )\$$ et donc $\$\backslash (\backslash alpha\; =\; (\; \backslash lambda\; I\_n\; +\; X\; X^\backslash top)^\{-1\}\; y.\backslash )\$$

Revenons maintenant à f : $\$\backslash (f(x)\; =\; x\; \backslash beta\; =\; x\; X^\backslash top\; \backslash alpha\backslash )\$$ et  nous avons donc bien notre équation

$\$\backslash (f(x)\; =\; x\; X^\backslash top\; (\; \backslash lambda\; I\_n\; +\; X\; X^\backslash top)^\{-1\}\; y\backslash )\$$

Supposons maintenant une application  $\$\backslash (\backslash phi\backslash )\$$ vers un espace de redescription H. Appliquons maintenant la régression ridge dans H :

$\$\backslash (f\_\backslash phi(x)\; =\; \backslash phi(x)\; \backslash Phi^\backslash top\; (\; \backslash lambda\; I\_n\; +\; \backslash Phi\; \backslash Phi^\backslash top)^\{-1\}\; y\backslash )\$$

où $\$\backslash (\backslash Phi\backslash )\$$ est la matrice de taille n x d (d étant la dimension de H) dont la i-ième ligne est l'image du i-ème point du jeu de données dans H, autrement dit le vecteur $\$\backslash (\backslash phi(x^\{(i)\})\backslash )\$$ .

À cette application $\$\backslash (\backslash phi\backslash )\$$ correspond un noyau, défini par $\$\backslash (k(x,\; x\text{'})\; =\; \backslash langle\; \backslash phi(x),\; \backslash phi(x\text{'})\; \backslash rangle.\backslash )\$$

Il suffit maintenant de remplacer le vecteur $\$\backslash (\backslash phi(x)\; \backslash Phi^\backslash top\; \backslash )\$$ par le vecteur $\$\backslash (\; \backslash kappa\backslash )\$$ et la matrice $\$\backslash (\backslash Phi\; \backslash Phi^\backslash top\; \backslash )\$$ par la matrice de Gram K, où $\$\backslash (\backslash kappa\; =\; (\; k(x,\; x^\{(1)\}),\; k(x,\; x^\{(2)\}),\; \backslash dots,\; k(x,\; x^\{(n)\}))\backslash )\$$ et K, comme pour les SVMs est la matrice n x n telle que $\$\backslash (\; K\_\{il\}\; =\; k(x^\{(i)\},\; x^\{(l)\}).\backslash )\$$

On peut donc écrire

$\$\backslash (f\_\backslash phi(x)\; =\; \backslash kappa\; (\; \backslash lambda\; I\_n\; +\; K)^\{-1\}\; y\backslash )\$$

et ici aussi, comme dans le cas des SVMs, entraîner et utiliser une régression ridge dans l'espace de redescription sans avoir à connaître $\$\backslash (\; \backslash phi\; \backslash )\$$ ni à calculer explicitement l'image d'aucun point par cette application !

Cette méthode, que l'on appelle donc, vous l'aurez deviné, la régression ridge à noyau, s'appelle kernel ridge regression en anglais (ou kRR).

L'astuce du noyau ne nous permet pas de déterminer $\$\backslash (\backslash beta\; \backslash )\$$ explicitement. D'ailleurs souvenez-vous, dans le cas du noyau RBF gaussien, l'espace de redescription est de dimension infinie, et donc \beta aussi... Ça n'aurait pas grand sens d'essayer de le calculer !

Contrairement à sa version linéaire, la version à noyau de la régression ridge ne nous donne pas une forme explicite de la fonction de décision f en fonction des variables. C'est ce qu'on appelle une approche non-paramétrique (eh oui, malgré les paramètres du noyau), comme pour la SVM à noyau.

Il existe bien d'autres approches non-paramétriques, en particulier la méthode des plus proches voisins ou les arbres de décisions et les forêts aléatoires.

Les modèles appris par la régression ridge et une SVR ont exactement la même forme, mais pas les mêmes coefficients. En effet, on a choisi d'optimiser des fonctions de perte différentes pour l'une et pour l'autre. Dans le cas de la régression ridge, on choisit de minimiser l'erreur quadratique entre la prédiction et la réalité. Pour la SVR, on utilise en fait une fonction de perte dite insensible à \epsilon, c'est à dire qu'elle vaut la valeur absolue de la différence entre la prédiction et la réalité, sauf si cette différence est faible, comprise entre $\$\backslash (-\backslash epsilon\backslash )\$$ et $\$\backslash (\backslash epsilon\backslash )\$$ , auquel cas on l'estime négligeable et la fonction de perte vaut 0.

En pratique, entraîner une kRR sera plus efficace car la solution est analytique est exacte ; prédire sera par contre plus rapide avec une SVR.

En pratique avec scikit-learn

La régression ridge à noyau est implémentée dans scikit-learn dans la classe kernel_ridge.KernelRidge.

Nous allons utiliser les données concernant les caractéristiques physico-chimiques de vins blancs portugais disponibles sur l'archive UCI. Il s'agit ici de prédire le score (entre 3 et 9) donné par des experts aux différents vins.

Chargeons les données, séparons-les en un jeu d'entraînement et un jeu de test contenant respectivement 70% et 30% des données, et standardisons les variables sur le jeu d'entraînement.

# charger les données
import pandas as pd
data = pd.read_csv('winequality-white.csv', sep=';')

# créer la matrice de données
X = data[data.columns[:-1]].values

# créer le vecteur d'étiquettes
y = data['quality'].values

# créer un jeu d'entrainement et un jeu de test (30% des données)
from sklearn import model_selection
X_train, X_test, y_train, y_test = \
    model_selection.train_test_split(X, y, test_size=0.3)
                                
# standardiser les données
from sklearn import preprocessing
std_scale = preprocessing.StandardScaler().fit(X_train)
X_train_std = std_scale.transform(X_train)
X_test_std = std_scale.transform(X_test)                               

Nous pouvons maintenant entraîner une kRR sur le jeu d'entraînement en utilisant des paramètres par défaut pour le paramètre de régularisation et la bande passante du noyau RBF gaussien :

from sklearn import kernel_ridge
predicteur = kernel_ridge.KernelRidge(
    alpha=1.0, # valeur par défaut 
    kernel='rbf', # noyau Gaussien
    gamma=0.01)   # valeur de 1/(2 * sigma**2)
                                     
# entraîner le classifieur sur le jeu d'entrainement
predicteur.fit(X_train_std, y_train)

# prédire sur le jeu de test
y_test_pred = predicteur.predict(X_test_std)

# calculer la RMSE sur le jeu de test
from sklearn import metrics
rmse = np.sqrt(metrics.mean_squared_error(y_test, y_test_pred))
print("RMSE: {:.2f}".format(rmse))

On obtient une RMSE de 0.72, ce qui est correct pour des nombres entiers allant de 3 à 9.

Pour visualiser les prédictions, on peut utiliser un nuage de points dans lequel la surface de chaque point est proportionnelle au nombre d'observations ayant exactement ces valeurs de score prédit et de score réel. Pour plus de détails, vous pouvez vous référer à la procédure utilisée dans le cours Comparez votre algorithme à des approches de régression naïves.

# créer une figure
fig = plt.figure(figsize=(6, 6))

# Compter, pour chaque paire de valeurs (y, y') où y est un vrai score et y' le score prédit,
# le nombre de ces paires.
# Ce nombre sera utilisé pour modifier la taille des marqueurs correspondants 
# dans un nuage de points
sizes = {}
for (yt, yp) in zip(list(y_test), list(y_test_pred)):
    if (yt, yp) in sizes.keys():
        sizes[(yt, yp)] += 1
    else:
        sizes[(yt, yp)] = 1        
keys = sizes.keys()

# afficher les prédictions
plt.scatter([k[0] for k in keys], 
            [k[1] for k in keys], 
             s=[sizes[k] for k in keys], 
            label="gamma = 0.01: RMSE = {:.2f}".format(rmse))

# étiqueter les axes et le graphique
plt.xlabel('Vrai score', fontsize=16)
plt.ylabel(u'Score prédit', fontsize=16)
plt.title('kernel Ridge Regression', fontsize=16)

# limites des axes
plt.xlim([2.9, 9.1])
plt.ylim([2.9, 9.1])

# afficher la légende
plt.legend(loc="lower right", fontsize=12)

On obtient le graphique suivant :

On observe une corrélation entre les scores prédits et les score réels.

Comme dans le cas de la SVM à noyau, le paramètre gamma du noyau RBF gaussien joue un rôle important : s'il est trop élevé, la matrice de Gram sur le jeu d'entraînement est dominée par sa diagonale et la kRR ne peut pas apprendre. Si l'on recommence avec gamma=50, on obtient les prédictions suivantes :

Les prédictions avec gamma=50 sont de très mauvaise qualité!

Pour optimiser le paramètre de régularisation alpha et le paramètre gamma du noyau gaussien, on peut utiliser une recherche sur grille :

# valeurs du paramètre C
alpha_range = np.logspace(-2, 2, 5)

# valeurs du paramètre gamma
gamma_range = np.logspace(-2, 1, 4)

# grille de paramètres
param_grid = {'alpha': alpha_range, 'gamma': gamma_range}

# score pour sélectionner le modèle optimal
score = 'neg_mean_squared_error'

# initialiser la validation croisée
grid_pred = model_selection.GridSearchCV(
        kernel_ridge.KernelRidge(kernel='rbf'),
        param_grid,
        cv=5,
        scoring=score)
                                    
# exécuter la validation croisée sur le jeu d'entraînement
grid_pred.fit(X_train_std, y_train)

# prédire sur le jeu de test avec le modèle sélectionné 
y_test_pred_cv = grid_pred.predict(X_test_std)

# calculer la RMSE correspondante
rmse_cv = np.sqrt(metrics.mean_squared_error(y_test, y_test_pred_cv))

On obtient une RMSE légèrement meilleure (0.71) en optimisant le modèle.

Les prédictions faites se superposent à peu près à celles obtenues avec gamma=0.01 :

En résumé

• Tout comme pour la SVM, l’astuce du noyau permet d’utiliser la régression ridge sur des problèmes non linéaires.

• La SVR et kRR s’appliquent sur des problèmes de régression. 

• La validation croisée permet de choisir les bons hyperparamètres lors de l’utilisation de ces algorithmes avec Scikit-learn.

Vous avez découvert comment appliquer des algorithmes linéaires à des problèmes non linéaires.

Il est maintenant temps de tester vos connaissances à l’aide d’un petit quizz dans le chapitre suivant. Bonne chance !