Sélection du noyau et des hyperparamètres pour la réduction de l'ACP par le noyau

Question

Je lis Apprentissage machine pratique avec Scikit-Learn et TensorFlow : Concepts, outils et techniques pour construire des systèmes intelligents

J'essaie d'optimiser un algorithme d'ACP à noyau non supervisé. Voici un peu de contexte :

Une autre approche, cette fois-ci entièrement non supervisée, consiste à sélectionner le noyau et h l'erreur de reconstruction la plus faible. Cependant, la reconstruction n'est pas aussi facile qu'avec l'ACP linéaire

....

Heureusement, il est possible de trouver un point dans l'espace original où se rapproche du point reconstruit. C'est ce qu'on appelle la pré-image de reconstruction. Une fois que vous avez cette pré-image, vous pouvez mesurer sa distance au carré par rapport à l'instance originale. Vous pouvez alors sélectionner le noyau et les hyperparamètres qui minimisent cette l'erreur de pré-image de reconstruction.

Une solution consiste à entraîner une régression supervisée. instances projetées comme l'ensemble d'apprentissage et cibles.

Vous pouvez désormais utiliser la recherche par grille avec des valeurs croisées. et les hyperparamètres qui minimisent l'erreur de reconstruction de la pré-image.

Le code fourni dans le livre pour effectuer la reconstruction sans validation croisée est le suivant :

rbf_pca = KernelPCA(n_components = 2, kernel="rbf", gamma=0.0433,fit_inverse_transform=True)
X_reduced = rbf_pca.fit_transform(X)
X_preimage = rbf_pca.inverse_transform(X_reduced)

>>> from sklearn.metrics import mean_squared_error
>>> mean_squared_error(X, X_preimage)
32.786308795766132

Ma question est la suivante : comment mettre en œuvre la validation croisée pour ajuster le noyau et les hyperparamètres afin de minimiser l'erreur de reconstruction de la pré-image ?

Voici ce que j'ai fait jusqu'à présent :

from sklearn.metrics import mean_squared_error
from sklearn.decomposition import KernelPCA

mean_squared_error(X, X_preimage)

kpca=KernelPCA(fit_inverse_transform=True, n_jobs=-1) 

from sklearn.model_selection import GridSearchCV

param_grid = [{
        "kpca__gamma": np.linspace(0.03, 0.05, 10),
        "kpca__kernel": ["rbf", "sigmoid", "linear", "poly"]
    }]

grid_search = GridSearchCV(clf, param_grid, cv=3, scoring='mean_squared_error')
X_reduced = kpca.fit_transform(X)
X_preimage = kpca.inverse_transform(X_reduced)
grid_search.fit(X,X_preimage)

Merci de votre attention.

Answer 1

GridSearchCV est capable d'effectuer une validation croisée de l'apprentissage non supervisé (sans un y ) comme on peut le voir ici dans la documentation :

fit(X, y=None, groups=None, **fit_params)

...
y : array-like, shape = [n_samples] or [n_samples, n_output], optional 
Target relative to X for classification or regression; 
None for unsupervised learning
...

La seule chose qui doit être gérée est donc la manière dont la scoring se fera.

Ce qui suit se produit dans GridSearchCV :

1. Les données X sera divisé en deux parties, formation et test, sur la base des plis définis dans la section cv paramètre

2. Pour chaque combinaison de paramètres que vous avez spécifiée dans param_grid le modèle sera formé sur les train de l'étape précédente et ensuite scoring sera utilisé sur test partie.

3. Les scores pour chaque combinaison de paramètres sera combinée pour tous les plis et fera l'objet d'une moyenne. La combinaison de paramètres la plus performante sera sélectionnée.

La partie la plus délicate est le point 2. Par défaut, si vous fournissez un 'string' dans ce cas, il sera converti en make_scorer en interne. Dans le cas d'un 'mean_squared_error' les Le code est ici :

....
neg_mean_squared_error_scorer = make_scorer(mean_squared_error,
                                        greater_is_better=False)
....

C'est ce que vous ne voulez pas, parce que cela nécessite y_true y y_pred .

L'autre option est de faire votre son propre évaluateur personnalisé, comme indiqué ici avec signature (estimator, X, y) . Quelque chose comme ce qui suit pour votre cas :

from sklearn.metrics import mean_squared_error
def my_scorer(estimator, X, y=None):
    X_reduced = estimator.transform(X)
    X_preimage = estimator.inverse_transform(X_reduced)
    return -1 * mean_squared_error(X, X_preimage)

Utilisez-le ensuite dans GridSearchCV comme suit :

param_grid = [{
        "gamma": np.linspace(0.03, 0.05, 10),
        "kernel": ["rbf", "sigmoid", "linear", "poly"]
    }]

kpca=KernelPCA(fit_inverse_transform=True, n_jobs=-1) 
grid_search = GridSearchCV(kpca, param_grid, cv=3, scoring=my_scorer)
grid_search.fit(X)