Python: apprentissage non supervisé: analyse principale

Analyse des composants principaux

Analyse des composants principaux

Analyse en composantes principales (ACP) C'est l'une des méthodes puissantes de synthèse des données (représentant les données d'origine avec un petit nombre de données).

À titre d'exemple, à l'aide de l'analyse des composantes principales, compressez les données de score en mathématiques et en langue nationale (2D) de 10 élèves. Affiche l'image à convertir en une dimension.

Plutôt que d'expliquer le score de chaque individu uniquement avec le score mathématique (1 dimension) comme indiqué sur la figure de droite Il est possible d'expliquer avec une erreur plus petite en préparant un nouvel axe et en créant de nouvelles données unidimensionnelles comme le montre la figure de gauche.

La figure de gauche est un diagramme de compression de données utilisant l'analyse en composantes principales. En utilisant l'analyse en composantes principales, l'axe (l'axe de la première composante principale) qui peut expliquer toutes les données le plus efficacement Un axe (axe du deuxième composant principal) qui explique les données qui ne peuvent pas être expliquées par elles-mêmes le plus efficacement est créé.

Parce que le premier composant principal peut bien exprimer les données d'origine Les données peuvent être compressées de manière efficace en supprimant (sans utiliser) les informations du deuxième composant principal.

À titre d'exemple pratique d'analyse des composants principaux, de notation et de comparaison des produits et services (compressés à une dimension) Visualisation des données (compressées en 2 ou 3 dimensions), prétraitement pour analyse de régression, etc.

L'analyse des composants principaux est très pratique et est devenue l'un des thèmes importants dans le domaine de l'apprentissage automatique.

Flux jusqu'à la conversion des fonctionnalités

La compression des données (conversion de caractéristiques) est effectuée selon la procédure suivante en utilisant l'analyse des composants principaux.

• Standardisez les données.
• Calculez la matrice de corrélation entre les caractéristiques.
• Trouvez le vecteur propre et la valeur propre de la matrice de corrélation.
• Sélectionnez k des valeurs propres obtenues parmi les plus grandes et sélectionnez les vecteurs propres correspondants. Pour cette valeur de k, spécifiez le nombre de dimensions que vous souhaitez compresser.
• Créer une matrice de conversion de caractéristiques WW à partir de k vecteurs propres.
• Prenez le produit des données en d dimensions XX et de la matrice WW pour obtenir les données converties en k dimensions X'X '.

La figure ci-dessous est une image d'un jeu de données Wine qui a été transformé en fonction et les données résumées de 13 dimensions à 2 dimensions.

Préparation des données

Nous analyserons les principaux composants. Les données utilisées sont les données sur le vin publiées dans le "UCI Machine Learning Repository". Représente les données sur le type de raisin (étiquettes 1 à 3) et les propriétés chimiques du vin pour 178 lignes d'échantillons de vin Il se compose de données de caractéristiques (13 types).

Obtenez les données comme suit.

import pandas as pd
df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header = None)
#Les données d'objet sont stockées dans X et les données d'étiquette sont stockées dans y.
# df_La première colonne de wine est des données d'étiquette, et la deuxième colonne et les suivantes sont des données de caractéristiques.
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values

print(X.shape)

Standardisation

Les données de vin sont converties à l'avance afin que la moyenne soit de 0 et la variance de 1 pour chaque quantité caractéristique. C'est ce qu'on appelle la normalisation.

En normalisant, il devient possible de traiter différents types de données avec différentes unités et valeurs standard, telles que la teneur en alcool et la teinte du vin, de la même manière.

import numpy as np
#Standardisation
X = (X - X.mean(axis=0)) / X.std(axis=0)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header=None)
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values

#Visualisez les données avant la normalisation
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.set_title('before')
ax2.set_title('before')
ax1.scatter(X[:, 0], X[:, 1])
ax2.scatter(X[:, 5], X[:, 6])
plt.show()

print("before")
print("mean: ", X.mean(axis=0), "\nstd: ", X.std(axis=0))

#Remplacer les données normalisées X
X = (X - X.mean(axis=0)) / X.std(axis=0)

#Visualisez les données après la normalisation
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.set_title('after')
ax2.set_title('after')
ax1.scatter(X[:, 0], X[:, 1])
ax2.scatter(X[:, 5], X[:, 6])
plt.show()

print("after")
print("mean: ", X.mean(axis=0), "\nstd: ", X.std(axis=0))

Calcul de la matrice de corrélation

Calculez la matrice de corrélation des données pour vérifier la similitude de chaque quantité d'entités.

