Vous êtes sur la page 1sur 15

Compression des données via la

réduction de dimensionnalité

Dans Chapitre 4, Création de bons ensembles de données de formation - prétraitement des données, vous avez découvert
les différentes approches pour réduire la dimensionnalité d'un ensemble de données à l'aide de différentes techniques de
sélection d'entités. Une autre approche de la sélection des fonctionnalités pour la réduction de extraction de
caractéristiques. Dans ce chapitre, vous découvrirez trois techniques fondamentales qui vous aideront à résumer le
contenu informationnel d'un ensemble de données en le transformant en un nouveau sous-espace d'entités de
dimensionnalité inférieure à l'original. La compression des données est un sujet important dans l'apprentissage automatique,
et elle nous aide à stocker et analyser les quantités croissantes de données qui sont produites et collectées à l'ère moderne
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

de la technologie. Dans ce chapitre, nous couvrirons les sujets suivants:

• Analyse en composantes principales (ACP) pour la compression de données non supervisée

• Analyse discriminante linéaire (LDA) comme technique de réduction de dimensionnalité supervisée


pour maximiser la séparabilité des classes

• Réduction de dimensionnalité non linéaire via analyse des composants principaux du noyau (KPCA)

Réduction de la dimensionnalité non supervisée via l'analyse


des composants principaux
Comme pour la sélection d'entités, nous pouvons utiliser différentes techniques d'extraction d'entités pour réduire le nombre d'entités
dans un ensemble de données. La différence entre la sélection et l'extraction de fonctionnalités est que, bien que nous conservions les
fonctionnalités originales lorsque nous utilisons des algorithmes de sélection de fonctionnalités, tels que sélection en arrière
séquentielle, nous utilisons l'extraction d'entités pour transformer ou projeter les données sur un nouvel espace d'entités.

[145]
Compression des données via la réduction de dimensionnalité

Dans le contexte de la réduction de la dimensionnalité, l'extraction de caractéristiques peut être comprise comme une approche
de la compression de données dans le but de conserver la plupart des informations pertinentes. En pratique, l'extraction de
fonctionnalités n'est pas seulement utilisée pour améliorer l'espace de stockage ou l'efficacité de calcul de l'algorithme
d'apprentissage, mais peut également améliorer les performances prédictives en réduisant la malédiction de la dimensionnalité -
surtout si nous travaillons avec des modèles non régularisés.

Les principales étapes de l'analyse des principaux composants

Dans cette section, nous discuterons de l'ACP, une technique de transformation linéaire non supervisée qui est
largement utilisée dans différents domaines, principalement pour l'extraction de caractéristiques et la réduction
de dimensionnalité. D'autres applications populaires de l'ACP comprennent les analyses exploratoires des
données et le débruitage des signaux dans le commerce boursier, et l'analyse des données du génome et des
niveaux d'expression des gènes dans le domaine de la bioinformatique. PCA nous aide à identifier les modèles
de données en fonction de la corrélation entre les fonctionnalités. En résumé, l'ACP vise à trouver les directions
de variance maximale dans les données de grande dimension et projette les données sur un nouveau
sous-espace de dimensions égales ou inférieures à celui d'origine.
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

Dans la figure précédente, •• 1 et •• 2 sont les axes caractéristiques d'origine, et PC1 et PC2 sont les principaux
composants.

[146]
Chapitre 5

Si nous utilisons l'ACP pour réduire la dimensionnalité, nous construisons un •• × •• - matrice de transformation dimensionnelle, W, qui
nous permet de cartographier un vecteur, X, les caractéristiques d'un exemple de formation, sur un nouveau k- sous-espace d'entité
dimensionnelle qui a moins de dimensions que l'original ré- espace d'entités dimensionnelles. Par exemple, le processus est le
suivant. Supposons que nous ayons un vecteur caractéristique, X:

•• = [•• 1, •• 2, …, •• ••], •• ∈ ℝ ••

qui est ensuite transformé par une matrice de transformation, •• ∈ ℝ •• × •• :

•••• = ••

résultant dans le vecteur de sortie:

•• = [•• 1, •• 2, …, •• ••], •• ∈ ℝ ••

