L’analyse en composantes principales est un processus essentiel de réduction de la dimensionnalité dans l’apprentissage machine. Cette technique comprend une simple opération matricielle à partir de statistiques et d’algèbre linéaire. La raison d’utiliser cette méthode est de calculer, d’analyser les données originales et de générer une projection dans la dimension la plus faible. Vous pouvez également utiliser cette technique pour trouver la projection du même nombre. Cet article vous aidera à comprendre le concept d’analyse en composantes principales et comment effectuer l’analyse en R et Python.

Analyse en composantes principales

L’ACP ou analyse en composantes principales permet de réduire la dimensionnalité des points de données massifs dans des formes plus simples. Cette propriété de l’ACP en fait une méthode de réduction de la dimensionnalité. Elle fonctionne en transformant les variables en plus petites en éliminant les informations majeures du grand ensemble.
En réduisant les variables de l’ensemble de données, vous diminuez la précision des données. Pour simplifier l’ensemble des données, vous devez accepter le risque d’une faible précision.
Des ensembles de données plus petits vous aideront à visualiser et à explorer facilement la situation. De cette façon, l’algorithme d’apprentissage automatique analysera les données rapidement et facilement, en maintenant la pertinence des données. En d’autres termes, l’ACP réduira les variables et préservera les informations importantes afin de faciliter l’analyse des données.

Exemple d’analyse en composantes principales

Exemple d’analyse des composantes principales en 2D

Vous pouvez comprendre le concept d’analyse en composantes principales en deux dimensions. Ces dimensions sont la taille et le poids. Vous tracerez l’ensemble des données dans le plan sous forme de points. Mais lorsque nous aurons éliminé les variations, l’ACP identifiera un nouveau système de coordonnées. Dans ce système, chaque point contiendra une valeur x et une valeur y. Il n’y a pas de signification physique des axes. Ces axes sont les composantes principales et la combinaison de la hauteur et du poids. De cette façon, même les axes simples auront beaucoup de variations.

Exemple d’analyse des composantes principales en 3D

L’analyse en composantes principales devient plus utile en ayant trois dimensions. Ainsi, vous pouvez analyser les données sous différents angles. Par exemple, vous pouvez visualiser les données en 2D après les avoir tracées dans le plan 3D. En tournant l’angle de la caméra, vous pouvez visualiser les données du meilleur point de vue. La transformation de l’ACP permet de le faire :

  • Il y a plus de variations dans l’axe horizontal ou PC1.
  • Il y a ensuite des variations plus importantes sur l’axe vertical ou PC2,
  • C’est dans le troisième axe ou PC3 qu’il y a le moins de variations.
    De cette façon, vous pouvez facilement laisser tomber le troisième axe. Les données de cet axe ne sont pas aussi importantes que l’axe horizontal et l’axe vertical dans le plan.

Analyse en composantes principales dans R

Vous pouvez calculer l’analyse en composantes principales dans R en utilisant les fonctions princomp() et prcomp(). Ces fonctions permettent une analyse simple et directe. Ces deux fonctions se différencient par les méthodes de calcul de l’ACP.

Fonction Prcomp() pour calculer l’ACP

Vous pouvez choisir cette méthode pour l’analyse en composantes principales dans R afin d’obtenir des chiffres précis. La méthode calcule l’ACP en utilisant la décomposition en valeurs singulières de la matrice de données. Elle n’inclut pas les valeurs propres de la matrice de covariance.

Fonction Princomp() pour calculer l’ACP

