Réduction de la dimension d'un jeu de données

L'objectif est de mettre en pratique ce qui a été vu en cours concernant la réduction de dimension d'un jeu de données. On commence en traitant brièvement l'analyse en composantes principales ; on continue avec la mise à l'échelle multi-dimensionnelle.

Toutes les manipulations se feront avec R.

Ce TP est réalisé sous Linux. Sachez néanmoins que R fonctionne sous Windows et sous MacOS.

Analyse en composantes principales

L'ACP peut être vue comme une méthode de réduction de dimension. Comme vous l'étudiez également en cours de maths, cette partie du TP consiste seulement à vous présenter les fonctions à connaître pour effectuer une ACP en R. Bien entendu, analyse des correspondances et analyse des correspondances multiples peuvent également être faites en R.

Les fonctions R pour effectuer une ACP

Les fonctions sont disponibles dans la bibliothèque stats. Il faut donc taper la commande :

library(stats)

Ensuite, l'ACP est effectuée en utilisant la fonction princomp() à laquelle on passe un data frame en paramètre ainsi que le paramètre cor = TRUE.

Le résultat est une liste dont les composantes sont :

• sdev qui est le vecteur des écart-types sur chacun des axes principaux ;
• loadings qui est la matrice de rotation, autrement dit, une matrice dont chacune des colonnes est un vecteur propre de l'ACP ;
• center qui est le vecteur des moyennes pour chacun des attributs (pour que l'attribut soit centrée) ;
• scale qui est un vecteur des facteurs de mise mise à l'échelle pour chaque des attributs (pour que l'attribut soit réduit) ;
• scores qui est une matrice donnant les coordonnées dans l'espace factoriel de chacun des points du data frame initial.

Les fonctions R pour visualiser le résultat d'une ACP

On suppose que l'on a effectué une ACP avec la fonction princomp() et que le résultat a été placé dans un objet dénommé mon.acp.

Une fois une ACP réalisée, on peut obtenir et visualiser les éléments suivants :

• les valeurs des écart-types sur chacun des axes factoriels en tapant le nom de l'objet ;
• plot (mon.acp) produit un graphique représentation ces écart-types ;
• biplot (mon.acp) produit un biplot, c'est-à-dire un graphique représentant en même temps les données dans le plan principal et la projection des attributs dans ce plan.

Le cercle de corrélation s'obtient comme suit :

> angles.pour.dessiner.un.cercle <- seq (from = 0, to = 2 * pi, by = 0.01)
> plot (cos (angles.pour.dessiner.un.cercle),
        sin (angles.pour.dessiner.un.cercle),
        xlab = "composante principale 1",
        ylab = "composante principale 2",
        main = "Cercle des corrélations",
        type = 'l',
        asp = 1)
> mon.acp.v <- t (mon.acp$loadings) [1:2,]
> arrows (0, 0, mon.acp.v [1,], mon.acp.v [2,], col="blue")
> text (v [1,], v [2, ], colnames (mon.acp.v))

Mise en œuvre

• effectuez une ACP sur le jeu de données USArrests
• comment obtenez-vous l'inertie des axes principaux ?
• comment obtenez-vous la visualisation des données dans un plan quelconque (par exemple, celui formé par les axes 1 et 3 ou 2 et 3) ?

Mise à l'échelle multi-dimensionnelle

On passe en revue 3 fonctions disponibles en R pour effectuer les différentes sortes de mise à l'échelle multi-dimensionnelle vues en cours.

Mise à l'échelle classique

Elle se fait par la fonction cmdscale() de la bibliothèque stats. Rappelons que c'est équivalent à une ACP de la matrice des distances. Si le nombre d'objets est grand, c'est (très) long à calculer !

Paramètres :

• matrice de distance/dissimilarité entre les points ;
• paramètre optionnel k qui indique la dimension de l'espace dans lequel on veut faire la projection (2 par défaut).

Résultat : une liste ayant plusieurs champs, parmi lesquels :

• points : la position des points dans le plan.

Mise à l'échelle de Sammon

Description de la fonction sammon()

Elle se fait par la fonction sammon() de la bibliothèque MASS.

Paramètres :

• matrice de distance/dissimilarité entre les points ;
• paramètre optionnel k pour indiquer la dimension de l'espace dans lequel on projette les données (2 par défaut) ;
• paramètre optionnel y pour fournir une configuration initiale ;
• paramètre optionnel tol pour indiquer le seuil de variation du stress entre deux itérations qui entraîne l'arrêt de la relaxation (plus il est bas, plus le nombre d'itérations peut être grand et plus le stress peut baisser) ;
• paramètre optionnel niter qui indique le nombre maximum d'intérations à effectuer.

Résultat : une liste contenant deux champs :

• points : la position des points dans le plan ;
• stress : la valeur finale du stress.

Exemple d'utilisation

On utilise le jeu de données que vous obtenez en cliquant ici. On suppose qu'il est chargé dans le data frame dénommé helice.30. Ce jeu représente 30 points situés sur une hélice, d'où son nom...