À la suite de la transformation de l'original ré- des données dimensionnelles sur cette nouvelle
k- sous-espace dimensionnel (généralement k << ré), la première composante principale aura la plus grande variance
possible. Tous les composants principaux conséquents auront la plus grande variance étant donné la contrainte que ces
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

composants ne sont pas corrélés (orthogonaux) aux autres composants principaux - même si les caractéristiques d'entrée
sont corrélées, les composants principaux résultants seront mutuellement orthogonaux (non corrélés). Notez que les
directions PCA sont très sensibles à la mise à l'échelle des données, et nous devons standardiser les fonctionnalités avant à
PCA si les entités ont été mesurées à différentes échelles et nous voulons attribuer une importance égale à toutes les
entités.

Avant d'examiner plus en détail l'algorithme PCA pour la réduction de la dimensionnalité, résumons
l'approche en quelques étapes simples:

1. Standardisez le ré- ensemble de données dimensionnelles.

2. Construisez la matrice de covariance.

3. Décomposer la matrice de covariance en ses vecteurs propres et valeurs propres.

4. Triez les valeurs propres par ordre décroissant pour classer les vecteurs propres correspondants.

5. Sélectionnez k vecteurs propres, qui correspondent aux k les plus grandes valeurs propres, où k
est la dimensionnalité du nouveau sous-espace d'entités ( •• ≤ •• ).

6. Construire une matrice de projection, W, du haut" k vecteurs propres.

[147]
Compression des données via la réduction de dimensionnalité

7. Transformez le ré- jeu de données d'entrée dimensionnel, X, en utilisant la matrice de projection, W,


pour obtenir le nouveau k- sous-espace d'entités dimensionnelles.

Dans les sections suivantes, nous effectuerons un PCA étape par étape, en utilisant Python comme exercice d'apprentissage.
Ensuite, nous verrons comment effectuer une PCA plus facilement en utilisant scikit-learn.

Extraire les principaux composants étape par étape

Dans cette sous-section, nous aborderons les quatre premières étapes d'un APC:

1. Standardiser les données.

2. Construire la matrice de covariance.

3. Obtention des valeurs propres et des vecteurs propres de la matrice de covariance.

4. Tri des valeurs propres par ordre décroissant pour classer les vecteurs propres.

Tout d'abord, nous allons commencer par charger l'ensemble de données Wine avec lequel nous travaillions Chapitre

4, Création de bons ensembles de données de formation - Prétraitement des données:

>>> importer des pandas en tant que pd

> > > df_wine = pd.read_csv ('https://archive.ics.uci.edu/ml/'


international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

. . . «bases de données d'apprentissage automatique / wine / wine.data»,


. . . en-tête = Aucun)

Obtention de l'ensemble de données Wine

Vous pouvez trouver une copie de l'ensemble de données Wine (et de tous les autres ensembles
de données utilisés dans ce livre) dans l'ensemble de codes de ce livre, que vous pouvez utiliser
si vous travaillez hors ligne ou sur le serveur UCI à https: //
archive.ics.uci.edu/ml/machine-learning-databases/ wine / wine.data est temporairement indisponible. Par

exemple, pour charger l'ensemble de données Wine à partir d'un répertoire local, vous pouvez
remplacer la ligne suivante:

df = pd.read_csv (
'https://archive.ics.uci.edu/ml/' 'bases de données d'apprentissage machine
/ wine / wine.data', header = None)

avec le suivant:

df = pd.read_csv (
'votre / chemin / local / vers / wine.data', en-tête =
Aucun)

[148]
Chapitre 5

Ensuite, nous traiterons les données Wine dans des ensembles de données de formation et de test distincts - en utilisant
respectivement 70% et 30% des données - et les normaliserons en fonction de la variance unitaire:

> > > de sklearn.model_selection import train_test_split


> > > 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,3,
. . . stratifier = y,
. . . random_state = 0)
> > > # standardiser les fonctionnalités
> > > à partir de sklearn.preprocessing import StandardScaler
> > > sc = StandardScaler ()
> > > X_train_std = sc.fit_transform (X_train)
> > > X_test_std = sc.transform (X_test)