Le coefficient de corrélation est un indice qui indique la force de la relation linéaire entre deux données et prend une valeur de -1 à 1. Lorsque le coefficient de corrélation est proche de 1 (la corrélation positive est forte), lorsque l'une des deux données augmente comme le montre la figure de gauche. Il a une distribution linéaire dans laquelle l'autre augmente également.

Lorsque la corrélation négative est forte, elle a une distribution linéaire dans laquelle l'une augmente et l'autre diminue.

Lorsque le coefficient de corrélation est proche de 0, il n'y a pas beaucoup de relation linéaire comme le montre la figure ci-dessous (r = 0).

Ici, le coefficient de corrélation de chacun des 13 types de données caractéristiques du vin est conservé. Trouvez la matrice de corrélation 13x13. La matrice de corrélation à obtenir a la forme suivante.

Obtenez la matrice de corrélation comme suit. La fonction corrcoef () n'est pas la corrélation entre les colonnes (horizontal) Créez une matrice de corrélation pour chaque corrélation entre les lignes (direction verticale). Par conséquent, si rien n'est fait, la matrice de corrélation entre les données sera Me sera demandé.

X est transposé en X.T pour trouver la matrice de corrélation entre les caractéristiques plutôt que les données

import numpy as np
R = np.corrcoef(X.T)

C'est une histoire évolutive, mais la matrice de corrélation elle-même peut être calculée de la même manière en utilisant X avant la standardisation. Pré-normalisé pour plus tard.

Il existe également une analyse en composantes principales qui utilise une matrice de covariance au lieu d'une matrice de corrélation.

Le code pour créer une matrice d'unité carrée est le suivant.

import numpy as np

# np.identity(Taille de la matrice)
identity = np.identity(3)

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Comme méthode pratique

import pandas as pd
import numpy as np

df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header=None)
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values

#Créer une matrice de corrélation (13x13)
R = np.corrcoef(X.T)

#Composante diagonale 0
_R = R - np.identity(13)

#Obtenez l'indice qui prend le coefficient de corrélation maximal
index = np.where(_R == _R.max())

print(R[index[0][0], index[1][0]])
print(index)

Décomposition de valeur unique

Ensuite, appliquez une méthode mathématique appelée décomposition des valeurs propres à la matrice de corrélation obtenue. Obtient le vecteur propre et la valeur propre.

Lorsque la décomposition des valeurs propres est effectuée, la matrice originale R de 13x13 dimensions est constituée de 13 vecteurs spéciaux à 13 dimensions. (Vecteur unique) Et 13 numéros spéciaux (Valeur unique) Sera démonté en.

Intuitivement, la matrice d'origine a des informations concentrées dans la direction du vecteur propre. On peut dire que la valeur unique correspondante indique le degré de concentration des informations.

Vous pouvez utiliser numpy pour calculer la décomposition des valeurs propres comme suit: 13 valeurs propres et 13 vecteurs propres de R sont stockés respectivement dans les valeurs eigvals et eigvecs.

import numpy as np
#Obtenez le couple propre à partir de la matrice de corrélation. engourdi.linalg.eigh les renvoie par ordre croissant de valeurs propres
eigvals, eigvecs = np.linalg.eigh(R)

La matrice de corrélation R, la matrice V avec des vecteurs propres et la matrice diagonale D avec des valeurs propres satisfont les équations suivantes. Les éléments sont les suivants.

Le vecteur propre de la matrice de corrélation représente le vecteur composant principal Les composants du vecteur propre montrent l'effet de chaque fonction sur le composant principal.

De plus, le vecteur propre correspondant à une valeur propre plus grande est profondément impliqué dans la composition de la matrice d'origine.

En d'autres termes, en ignorant le vecteur propre (vecteur composant principal) correspondant à la petite valeur propre La perte d'informations peut être supprimée tout en réduisant le nombre de fonctionnalités.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header=None)
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values

#Créer une matrice de corrélation (13x13)
R = np.corrcoef(X.T)

#Décomposition de valeur unique
eigvals, eigvecs = np.linalg.eigh(R)

#Visualisation
plt.bar(range(13), eigvals)
plt.title("distribution of eigvals")
plt.xlabel("index")
plt.ylabel("eigvals")
plt.show()

#Veuillez ne pas l'effacer. Il est utilisé pour vérifier le résultat de l'exécution.
print(eigvals)

Conversion de fonctionnalités

Dans la session précédente, nous avons décomposé la matrice de corrélation en valeurs propres et vecteurs propres. Ensuite, en utilisant les deux vecteurs propres correspondant à la plus grande valeur propre et à la deuxième plus grande valeur propre.