Cette méthode utilise des données propres sur la matrice de covariance ou de corrélation. Cette méthode passe par la compatibilité par le résultat S-PLUS.

  • pilots.pca<-prcomp(pilots[,2:7])
  • pilots.pca
  • ## Écarts types (1, .., p=6) :
  • • ## [1] 41.497499 29.637102 20.035932 16.157875 11.353640 7.097781
  • • ##
  • ## Rotation (n x k) = (6 x 6) :
  • ## PC1 PC2 PC3 PC4
  • ## Renseignements 0,21165160 -0,38949336 0,88819049 -0,03082062
  • ## Formulaire.relations -0.03883125 -0.06379320 0.09571590 0.19128493
  • ## Dynamomètre 0.08012946 0.06602004 0.08145863 0.12854488
  • ## Pointillage 0,77552673 0,60795970 0,08071120 -0,08125631
  • Coordination.sensorielle.et.motrice -0,09593926 -0,01046493 0,01494473 -0,96813856
  • ## Perservation 0,58019734 -0,68566916 -0,43426141 -0,04518327
  • ## PC5 PC6
  • ## Renseignement -0,04760343 -0,10677164
  • ## Formulaire.relations -0.14793191 0.96269790
  • ## Dynamomètre 0.97505667 0.12379748
  • ## Pointillage -0,10891968 0,06295166
  • Coordination sensorielle et motrice 0.10919120 0.20309559
  • ## Perservation 0,03644629 0,03572141
    Vous pouvez également générer des sorties de la proportion de la variance à l’aide de la méthode de résumé prcomp() que les composantes expliquent.
  • summary(pilots.pca)
  • ## Importance des composants :
  • ## PC1 PC2 PC3 PC4 PC5 PC6
  • ## Écart-type 41,4975 29,6371 20,0359 16,15788 11,35364 7,09778
  • ## Proportion de la variance 0,5003 0,2552 0,1166 0,07585 0,03745 0,01464
  • ## Proportion cumulée 0,5003 0,7554 0,8721 0,94792 0,98536 1,00000

Analyse en composantes principales en Python

Vous pouvez utiliser la bibliothèque Scikit-learn pour calculer l’analyse en composantes principales de l’ensemble de données. Cette approche est avantageuse car vous pouvez appliquer de nouvelles données de manière répétitive pour trouver facilement la projection après avoir calculé la projection. Cette approche est avantageuse car vous pouvez appliquer de nouvelles données de manière répétitive pour trouver facilement la projection après le calcul de celle-ci.
La classe sera le premier ajustement de l’ensemble de données. Vous utiliserez la fonction fit(), réel, ou tout autre ensemble de données et vous choisirez la dimension pour trouver la fonction transform(). Vous pouvez accéder aux composantes principales et aux valeurs propres sur l’analyse des composantes principales avec components_attributes et explained_variance. Dans l’exemple ci-dessous, vous créez d’abord l’instance en utilisant la classe. Ensuite, vous ajustez les données sur une matrice 3×2. Cela vous donnera accès aux vecteurs et aux valeurs de la projection. Enfin, vous pouvez transformer les données réelles.

  • from numpy import array
  • de la moyenne d’importation numpy
  • de numpy import cov
  • de numpy.linalg import eig
  • # définir une matrice
  • A = tableau ([[4, 5], [6, 7], [8, 9])
  • imprimer(A)
  • # calculer la moyenne de chaque colonne
  • M = moyenne(A.T, axe=1)
  • imprimer(M)
  • # colonnes centrales en soustrayant les moyennes des colonnes
  • C = A – M
  • imprimer(C)
  • # calculer la matrice de covariance de la matrice centrée
  • V = cov(C.T)
  • print(V)
  • # eigendecomposition de la matrice de covariance
  • valeurs, vecteurs = eig(V)
  • impression(vecteurs)
  • imprimer(valeurs)
  • # données du projet
  • P = vecteurs.T.point(C.T)
  • print(P.T)
    En exécutant des données échantillons sur la matrice 3×2, nous trouverons les principales composantes et leurs valeurs. Ensuite, vous trouverez les projections de la matrice réelle. En utilisant cette méthode, nous identifierons la virgule flottante mineure et obtiendrons les mêmes composantes principales, projections et valeurs singulières.
  • • [[4 5]
  • • [6 7]
  • • [8 9]][6. 7.]
  • • [[-2. -2.]
  • • [ 0. 0.]
  • • [ 2. 2.]]
  • • [[4. 4.]
  • • [4. 4.]]
  • • [[ 0.70710678 -0.70710678]
  • • [ 0.70710678 0.70710678]]
  • • [8. 0.]
  • • [[-2.82842712 0. ]
  • • [ 0. 0. ]
  • • [ 2.82842712 0. ]]

Conclusion

Vous pouvez utiliser n’importe quel langage de programmation tel que Python, R, C++, etc., pour coder en dur l’ensemble du processus et trouver des applications d’analyse en composantes principales. De plus, vous pouvez également utiliser les bibliothèques de différents contributeurs et exécuter les données. Si la complexité du problème n’est pas très élevée, vous devriez utiliser une technique de codage en dur au lieu de bibliothèques. De cette façon, vous pouvez analyser le back-end pour comprendre facilement les problèmes. Lorsque vous utilisez l’analyse en composantes principales dans R, vous pouvez utiliser des bibliothèques telles que prcomp, princomp, HSAUR, et d’autres. Cela vous permet d’utiliser directement l’application.