Après avoir terminé le prétraitement obligatoire en exécutant le code précédent, passons à la deuxième étape:
construire la matrice de covariance. Le symétrique •• × ••
- matrice de covariance dimensionnelle, où ré est le nombre de dimensions dans l'ensemble de données, stocke les
covariances par paire entre les différentes entités. Par exemple, la covariance entre deux caractéristiques, •• •• et •• •• , au
niveau de la population peut être calculée via l'équation suivante:
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

•• ••

•• •••• = 1
•• - 1∑ (•• •• (••) - •• ••) ( •• •• (••) - •• ••)
=1

Ici, •• •• et •• •• sont les exemples de moyens de fonctionnalités j et k, respectivement. Notez que les moyennes d'échantillon sont
nulles si nous standardisons ized t il ensemble de données. Une covariance positive entre deux caractéristiques indique que les
caractéristiques augmentent ou diminuent ensemble, tandis qu'une covariance négative indique que les caractéristiques
varient dans des directions opposées. Par exemple, la matrice de covariance de trois entités peut alors s'écrire comme suit
(notez que Σ signifie la majuscule grecque sigma, qui ne doit pas être confondue avec le symbole de sommation):

•• 12 •• 13
Σ = [•• 12•• 21 •• 22 •• 23
•• 31 •• 32 •• 32]

Les vecteurs propres de la matrice de covariance représentent les principales composantes (les directions de variance
maximale), tandis que les valeurs propres correspondantes définiront leur amplitude. Dans le cas de l'ensemble de
données Wine, nous obtiendrions 13 vecteurs propres et valeurs propres du 13 × 13 - matrice de covariance
dimensionnelle.

[149]
Compression des données via la réduction de dimensionnalité

Maintenant, pour notre troisième étape, obtenons les paires propres de la matrice de covariance. Comme vous vous en
souviendrez de nos classes d'introduction d'algèbre linéaire, un vecteur propre,
v, remplit la condition suivante:

Σ•• = ••••

Ici, •• est un scalaire: la valeur propre. Étant donné que le calcul manuel des vecteurs propres et des valeurs propres est une
tâche quelque peu fastidieuse et complexe, nous utiliserons le linalg.eig
fonction de NumPy pour obtenir les paires propres de la matrice de covariance Wine:

> > > import numpy as np


> > > cov_mat = np.cov (X_train_std.T)
> > > eigen_vals, eigen_vecs = np.linalg.eig (cov_mat)
> > > print ('\ nEigenvalues ​\ n% s'% eigen_vals) Eigenvalues

[4,84274532 2,41602459 1,54845825 0,96120438 0,84166161


0,6620634 0,51828472 0,34650377 0,3131368 0,10754642
0,21357215 0,15362835 0,1808613]

En utilisant le numpy.cov fonction, nous avons calculé la matrice de covariance de l'ensemble de données
d'apprentissage normalisé. En utilisant le linalg.eig fonction, nous avons effectué la composition eigendec, qui a donné
un vecteur ( eigen_vals) composé de 13 valeurs propres et des vecteurs propres correspondants stockés sous forme de
colonnes
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

13 × 13 - matrice dimensionnelle ( eigen_vecs).

Eigendecomposition dans NumPy

le numpy.linalg.eig a été conçue pour fonctionner sur des matrices carrées symétriques
et non symétriques. Cependant, vous pouvez constater qu'il renvoie des valeurs
propres complexes dans certains cas.

Une fonction connexe, numpy.linalg.eigh, a été implémenté pour décomposer les


matrices hermétiennes, qui est une approche numériquement plus stable pour
travailler avec des matrices symétriques telles que la matrice de covariance; numpy.linalg.eigh

renvoie toujours des valeurs propres réelles.

[150]
Chapitre 5

Écart total et expliqué


Puisque nous voulons réduire la dimensionnalité de notre ensemble de données en le compressant dans un nouveau
sous-espace d'entités, nous sélectionnons uniquement le sous-ensemble des vecteurs propres (composants principaux) qui
contient la plupart des informations (variance). Les valeurs propres définissent la magnitude des vecteurs propres, nous devons
donc trier les valeurs propres en diminuant la magnitude; nous sommes intéressés par le haut k vecteurs propres basés sur les
valeurs de leurs valeurs propres correspondantes. Mais avant de les collecter k les vecteurs propres les plus informatifs, tracons
le ratios explication de la variance des valeurs propres. La variance expliquait le rapport d'une valeur propre, •• •• , est
simplement la fraction d'une valeur propre, •• •• , et la somme totale des valeurs propres:

•• ••
Rapport de variance expliqué =
∑ •• ••
•••• = 1

Utilisation de NumPy cumsum fonction, nous pouvons ensuite calculer la somme cumulée des variances expliquées,
que nous allons ensuite tracer via Matplotlib étape une fonction:

> > > tot = somme (valeurs propres)


> > > var_exp = [(i / tot) pour i in
. . . trié (valeurs propres, inverse = vrai)]
> > > cum_var_exp = np.cumsum (var_exp)
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

> > > import matplotlib.pyplot as plt


> > > plt.bar (range (1,14), var_exp, alpha = 0.5, align = 'center',
. . . label = 'Variation individuelle expliquée')
> > > plt.step (range (1,14), cum_var_exp, where = 'mid',
. . . label = 'Variance cumulée expliquée')
> > > plt.ylabel ('Explained variance ratio')
> > > plt.xlabel ('Index des composants principaux')
> > > plt.legend (loc = 'best')
> > > plt.tight_layout ()
> > > plt.show ()

Le graphique résultant indique que la première composante principale représente à elle seule environ
40% de la variance.

[151]
Compression des données via la réduction de dimensionnalité

De plus, nous pouvons voir que les deux premières composantes principales combinées expliquent près de 60% de la variance
dans l'ensemble de données:

international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

Bien que le graphique de variance expliqué nous rappelle les valeurs d'importance des caractéristiques que nous avons calculées dans Chapitre

4, Création de bons ensembles de données de formation - prétraitement des données,

via des forêts aléatoires, nous devons nous rappeler que PCA est une méthode non supervisée, ce qui signifie que les
informations sur les étiquettes de classe sont ignorées. Alors qu'une forêt aléatoire utilise les informations d'appartenance à
la classe pour calculer les impuretés du nœud, la variance mesure la propagation des valeurs le long d'un axe de
caractéristique.

Transformation des fonctionnalités


Maintenant que nous avons réussi à décomposer la matrice de covariance en paires propres, passons aux trois dernières
étapes pour transformer l'ensemble de données Wine en nouveaux axes de composants principaux. Les étapes restantes
que nous allons aborder dans cette section sont les suivantes:

5. Sélectionnez k vecteurs propres, qui correspondent aux k les plus grandes valeurs propres, où
k est la dimensionnalité du nouveau sous-espace d'entités ( •• ≤ •• ).

6. Construire une matrice de projection, W, du haut" k vecteurs propres.

[152]
Chapitre 5

7. Transformez le ré- jeu de données d'entrée dimensionnel, X, en utilisant la matrice de projection, W,


pour obtenir le nouveau k- sous-espace d'entités dimensionnelles.

Ou, en termes moins techniques, nous allons trier les paires propres par ordre décroissant des valeurs propres, construire

une matrice de projection à partir des vecteurs propres sélectionnés et utiliser la matrice de projection pour transformer les

données dans le sous-espace de dimension inférieure. On commence par trier les paires propres par ordre décroissant des

valeurs propres:

> > > # Faire une liste de tuples (valeur propre, vecteur propre)
> > > eigen_pairs = [(np.abs (eigen_vals [i]), eigen_vecs [:, i])
. . . pour i dans la plage (len (eigen_vals))]
> > > # Trier les tuples (valeur propre, vecteur propre) de haut en bas
> > > eigen_pairs.sort (clé = lambda k: k [0], reverse = True)

Ensuite, nous collectons les deux vecteurs propres qui correspondent aux deux plus grandes valeurs propres, pour
capturer environ 60% de la variance dans cet ensemble de données. Notez que deux vecteurs propres ont été choisis
à des fins d'illustration, car nous allons tracer les données via un nuage de points bidimensionnel plus loin dans cette
sous-section. En pratique, le nombre de composants principaux doit être déterminé par un compromis entre l'efficacité
de calcul et les performances du classificateur:

> > > w = np.hstack ((eigen_pairs [0] [1] [:, np.newaxis],


. . . eigen_pairs [1] [1] [:, np.newaxis]))
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

> > > print ('Matrice W: \ n', w) Matrice W:

[[-0,13724218 0,50303478] [0,24724326


0,16487119] [-0,02545159 0,24456476]
[0,20694508 -0,11352904] [-0,15436582
0,28974518] [-0,39376952 0,05080104]
[-0,41735106 -0,02287338] 0,08686 [0,048
-0.32613263 -0.20716433] [-0.36861022
-0.24902536] [-0.29669651 0.38022942]]

En exécutant le code précédent, nous avons créé un 13 × 2 - matrice de projection dimensionnelle, W, des deux
vecteurs propres supérieurs.

[153]
Compression des données via la réduction de dimensionnalité

Projections en miroir

Selon les versions de NumPy et LAPACK que vous utilisez, vous pouvez obtenir la
matrice, W, avec ses signes retournés. Veuillez noter que ce n'est pas un problème;
si v est un vecteur propre d'une matrice, Σ , on a:

Σ•• = ••••
Ici, v est le vecteur propre, et –V est également un vecteur propre, que nous pouvons montrer
comme suit. En utilisant l'algèbre de base, nous pouvons multiplier les deux côtés de l'équation par
un scalaire, ••:

••Σ•• = ••••••

Étant donné que la multiplication matricielle est associative pour la multiplication scalaire,
nous pouvons alors réorganiser cela comme suit:

Σ (••••) = •• (••••)

Maintenant, nous pouvons voir que •••• est un vecteur propre avec la même valeur propre, •• , pour les
deux •• = 1 et •• = −1 . Par conséquent, les deux v et
- v sont des vecteurs propres.
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

En utilisant la matrice de projection, nous pouvons maintenant transformer un exemple, X ( représenté comme un vecteur de
lignes à 13 dimensions), sur le sous-espace PCA (les principaux composants un et deux) •• ′ , maintenant un vecteur d'exemple en
deux dimensions composé de deux nouvelles fonctionnalités:

•• ′ = ••••

> > > Tableau X_train_std [0] .dot (w) ([2.38299011,


0.45458499])

De même, nous pouvons transformer l'ensemble 124 × 13 - jeu de données d'apprentissage dimensionnel sur les deux
composantes principales en calculant le produit scalaire matriciel:

•• ′ = ••••

> > > X_train_pca = X_train_std.dot (w)

Enfin, visualisons le jeu de données de formation Wine transformé, maintenant stocké en tant que 124 × 2
- matrice dimensionnelle, dans un nuage de points bidimensionnel:

[154]
Chapitre 5

> > > couleurs = ['r', 'b', 'g']


> > > marqueurs = ['s', 'x', 'o']
> > > pour l, c, m en zip (np.unique (y_train), couleurs, marqueurs):
. . . plt.scatter (X_train_pca [y_train == l, 0],
. . . X_train_pca [y_train == l, 1],
. . . c = c, étiquette = l, marqueur = m)
> > > plt.xlabel ('PC 1')
> > > plt.ylabel ('PC 2')
> > > plt.legend (loc = 'en bas à gauche')
> > > plt.tight_layout ()
> > > plt.show ()

Comme nous pouvons le voir dans le graphique résultant, les données sont plus réparties le long de la X- axe - le premier composant
principal - que le deuxième composant principal ( y- axe), ce qui est cohérent avec le graphique du rapport de variance expliqué que
nous avons créé dans la sous-section précédente. Cependant, nous pouvons dire qu'un classificateur linéaire sera probablement
capable de bien séparer les classes:
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

Bien que nous ayons codé les informations d'étiquette de classe à des fins d'illustration dans le diagramme de dispersion
précédent, nous devons garder à l'esprit que PCA est une technique non supervisée qui n'utilise aucune information
d'étiquette de classe.

Analyse des composants principaux dans scikit-learn


Bien que l'approche détaillée de la sous-section précédente nous ait aidés à suivre le fonctionnement interne de l'ACP, nous
allons maintenant discuter de la façon d'utiliser le PCA classe implémentée dans scikit-learn.