Créez une matrice 13x2 W qui convertit des entités 13 dimensions en 2 dimensions et créez des données Wine X avec des entités 13 dimensions. Convertit en nouvelles données Wine X 'avec uniquement les caractéristiques bidimensionnelles des premier et deuxième composants principaux.

Créez la matrice de conversion W comme suit.

#Concatène les vecteurs propres correspondant aux valeurs propres la plus grande et la deuxième plus grande dans la direction de la colonne
W = np.c_[eigvecs[:,-1], eigvecs[:,-2]]

À partir de ce qui précède, une matrice 13 par 2 a été créée. De plus, en prenant le produit de cette matrice W et des données d'origine X, il est possible de générer une matrice X 'compressée avec X.

Le calcul du produit matriciel est effectué par le code suivant

import numpy as np
X_pca = X.dot(W)

En utilisant le vecteur propre et la valeur propre, l'équation suivante est également valable.

Soit les deux valeurs propres de la plus grande λ1, λ2 et les vecteurs propres correspondants v1 et v2. Ces v1 et v2 sont des matrices de conversion.

Multiplier R par le vecteur propre v1 donne de nouvelles données qui s'étendent bien dans la direction v1 (grande variance)

Multiplier R par le vecteur propre v2 est orthogonal au vecteur v1 (ne peut pas être expliqué par v1) Vous pouvez obtenir de nouvelles données qui se développent bien dans la direction v2 (grande dispersion).

De même, multiplier X par les vecteurs propres v1 et v2 Vous pouvez obtenir des données d'entités qui s'étendent bien dans deux directions orthogonales.

Analyse des composants principaux à l'aide de scikit-learn

Jusqu'à présent, nous avons implémenté la conversion des fonctionnalités en utilisant l'analyse des composants principaux. En fait, vous pouvez facilement faire la même chose avec la classe PCA dans sklearn.decomposition. Utilisez la classe PCA comme suit.

from sklearn.decomposition import PCA
#Créez une instance de PCA en spécifiant le nombre de composants principaux. Spécifiez le nombre de dimensions après la conversion avec un argument.
pca = PCA(n_components=2)
#Apprenez le modèle de transformation à partir des données et transformez.
X_pca = pca.fit_transform(X)

La méthode fit_transform () génère automatiquement une matrice de transformation en interne.

Analyse des composants principaux comme prétraitement

En appliquant ce que nous avons appris jusqu'à présent, nous appliquerons l'analyse en composantes principales au prétraitement de l'analyse de régression. En compressant les données à l'avance, il est possible de générer un modèle d'analyse de régression plus polyvalent qui résiste aux perturbations telles que les valeurs aberrantes.

Commencez par diviser les données en données d'entraînement et en données de test.

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=0)

Lors de la conversion de caractéristiques, si différentes matrices de conversion sont obtenues pour les données d'apprentissage et les données de test, la conversion de caractéristiques est effectuée. Il n'est pas possible de comparer les données après la conversion des caractéristiques car la matrice de conversion est différente.

Il en va de même pour la normalisation. Cela peut être gênant

Utilisez des critères communs pour la formation et les données de test lors de la standardisation et de l'analyse des composants principaux.

Lors de la normalisation, il est pratique d'utiliser la classe StandardScalar comme suit.

from sklearn.preprocessing import StandardScaler
#Créer une instance pour la normalisation
sc = StandardScaler()
#Apprenez le modèle de transformation à partir des données d'entraînement et appliquez le même modèle aux données de test
X_train_std = sc.fit_transform(X_train)
X_test_std = sc.transform(X_test)

Lors de l'analyse des composants principaux, utilisez la classe PCA comme suit.

from sklearn.decomposition import PCA
#Générer une instance d'analyse des composants principaux
pca = PCA(n_components=2)
#Apprenez le modèle de transformation à partir des données d'entraînement et appliquez le même modèle aux données de test
X_train_pca = pca.fit_transform(X_train_std)
X_test_pca = pca.transform(X_test_std)

À titre de revue, l'analyse de régression est effectuée comme suit.

from sklearn.linear_model import LogisticRegression
#Générer une instance de régression logistique
lr = LogisticRegression()
#Apprendre le modèle de classification
lr.fit(X, y)
#Afficher le score
print(lr.score(X, y))

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression

df_wine = pd.read_csv("./5030_unsupervised_learning_data/wine.csv", header=None)

X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.4, random_state=0)

#Créer une instance pour la normalisation
sc = StandardScaler()
#Apprenez le modèle de transformation à partir des données d'entraînement et appliquez-le aux données de test
X_train_std = sc.fit_transform(X_train)
X_test_std = sc.transform(X_test)