La commande :

> helice.30.sammon <- sammon (dist (helice.30))

effectue une rds de base. Cette commande affiche un certain nombre de choses :

Initial stress        : 0.00171
stress after  10 iters: 0.00106, magic = 0.500
stress after  20 iters: 0.00105, magic = 0.500
$points
             [,1]        [,2]
 [1,] -10.3704504  1.06015253
 [2,]  -9.4743721  1.36230509
 [3,]  -8.8116692  0.75122529
 [4,]  -8.2561554 -0.01351095
 [5,]  -7.6044522 -0.67818419
 [6,]  -6.8368898 -1.17257483
 [7,]  -5.9746411 -1.27088913
 [8,]  -5.2458164 -0.73300606
 [9,]  -4.6527698  0.03824847
[10,]  -4.0016305  0.73365370
[11,]  -3.1930785  1.08439568
[12,]  -2.3840122  0.77401823
[13,]  -1.7508704  0.05384435
[14,]  -1.1514380 -0.71613425
[15,]  -0.4250276 -1.27354394
[16,]   0.4250276 -1.27354394
[17,]   1.1514380 -0.71613425
[18,]   1.7508704  0.05384435
[19,]   2.3840122  0.77401823
[20,]   3.1930785  1.08439568
[21,]   4.0016305  0.73365370
[22,]   4.6527698  0.03824847
[23,]   5.2458164 -0.73300606
[24,]   5.9746411 -1.27088913
[25,]   6.8368898 -1.17257483
[26,]   7.6044522 -0.67818419
[27,]   8.2561554 -0.01351095
[28,]   8.8116692  0.75122529
[29,]   9.4743721  1.36230509
[30,]  10.3704504  1.06015253

$stress
[1] 0.001053551

$call
sammon(d = dist(helice.30))

On y trouve :

• le stress de la configuration initiale ;
• toutes les 10 itérations de l'algorithme de relaxation, le stress est affiché ;
• puis le champ points qui contient les coordonnées dans le plan des 30 points initiaux ;
• le champ stress qui contient le stress de la configuration finale ;
• le champ call qui contient la commande qui a engendré cette projection (ce qui est utile quand on en fait plusieurs pour s'y retrouver).

On peut visualiser le résultat comme suit :

> plot (helice.30.sammon$points)

On voit un ensemble de points... bof, on n'y comprend pas grand chose (-( On va faire mieux.
On n'y voit pas grand chose parce que l'on ne sait pas dans quel ordre sont dessinés les points. Si on les relie par des segments de droite, on va voir quelque chose. Donc, tapons la commande :

> plot (helice.30.sammon$points, type='l')

Ça doit vous donner :

Rappelons que l'on sait qu'ici, les points sont disposés dans l'espace selon une hélice... Comment comprenez-vous ce résultat ?

La fonction sammon() a été utilisée avec ses paramètres par défaut. Dans la suite, pour obtenir une meilleure solution (un stress plus faible), on pourra utiliser les paramètres suivants :

> helice.30.sammon <- sammon (dist (helice.30), tol=1e-6, niter=500)

Mise à l'échelle non métrique

Description de la fonction isoMDS()

Elle se fait par la fonction isoMDS() de la bibliothèque MASS.

Paramètres (presque les mêmes que pour sammon()) :

• matrice de distance/dissimilarité entre les points ;
• paramètre optionnel k pour indiquer la dimension de l'espace dans lequel on projette les données (2 par défaut) ;
• paramètre optionnel y pour fournir une configuration initiale ;
• paramètre optionnel tol pour indiquer le seuil de variation du stress entre deux itérations qui entraîne l'arrêt de la relaxation (plus il est bas, plus le nombre d'itérations peut être grand et plus le stress peut baisser) ;
• paramètre optionnel maxit qui indique le nombre maximum d'intérations à effectuer.

Résultat : comme pour la fonction sammon(), une liste contenant deux champs :

• points : la position des points dans le plan ;
• stress : la valeur finale du stress.

Exemple d'utilisation

On reprend le jeu de données helice.30. On tape donc :

> helice.30.isoMDS <- isoMDS (dist (helice.30))

et on peut afficher le résultat avec :

> plot (helice.30.isoMDS$points, type='l')

Ça doit vous donner :

Graphe de Shepard

Description de la fonction Shepard()

Pour visualiser la déformation induite par la projection dans le plan, la fonction Shepard() de la bibliothèque MASS produit un objet permettant de dessiner le graphe du même nom.

Son utilisation se fait en lui passant deux paramètres, la matrice des distances initiales et la projection dans le plan.

Exemple d'utilisation

Toujours sur helice.30, on pourra faire :

> plot (Shepard (dist (helice.30), sammon (dist (helice.30))$points))

et obtenir :

ou

> plot (Shepard (dist (helice.30), isoMDS (dist (helice.30))$points))

et obtenir :

Étude de cas de la réduction de la dimension