Analyse des composants principaux avec python (version Scikit-learn, version pandas et numpy) ([High school information department information II] didacticiel pour la formation des enseignants)
introduction
L'analyse des composants principaux est une méthode de création de composants principaux (caractéristiques) en regroupant plusieurs variables à partir de données multivariées qui représentent les caractéristiques d'un objet. C'est une méthode qui peut réduire la dimension, ce qui facilite la visualisation de la structure des données et réduit la quantité de calcul en apprentissage automatique pour améliorer la vitesse de calcul. En termes simples, il s'agit d'une méthode d'expression de données multivariées corrélées par une fonction avec moins de corrélation, en se concentrant sur la direction et l'ampleur de la variation. Cette fois, je voudrais confirmer le mécanisme en implémentant en python ce qui est repris dans «Analyse des composants principaux et réduction de la dimension» dans le matériel de formation des enseignants d'Information II publié sur la page du Ministère de l'Éducation, de la Culture, des Sports, des Sciences et de la Technologie. pense.
Matériel pédagogique
[Matériel de formation des enseignants du Département de l'information du lycée "Information II" (volume principal): Ministère de l'éducation, de la culture, des sports, de la science et de la technologie](https://www.mext.go.jp/a_menu/shotou/zyouhou/detail/mext_00742.html "Département de l'information du lycée Matériel pédagogique "Information II" pour la formation des enseignants (partie principale): Ministère de l'éducation, de la culture, des sports, des sciences et de la technologie ") Chapitre 3 Information et science des données, premier semestre (PDF: 8,9 Mo)
environnement
- ipython
- Colaboratory - Google Colab
Ce que je veux faire cette fois
Après avoir donné un aperçu de l'analyse des composants principaux sans utiliser autant que possible des formules mathématiques,
Apprentissage 14 Analyse en composantes principales et réduction des dimensions: "4. Analysons les données de condition physique avec R"
J'aimerais voir comment cela fonctionne lors de l'implémentation du code source écrit en R en python.
Analyse des composants principaux
Aperçu de l'analyse des principales composantes (à partir du matériel didactique)
Pour expliquer brièvement le mécanisme de l'analyse en composantes principales (ACP), une nouvelle quantité de caractéristiques appelée composante principale qui maximise la différence entre les objets individuels en regroupant des variables à forte covariance et corrélation entre les variables Il s'agit de créer une variable).
Comme le montre la figure, à partir de p variables $ (X_1, X_2, \ cdots, X_p) $, p variables totales mutuellement indépendantes sont obtenues par connexion linéaire (somme pondérée) sans perte d'information. Créer comme composant principal $ (Z_1, Z_2, \ cdots, Z_p) $.
Les composants principaux sont créés dans l'ordre dans lequel la dispersion est la plus grande, et la fluctuation (dispersion) de la valeur du composant principal (score du composant principal) entre les objets diminue à mesure que les composants principaux inférieurs deviennent.
C'est-à-dire qu'en rejetant le composant inférieur avec une faible contribution et en n'adoptant que le composant supérieur, il est possible de profiler la caractéristique de la cible avec un nombre inférieur au nombre d'origine p, et de réduire la dimension. C'est ce qu'on appelle (réduction de dimension).
Prenons l'exemple simple suivant (données de résultats pour les examens dans 5 matières).
Considérons une variable composite créée comme a, b, c, d, e en généralisant les coefficients de chaque matière.
Total des variables = a x langue nationale + b x anglais + c x mathématiques + d x physique + e x chimie
En donnant différentes valeurs numériques à a, b, c, d et e, il est possible de créer différents totaux de points autres que le simple total des points. La composante principale créée par l'analyse en composantes principales est telle que les coefficients a, b, c, d et e sont les plus variables de la valeur ** (score de la composante principale) ** de la variable totale de 50 élèves, c'est-à-dire que la variance est Une variable jugée maximale.
Une grande variabilité correspond à la quantité d'informations dans cette variable. Le premier composant principal à obtenir est appelé le premier composant principal, et le second composant principal à obtenir ensuite maximise la dispersion à la condition qu'il soit indépendant du premier composant (pas de corrélation). Il s'agit d'une quantité de caractéristiques qui ne se corrèle pas les unes avec les autres et ne duplique pas les informations.
Discussion sur la normalisation dans l'analyse en composantes principales
À partir du matériel pédagogique
Il y a deux positions lors de la création de variables synthétiques.
- (1) Alignez les niveaux de score (positions) des cinq sujets (faites en sorte que la moyenne soit la même, faites-en un écart par rapport à la moyenne).
- (2) Aligner à la fois le niveau de score (position) des cinq sujets et l'ampleur de la variation (rendre la moyenne et l'écart type identiques, normaliser (standardiser) ou faire la valeur de l'écart).
Lorsqu'il s'agit de plusieurs variables avec des unités différentes, il est nécessaire de standardiser (2) et d'aligner les unités. Si les unités sont les mêmes, l'analyse peut être effectuée à la fois du point de vue de ① et de ②. En (1), un coefficient qui considère l'amplitude de la variance de chaque variable est obtenu, et en (2), un coefficient qui ignore la différence de la variance de chaque variable est obtenu.
Pour la discussion sur les points (1) et (2) à adopter, les informations résumées ci-dessous sont détaillées.
https://qiita.com/koshian2/items/2e69cb4981ae8fbd3bda
--Il n'est pas toujours bon de standardiser (diviser par l'écart-type) dans l'analyse en composantes principales
- Au contraire, la division par l'écart-type a un effet défavorable.
- La normalisation dépend de l'endroit où vous utilisez l'analyse des composants principaux (que vous l'utilisiez comme visualisation ou comme pipeline), alors réfléchissez-y correctement.
Données à analyser cette fois
Les éléments sont extraits des données de condition physique (force de préhension, soulèvement du haut du corps, etc.) et l'analyse des composants principaux est effectuée. Je souhaite utiliser les données prétraitées suivantes créées ici.
https://gist.github.com/ereyester/5bf6d48fe966238632eca537756a06b0/raw/805c2eea83c7608d4d85ec15e56761133dc5ff4d/high_male2.csv
python: exemple d'implémentation et résultat
python: exemple d'implémentation (capture de données)
import numpy as np
import pandas as pd
import urllib.request
import matplotlib.pyplot as plt
import sklearn #Bibliothèque d'apprentissage automatique
from sklearn.decomposition import PCA #Analyseur de composants principaux
from sklearn.preprocessing import StandardScaler
from IPython.display import display
high_male2 = pd.read_csv('/content/high_male2.csv')
high_male3 = high_male2[['Poignée', 'Soulevez le haut du corps', 'Flexion avant du siège long', 'Saut latéral répété', 'Navette', 'Piste X50m', 'Saut en longueur debout', 'Lancer de handball']]
display(high_male3)
Cette fois, je voudrais implémenter deux méthodes, une avec le module scicit-learn et une sans. La méthode utilisant le module scikit-learn utilise sklearn.decomposition.PCA et sklearn.preprocessing.StandardScaler. La méthode qui n'utilise pas le module scikit-learn est d'implémenter le traitement par vous-même avec numpy et pandas.
python: résultat de sortie (capture de données)
Cette fois, je voudrais utiliser activement pandas.DataFrame pour procéder à l'implémentation.
python: exemple d'implémentation (PCA pour une utilisation scikit-learn)
#Standardisation de la matrice
#Standardisation(Comment utiliser le scaler standard)
std_sc = StandardScaler()
std_sc.fit(high_male3)
std_data = std_sc.transform(high_male3)
std_data_df = pd.DataFrame(std_data, columns = high_male3.columns)
display(std_data_df)
#Effectuer une analyse des composants principaux
pca = PCA()
pca.fit(std_data_df)
#Mappage des données sur l'espace des composants principaux
pca_cor = pca.transform(std_data_df)
#print(pca.get_covariance()) #Matrice co-distribuée distribuée
#Affichage matriciel des vecteurs propres
eig_vec = pd.DataFrame(pca.components_.T, index = high_male3.columns, \
columns = ["PC{}".format(x + 1) for x in range(len(std_data_df.columns))])
display(eig_vec)
#valeur propre
eig = pd.DataFrame(pca.explained_variance_, index=["PC{}".format(x + 1) for x in range(len(std_data_df.columns))], columns=['valeur propre']).T
display(eig)
#Dans le code source par R, l'écart type est calculé à la place de la valeur propre (distribution).
#Écart type de la composante principale
dv = np.sqrt(eig)
dv = dv.rename(index = {'valeur propre':'Écart type de la composante principale'})
display(dv)
#Taux de cotisation
ev = pd.DataFrame(pca.explained_variance_ratio_, index=["PC{}".format(x + 1) for x in range(len(std_data_df.columns))], columns=['Taux de cotisation']).T
display(ev)
#Taux de cotisation cumulé
t_ev = pd.DataFrame(pca.explained_variance_ratio_.cumsum(), index=["PC{}".format(x + 1) for x in range(len(std_data_df.columns))], columns=['Taux de cotisation cumulé']).T
display(t_ev)
#Score du composant principal
print('Score du composant principal')
cor = pd.DataFrame(pca_cor, columns=["PC{}".format(x + 1) for x in range(len(std_data_df.columns))])
display(cor)
Tout d'abord, nous utilisons sklearn.preprocessing.StandardScaler pour standardiser les données. Par standardisation, il est converti en données avec une moyenne de 0 et une distribution de 1.
L'analyse des composants principaux est effectuée sur les données standardisées à l'aide de sklearn.decomposition.PCA. Dans l'analyse en composantes principales, les résultats du vecteur propre, de la valeur propre, du taux de cotisation et du score de la composante principale peuvent être confirmés.
python: résultat de sortie (PCA pour une utilisation scikit-learn)
Données standardisées
Résultat du vecteur propre (PC1: 1er composant principal PC2: 2ème composant principal ....)
Résultat de valeur unique
Écart type du composant principal (valeur naturelle convertie en valeur d'écart type)
Taux de cotisation
Taux de cotisation cumulé
Score du composant principal
Du résultat
À partir de ces résultats, il a été montré que le résultat de sortie dans R était presque le même.
Ici, la relation entre le score de la composante principale, le vecteur propre et les données standardisées est la suivante.
Score de la composante principale = vecteur propre (force de préhension) x valeur de la force de préhension après standardisation + vecteur propre (relèvement du haut du corps) x valeur d'élévation du haut du corps après standardisation + ... + vecteur propre (lancer de handball) x valeur de lancer de handball après standardisation
Le matériel didactique décrit les critères de réduction des dimensions.
- Taux de cotisation cumulatif: à titre indicatif, utilisez le taux de cotisation cumulatif de 70% à 80%.
- La valeur intrinsèque (dispersion) est égale ou supérieure à 1 (norme de Kaiser): la composante principale avec une valeur propre supérieure à 1 est adoptée (lors de l'analyse de la matrice de corrélation = dans ce cas), le taux de cotisation est (1 / nombre de variables) x 100 (%) ) Adoptez les composantes principales ci-dessus (lors de l'analyse de la matrice de covariance). --Graphique à fluage: De gauche à droite dans l'ordre décroissant de la valeur propre (dispersion) Pour le graphique linéaire (tracé à éboulis), les principales composantes jusqu'à avant que la quantité de diminution de la dispersion devienne faible (diminution progressive) sont adoptées.
python: exemple d'implémentation (version PCA inutilisée scikit-learn)
#Standardisation(Comment ne pas utiliser le détartreur standard)
# default:axis = 0(Application d'orientation de colonne)
std_data_df_noskl = (high_male3 - high_male3.mean()) / high_male3.std(ddof = 0)
display(std_data_df_noskl)
#Matrice de covariance
cov_vec = np.cov(std_data_df_noskl.T, bias = 0)
#Trouver des valeurs propres et des vecteurs propres
# np.linalg.svd: décomposition de singularité
# np.linalg.eig:Décomposition de valeur unique
#Ici, sélectionnez la décomposition de valeur singulière
eig_vec_noskl_l, eig_noskl_l, _ = np.linalg.svd(cov_vec)
#Score du composant principal
pca_cor_noskl = np.dot(std_data_df_noskl, eig_vec_noskl_l)
#display(cor_noskl)
#Affichage matriciel du vecteur de valeurs propres
eig_vec_noskl = pd.DataFrame(eig_vec_noskl_l, index = high_male3.columns, \
columns = ["PC{}".format(x + 1) for x in range(len(std_data_df_noskl.columns))])
display(eig_vec_noskl)
#valeur propre
eig_noskl = pd.DataFrame(eig_noskl_l, index=["PC{}".format(x + 1) for x in range(len(std_data_df_noskl.columns))], columns=['valeur propre']).T
display(eig_noskl)
#Dans le code source par R, l'écart type est calculé à la place de la valeur propre (distribution).
#Écart type de la composante principale
dv_noskl = np.sqrt(eig_noskl)
dv_noskl = dv_noskl.rename(index = {'valeur propre':'Écart type de la composante principale'})
display(dv_noskl)
#Taux de cotisation
ev_noskl_l = eig_noskl_l / eig_noskl_l.sum()
ev_noskl = pd.DataFrame(ev_noskl_l, index=["PC{}".format(x + 1) for x in range(len(std_data_df_noskl.columns))], columns=['Taux de cotisation']).T
display(ev_noskl)
#Taux de cotisation cumulé
t_ev_noskl = pd.DataFrame(ev_noskl_l.cumsum(), index=["PC{}".format(x + 1) for x in range(len(std_data_df_noskl.columns))], columns=['Taux de cotisation cumulé']).T
display(t_ev_noskl)
#Score du composant principal
print('Score du composant principal')
cor = pd.DataFrame(pca_cor_noskl, columns=["PC{}".format(x + 1) for x in range(len(std_data_df_noskl.columns))])
display(cor)
Premièrement, nous normalisons
La formule de normalisation est la suivante.
X_{i,j}^{(std)} ← \frac{x_{i,j} - \mu}{\sigma}
\mu：\frac{1}{n}\sum_{i=1}^{n} X_{i,j}
\sigma：\sqrt{\frac{1}{n}\sum_{i=1}^{n} (X_{i,j} - \mu)^2 }
{\boldsymbol{X}}=
\begin{pmatrix}
X_{1,1}^{(std)} & \cdots & X_{135,1}^{(std)} \\
\vdots & \ddots & \vdots \\
X_{1,8}^{(std)} & \cdots & X_{135,8}^{(std)}
\end{pmatrix}
Ici, x = 1,…, 135 = N, j = 1,…, 8
Dans ce code python, l'écart type est calculé avec 0 degré de liberté. https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.std.html Il convient de noter que dans pandas.DataFrame.std, il s'agit de ddofint, par défaut 1, et si aucun argument n'est spécifié, l'écart type dû à la distribution non biaisée avec 1 degré de liberté sera utilisé. Au fait, https://numpy.org/doc/stable/reference/generated/numpy.std.html C'est dd de int, ddof par défaut facultatif est zéro dans numpy.std et le degré de liberté est 0. https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html Notez que l'écart type utilisé lors du calcul de sklearn.preprocessing.StandardScaler est ddof = 0.
Ensuite, pour les données standardisées, la formule de la matrice distribuée co-distribuée (matrice auto-co-distribuée) est
E[\boldsymbol{X}]=0
Que,
cov({\boldsymbol{X,X}})=E[\boldsymbol{X^TX}]-E[{\boldsymbol{X}}]^TE[{\boldsymbol{X}}]=E[\boldsymbol{X^TX}]=\frac{1}{N-1}\boldsymbol{X^TX}
cov({\boldsymbol{X,X}})=\Sigma
Puis $ U $: 135 $ \ fois 135 $ matrice orthogonale $ S $: $ 135 \ fois 8 $ matrice diagonale réelle (composante non négative) $ V_ {svd} $: $ 8 \ times 8 $ matrice orthogonale
\boldsymbol{X}=U S {V^T_{svd}}
\boldsymbol{X^TX}=[U S {V^T_{svd}}]^T[U S {V^T_{svd}}]=V_{svd} S^T SV^T_{svd}
\Sigma=\frac{V_{svd} S^T SV^T_{svd}}{N-1}
$ S ^ 2 $: valeurs uniques disposées en diagonale Vecteur unique de $ V_ {svd} $: $ \ boldsymbol {X ^ TX} $
L'article suivant est détaillé sur la décomposition de valeurs singulières.
https://qiita.com/kidaufo/items/0f3da4ca4e19dc0e987e
L'article suivant est détaillé sur la relation entre l'analyse en composantes principales et la décomposition de valeurs singulières.
https://qiita.com/horiem/items/71380db4b659fb9307b4 https://qiita.com/sakami/items/50b8485159312573e3c7
L'utilisation de la décomposition en valeur propre ou de la décomposition en valeur singulière a été choisie à partir des points de vue suivants.
https://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html
Renvoie: w: ... Les valeurs propres ne sont pas nécessairement ordonnées.Dans numpy.linalg.eig, les valeurs propres ne sont pas nécessairement ordonnées, nous voulons donc ordonner PC1 PC2 ... par ordre décroissant des valeurs propres, donc une opération de classement est nécessaire. Sera.
https://numpy.org/doc/stable/reference/generated/numpy.linalg.svd.html
Renvoie: Vecteur (s) avec les valeurs singulières, à l'intérieur de chaque vecteur triés par ordre décroissant. Ceci est plus facile car vous pouvez les classer par ordre décroissant.
python: résultat de sortie (version PCA inutilisée scikit-learn)
Données standardisées
Résultat du vecteur propre (PC1: 1er composant principal PC2: 2ème composant principal ....)
Résultat de valeur unique
Écart type du composant principal (valeur naturelle convertie en valeur d'écart type)
Taux de cotisation
Taux de cotisation cumulé
Score du composant principal
R: [Référence] Exemple de mise en œuvre et résultats (à partir du matériel pédagogique)
R: exemple d'implémentation
#Analyse des principaux composants utilisant 8 variables de la force de préhension au lancer de handball, à l'exclusion de la taille, du poids et de la hauteur d'assise #Matrice de corrélation #base de données(Colonnes 4 à 11)Importer high_male2 <- read.csv("high_male2.csv") high_male3 <- high_male2[c(4:11)] #Exécution de l'analyse des composants principaux prcomp basée sur la matrice de corrélation (res2 <- prcomp(high_male3, scale=T)) summary(res2) pc <- res2$x #Balayer la partition du composant principal dans le fichier write.csv(pc, file = "pca_cor.csv")
L'argument scale = T de prcomp () indique scale = True Il s'agit d'un paramètre qui spécifie que l'analyse en composantes principales doit être effectuée à l'aide de la matrice de corrélation des données. En ce qui concerne les événements traités cette fois, il est dit que l'analyse des principales composantes a été réalisée sur des données substantiellement standardisées. Devrait être équivalent.
R: résultat de sortie
Standard deviations (1, .., p=8): [1] 1.9677462 0.9524611 0.9096410 0.8553785 0.7327083 0.6857621 0.6399714 [8] 0.4949534
Rotation (n x k) = (8 x 8): PC1 PC2 PC3 PC4 PC5 Puissance de préhension 0.3252018 0.2682176 -0.53297421 0.39993408 -0.3653663 Soulevez le haut du corps 0.3141190 0.4351668 0.42225757 0.40834395 0.4032249 Flexion avant du siège long 0.3077864 0.3745785 0.01503113 -0.75987597 -0.2411453 Saut latéral répété 0.3933948 0.1203619 0.05183489 -0.20404673 0.4967487 Navette run 0.3132617 -0.4444223 0.59760197 0.01703693 -0.3900527 Piste X50m-0.4057185 0.4620511 0.11729178 -0.10636452 -0.0709927 Saut de largeur debout 0.3681042 -0.3669386 -0.40018514 -0.13933339 0.3055848 Lancer de handball 0.3844997 0.1955680 0.06075045 0.15245958 -0.3852838 PC6 PC7 PC8 Poignée-0.31441687 0.34209544 -0.17004275 Soulevez le haut du corps-0.33321281 -0.29431157 0.08168542 Flexion avant du siège long-0.28776668 -0.10238851 0.18941208 Saut latéral répété 0.35638527 0.61198108 -0.19529718 Navette-0.21759749 0.17541898 -0.34157859 Course X50m 0.04215936 -0.08597965 -0.76329592 Saut en longueur debout-0.10049579 -0.50594605 -0.43684157 Lancer de handball 0.72184877 -0.34234695 0.01636705 Importance of components: PC1 PC2 PC3 PC4 PC5 PC6 PC7 Standard deviation 1.968 0.9525 0.9096 0.85538 0.73271 0.68576 0.6400 Proportion of Variance 0.484 0.1134 0.1034 0.09146 0.06711 0.05878 0.0512 Cumulative Proportion 0.484 0.5974 0.7008 0.79229 0.85940 0.91818 0.9694 PC8 Standard deviation 0.49495 Proportion of Variance 0.03062 Cumulative Proportion 1.00000
Pour pca_cor.csv, la sortie est la suivante.
Code source
version python https://gist.github.com/ereyester/3c2173eb61cbcd64b61f23b3d4d6480c
Version R https://gist.github.com/ereyester/cd309a9ab46c37a3f594963d1ad55495
Recommended Posts