La régression par l’ACP¶
Dans les sections précédentes, nous avons vu que nous avons pu contrôler la variance en réduisant leurs coefficients vers zéro. Avec cette méthode, nous avons utilisé les prédicteurs \(X_{1}, X_{2}, \ldots, X_{p}\). Nous explorons maintenant une classe d’approches qui transforment les prédicteurs et ajustent ensuite un modèle des moindres carrés en utilisant les variables, cette fois, transformées. Nous appellerons ces techniques des méthodes de réduction dimensionnalité.
L’analyse en composantes principales (ACP) est une méthode non supervisée permettant d’identifier les variables pour lesquelles les données varient le plus. Supposons que nous ayons des variables \(X_{1}, X_{2}, \ldots, X_{k}\) et que nous souhaitions sélectionner une composante principale \(Z_{1}=\sum_{j} \phi_{j 1} X_{j} .\) Alors \(\phi_{j 1}\) sont sélectionnés de sorte que \(\sum \phi_{j 1}^{2}=1\) et la variance de
est maximisée. La direction de la composante principale est celle qui minimise la distance des données par rapport à la droite.
La deuxième composante principale est choisie pour maximiser la variance et pour être non corrélée à la première composante principale. Elle est perpendiculaire à la direction de la première composante principale. Ce processus peut être répété pour générer des composantes principales supplémentaires.
Avec \(n\) d’observations, les \(Z_{i}\) sont des vecteurs avec \(n\) de composantes tout comme les \(X_{i}\). Les composantes de \(Z_{1}\) sont
et il en va de même pour \(Z_{2}, \ldots, Z_{k}\), en remplaçant l’indice 1 dans la formule par l’indice de \(Z\). Les \(\phi_{j i}\) sont appelés loadings et les \(z_{i 1}\) sont appelés scores des composantes principales. \({ }^{2}\) Les scores sont les distances entre les points et la composante principale.
Par exemple, Pour deux variables \(X\) et \(Y\), si \(\bar{X}=5\), \(\bar{Y}=9\), et la composante principale est \(Z=0.6 X+0.8 Y\).
Alors le score de la composante principale de \((X Y)=(5.5,8.5)\) est égale à \(-0.1\)
\(0.6(5.5-5)+0.8(8.5-9)=-0,1\)
Soit \(Z_{1}, Z_{2}, \ldots, Z_{M}\) représentent \(M<p\) des combinaisons linéaires de nos prédicteurs \(p\) originaux. C’est-à-dire,
pour certaines constantes \(\phi_{1 m}, \phi_{2 m} \ldots, \phi_{p m}, m=1, \ldots, M .\) Nous pouvons alors ajuster le modèle de régression linéaire
en utilisant les moindres carrés. Notez que dans (6.17), les coefficients de régression sont donnés par. \(\theta_{0}, \theta_{1}, \ldots, \theta_{M}\). Si les constantes \(\theta_{0}, \theta_{1}, \ldots, \theta_{M}\) sont choisies judicieusement, alors ces approches de réduction dimensionnelle peuvent souvent surpasser la régression par moindres carrés. En d’autres termes, l’ajustement (6.17) à l’aide des moindres carrés peut donner de meilleurs résultats que l’ajustement \(Y=\beta_{0}+\beta_{1} X_{1}+\cdots+\beta_{p} X_{p}+\epsilon\) à l’aide des moindres carrés.
Le terme de réduction de la dimension vient du fait que cette approche réduit le problème de l’estimation des \(p+1\) coefficients \(\beta_{0}, \beta_{1}, \ldots, \beta_{p}\) au problème plus simple de l’estimation des \(M+1\) coefficients \(\theta_{0}, \theta_{1}, \ldots, \theta_{M}\), où \(M<p\). En d’autres termes, la dimension du problème a été réduite de \(p+1\) à \(M+1\).
Notez que de (6.16)
où $\( \beta_{j}=\sum_{m=1}^{M} \theta_{m} \phi_{j m} \tag{6.18} \)$
On peut donc considérer (6.17) comme un cas particulier du modèle de régression linéaire originale donné par (6.1). La réduction de la dimension sert à contraindre les coefficients estimés de \(\beta_{j}\), puisqu’ils doivent maintenant prendre la forme (6.18). Cette contrainte sur la forme des coefficients risque de biaiser les estimations des coefficients. Cependant, dans les situations où \(p\) est grand par rapport à \(n\), le choix d’une valeur de \(M \ll p\) peut réduire de manière significative la variance des coefficients ajustés. Si \(M=p\), et que tous les \(Z_{m}\) sont linéairement indépendants, alors (6,18) ne pose aucune contrainte. Dans ce cas, il n’y a pas de réduction de dimension, et l’ajustement (6.17) équivaut donc à effectuer des moindres carrés sur les p prédicteurs originaux.
Toutes les méthodes de réduction des dimensions fonctionnent en deux étapes. Tout d’abord, on obtient les prédicteurs transformés \(Z_{1}, Z_{2}, \ldots, Z_{M}\). Ensuite, le modèle est ajusté à l’aide de ces prédicteurs \(M\). Cependant, le choix de \(Z_{1}, Z_{2}, \ldots, Z_{M},\) ou de manière équivalente, la sélection des \(\phi_{j m}\), peut être réalisé de différentes manières; les composantes principales et les moindres carrés partiels. Dans ce cours, nous étudions la première approche.
Exemple¶
On vous donne les 5 observations suivantes de 2 variables :
\(X_1\) |
\(X_2\) |
|
|---|---|---|
1 |
5 |
|
2 |
7 |
|
4 |
4 |
|
6 |
3 |
|
9 |
1 |
Les loadings de la première composante principale sont \(-0.8297\) et \(0.5583\). Calculez le score de la première composante principale pour la première observation.
X_1=[1,2,4,6,9]
X_2=[5,7,4,3,1]
-0.8297*(X_1[0]-np.mean(X_1))+0.5583*((X_2[0]-np.mean(X_2)))
3.3792800000000005
Visualization avec l’ACP : Hand-written digits¶
L’utilité de la réduction de la dimensionnalité n’est peut-être pas entièrement apparente dans deux dimensions seulement, mais elle devient beaucoup plus claire lorsqu’on examine des données à haute dimension. Examinons rapidement l’application de l’ACP aux données cHand-written digits
Nous commençons par charger les données :
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shape
(1797, 64)
Rappelons que les données sont constituées d’images de 8×8 pixels, ce qui signifie qu’elles sont en 64 dimensions. Pour avoir une idée des relations entre ces points, nous pouvons utiliser l’ACP pour les projeter sur un nombre plus gérable de dimensions, disons deux :
pca = PCA(2) # project from 64 to 2 dimensions
projected = pca.fit_transform(digits.data)
print(digits.data.shape)
print(projected.shape)
(1797, 64)
(1797, 2)
Nous pouvons maintenant tracer les deux premières composantes principales de chaque point pour en savoir plus sur les données :
fig = plt.figure(figsize=(12, 7.6))
plt.scatter(projected[:, 0], projected[:, 1],
c=digits.target, edgecolor='none', alpha=0.5,
cmap=plt.cm.get_cmap('nipy_spectral', 10))
plt.xlabel('Composante 1')
plt.ylabel('Composante 2')
plt.colorbar();
plt.show()
Notons que ces composantes signifient que les données complètes sont un nuage de points en 64 dimensions, et ces points sont la projection de chaque point de données le long des directions ayant la plus grande variance. Nous avons essentiellement trouvé l’étirement et la rotation optimaux dans un espace à 64 dimensions qui nous permet de voir la disposition des chiffres en deux dimensions, et nous l’avons fait de manière non supervisée, c’est-à-dire sans référence aux étiquettes.
L’ACP pour la compression¶
Il est évident qu’après la réduction de la dimensionnalité, la taille de l’ensemble d’entraînement est beaucoup réduite. Par exemple, essayez d’appliquer l’ACP à l’ensemble de données du MNIST tout en préservant 95 % de sa variance. Vous devriez constater que chaque instance aura un peu plus de 150 caractéristiques, au lieu des 784 caractéristiques d’origine. Ainsi, bien que la majeure partie de la variance soit préservée, l’ensemble de données est maintenant inférieur à 20 % de sa taille originale !
C’est un taux de compression raisonnable, et vous pouvez voir comment cela peut accélérer considérablement un algorithme de classification (tel qu’un classificateur SVM).
L’ACP pour la compression¶
Il est également possible de décompresser l’ensemble de données réduit à 784 dimensions en appliquant la transformation inverse de la projection PCA. Bien sûr, cela ne vous rendra pas les données originales, puisque la projection a perdu un peu d’information, mais elle sera probablement assez proche des données originales. La distance moyenne au carré entre les données originales et les données reconstruites (compressées puis décompressées) est appelée l’erreur de reconstruction. Par exemple, le code suivant compresse l’ensemble de données MNIST à 154 dimensions, puis utilise la méthode inverse_transform() pour le décompresser à nouveau à 784 dimensions.
La figure ci-dessous montre quelques chiffres de l’ensemble de formation original (à gauche), et les chiffres correspondants après compression et décompression. Vous pouvez voir qu’il y a une légère perte de qualité de l’image, mais les chiffres sont encore pour la plupart intacts.
from sklearn.model_selection import train_test_split
X = mnist["data"]
y = mnist["target"]
X_train, X_test, y_train, y_test = train_test_split(X, y)
pca = PCA()
pca.fit(X_train)
cumsum = np.cumsum(pca.explained_variance_ratio_)
d = np.argmax(cumsum >= 0.95) + 1
d
154
Lorsqu’on fait la transformation
pca = PCA(n_components=0.95)
X_reduced = pca.fit_transform(X_train)
pca.n_components_
154
np.sum(pca.explained_variance_ratio_)
0.9503773692897122
pca = PCA(n_components = 154)
X_reduced = pca.fit_transform(X_train)
X_recovered = pca.inverse_transform(X_reduced)
Text(0.5, 1.0, 'Compressée')
plt.show()
APC incrémentielle¶
L’un des problèmes de la mise en oeuvre précédente de l’ACP est qu’elle exige que l’ensemble d’entrainement s’inscrive en mémoire pour que l’algorithme de l’SVD (que nous verrons plus tard) puisse fonctionner. Heureusement, des algorithmes PCA incrémentaux (IPCA) ont été développés : vous pouvez diviser l’ensemble d’entrainememt en mini lots et alimenter un algorithme IPCA un mini lot à la fois. Cela est utile pour les grands ensembles d’entraînement, mais aussi pour appliquer l’IPCA en ligne (c’est-à-dire en mode diffusion streaming, à mesure que de nouvelles instances arrivent).
Le code suivant divise l’ensemble de données MNIST en 100 mini lots (à l’aide de la fonction array_split() de NumPy) et les transmet à la classe IPCA incrémentielle5 de Scikit-Learn afin de réduire la dimensionnalité de l’ensemble de données MNIST à 154 dimensions (comme auparavant). Notez que vous devez appeler la méthode partial_fit() avec chaque mini-batch plutôt que la méthode fit() avec l’ensemble de l’entraînement :
from sklearn.decomposition import IncrementalPCA
n_batches = 100
inc_pca = IncrementalPCA(n_components=154)
for X_batch in np.array_split(X_train, n_batches):
print(".", end="") # not shown in the book
inc_pca.partial_fit(X_batch)
X_reduced = inc_pca.transform(X_train)
...
...
...
...
..
...
...
...
..
...
..
...
...
..
...
...
...
..
...
...
...
...
...
..
...
...
...
...
...
...
...
...
..
...
..
...
X_recovered_inc_pca = inc_pca.inverse_transform(X_reduced)
plt.show()
Comparons les résultats de la transformation du MNIST en utilisant l’ACP régulière et l’ACP incrémentielle. Tout d’abord, les moyennes sont égales :
np.allclose(pca.mean_, inc_pca.mean_)
True
Mais les résultats ne sont pas exactement identiques. L’ACP incrémentielle donne une très bonne solution approximative, mais elle n’est pas parfaite :
np.allclose(X_reduced_pca, X_reduced_inc_pca)
False
Conclusion¶
Dans cette section, nous avons discuté de l’utilisation de l’analyse par composantes principales pour la réduction de la dimensionnalité, pour la visualisation de données en haute dimension, pour le filtrage du bruit et pour la sélection des caractéristiques dans les données en haute dimension.
En raison de sa polyvalence et de sa capacité d’interprétation, l’ACP s’est avérée efficace dans une grande variété de contextes et de disciplines. Pour tout ensemble de données à haute dimension, nous commençons par l’ACP afin de visualiser la relation entre les points (comme nous l’avons fait avec les chiffres), de comprendre la principale variance des données et de comprendre la dimensionnalité intrinsèque (en traçant le rapport de variance expliqué).
L’ACP n’est certainement pas utile pour tous les ensembles de données à haute dimension, mais elle offre un moyen simple et efficace de comprendre les données à haute dimension.
La principale faiblesse de l’ACP est qu’elle a tendance à être fortement affectée par les valeurs aberrantes des données. C’est pourquoi de nombreuses variantes robustes de l’ACP ont été développées, dont beaucoup agissent de manière itérative en rejetant les points de données qui sont mal décrits par les composantes initiales.
Scikit-Learn contient quelques variantes intéressantes de l’ACP, dont l’ACP Stochastique et l’ACP sparse, toutes deux également dans le sous-module sklearn.decomposition. La méthode RandomizedPCA utilise une méthode non déterministe pour approcher rapidement les premiers composants principaux dans des données à très haute dimension, tandis que SparsePCA introduit un terme de régularisation.
Dans les sections suivantes, nous examinerons d’autres méthodes d’apprentissage non supervisées qui s’appuient sur certaines des idées de l’ACP.