#Générer une instance d'analyse des composants principaux
pca = PCA(n_components=2)
#Apprenez le modèle de transformation à partir des données d'entraînement et appliquez-le aux données de test
X_train_pca = pca.fit_transform(X_train_std)
X_test_pca = pca.transform(X_test_std)

#Générer une instance de régression logistique
lr = LogisticRegression()
#Apprendre le modèle de classification avec des données d'entraînement après la réduction de dimension
lr.fit(X_train_pca, y_train)

#Afficher le score
print(lr.score(X_train_pca, y_train))
print(lr.score(X_test_pca, y_test))

Analyse des composants principaux du noyau

Analyse des composants principaux du noyau

De nombreux algorithmes d'apprentissage automatique, tels que l'analyse de régression, peuvent être séparés linéairement On suppose que les données seront fournies. Cependant, en pratique, les données difficiles à séparer linéairement En d'autres termes, la plupart des données doivent être séparées de manière non linéaire. Dans cette session, une PCA avec noyau qui peut gérer les données qui doivent être séparées de manière non linéaire.

"Kernel PCA(kernel PCA)Sera traité dans cette section.

Tout d'abord avec le noyau PCA Données X d'un NxM donné (nombre de données x type d'entité) Remake-le en données K d'un tout nouveau NxM´ (nombre de données x type de fonctionnalités) (astuce du noyau).

Lorsque les astuces du noyau sont utilisées, les types de fonctionnalités augmentent généralement (les fonctionnalités sont développées). Cela facilite la séparation linéaire.

On sait que l'utilisation de l'analyse en composantes principales pour des données hautement non linéaires ne fonctionne pas. En étendant les données à la matrice du noyau K, il devient possible d'effectuer une analyse en composantes principales.

La figure ci-dessous montre des données bidimensionnelles distribuées dans un cercle après avoir augmenté les fonctionnalités à l'aide des astuces du noyau. C'est la figure qui a effectué l'analyse des composants principaux et a renvoyé la quantité de caractéristiques à deux et tracée.

En utilisant le noyau PCA, les données suivantes qui ne peuvent pas être séparées linéairement dans l'espace bidimensionnel peuvent être obtenues. Il peut être converti en données séparables linéairement.

Astuce du noyau 1

Tout d'abord, calculez la matrice de noyau (similarité) K. La matrice suivante est appelée matrice de noyau et la similitude est calculée pour chaque paire de données d'échantillon. La matrice noyau de données X de N x M (nombre de données x type d'entités) est Il devient N x N (nombre de données x nombre de données). Vous pouvez traiter la matrice du noyau K comme des données et effectuer des analyses telles que la régression et la classification.

Montré ici Est

Cela s'appelle une "fonction noyau" et il en existe plusieurs types.

Cette fois, nous utiliserons la fonction noyau appelée "noyau gaussien" dans "Fonction radio (RBF)" et exprimée par la formule suivante. Deux données avec cette formule Représente le degré de similitude.

Comme X, K représente des données individuelles en lignes et des entités (similitude avec d'autres données) en colonnes.

Ici est ci-dessous C'est une fonction du graphique comme.

を大きくするとより近接するものだけに注目したような特徴量行列Kが作られます。

Astuce du noyau 2

Implémentez les fonctions suivantes utilisées pour les astuces du noyau.

Vous pouvez calculer la matrice du noyau comme suit:

#Calculer le carré de la distance entre les données (distance euclidienne carrée)
M = np.sum((X - X[:, np.newaxis])**2, axis=2)
#Calculer la matrice du noyau
K = np.exp(-gamma * M)

Ici, pour obtenir la distance entre les données, une fonction appelée numpy array broadcast (Développe automatiquement la matrice, aligne la forme de la matrice et exécute l'opération).

import numpy as np

np.random.seed(39)

X = np.random.rand(8, 3)

#Calculer la distance euclidienne carrée par paire
M =np.sum((X - X[:, np.newaxis])**2, axis=2)

#Calculer la matrice du noyau
gamma = 15
K = np.exp(-gamma * M)

# ---------------------------
#K est un tableau numpy.
#La taille du tableau numpy A peut être obtenue et affichée comme suit.
print(K.shape)
# 
# ---------------------------

print(M)  #Veuillez ne pas l'effacer. Il est utilisé pour vérifier le résultat de l'exécution.
print(K)  #Veuillez ne pas l'effacer. Il est utilisé pour vérifier le résultat de l'exécution.

Conversion de fonctionnalités

Substituer la matrice du noyau K aux données originales X, pour K comme dans la méthode standard d'analyse en composantes principales Il peut être converti en données linéairement séparables X'en effectuant une décomposition de valeurs propres, une conversion de caractéristiques, etc.

À l'origine, K est une expansion de la quantité de caractéristiques de X, donc la matrice obtenue par conversion de caractéristiques de K est Il peut être traité comme une matrice transformée de caractéristiques X.

En utilisant ce que nous avons appris jusqu'à présent, nous transformerons les données circulaires en fonctionnalités en utilisant l'analyse des composants principaux du noyau.

En tant que développement La matrice de conversion W créée à partir du vecteur propre de la matrice noyau K est Vous pouvez également traiter X tel quel comme X ', qui est compressé et résumé dimensionnellement.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles

#Obtenez des données là où les données sont distribuées en cercle
X, y = make_circles(n_samples=1000, random_state=123, noise=0.1, factor=0.2)

#Calculer la distance euclidienne carrée par paire
M = np.sum((X - X[:, np.newaxis])**2, axis=2)

#Calculer la matrice de noyau symétrique
gamma = 15
K = np.exp(-gamma * M)

#Obtenez la paire unique de la matrice du noyau. engourdi.linalg.eigh les renvoie par ordre croissant de valeurs propres
eigvals, eigvecs = np.linalg.eigh(K)
#Top K des vecteurs propres(Échantillon projeté)Collecte
W = np.column_stack((eigvecs[:, -1], eigvecs[:, -2]))

#Trouvez le produit interne de K et W pour obtenir des données linéairement séparables.
X_kpca = K.dot(W)

#Visualisation
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.scatter(X[y == 0, 0], X[y == 0, 1], color="r", marker="^")
ax1.scatter(X[y == 1, 0], X[y == 1, 1], color="b", marker="o")
ax2.scatter(X_kpca[y == 0, 0], X_kpca[y == 0, 1], color="r", marker="^")
ax2.scatter(X_kpca[y == 1, 0], X_kpca[y == 1, 1], color="b", marker="o")
ax1.set_title("circle_data")
ax2.set_title("kernel_pca")
plt.show()

print(M)  #Veuillez ne pas l'effacer. Il est utilisé pour vérifier le résultat de l'exécution.
print(K)  #Veuillez ne pas l'effacer. Il est utilisé pour vérifier le résultat de l'exécution.
print(W)  #Veuillez ne pas l'effacer. Il est utilisé pour vérifier le résultat de l'exécution.
print(X_kpca)  #Veuillez ne pas l'effacer. Il est utilisé pour vérifier le résultat de l'exécution.

Analyse des composants principaux du noyau à l'aide de scikit-learn

L'analyse des composants principaux du noyau est similaire à l'ACP standard

sklearn.Facile à mettre en œuvre par décomposition.

L'utilisation est presque la même que celle du PCA standard. Les arguments vous permettent de spécifier le nombre de dimensions compressées et le type de noyau non trouvé dans PCA standard.

from sklearn.decomposition import KernelPCA
#Le noyau (fonction de base radiale) utilisé cette fois est le noyau="rbf"Peut être spécifié avec.
kpca = KernelPCA(n_components=2, kernel="rbf", gamma=15)
X_kpca = kpca.fit_transform(X)

Ici, les données en forme de lune sont séparées comme indiqué dans la figure ci-dessous. Obtenez les données comme suit:

from sklearn.datasets import make_moons
#Obtenez les données de la lune
X, y = make_moons(n_samples=100, random_state=123)

import numpy as np
import matplotlib.pyplot as plt

from sklearn.datasets import make_moons
#Importer le noyau PCA
# ---------------------------
from sklearn.decomposition import KernelPCA
# ---------------------------

#Obtenez les données de la lune
X, y = make_moons(n_samples=100, random_state=123)

#Instancier la classe KernelPCA
kpca = KernelPCA(n_components=2, kernel="rbf", gamma=15)
#Convertir les données X à l'aide de Kernel PCA
X_kpca = kpca.fit_transform(X)

#Visualisation
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))
ax1.scatter(X[y == 0, 0], X[y == 0, 1], c="r")
ax1.scatter(X[y == 1, 0], X[y == 1, 1], c="b")
ax1.set_title("moon_data")
ax2.scatter(X_kpca[y == 0, 0], X_kpca[y == 0, 1], c="r")
ax2.scatter(X_kpca[y == 1, 0], X_kpca[y == 1, 1], c="b")
ax2.set_title("kernel_PCA")
plt.show()

print(X_kpca)  #Veuillez ne pas l'effacer. Il est utilisé pour vérifier le résultat de l'exécution.