[155]
Compression des données via la réduction de dimensionnalité

le PCA La classe est une autre des classes de transformateurs de scikit-learn, où nous ajustons d'abord le modèle en utilisant les
données d'apprentissage avant de transformer à la fois les données d'apprentissage et l'ensemble de données de test en utilisant les
mêmes paramètres de modèle. Maintenant, utilisons le PCA classe de scikit - apprenez sur l'ensemble de données de formation Wine,
classifiez les exemples transformés via la régression logistique et visualisez les régions de décision via le plot_decision_regions

fonction que nous avons définie dans Chapitre 2, Formation à des algorithmes d'apprentissage automatique simples pour la classification:

à partir de matplotlib.colors, importez ListedColormap

def plot_decision_regions (X, y, classificateur, résolution = 0,02):

# configurer le générateur de marqueurs et les marqueurs de


carte de couleur = ('s', 'x', 'o', '^', 'v')
couleurs = ('rouge', 'bleu', 'vert clair', 'gris', 'cyan') cmap = ListedColormap (couleurs [: len
(np.unique (y))]])

# tracer la surface de décision


x1_min, x1_max = X [:, 0] .min () - 1, X [:, 0] .max () + 1 x2_min, x2_max = X [:, 1] .min () - 1, X [:, 1] .max
() + 1 xx1, xx2 = np.meshgrid (np.arange (x1_min, x1_max, resolution),

np.arange (x2_min, x2_max, résolution))


Z = classifier.predict (np.array ([xx1.ravel (), xx2.ravel ()]). T) Z = Z.reshape (xx1.shape)
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

plt.contourf (xx1, xx2, Z, alpha = 0.4, cmap = cmap) plt.xlim (xx1.min (), xx1.max
()) plt.ylim (xx2.min (), xx2.max ())

# exemples de tracé par classe


pour idx, cl in enumerate (np.unique (y)):
plt.scatter (x = X [y == cl, 0],
y = X [y == cl, 1], alpha = 0,6, color
= cmap (idx), edgecolor = 'black',
marker = markers [idx], label = cl)

Pour votre commodité, vous pouvez placer le plot_decision_regions code ci-dessus dans un fichier de code distinct
dans votre répertoire de travail actuel, par exemple,
plot_decision_regions_script.py, et importez-le dans votre session Python actuelle.

> > > à partir de sklearn.linear_model import LogisticRegression


> > > à partir de sklearn.decomposition importation PCA
> > > # initialiser le transformateur PCA et
> > > # Estimateur de régression logistique:

[156]
Chapitre 5

> > > pca = PCA (n_components = 2)


> > > lr = LogisticRegression (multi_class = 'ovr',
. . . random_state = 1,
. . . solveur = 'lbfgs')
> > > # réduction de dimensionnalité:
> > > X_train_pca = pca.fit_transform (X_train_std)
> > > X_test_pca = pca.transform (X_test_std)
> > > # ajustement du modèle de régression logistique sur l'ensemble de données réduit:
> > > lr.fit (X_train_pca, y_train)
> > > plot_decision_regions (X_train_pca, y_train, classifier = lr)
> > > plt.xlabel ('PC 1')
> > > plt.ylabel ('PC 2')
> > > plt.legend (loc = 'en bas à gauche')
> > > plt.tight_layout ()
> > > plt.show ()

En exécutant le code précédent, nous devrions maintenant voir les régions de décision pour les données
d'apprentissage réduites à deux axes principaux:
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

Lorsque nous comparons des projections PCA via scikit-learn avec notre propre implémentation PCA, il peut arriver
que les graphiques résultants soient des images miroir les uns des autres. Notez que cela n'est pas dû à une erreur
dans l'une de ces deux implémentations; la raison de cette différence est que, selon le solveur, les vecteurs propres
peuvent avoir des signes négatifs ou positifs.

[157]
Compression des données via la réduction de dimensionnalité

Ce n'est pas important, mais nous pourrions simplement inverser l'image miroir en multipliant les données par –1 si nous le
voulions; notez que les vecteurs propres sont généralement mis à l'échelle à la longueur unitaire 1. Par souci d'exhaustivité,
traçons les régions de décision de la régression logistique sur l'ensemble de données de test transformé pour voir s'il peut
bien séparer les classes:

> > > plot_decision_regions (X_test_pca, y_test, classifier = lr)


> > > plt.xlabel ('PC1')
> > > plt.ylabel ('PC2')
> > > plt.legend (loc = 'en bas à gauche')
> > > plt.tight_layout ()
> > > plt.show ()

Après avoir tracé les régions de décision pour l'ensemble de données de test en exécutant le code précédent, nous pouvons voir que la
régression logistique fonctionne assez bien sur ce petit sous-espace d'entités bidimensionnelles et ne classe mal que quelques exemples
dans l'ensemble de données de test: international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

Si nous sommes intéressés par les ratios de variance expliqués des différentes composantes principales, nous pouvons
simplement initialiser le PCA classe avec le n_components paramètre défini sur Aucun, de sorte que tous les composants
principaux sont conservés et le rapport de variance expliqué peut ensuite être consulté via le expliqué_variance_ratio_ attribut:

> > > pca = PCA (n_components = None)


> > > X_train_pca = pca.fit_transform (X_train_std)
> > > pca.explained_variance_ratio_
tableau ([0,36951469, 0,18434927, 0,11815159, 0,07334252,
0,06422108, 0,05051724, 0,03954654, 0,02643918,
0,02389319, 0,01629614, 0,01380021, 0,01172226,
0,00820609])

[158]
Chapitre 5

Notez que nous définissons n_components = Aucun lorsque nous avons initialisé le PCA afin de renvoyer tous les
composants principaux dans un ordre trié, au lieu d'effectuer une réduction de dimensionnalité.

Compression de données supervisée via une analyse


discriminante linéaire
LDA peut être utilisé comme technique d'extraction de caractéristiques pour augmenter l'efficacité de calcul et réduire
le degré de sur-ajustement en raison de la malédiction de la dimensionnalité dans les modèles non régularisés. Le
concept général derrière LDA est très similaire à PCA, mais alors que PCA tente de trouver les axes des composants
orthogonaux de variance maximale dans un ensemble de données, le but dans LDA est de trouver le sous-espace
d'entités qui optimise la séparabilité des classes. Dans les sections suivantes, nous aborderons plus en détail les
similitudes entre LDA et PCA et parcourrons pas à pas l'approche LDA.

Analyse en composantes principales versus analyse


discriminante linéaire
PCA et LDA sont des techniques de transformation linéaire qui peuvent être utilisées pour réduire le nombre de dimensions
dans un ensemble de données; le premier est un algorithme non supervisé, tandis que le second est supervisé. Ainsi, nous
international.scholarvox.com:Universiapolis:897020685:88877968:41.137.222.34:1591358973

pourrions penser que LDA est une technique d'extraction de caractéristiques supérieure pour les tâches de classification par
rapport à PCA. Cependant, AM Martinez a signalé que le prétraitement via PCA a tendance à entraîner de meilleurs résultats
de classification dans une tâche de reconnaissance d'image dans certains cas, par exemple, si chaque classe ne comprend
qu'un petit nombre d'exemples ( PCA contre LDA, AM Martinez et AC Kak, IEEE Transactions on Pattern Analysis and Machine
Intelligence, 23 (2): 228-233, 2001).

Fisher LDA

LDA est parfois aussi appelé LDA de Fisher. Ronald A. Fisher initialement formulé Discriminant
linéaire de Fisher pour des problèmes de classification à deux classes en 1936 ( L'utilisation de
mesures multiples dans les problèmes taxonomiques, RA Fisher, Annales d'eugénisme, 7 (2):
179-
188, 1936). Le discriminant linéaire de Fisher a ensuite été généralisé pour les problèmes
multi-classes par C. Radhakrishna Rao sous l'hypothèse de covariances de classes égales et
de classes normalement distribuées en 1948, que nous appelons maintenant LDA ( L'utilisation
de mesures multiples dans les problèmes de classification biologique,

CR Rao, Journal de la Royal Statistical Society. Série B


(méthodologique), 10 (2): 159-203, 1948).

[159]

Vous aimerez peut-être aussi