projet de fouilles de donnees

Emeline COURCELLE Patrick JAMET PROJET DE FOUILLES DE DONNEES Enseignement dirigé par M. Mohamed NADIF Avril 2012 SOMMAIRE Partie I : Evaluation de K-­‐means et CAH ............................................................................................................ 3 1. On commence par visualiser les nuages des individus sur un plan ........................................................................ 3 2. On visualise ensuite les vraies classes sur ces plans ...................................................................................................... 3 3. On applique K-­‐means sur chaque base choisie ............................................................................................................... 3 4. On visualise les classes de l’algorithme K-­‐means sur un plan .................................................................................. 4 5. Comparaison de la partition obtenue avec K-­‐means et de la vraie partition ................................................... 4 6. On applique une classification ascendante hiérarchique ........................................................................................... 5 7 & 8. On visualise les arbres hiérarchiques obtenus et on propose une partition pour chacun ................... 5 9. On compare la partition obtenue et la vraie partition ................................................................................................ 6 10. Comparaison entre k-­‐means et CAH ................................................................................................................................. 7 Partie II : Interprétation des classes ................................................................................................................... 8 Jeu de données Wine ........................................................................................................................................................................ 8 Présentation du jeu de données Wine ......................................................................................................................... 8 Etude de la distribution des données Wine ............................................................................................................... 8 ACP sur Wine ....................................................................................................................................................................... 10 HCPC sur Wine .................................................................................................................................................................... 13 Algorithme K-­‐means sur Wine ..................................................................................................................................... 13 Jeu de données E.coli .................................................................................................................................................................... 14 Présentation du jeu de données E.coli ...................................................................................................................... 14 Etude de la distribution des données E.coli ........................................................................................................... 14 ACP sur E.coli ....................................................................................................................................................................... 15 HCPC sur E.coli .................................................................................................................................................................... 18 Algorithme K-­‐means sur E.coli ..................................................................................................................................... 18 Partie III : Classification dans la bioinformatique ....................................................................................... 20 1. Apport de la classification dans le domaine des données biopuces .................................................................... 20 2. Application de K-­‐means et de la CAH ............................................................................................................................... 20 3. Construction des matrices de confusion ......................................................................................................................... 21 Annexe ....................................................................................................................................................................... 22 # Partie 1 : Evaluations K-­‐means et CAH ............................................................................................................................ 22 # Partie 2 : Interpretation des classes .................................................................................................................................. 26 # Partie 3 : Classification dans la bio-­‐informatique ...................................................................................................... 30 Note : Toutes les lignes de code se trouvent en annexe. Partie I : Evaluation de K-­‐means et CAH Nous avons choisi de travailler sur les 3 datasets suivant : TwoDiamonds, Chainlink et WingNut. On s’intéresse aux avantages et aux défauts de plusieurs algorithmes de classification : K-­‐means et CAH (ward, lien minimum, lien maximum, lien moyen). 1. On commence par visualiser les nuages des individus sur un plan •
•
•
On visualise deux groupes d’individus en forme de diamants sur le nuage de TwoDiamonds. On distingue deux formes rectangulaires un peu dense par endroit sur le nuage des individus de WingNut. On voit très nettement deux anneaux sur le nuage des individus de Chainlink. 2. On visualise ensuite les vraies classes sur ces plans •
•
•
On visualise bien les deux classes en forme de diamants du dataset TwoDiamonds. On distingue bien les deux classes en forme rectangulaire du dataset WingNut. On voit très nettement deux cercles sur le nuage des individus du dataset Chainlink. 3. On applique K-­‐means sur chaque base choisie L’algorithme K-­‐means cherche à diminuer l’inertie intra-­‐classe et à maximiser l’inertie inter-­‐classe. Le problème de l’algorithme K-­‐means est que des initialisations différentes peuvent mener à des clusters différents (problème des minimas locaux). Ainsi, pour obtenir des clusters stables (“formes fortes”), on effectue l’algorithme 10 fois et on regroupe les individus qui se retrouvent toujours dans le même cluster. K-MEANS TwoDiamonds
K-means clustering with 2 clusters of
sizes 400, 400
K-MEANS WingNut
K-means clustering with 2 clusters of
sizes 509, 507
K-MEANS Chainlink
K-means clustering with 2 clusters of
sizes 501, 499
Cluster means:
V2
V3
1 1.004370 0.004422253
2 3.084087 -0.002055800
Cluster means:
V2
V3
1 0.9176798 1.053922
2 -0.9212998 1.947837
Cluster means:
V2
V3
V4
1 -0.016656 -0.294123 0.008488
2 0.000888 1.156772 -0.024356
Clustering vector:
1 2 3 4 5
1 1 1 1 1
6
1
7
1
8
1
9
1
Clustering vector:
1 2 3 4 5
1 1 1 1 1
6
1
7
1
8
1
9
2
Clustering vector:
1 2 3 4 5
1 1 2 2 1
6
2
7
2
8
1
9 10
1 1
[...]
[...]
[...]
793 794 795 796 797 798 799 800
2 2 2 2 2 2 2 2
1011 1012 1013 1014 1015 1016
2
2
2
2
2
2
994 995 996 997 998 999 1000
1
2
1
2
2
2
2
Within cluster sum of squares by
cluster:
[1] 144.9399 144.3263
(between_SS / total_SS = 74.9 %)
Within cluster sum of squares by
cluster:
[1] 484.6214 481.9787
(between_SS / total_SS = 52.4 %)
Within cluster sum of squares by
cluster:
[1] 334.9777 384.3083
(between_SS / total_SS = 42.3 %))
L’algorithme k-­‐means a partitionné le jeu de données en : TwoDiamonds, -­‐ 2 classes contenant chacune 400 individus pour le jeu de données -­‐ 2 classes contenant 509 et 507 individus pour le jeu de données Wingnut, -­‐ 2 classes contenant 501 et 499 individus pour le jeu de données Chainlink. “Cluster means” indique les positions des centres de chaque classe. Puis “Clustering vector” est un vecteur qui contient la classe prédite avec l’algortihme K-­‐means de chaque individu. Le R2 exprime la part de variance expliquée (rapport de la variance inter-­‐classes entre les centres pondérés des classes à la variance totale) par la partition et permet ainsi d’apprécier la qualité de la partition générée par l’algorithme K-­‐means. Il est égale à : -­‐
-­‐
-­‐
74,9% pour le jeu de données TwoDiamonds, ce qui est satisfaisant, 52,4% pour le jeu de données WingNut, ce résultat n’est pas très satisfaisant, 42,3% pour le jeu de données Chainlink, ce résultat n’est pas du satisfaisant. 4. On visualise les classes de l’algorithme K-­‐means sur un plan On voit ci-­‐dessus que pour le dataset TwoDiamonds les classes sont bien faites mais pour le dataset WingNut, beaucoup d’individus sont mal classés. En ce qui concerne le dataset Chainlink, on peut dire que l’algorithme k-­‐means n’est pas du tout adapté. 5. Comparaison de la partition obtenue avec K-­‐means et de la vraie partition Nous construisons des matrices de confusion pour mesurer la qualité de l’algorithme k-­‐means sur nos trois datasets. MATRICE DE CONFUSION
TwoDiamonds
1 2
1 400 0
2 0 400
MATRICE DE CONFUSION
WingNut
1 2
1 490 18
2 19 489
MATRICE DE CONFUSION
Chainlink
1 2
1 327 173
2 174 326
Le résultat est très satisfaisant pour la matrice de confusion du dataset Two Diamonds, tous les individus sont bien classés. Pour le dataset WingNut, le résultat est moyennement satisfaisant. En effet, la majorité des individus sont bien classés mais 37 individus sont mal classés ce qui n’est pas négligeable. En effet, sur les 509 individus de la classe 1, 19 seront estimés comme étant de la classe 2 et sur les 507 individus de la classe 2, 18 seront estimés comme étant de la classe 1. Enfin, pour le dataset Chainlink, sur les 501 individus de la classe 1, 174 seront estimés comme étant de la classe 2 et sur les 499 individus de la classe 2, 173 seront estimés comme étant de la classe 1. Le résultat n’est pas satisfaisant du tout. En effet, un tiers des individus sont mal classés. Cela est cohérent par rapport aux graphes où l’on peut visualiser les classes déterminées par l’algorithme k-­‐means. 6. On applique une classification ascendante hiérarchique avec le lien minimum, le lien maximum, le lien moyen et le critère de Ward Les arbres hiérarchiques mettent en évidence les ressemblances entre les individus. On commence par construire les matrices de dissimilarités. 7 & 8. On visualise les arbres hiérarchiques obtenus et on propose une partition pour chacun Ci-­‐dessous les arbres hiérarchiques du dataset TwoDiamonds : On peut voir qu’avec la CAH effectuée avec le lien minimum presque tous les individus sont dans la même classe ce qui n’est pas satisfaisant du tout. Les CAH effectuées avec le lien maximum, le lien moyen et le critère de Ward ont l’air de donner des résultats très satisfaisant. On peut même ajouter qu’en utilisant le critère de Ward, la classification s’effectue plus “vite”. On s’intéresse ensuite à Wingnut : Pour le jeu de données WingNut, on voit que les CAH effectuées avec le lien minimum, le lien moyen et le critère de Ward ont l’air de donner des résultats satisfaisants car les individus ont l’air bien répartis dans les deux classes (le meilleur étant le critère de Ward). Ce qui n’est pas le cas avec le lien maximum, ce qui nous fait penser que la CAH effectuée avec le lien maximum n’est pas très satisfaisante. Enfin, on s’intéresse au jeu de données Chainlink : Pour le jeu de données Chainlink, on voit que la CAH effectuée à partir du lien minimum a l’air d’être très satisfaisante car les individus sont répartis équitablement dans chaque classe et la classification s’effectue “vite”. En revanche, les trois autres CAH (lien maximum, lien moyen et critère de Ward) n’ont pas l’air très satisfaisantes car une des classes contient plus d’individus que l’autre. 9. On compare la partition obtenue et la vraie partition Pour cela, on commence par regarder les nuages des individus en fonction des classes obtenues. Pour le jeu de données TwoDiamonds, on voit ci-­‐dessous que la CAH effectuée avec le lien minimum n’est vraiment pas du tout satisfaisante. En revanche, les CAH effectuées avec les trois autres critères sont très satisfaisante. On peut juste noter qu’il y a trois points mal classés avec le lien maximum et un point mal classé avec le lien moyen. La partition obtenue avec le critère de Ward est “parfaite”. On construit les matrices de confusion et on obtient les matrices suivantes : MATRICES DE CONFUSION
Two Diamonds
Lien minimum
Lien maximum
Lien moyen
Critere de Ward
1 2
1 2
1 2
1 2
1 400 0
1 400 0
1 399 1
1 400 0
2 399 1
2 3 397
2 0 400
2 0 400
Pour le jeu de données WingNut, on voit sur les nuages de points ci-­‐dessous que les partitions trouvées avec le lien minimum, le lien moyen et le critère de Ward sont “parfaites”. En revanche, la CAH effectuée avec le lien maximum est peu satisfaisante avec 160 individus mal classés sur 1016 comme on peut le voir sur la matrice de confusion ci-­‐dessous. MATRICES DE CONFUSION
WingNut
Lien minimum
Lien maximum
Lien moyen
Critere de Ward
1 2
1 2
1 2
1 2
1 508 0
1 508
0
1 508 0
1 508 0
2 0 508
2 160 348
2 0 508
2 0 508
Pour Chainlink, on voit ci-­‐dessous que la partition trouvée avec le lien minimum est “parfaite”. En revanche, les partitions trouvées avec le lien maximum, le lien moyen et le critère de Ward ne sont pas satisfaisante du tout. En effet, on relève 220 individus mal classés avec le lien maximum, 239 individus mal classés avec le lien moyen et 186 individus mal classés avec le critère de Ward. On construit les matrices de confusion et on obtient les matrices suivantes : MATRICES DE CONFUSION
Chainlink
Lien minimum
1 2
1 500 0
2 0 500
Lien maximum
1 2
1 280 220
2 0 500
Lien moyen
1 2
1 500 0
2 239 261
Critere
1
1 314
2 0
de Ward
2
186
500
10. Comparaison entre k-­‐means et CAH En ce qui concerne la CAH, l’agrégation selon le lien minimum induit des “effets de chaîne”, c’est-­‐à-­‐dire que les objets s’agrègent un par un au groupe déjà constitué. Avec les problèmes de chainage, on se retrouve souvent avec un groupe démesurément gros et des groupes satellites. L’agrégation selon le lien maximum a l’inconvénient de déformer beaucoup et contrairement au lien minimum il tend à former des groupes de taille égale. Avec la méthode K-­‐means, un individu peut être affecté à une classe au cours d’une itération puis changer de classe à l’itération suivante, ce qui n’est pas possible avec la classification ascendante hiérarchique pour laquelle une affectation est irréversible. En multipliant les points de départ et les répétitions on peut explorer plusieurs solutions possibles. L’inconvénient de cette méthode est qu’elle ne permet pas de découvrir quel peut être un nombre cohérent de classes, ni de visualiser la proximité entre les classes ou les individus. Les méthodes k-­‐means et CAH sont donc complémentaires. Partie II : Interprétation des classes Jeu de données Wine Présentation du jeu de données Wine Les données du jeu de données Wine sont les résultats des analyses chimiques de vins provenant de 3 prodcteurs différents (de la même région en Italie). Les analyses déterminent les quantités de 13 constituants trouvés dans chaque vins (Alcool, Acide malique, Cendres, Alcalinité des cendres, Magnésium, Phénols totaux, Flavanoïdes, Non Flavanoïdes, Proanthocyanins, Intensité de couleur, Nuances, OD280/OD315 des vins dilués, Proline). La base de données Wine est constituée de 178 vins italiens et de 14 variables dont 13 variables explicatives. La 14ème variable est qualitative et indique la provenance de chaque vin. Les 13 autres sont quantitatives. Remarque : Aucun traitement sur les données manquantes n’a été effectué car il n’y en a pas. On s’intéresse à la reconnaissance des 3 producteurs de vins italiens. On peut ainsi se poser la question suivante : Est-­‐ce que l’on peut trouver quel est le producteur de vin en sachant les quantités des 13 constituants de celui-­‐ci ? On cherche à classer les 178 vins en 3 classes. Etude de la distribution des données Wine On commence par visualiser les boîtes à moustaches des variables quantitatives en fonction de la variable qualitative. On voit sur ces boîtes à moustache ci-­‐dessus que les 13 variables varient en fonction du producteur. Par exemple, les vins du producteur 2 contiennent en moyenne moins d’alcool que les autres et les vins du producteur 1 en contiennent en moyenne plus. Si on prend pour autre exemple le constituant flavanoïdes, on remarque que les vins du producteur 1 contiennent en moyenne plus de flavanoïdes que les autres tandis que les vins du producteur 3 en contiennent moins en moyenne. Ensuite, on s’intéresse à la répartition des vins parmi les producteurs et on visualise celle-­‐ci sur le graphique en secteurs ci-­‐dessous. Ensuite, on s’intéresse aux corrélations entre les variables. On commence par construire la matrice de corrélation ci-­‐dessous. On note une forte corrélation entre les variables Flavanoids et Total Phenols. On remarque également que les variables Proanthocyanins et OD280/OD315 sont corrélées aux variables Total phenols et Flavanoids. Enfin, la variable Proline est corrélée à la variable Alcohol. MATRICE DE CORRELATION
Alco.
Alco.
1.00
Malic a.
Ash
Alcalin.
Magnes.
Total Ph.
Flav.
Nonflav.
Proanth.
Color
Hue
OD
Pro.
Malic a. Ash
0.09
0.21
1.00
0.16
1.00
Alcalin.
-0.31
0.29
0.44
1.00
Magnes. Total Ph. Flav.
0.27
0.29
0.24
-0.05 -0.34 -0.41
0.29
0.13
0.12
-0.08 -0.32 -0.35
1.00
0.21
0.20
1.00
0.86
1.00
Nonflav.
-0.16
0.29
0.19
0.36
-0.26
-0.45
-0.54
1.00
Proanth.
0.14 -0.22
0.01
-0.20
0.24
0.61
0.65
-0.37
1.00
Color
0.55
0.25
0.26
0.02
0.20
-0.06
-0.17
0.14
-0.03
1.00
Hue
-0.07
-0.56
-0.07
-0.27
0.06
0.43
0.54
-0.26
0.30
-0.52
1.00
OD
0.07
-0.37
0.00
-0.28
0.07
0.70
0.79
-0.50
0.52
-0.43
0.57
1.00
Pro.
0.64
-0.19
0.22
-0.44
0.39
0.50
0.49
-0.31
0.33
0.32
0.24
0.31
1.00
Après avoir construit la matrice de corrélation, on visualise tous les nuages de points possible entre les variables quantitatives. On distingue assez nettement plusieurs formations de 3 groupes. ACP sur Wine On va chercher à mettre en évidence des similarités ou des oppositions entre variables et à repérer les variables les plus corrélées entre elles. Grâce à l’ACP, on va tenter d’extraire les informations suivantes : -­‐ l’existence et la localisation d’observation(s) aberrantes ou “exceptionnelle(s)” très éloignées de l’ensemble des autres observations, -­‐ l’existence de regroupements bien marqués suggérant l’existence de plusieurs sous-­‐
populations. Choix des variables et des individus actifs Nous avons mis en variable qualitative supplémentaire la variable “classe”. Celle-­‐ci nous aidera à interpréter les axes. Les 13 variables quantitatives participent à la construction des axes factoriels et tous les individus sont actifs. Choix de standardisation des variables Les variables actives ont des unités différentes et n’ont pas le même ordre de grandeur. C’est pourquoi on choisit de normaliser les variables. Choix du nombre d’axes Pour déterminer le nombre de dimensions à étudier on regarde l’inertie des axes factoriels. Pour cela, on affiche les valeurs propres associées aux axes car elles représentent le pourcentage d’inertie : VALEURS PROPRES
comp
comp
comp
comp
comp
comp
comp
comp
comp
comp
comp
comp
comp
eigenvalue percentage of variance cumulative percentage of variance
1
4.71
36.20
36.20
2
2.50
19.21
55.41
3
1.45
11.12
66.53
4
0.92
7.07
73.60
5
0.85
6.56
80.16
6
0.64
4.94
85.10
7
0.55
4.24
89.34
8
0.35
2.68
92.02
9
0.29
2.22
94.24
10
0.25
1.93
96.17
11
0.23
1.74
97.91
12
0.17
1.30
99.20
13
0.10
0.80
100.00
On cherche à obtenir le maximum d’inertie conservée avec le minimum de facteurs. On utilise la technique du coude pour déterminer le nombre d’axes. Autrement dit, on coupe l’éboulis des valeurs propres à l’endroit où celui-­‐ci possède un coude. On voit une “cassure” au niveau de la 4ème valeur propre et on choisit de ne garder que les 3 premières composantes principales. Comme on peut le lire sur le tableau des valeurs propres ci-­‐dessus, le premier axe factoriel exprime 36,20% de l’inertie totale, le deuxième axe factoriel exprime 19,21% de l’inertie total et le troisième axe factoriel exprime 11,12% de l’inertie totale. Les trois premiers axes expriment 66,53% de l’inertie totale. Et le premier plan factoriel expliquent 55,41% de l’information du jeu de données. Analyse des résultats Maintenant que l’on connaît les composantes principales, on visualise les différentes représentations du nuage des variables ainsi que celui des individus. Ci-­‐dessous, on commence par visualiser le premier plan factoriel (axe 1 et 2), un deuxième plan factoriel (axe 1 et 3) et un troisième plan factoriel (axe 2 et 3). Le premier axe factoriel est expliqué par les variables Hue, OD280/OD315, Proanthocyanins, Non flavanoids Phenols, Flavanoids et Total phenol et le deuxième axe factoriel semble être expliqué par les variables Alcohol, Magnesium, Color intensity et Proline. Le troisième axe, lui, semble être expliqué par les variables Alcalinity of ash et Ash. Sur le graphique des individus on a coloré les vins italiens en fonction de leur producteur et on voit que des groupes de vins provenant du même producteur se sont formés (producteur 1 en noir, producteur 2 en rouge et producteur 3 en vert). En effectuant une analyse conjointe du nuage des variables et du nuage des individus, on remarque que plus les vins sont situés à droite du premier plan factoriel et plus les constituants suivants sont élevés : Hue, OD280/OD315, Proanthocyanins, Flavanoids DESCRIPTION AUTO DE l’AXE 1
et Total phenol. Et plus les vins sont situés à gauche du $Dim.1$quanti
premier plan factoriel et plus la concentration de Non correlation
p.value
flavanoids Phenols est élevée. Aussi, plus les vins sont Flavanoids
0.9174702 2.277174e-72
situés en haut du premier plan factoriel et plus les Total.Phenols
0.8561367 2.412279e-52
OD280/OD315... 0.8160189 9.295759e-44
constituants suivants sont élevées : Alcohol, Magnesium, Proanthocyanins 0.6799217 1.703326e-25
Color intensity et Proline. Sur le deuxième plan factoriel Hue
0.6436621 3.325743e-22
(axe 1 et 3), plus les vins sont situés en haut du plan et Proline
0.6220508 1.908845e-20
plus les constituants Alcalinity of ash et Ash sont élevés. Alcohol
0.3130934 2.088257e-05
Magnesium
0.3080229 2.880155e-05
Color.intensity
-0.1922360 1.014930e-02
On effectue une description automatique des axes qui Alcalinity.of.ash -0.5191571 1.132941e-13
nous confirme que l’axe 1 est très lié aux variables Malic.acid
-0.5318847 2.176263e-14
Flavanoids, Total phenols, OD280/OD315 of diluted Nonflavanoid.ph. -0.6476070 1.532702e-22
wines, Proanthocyanins, Hue , Non flavanoids phenols classe
-0.8933369 4.877895e-63
DESCRIPTION AUTO DES AXES 2 et 3
$Dim.2
$Dim.2$quanti
Color.intensity
Alcohol
Proline
Ash
Magnesium
Malic.acid
OD280/OD315...
Hue
correlation
p.value
0.8374894 4.612471e-48
0.7642573 2.320753e-35
0.5766127 3.678262e-17
0.4994461 1.278235e-12
0.4734761 2.478447e-11
0.3554317 1.124118e-06
-0.2599338 4.584234e-04
-0.4412422 7.060723e-10
$Dim.3
$Dim.3$quanti
Ash
Alcalinity.of.ash
Nonflavanoid.ph.
OD280/OD315...
Flavanoids
Proanthocyanins
Total.Phenols
Magnesium
Proline
Color.intensity
Alcohol
correlation
p.value
0.7530514 8.002256e-34
0.7360433 1.218493e-31
0.2048724 6.083605e-03
0.1996251 7.551073e-03
0.1811991 1.549759e-02
0.1797229 1.637321e-02
0.1757842 1.892340e-02
0.1572388 3.607295e-02
-0.1524154 4.225185e-02
-0.1651145 2.762847e-02
-0.2493833 7.880865e-04
CONTRIBUTIONS
Dim.1
Alcohol
2.08
Malic acid
6.01
Ash
0.00
Alcalinity of ash 5.73
Magnesium
2.02
Total Phenols
15.58
Flavanoids
17.89
Nonflavanoid ph. 8.91
Proanthocyanins 9.82
Color intensity 0.79
Hue
8.80
OD280/OD315... 14.15
Proline
8.22
Dim.2
23.39
5.06
9.99
0.01
8.98
0.42
0.00
0.08
0.15
28.09
7.80
2.71
13.32
Dim.3
4.30
0.79
39.22
37.46
1.71
2.14
2.27
2.90
2.23
1.89
0.73
2.76
1.61
mais aussi Proline. Il est également fortement liée à la variable classe. L’axe 2 est fortement lié aux variables Color intensity et Alcohol. Et l’axe 3 est lié aux variables Ash et Alcalinity of ash. Ensuite, on s’intéresse à la contribution des variables. Les variables dont la contribution est supérieure ou égale à son poids (7,69% (=1/13)) contribuent fortement à la création de l’axe. On retrouve les mêmes résultats que précédemment : les variables Total phenols, Flavanoids, Non flavanoids phenols, Proanthocyanins, Hue et OD280/OD315 contribuent à l’axe 1. Ensuite, on voit que les variables Alcohol, Magnesium, Color intensity et Proline contribuent à l’axe 2. Et enfin, les variables Ash et Alcalinity of ash contribuent à l’axe 3. On note que la variable Malic acid est la seule à ne contribuer ni à l’axe 1, ni à l’axe 2, ni à l’axe 3. Pour finir, on regarde la qualité de représentation des variables sur le tableau des cosinus carré des variables. On s’intéresse aux cos2 supérieur ou égale à 0,5. On peut dire que les variables Total phenols, Flavanoids et OD280/OD315 sont bien représentées sur l’axe 1. Les variables Alcohol et Color intensity sont bien COSINUS CARRE
Dim.1
Alcohol
0.10
Malic acid
0.28
Ash
0.00
Alcalinity of ash 0.27
Magnesium
0.09
Total Phenols
0.73
Flavanoids
0.84
Nonflavanoid ph. 0.42
Proanthocyanins 0.46
Color intensity 0.04
Hue
0.41
OD280/OD315... 0.67
Proline
0.39
Dim.2
0.58
0.13
0.25
0.00
0.22
0.01
0.00
0.00
0.00
0.70
0.19
0.07
0.33
Dim.3
0.06
0.01
0.57
0.54
0.02
0.03
0.03
0.04
0.03
0.03
0.01
0.04
0.02
représentées sur l’axe 2. Les variables Alcalinity of ash et Ash sont bien représentées sur l’axe 3. En revanche, la variable Malic acid n’est bien représentée sur aucun des 3 axes et ne peut donc pas être “repêchée”. En conclusion, on peut dire que : -­‐ les vins du producteur 1 se caractérisent par une concentration plus élevée en flavanoïdes, en phénols totaux, ainsi qu’en OD280/OD315 des vins dilués. Ils sont également plus alcolisées et ont une intensité de couleur plus élevée. En ce qui concerne les cendres et l’alcalinité de celles-­‐
ci pour les vins du producteur 1, elles sont légèrement moins concentrée, -­‐ les vins du producteur 2 se situent entre les vins des producteur 1 et 3 en termes de concentration en flavanoïdes, en phénols totaux et en OD280/OD315 des vins dilués. Ceux sont les moins alcolisés et ont une intensité de couleur la plus faible. Ils sont très légèrement plus concentrés en cendres et en alcalinité de celles-­‐ci. -­‐ les vins du producteur 3 sont les moins concentrés en flavanoïdes, en phénols totaux et en OD280/OD315 des vins dilués. Ils se caractérisent également par une intensité de couleur plus forte et une alcolisation plus élevée. Enfin, ils contiennent légèrement moins de cendres et sont légèrement moins concentrés en alcalinité des cendres. HCPC sur Wine Une classification hiérarchique sur composantes principales (HCPC) permet de réaliser un classification non supervisée des individus. Elle permet de mettre l’accent sur les similarités entre individus. Lorsque l’on effectue une HCPC, celle-­‐ci classe les vins italiens en 3 classes. Les 3 classes trouvées avec l’HCPC ressemblent beaucoup aux vraies classes. Algorithme K-­‐means sur Wine Après avoir appliqué l’algorithme K-­‐means, on visualise ensuite les classes obtenues avec l’algorithme K-­‐means sur le premier plan factoriel. Visuellement, le résultat n’est pas très satisfaisant mais il faut faire attention car deux individus proches sur le premier plan factoriel ne sont pas forcément proches en réalité si ceux-­‐ci sont mal représentés. Quand on regarde la qualité de la partition en lisant le R2, on note que la part de la variance expliquée par la partition est de 86,5 ce qui semble très satisfaisant. Puis quand on regarde la matrice de confusion, on relève 53 individus mal classés sur 178. Cela représente 30% de mal classés. K-MEANS WINE
K-means clustering with 3 clusters of sizes 62, 69, 47
Within cluster sum of squares by cluster:
[1] 566572.5 443166.7 1360950.5
(between_SS / total_SS = 86.5 %)
MATRICE DE CONFUSION
1 2 3
1 13 0 46
2 20 50 1
3 29 19 0
Jeu de données E.coli Présentation du jeu de données E.coli La base de données E.coli est constituée de 336 séquences protéiques d’e.coli et de 9 variables dont 7 variables explicatives. La 1ère variable contient les noms des séquences dans la banque de données biologique Swiss-­‐Prot. La 2ème (quantitative) est le résultat de la méthode McGeoch pour la reconnaissance d’un signal dans une séquence. La 3ème (quantitative) est le résultat de la méthode von Heijne’s pour la reconnaissance d’un signal dans une séquence. La 4ème (binaire) est le score du signal de la séquence de la protéine peptidase II selon la méthode von Heijne’s. La 5ème (binaire) indique la présence de charge sur la N-­‐terminaison des lipoprotéines prédites. La 6ème (quantitative) est le score de l’analyse discriminante des compositions en acide aminé des protéines de membrane plasmique et périplasmique. La 7ème (quantitative) est de score d’ALOM (programme de prédiction des régions membranaires). Et la 8ème (quantitative) est le score d’ALOM après avoir exclu de leur séquence les régions pouvant être séparées. Nous disposons également d’une variable (qualitative) indiquant le site de localisation cellulaire (cytoplasme, membrane interne sans séquence signal, périplasme, membrane interne dont la séquence signal ne peut être séparé, membrane externe, membrane lipoprotéine externe, membrane lipoprotéine interne, membrane interne dont la séquence signal peut être séparée). Remarque : Aucun traitement sur les données manquantes n’a été effectué car il n’y en a pas. On s’intéresse à la prédiction des localisations cellulaires des sites de protéines. On peut ainsi se poser la question suivante : Y-­‐a-­‐t-­‐il des séquences protéiques qui ont des caractéristiques de localisation cellulaire similaires ? Etude de la distribution des données E.coli Note : Les résultats obtenus pour les séquences protéiques de la Nombre d’individus par classe
membrane lipoprotéine interne (imL) et de la membrane interne cp im imL imS imU om omL pp
dont la séquence peut-­‐être séparée (imS) ne seront pas interprétés 143 77 2 2 35 20 5 52
car elles ne sont pas assez nombreuses. Il en est de même pour celles de la membrane lipoprotéine externe (omL). On commence par visualiser les boîtes à moustaches des variables quantitatives en fonction de la variable qualitative. On voit sur ces boîtes à moustache ci-­‐dessus que les 5 variables varient en fonction du site de localisation. Par exemple, les séquences protéiques situées au niveau de la membrane externe et du périplasme ont des résultats plus élevés que les autres pour la méthode von Heijne’s. Ensuite, on s’intéresse aux variables binaires. On choisit de faire des graphiques en secteurs (camemberts) pour les visualiser. On voit ci-­‐dessous que seulement 2,97% des séquences protéiques ont un résultat de reconnaissance du signal égale à 1 tandis que 97,02% ont un résultat égale à 0,48. Sur le deuxième graphique circulaire, on voit que seulement 0,30% des séquences protéiques ont une valeur égale à 1 pour la variable qui informe sur la présence de charge sur la N-­‐terminaison des lipoprotéines et 99,70% ont une valeur égale à 0,5. Ensuite, on s’intéresse aux corrélations entre les variables. On commence par construire la matrice de corrélation ci-­‐dessous. Les corrélations entre les variables sont assez faibles voire inexistantes. La méthode de McGeoch est légèrement corrélée à la méthode von Heijne’s et au score d’ALOM1. Aussi, les scores d’ALOM1 et d’ALOM2 sont fortement correlés. MATRICE DE CORRELATION
McGeoch von Heijne's Score de l'analyse Score d'ALOM1 Score d'ALOM2
McGeoch
1.00
0.45
0.22
0.40
0.17
von Heijne's
1.00
0.07
0.17
-0.12
Score de l'analyse
1.00
0.28
0.25
Score d'ALOM1
1.00
0.81
Score d'ALOM2
1.00
Après avoir construit la matrice de corrélation, on visualise tous les nuages de points possible entre les variables quantitatives. On distingue assez nettement plusieurs formation de groupes. ACP sur E.coli On va chercher à mettre en évidence des similarités ou des oppositions entre variables et à repérer les variables les plus corrélées entre elles. Grâce à l’ACP, on va tenter d’extraire les informations suivantes : -­‐ l’existence et la localisation d’observation(s) aberrantes ou “exceptionnelle(s)” très éloignées de l’ensemble des autres observations, -­‐ l’existence de regroupements bien marqués suggérant l’existence de plusieurs sous-­‐
populations. Choix des variables et des individus actifs Nous avons mis en variable qualitative supplémentaire la variable “Sites de localisation”. Celle-­‐ci nous aidera à interpréter les axes. Nous avons également mise en variables supplémentaires les deux variables binaires. En effet, on a vu que seulement 10 individus sur 336 prennent la valeur 1 pour la variable “score du signal” et que seulement 1 individus sur 336 prend la valeur 1 pour la variable “présence de charge”. Donc on estime que ces deux variables n’apportent pas assez d’informations et on les exclue de l’ACP. Enfin, nous ajoutons la variable quantitative “Score de l’analyse factorielle” en supplémentaire car nous nous intéressons aux scores de 4 méthodes différentes utilisées pour la prédiction de la localisation cellulaire des sites de protéines. C’est-­‐à-­‐dire que ces quatre variables supplémentaires ne participeront pas à la construction des axes factoriels mais nous pourrons tout de même les visualiser. Tous les individus du jeu de données sont actifs mais nous rappelons que les résultats sur les individus de classe imL, imS et omL sont à interpréter avec précaution en raison de leur faible nombre. Choix de standardisation des variables Toutes les variables actives étant exprimées par des nombres compris entre 0 et 1, on choisit de ne pas normaliser les variables car elles ont le même ordre de grandeur même si nous ne connaissons pas leur unité respective. Choix du nombre d’axes Pour déterminer le nombre de dimensions à étudier on regarde l’inertie des axes factoriels. Pour cela, on affiche les valeurs propres associées aux axes qui représentent le pourcentage d’inertie : VALEURS PROPRES
eigenvalue percentage of variance cumulative percentage of variance
comp 1
0.09
58.59
58.59
comp 2
0.04
28.08
86.67
comp 3
0.01
9.45
96.11
comp 4
0.01
3.89
100.00
Comme on peut le voir sur le graphique du coude, on voit une “cassure” au niveau de la 3ème valeur propre. En utilisant la méthode du coude, on choisit de ne garder que les 2 premières composantes. Le premier axe factoriel exprime à lui seul 58,59% de l’inertie totale et le deuxième axe factoriel exprime 28,08% de l’inertie total. Les deux premiers axes expriment 86,67% de l’inertie totale. C’est-­‐à-­‐
dire que le premier plan factoriel expliquent 86,67% de l’information du jeu de données. Analyse des résultats Ensuite, on visualise le graphique des variables et le graphique des individus (voir ci-­‐dessous). Le premier axe factoriel est expliqué par les variables alm1 et alm2 (score d’ALOM avec et sans les régions pouvant être séparée) et le deuxième axe factoriel semble être expliqué par les variables mcg et gvh (méthode de McGeoch et de von Heijne’s). Sur le graphique des individus on a coloré les séquences en fonction de leur site de localisation cellulaire et on voit que des groupes de séquences ayant le même site de localisation se sont formés. En effectuant une analyse conjointe du nuage des variables et du nuage des individus, on remarque que plus les séquences protéiques des e.coli sont situés à droite du graphique et plus leurs scores d’ALOM sont élevés. Et plus les séquences protéiques sont situés en haut du graphique et plus leurs résultats obtenus avec les méthodes McGeoch et von Heijne’s sont élevés. On effectue une description automatique des axes DESCRIPTION AUTOMATIQUE DES AXES
$Dim.1
(ci-­‐dessous) qui nous confirme que l’axe 1 est très correlation
p.value
lié aux variables alm1 et alm2 et que l’axe 2 est Score.d'ALOM1
0.9602678 3.394311e-187
très lié aux variables mcg et gvh. Score.d'ALOM2
0.8825533 1.737293e-111
McGeoch
0.5191895 1.379823e-24
Mais il y a des variables avec des corrélations Score.de.l'analyse
0.3055160 1.086850e-08
moyennes sur ces deux premiers axes factoriels von.Heijne's
0.1823509 7.842601e-04
(autour de 0.5 en valeur absolue), rendant $Dim.2$quanti
l’interprétation des axes un peu compliquée. C’est correlation
p.value
pourquoi on va utiliser une méthode de rotation McGeoch
0.7769448 4.255158e-69
des axes appelée VARIMAX qui va rendre les von.Heijne's
0.7418690 6.241210e-60
valeurs de ces corrélations plus “tranchées” en Score.du.signal
0.1369569 1.197237e-02
faisant pivoter les axes. Score.d'ALOM2
-0.4013374 1.957904e-14
Comme on peut le constater, la lecture est plus VARIMAX
Loadings:
facile et on voit clairement que les scores Dim.1 Dim.2
d’ALOM1 et d’ALOM2 sont fortement corrélés à McGeoch
0.240 0.903
l’axe 1 et que les méthodes McGeoch et von von Heijne's
0.761
Heijne’s sont fortement corrélées à l’axe 2. Score d'ALOM1
0.928 0.253
Score d'ALOM2
0.965
Ensuite, on s’intéresse à la contribution des variables. Les variables dont la contribution est CONTRIBUTIONS
supérieure ou égale à son poids (14,28%) contribuent fortement à Dim.1 Dim.2
la création de l’axe. On retrouve les mêmes résultats que McGeoch
11.60 54.21
précédemment : les variables alm1 et alm2 contribuent au premier von Heijne's
0.83
28.64
axe factoriel et les variables mcg et gvh contribuent au deuxième Score d'ALOM1 48.76 0.41
Score d'ALOM2 38.81 16.74
axe factoriel. COSINUS CARRE
Enfin, on regarde la qualité de représentation des variables sur le Dim.1 Dim.2
tableau des cosinus carré des variables. On s’intéresse aux cos2 McGeoch
0.27
0.60
supérieur ou égale à 0,5. On peut dire que les scores d’ALOM1 et von Heijne's
0.03
0.55
d’ALOM2 sont bien représentés sur l’axe 1 et les méthodes Score d'ALOM1 0.92
0.00
Score d'ALOM2 0.78
0.16
McGeoch et von Heijne’s sont bien représentées sur l’axe 2. En conclusion, on peut dire que : -­‐ Les séquences protéiques localisées au niveau des membranes internes (im et imU) ont des scores d’ALOM plus élevés. -­‐ Les séquences localisées au niveau des membranes internes qui n’ont pas de séquence signal (im) ont des résultats moins élevés pour les méthodes de reconnaissance de signal dans une séquence. -­‐ Les séquences localisé au niveau du périplasme (pp), de la membrane externe (om) et de la membrane lipoprotéine externe (omL) ont des caractérisques similaires : ces séquences ont des résultats plus élevés pour les méthodes McGeoch et von Heijne’s. -­‐ Les séquences localisées au niveau du cytoplasme (cp) ont des scores d’ALOM les plus faibles et des résultats également plus faible pour les méthodes de reconnaisance de signal dans une séquence. -­‐ On ne conclue rien pour les séquences dont le site de localisation est imS ou imL car elles sont mal représentés. HCPC sur E.coli Une classification hiérarchique sur composantes principales (HCPC) permet de réaliser un classification non supervisée des individus. Elle permet de mettre l’accent sur les similarités entre individus. Lorsque l’on effectue une HCPC, celle-­‐ci classe les séquences protéiques en 3 classes : Les séquences situées au niveau des membranes internes, les séquences situées au niveau du cytoplasme et celles situées au niveau des membranes externes et du périplasme. Ainsi, elle met en évidence que les séquences localisées au niveau des membrances internes ont des caractéristiques similaires et que celles localisées au niveau des membranes externes ont des caractéristiques similaires à celles situées dans le périplasme. Algorithme K-­‐means sur E.coli On applique l’algorithme K-­‐means sur le jeu de données E.coli et on obtient les résultats ci-­‐dessous. Puis on visualise ensuite les classes obtenues avec l’algorithme K-­‐means sur le premier plan factoriel. Quand on regarde la qualité de la partition en lisant le R2, on note que la part de la variance expliquée par la partition est de 75,3 ce qui semble satisfaisant. On remarque que les tailles des 8 classes ne correspondent pas à celles des vraies classes ce qui est plutôt normal étant donné que certaines classes ont de faible effectif, cela ne facilite pas l’algorithme. KMEANS
K-means clustering with 8 clusters of sizes
10, 61, 7, 45, 52, 41, 51, 6
1
2
3
4
5
6
7
8
V2
0.66
0.71
0.27
0.36
0.47
0.39
0.25
0.68
V3
0.54
0.48
0.52
0.37
0.44
0.48
0.41
0.71
V4
1.00
0.48
0.48
0.48
0.48
0.48
0.48
0.48
V5
0.55
0.50
0.50
0.50
0.50
0.50
0.50
0.50
V6
0.55
0.57
0.34
0.48
0.43
0.56
0.45
0.52
V7
0.62
0.76
0.75
0.21
0.38
0.77
0.35
0.46
V8
0.43
0.77
0.30
0.30
0.44
0.79
0.44
0.34
Within cluster sum of squares by cluster:
[1] 1.3297600 2.2445213 0.6011714
1.4171022 1.7243250 1.7263415
1.3341647 4.0244522
(between_SS / total_SS = 75.3 %)
MATRICE DE CONFUSION
Partie III : Classification dans la bioinformatique 1. Apport de la classification dans le domaine des données biopuces Une biopuce (ou puce à ADN) est un ensemble de molécules d'ADN fixées en rangées ordonnées sur une petite surface permettant d'analyser le niveau d'expression des gènes. Le nombre de gènes étant tres élevé, l'analyse de leur expression n'est pas aisée et l'utilisation de méthodes de classification informatisée est alors indispensable. En effet, l'objectif des biopuces est de définir l'expression des gènes et donc de savoir quelle expression des gènes d'une biopuce va influer sur une éventuelle tumeur par exemple. Dans une des approches les algorithmes se focalisent sur la localisation des gènes responsable du développement d’une tumeur pour ensuite mieux classer les biopuces. Les biopuces, par leur complexité, n'aurait en fait pas existé sans méthodes de classification. En effet, les biopuces n’aurait pas pu servir sans qu’il y ait des outils disponibles pour les étudier. On peut maintenant grâce aux biopuces et aux méthodes de classification par exemple faire l'étude des gènes exprimés sur un grand nombre de patient pour observer l'effet d'un médicament, ou bien établir des signature génétique liées aux tumeurs, ce qui aurait été impossible sans la classification. 2. Application de K-­‐means et de la CAH Nous avons choisi le jeu de données Colon. Celui-­‐ci est K-MEANS
composé de 62 muscles (chaque muscle provenant d’une K-means clustering with 2 clusters of sizes
personne différente) caractérisés par 2000 gènes. Les gènes 17, 45
sont de deux types : porteur de tumeur ou normal. Within cluster sum of squares by cluster:
[1] 7550112916 9112416366
La procédure K-­‐means créée des classes de taille 17 et 45. (between_SS / total_SS = 27.0 %)
Les vraies classes ont des tailles de classes 22 et 40. On relève un R2 de 27% ce qui n’est pas satisfaisant du tout. Graphiquement, on voit que ça ne correspond pas tout à fait à ce qu’on voit sur le nuage de points avec les vraies classes. Il est difficile de bien commenter ces différents nuages de points. En effet, on peut supposer que cette représentation en 2D ne représente pas bien les 2000 variables. Dans tous les cas, on observe que les CAH et le K-­‐means n'obtiennent pas de résultats concluant car ils n'arrivent pas retrouver les vraies classes. On peut voir ci-­‐dessus les quatre dendrogrammes représentant le résultat de la CAH appliquée au jeu de données The Colon avec les liens minimum, moyen, maximum, et le critère de ward. En analysant seulement les dendrogrammes (sans comparer les vraies classes aux classes trouvées par la CAH), on remarque que le lien minimum et lien moyen ne sont pas apprioriés pour notre CAH. En effet, les classes ne sont “trouvées” que tres tard. Le lien maximum et le critère de Ward semble quant à eux beaucoup plus appropriés pour notre jeu de données. En effet, les classes sont beaucoup mieux ordonnées et “trouvées” plus tôt. C’est le cas particulièrement pour le critère de Ward qui trouve très “vite” les classes. 3. Construction des matrices de confusion En comparant les résultats obtenus avec les vraies valeurs, on se rend compte que nos résultats ne sont pas satisfaisant, les classes ne sont pas du tout reconnues. En effet, pour la matrice de confusion de la procédure K-­‐means on voit que presque la moitié des individus sont mal classés avec la procédure K-­‐means . Ce résultat n’est pas satisfaisant. Pour celle du lien minimum, tous les individus ont été classés dans la même classe sauf un. Ce résultat est très mauvais. Les autres critères de la CAH donnent également de mauvais résultats. On peut donc penser que ces méthodes ne sont pas appropriées pour ce genre de traitement. En effet, celles-­‐ci ne semblent pas appropriées pour trouver seulement deux classes à partir de 2000 variables. MATRICES DE CONFUSION
K-means
1 2
1 14 3
2 26 19
Lien minimum
1 2
1 39 22
2 1 0
Lien moyen
1 2
1 35 22
2 5
0
Lien maximum
1 2
1 29 20
2 11 2
Critere de Ward
1 2
1 25 21
2 15 1
Annexe # Partie 1 : Evaluations K-­‐means et CAH # Importation des datasets
# On utilise la fonction read.table() pour importer les datasets
# L’argument comment.char indique l’emplacement des commentaires dans le fichier afin de les “sauter”
# L’argument row.names indique que la colonne 1 du fichier contient le nom des lignes
# On utilise la fonction cbind() effectue une concatenation
TDc=read.table("/Users/Emeline/Downloads/TwoDiamonds.cls", comment.char = "%", row.names=1)
TD=read.table("/Users/Emeline/Downloads/TwoDiamonds.lrn", comment.char = "%", row.names=1)
x=cbind(TD,TDc)
WNc=read.table("/Users/Emeline/Downloads/WingNut.cls", comment.char = "%", row.names=1)
WN=read.table("/Users/Emeline/Downloads/WingNut.lrn", comment.char = "%", row.names=1)
y=cbind(WN,WNc)
CLc=read.table("/Users/Emeline/Downloads/Chainlink.cls", comment.char = "%", row.names=1)
CL=read.table("/Users/Emeline/Downloads/Chainlink.lrn", comment.char = "%", row.names=1)
z=cbind(CL,CLc)
# On visualise le nuages des individus sur un plan
# On utilise la fonction png() pour ouvrir un fichier pour ecrire un png
# On effectue les operations graphiques
# On trace les graphes dans une seule image grace a la fonction par()
# On trace les graphes sur 1 lignes et 3 colonnes avec l’argument mfrow
# Remarque : il n’y a que 2 graphes mais on met 3 colonnes pour laisser de l’espace pour le graphe en 3D
# On ajoute un titre au graphe avec le parametre main
# on referme le fichier png avec la fonction dev.off()
png(filename = "/Users/Emeline/Desktop/g1.png", width = 1000, height = 300)
par(mfrow = c(1,3))
plot(x[,1:2], main="TwoDiamonds", cex.main=1.5)
plot(y[,1:2], main="WingNut", cex.main=1.5)
dev.off()
# on charge le package rgl pour pouvoir tracer un graphique en 3D
library(rgl)
plot3d(z[,1:3], main=”Chainlink”)
# On visualise les vraies classes sur ce plan
# Pour cela on colorie en fonction de la colonne qui correspond aux vraies classes avec le parametre col
png(filename = "/Users/Emeline/Desktop/g2.png", width = 1000, height = 300)
par(mfrow = c(1,3))
plot(x[,1:2], col=x[,3], main="TwoDiamonds", cex.main=1.5)
plot(y[,1:2], col=y[,3], main="WingNut", cex.main=1.5)
dev.off()
plot3d(z[,1:3], col=z[,4], main="Chainlink")
# On effectue un k-means sur chaque base choisie
# On utilise pour cela la fonction kmeans() en precisant le nombre de clusters
# On lance l’algorithme 10 fois avec le parametre nstart
# On precise que l’on veut 20 iterations avec le parametre iter.max, on en a pas besoin de plus car
l’algorithme converge
km=kmeans(TD, centers=2, iter.max=20, nstart=10)
km2=kmeans(WN, centers=2, iter.max=20, nstart=10)
km3=kmeans(CL, centers=2, iter.max=20, nstart=10)
# On visualise les classes de l’algorithme k-means sur un plan
png(filename = "/Users/Emeline/Desktop/g3.png", width = 1000, height = 400)
par(mfrow = c(1,3))
plot(TD,col=km$cluster, main="Partition de l'algorithme K-means – Two Diamonds")
plot(WN,col=km2$cluster, main="Partition de l'algorithme K-means – Wing Nut")
dev.off()
plot3d(CL,col=km3$cluster, main="Partition de l'algorithme K-means – Chainlink")
# On construit les matrices de confusions
# Pour cela on utilise la fonction table qui cree un tableau de contingence
kmt1=table(x[,3],km$cluster)
kmt2=table(y[,3],km2$cluster)
kmt3=table(z[,4],km3$cluster)
# On effectue une CAH
# Pour cela on commence par calcule les matrices de dissimilarites avec la fonction dist()
# La fonction dist() calcule la distance euclidienne entre chaque paire de donnees
dTD=dist(TD)
dWN=dist(WN)
dCL=dist(CL)
# On effectue une CAH avec le lien minimum
# On utilise la fonction hclust() en precisant avec le parametre method que l’on utilise le lien minimum
# La fonction hclust() s’applique sur la matrice de distance calculee ci-dessus
hsTD=hclust(dTD,method="single")
hsWN=hclust(dWN,method="single")
hsCL=hclust(dCL,method="single")
# On effectue une CAH avec le lien maximum
# On precise avec le parametre method que l’on utilise le lien maximum
hcTD=hclust(dTD,method="complete")
hcWN=hclust(dWN,method="complete")
hcCL=hclust(dCL,method="complete")
# On effectue une CAH avec le lien moyen
# On precise avec le parametre method que l’on utilise le lien moyen
haTD=hclust(dTD,method="average")
haWN=hclust(dWN,method="average")
haCL=hclust(dCL,method="average")
# On effectue une CAH avec le critere de ward
# On precise avec le parametre method que l’on utilise le critere de ward
hwTD=hclust(dTD,method="ward")
hwWN=hclust(dWN,method="ward")
hwCL=hclust(dCL,method="ward")
# On visualise l’arbre hierarchique obtenu
# On peut visualiser le dendogramme avec la fonction plot()
# TwoDiamonds
png(filename = "/Users/Emeline/Desktop/g4.png", width = 1000, height = 250)
par(mfrow = c(1,4))
plot(hsTD, hang=-1, cex.main=1.8, main="Dendrogramme - Lien minimum", xlab='TwoDiamonds')
plot(hcTD, hang=-1, cex.main=1.8, main="Dendrogramme - Lien maximum", xlab='TwoDiamonds')
plot(haTD, hang=-1, cex.main=1.8, main="Dendrogramme - Lien moyen", xlab='TwoDiamonds')
plot(hwTD, hang=-1, cex.main=1.8, main="Dendrogramme - Critere de Ward", xlab='TwoDiamonds')
dev.off()
# WingNut
png(filename = "/Users/Emeline/Desktop/g5.png", width = 1000, height = 250)
par(mfrow = c(1,4))
plot(hsWN, hang=-1, cex.main=1.8, main="Dendrogramme - Lien minimum", xlab='WingNut')
plot(hcWN, hang=-1, cex.main=1.8, main="Dendrogramme - Lien maximum", xlab='WingNut')
plot(haWN, hang=-1, cex.main=1.8, main="Dendrogramme - Lien moyen", xlab='WingNut')
plot(hwWN, hang=-1, cex.main=1.8, main="Dendrogramme - Critere de Ward", xlab='WingNut')
dev.off()
# Chainlink
png(filename = "/Users/Emeline/Desktop/g6.png", width = 1000, height = 250)
par(mfrow = c(1,4))
plot(hsCL, hang=-1, cex.main=1.8, main="Dendrogramme - Lien minimum", xlab='Chainlink')
plot(hcCL, hang=-1, cex.main=1.8, main="Dendrogramme - Lien maximum", xlab='Chainlink')
plot(haCL, hang=-1, cex.main=1.8, main="Dendrogramme - Lien moyen", xlab='Chainlink')
plot(hwCL, hang=-1, cex.main=1.8, main="Dendrogramme - Critere de Ward", xlab='Chainlink')
dev.off()
# On propose une partition a partir de chaque arbre
# On decoupe le dendogramme a l’aide de la fonction rect.hclust()
# On precise le nombre de classes avec la parametre k
# On precise la taille du texte avec la parametre cex
# Le parametre hang place les labels sur le graphique, une valeur negative affiche les labels sous le 0
# On precise que les encadres des partitions seront d’une certaine couleur avec la parametre border
# On genere une couleur de bordure en couleur RGB (Red-Green-Blue)
# On precise dans la fonction rgb() que maxColorValue=255 pour que les valeurs soient entre 0 et 255
# TwoDiamonds
png(filename = "/Users/Emeline/Desktop/g7.png", width = 1000, height = 250)
par(mfrow = c(1,4))
plot(hsTD, hang=-1, cex.main=1.8, main="Dendrogramme - Lien minimum", xlab='TwoDiamonds')
res.hsTD=rect.hclust(hsTD, k=2, border= rgb(178,51,153, maxColorValue=255))
plot(hcTD, hang=-1, cex.main=1.8, main="Dendrogramme - Lien maximum", xlab='TwoDiamonds')
res.hcTD=rect.hclust(hcTD, k=2, border= rgb(178,51,153, maxColorValue=255))
plot(haTD, hang=-1, cex.main=1.8, main="Dendrogramme - Lien moyen", xlab='TwoDiamonds')
res.haTD=rect.hclust(haTD, k=2, border= rgb(178,51,153, maxColorValue=255))
plot(hwTD, hang=-1, cex.main=1.8, main="Dendrogramme - Critere de Ward", xlab='TwoDiamonds')
res.hwTD=rect.hclust(hwTD, k=2, border= rgb(178,51,153, maxColorValue=255))
dev.off()
# WingNut
png(filename = "/Users/Emeline/Desktop/g8.png", width = 1000, height = 250)
par(mfrow = c(1,4))
plot(hsWN, hang=-1, cex.main=1.8, main="Dendrogramme - Lien minimum", xlab='WingNut')
res.hsWN=rect.hclust(hsWN, k=2, border=rgb(178,51,153, maxColorValue=255))
plot(hcWN, hang=-1, cex.main=1.8, main="Dendrogramme - Lien maximum", xlab='WingNut')
res.hcWN=rect.hclust(hcWN, k=2, border=rgb(178,51,153, maxColorValue=255))
plot(haWN, hang=-1, cex.main=1.8, main="Dendrogramme - Lien moyen", xlab='WingNut')
res.haWN=rect.hclust(haWN, k=2, border=rgb(178,51,153, maxColorValue=255))
plot(hwWN, hang=-1, cex.main=1.8, main="Dendrogramme - Critere de Ward", xlab='WingNut')
res.hwWN=rect.hclust(hwWN, k=2, border=rgb(178,51,153, maxColorValue=255))
dev.off()
# Chainlink
png(filename = "/Users/Emeline/Desktop/g9.png", width = 1000, height = 250)
par(mfrow = c(1,4))
plot(hsCL, hang=-1, cex.main=1.8, main="Dendrogramme - Lien minimum", xlab='Chainlink')
res.hsCL=rect.hclust(hsCL, k=2, border= rgb(178,51,153, maxColorValue=255))
plot(hcCL, hang=-1, cex.main=1.8, main="Dendrogramme - Lien maximum", xlab='Chainlink')
res.hcCL=rect.hclust(hcCL, k=2, border= rgb(178,51,153, maxColorValue=255))
plot(haCL, hang=-1, cex.main=1.8, main="Dendrogramme - Lien moyen", xlab='Chainlink')
res.haCL=rect.hclust(haCL, k=2, border= rgb(178,51,153, maxColorValue=255))
plot(hwCL, hang=-1, cex.main=1.8, main="Dendrogramme - Critere de Ward", xlab='Chainlink')
res.hwCL=rect.hclust(hwCL, k=2, border= rgb(178,51,153, maxColorValue=255))
dev.off()
#
#
#
#
#
On compare la partition obtenue avec la vraie partition
Avec la fonction cutree(), on “decoupe” l’arbre hierarchique en precisant le nombre de classes
La fonction cutree() cree un vecteur contenant la classe estimee de chaque individu
A partir de ce vecteur on visualise les classes predites sur le nuage des individus avec la fonction plot()
On precise que l’on veut colorer les individus en fonction des classes predites avec le parametre col
# TwoDiamonds
png(filename = "/Users/Emeline/Desktop/g10.png", width = 1000, height = 250)
par(mfrow = c(1,4))
sTD=cutree(hsTD,2)
plot(TD,col=sTD, cex.main=1.5, main="Partition TwoDiamonds - Lien minimum")
cTD=cutree(hcTD,2)
plot(TD,col=cTD, cex.main=1.5, main="Partition TwoDiamonds - Lien maximum")
aTD=cutree(haTD,2)
plot(TD,col=aTD, cex.main=1.5, main="Partition TwoDiamonds - Lien moyen")
wTD=cutree(hwTD,2)
plot(TD,col=wTD, cex.main=1.5, main="Partition TwoDiamonds - Critere de Ward")
dev.off()
# WingNut
png(filename = "/Users/Emeline/Desktop/g11.png", width = 1000, height = 250)
par(mfrow = c(1,4))
sWN=cutree(hsWN,2)
plot(WN,col=sWN, cex.main=1.5, main="Partition WingNut - Lien minimum")
cWN=cutree(hcWN,2)
plot(WN,col=cWN, cex.main=1.5, main="Partition WingNut - Lien maximum")
aWN=cutree(haWN,2)
plot(WN,col=aWN, cex.main=1.5, main="Partition WingNut - Lien moyen")
wWN=cutree(hwWN,2)
plot(WN,col=wWN, cex.main=1.5, main="Partition WingNut - Critere de Ward")
dev.off()
# Chainlink
sCL=cutree(hsCL,2)
plot3d(CL,col=sCL, main="Partition Chainlink - Lien minimum")
cCL=cutree(hcCL,2)
plot3d(CL,col=cCL, main="Partition Chainlink - Lien maximum")
aCL=cutree(haCL,2)
plot3d(CL,col=aCL, main="Partition Chainlink - Lien moyen")
wCL=cutree(hwCL,2)
plot3d(CL,col=wCL, main="Partition Chainlink - Critere de Ward")
# On construit les matrices de confusion
# TwoDiamonds
tsTD=table(x[,3],sTD)
tcTD=table(x[,3],cTD)
taTD=table(x[,3],aTD)
twTD=table(x[,3],wTD)
# WingNut
tsWN=table(y[,3],sWN)
tcWN=table(y[,3],cWN)
taWN=table(y[,3],aWN)
twWN=table(y[,3],wWN)
# Chainlink
tsCL=table(z[,4],sCL)
tcCL=table(z[,4],cCL)
taCL=table(z[,4],aCL)
twCL=table(z[,4],wCL)
# Partie 2 : Interpretation des classes
# WINE
# On importe le jeu de donnees
wine=read.table("/Users/Emeline/Downloads/wine_data.txt", sep=",", dec=".", header=FALSE)
# On donne des noms aux colonnes avec la fonction colnames()
colnames(wine)=c("Classe", "Alcohol", "Malic acid", "Ash", "Alcalinity of ash",
"Magnesium", "Total Phenols", "Flavanoids", "Nonflavanoid phenols", "Proanthocyanins", "Color intensity", "Hue",
"OD280/OD315 of diluted wines", "Proline")
# On fait un analyse unidimensionnelle
# Statistiques descriptives
# On commence par utiliser une fonction summary() sans la premiere variable car elle contient les classes
summary(wine[,-1])
# On evalue la tendance centrale avec la fonction mean() qui calcule la moyenne
mean(wine[,-1])
# On evalue la dispersion avec la fonction sd() qui calcule l’ecart-type
sd(wine[,-1])
# On cherche si le jeu de donnes contient des valeurs manquantes avec la fonction is.na()
missing = is.na(wine)
which(missing)
# Boites a moustache
# On cree une boucle for() pour visualiser les boites a moustaches plus facilement
# On cree des boites a moustaches avec la fonction boxplot() en fonction (tilde) des classes
# La commande par(ask=T)) fait en sorte que R fasse des pauses entre les affichages et nous demande
d’appuyer sur “entree” pour afficher le graphique suivant.
for (i in 2:14){
+ boxplot(wine[,i]~wine[,1])
+ par(ask=T)
+}
# Etant donne qu’il y a beaucoup de boites a moustache, on en selectionne 3 pour les mettre dans le rapport
# On colore les boites a moustache en bleu clair avec le parametre col
# On ajoute un titre avec le parametre main et une etiquette a l’axe x avec le parametre xlab
png(filename = "/Users/Emeline/Desktop/g12.png", width = 1000, height = 650)
par(mfrow = c(1,3))
boxplot(wine[,2]~wine[,1], main="Boîte à moustache - Alcool" , xlab="Classe de vin", col="light blue")
boxplot(wine[,3]~wine[,1], main=" Boîte à moustache - Acide malique" , xlab="Classe de vin", col="light blue")
boxplot(wine[,4]~wine[,1], main=" Boîte à moustache - Cendres" , xlab="Classe de vin", col="light blue")
boxplot(wine[,5]~wine[,1], main="Boîte à moustache - Alcalinite des cendres" , xlab="Classe de vin", col="light blue")
boxplot(wine[,6]~wine[,1], main=" Boîte à moustache - Magmesium" , xlab="Classe de vin", col="light blue")
boxplot(wine[,7]~wine[,1], main=" Boîte à moustache - Phenols totaux" , xlab="Classe de vin", col="light blue")
boxplot(wine[,8]~wine[,1], main=" Boîte à moustache - Flavanoides" , xlab="Classe de vin", col="light blue")
boxplot(wine[,9]~wine[,1], main=" Boîte à moustache - Non flavanoides" , xlab="Classe de vin", col="light blue")
boxplot(wine[,10]~wine[,1], main=" Boîte à moustache - Proanthocyanins" , xlab="Classe de vin", col="light blue")
boxplot(wine[,11]~wine[,1], main=" Boîte à moustache - Intensite de couleur" , xlab="Classe de vin", col="light blue")
boxplot(wine[,12]~wine[,1], main=" Boîte à moustache - Nuances" , xlab="Classe de vin", col="light blue")
boxplot(wine[,13]~wine[,1], main=" Boîte à moustache - OD280/OD315" , xlab="Classe de vin", col="light blue")
boxplot(wine[,14]~wine[,1], main=" Boîte à moustache - Proline" , xlab="Classe de vin", col="light blue")
dev.off()
# Camembert
png(filename = "/Users/Emeline/Desktop/g13.png", width = 400, height = 400)
mytable = table(wine[,1])
l = paste(names(mytable), " (",round(mytable/sum(mytable)*100), "%", ")", sep=" ")
pie(mytable, labels = l, main="Camembert des classes\n (en pourcentage)", col=c("light blue","light
yellow","light pink"))
dev.off()
# Matrice de correlations
round(cor(wine[,-1]),2)
# On affiche tous les nuages de points possibles et on enregistre le resultat au format png
png(filename = "/Users/Emeline/Desktop/pairswine.png", width = 1000, height = 1000)
pairs(wine[,-1], col=wine[,1])
dev.off()
# Analyse en composantes principales
# On commence par charger le package FactoMineR qui contient la fonction PCA() avec la commande library()
library(FactoMineR)
# On utilise la fonction PCA() pour faire une ACP sur notre jeu de donnees
# On reduit les donnees grace au parametre scale.unit, car les variables n’ont pas toutes les memes unites
# On met la variable contenant les classes en variable qualitative supplementaire avec quali.sup
res.pca = PCA(wine, scale.unit=TRUE, quali.sup=1)
# On affiche les valeurs propres arrondies a 2 chiffres apres la virgule
round(res.pca$eig,2)
# Barplot des valeurs propres enregistre au format png
png("/Users/Emeline/Desktop/valeurspropres.png", width = 400, height = 400)
barplot(res.pca$eig[,2], main="Histogramme des valeurs propres", ylab="Pourcentage de variance",
xlab="Valeurs propres associées à chaque dimension", ylim=c(0,max(res.pca$eig[,2])*1.2), col="pink",
cex.axis=0.8, cex.names=0.8, names.arg=paste("dim",1:nrow(res.pca$eig)))
dev.off()
# On visualise le coude sur un second graphique des valeurs propres
png("/Users/Emeline/Desktop/coude.png")
plot(res.pca$eig[,2], type='b', main="Graphique du coude", xlab="Valeurs propres", ylab="Pourcentage de
variance", cex=0.8)
dev.off()
# On cree le graphique des individus et on l’enregistre au format png
# On colore les individus en fonction des classes de vin avec le parametre habillage
# On affiche le graphique des individus sur les axes 1 et 2, les axes 1 et 3 et les axes 2 et 3
png("/Users/Emeline/Desktop/ind.png", width = 1000, height = 400)
par(mfrow = c(1,3))
plot.PCA(res.pca, choix="ind", habillage=1, axes=c(1,2), cex=0.5, new.plot=F)
plot.PCA(res.pca, choix="ind", habillage=1, axes=c(1,3), cex=0.5, new.plot=F)
plot.PCA(res.pca, choix="ind", habillage=1, axes=c(2,3), cex=0.5, new.plot=F)
dev.off()
# On affiche le graphique des variables sur les axes 1 et 2, les axes 1 et 3 et les axes 2 et 3
png("/Users/Emeline/Desktop/var.png", width = 1000, height = 400)
par(mfrow = c(1,3))
plot.PCA(res.pca, choix="var", axes=c(1,2), new.plot=F)
plot.PCA(res.pca, choix="var", axes=c(1,3), new.plot=F)
plot.PCA(res.pca, choix="var", axes=c(2,3), new.plot=F)
dev.off()
# On construit la matrice de correlation avec la fonction cor()
# On arrondi la matrice de correlation avec la fonction round() a 2 chiffres apres la virgule
correlation=round(cor(wine[,-1]),2)
write.infile(correlation, "/Users/Emeline/Desktop/correlation.csv")
# On decrit automatiquement des 3 premieres composantes avec la fonction dimdesc()
# On prend une erreur de premiere espece a 0.05
dim.desc = dimdesc(res.pca, axes=1:3, proba=0.05)
# On enregistre les resultats de la fonction dimdesc() dans un fichier csv
write.infile(dim.desc, file="/Users/Emeline/Desktop/dimdesc.csv")
# On regarde les contributions des variables pour determiner les variables explicatives pour chaque axe
# On arrondi le resultat a deux chiffres apres la virgule
# On affiche les contributions pour les 3 premiers axes seulement
# On enregistre le resultat dans un fichier csv avec la fonction write.infile
contribvar=round(res.pca$var$contrib[,1:3],2)
write.infile(contribvar, file="/Users/Emeline/Desktop/contribvar.csv")
# On regarde les cosinus carre des variables pour determiner les variables expliquees pour chaque axe
# On arrondi le resultat a deux chiffres apres la virgule
# On affiche les cosinus carre pour les 3 premiers axes seulement
round(res.pca$var$cos2[,1:3],2)
# On effectue une HCPC
HCPC(res.pca)
# On applique l’algorithme kmeans
km=kmeans(wine[-1], centers=3, iter.max=20, nstart=10)
# On concatene les classes obtenues avec kmeans au jeu de donnees ecoli
x=cbind(wine,km$cluster)
# On fait l’ACP sur ce nouveau jeu de donnees pour pouvoir visualiser les classes obtenues sur le premier plan factoriel
res.pca= PCA(x, scale.unit=TRUE, quali.sup=c(1,15))
png(filename = "/Users/Emeline/Desktop/kmwine.png", width = 400, height = 400)
plot(res.pca, choix="ind", axes=1:2, habillage=15, cex=0.5, new.plot=F)
dev.off()
# On construit la matrice de confusion
table(x[,1],x[,15])
# E.COLI
# On importe le jeu de donnees
ecoli=read.table("/Users/Emeline/Downloads/ecoli_data.txt", sep="", dec=".", header=FALSE, row.names=1)
# On donne les vrais noms des variables
colnames(ecoli)=c("mcg","gvh","lip","chg","aac","alm1","alm2","Classe")
# On renomme les variables pour que les libelles s’affiche sur les sorties de resultat
colnames(ecoli)=c("McGeoch","von Heijne's", "Score du signal","Presence charge","Score de l'analyse","Score
d'ALOM1","Score d'ALOM2","Site")
# On fait une analyse unidimensionnelle et bidimensionnelle
# On construit des boites a moustache
png(filename = "/Users/Emeline/Desktop/boxplotecoli.png", width = 1200, height = 250)
par(mfrow = c(1,5))
boxplot(ecoli[,1]~ecoli[,8], main="Boxplot – Methode McGeoch", xlab="Sites de localisation cellulaire", cex=0.7, col="pink",
cex.main=2)
boxplot(ecoli[,2]~ecoli[,8], main="Boxplot – Methode von Heijne's", xlab="Sites de localisation cellulaire", cex=0.7, col="pink",
cex.main=2)
boxplot(ecoli[,5]~ecoli[,8], main="Boxplot – Score de l'analyse", xlab="Sites de localisation cellulaire", cex=0.7, col="pink",
cex.main=2)
boxplot(ecoli[,6]~ecoli[,8], main="Boxplot – Score d'ALOM 1", xlab="Sites de localisation cellulaire", cex=0.7, col="pink",
cex.main=2)
boxplot(ecoli[,7]~ecoli[,8], main="Boxplot – Score d'ALOM 2", xlab="Sites de localisation cellulaire", cex=0.7, col="pink",
cex.main=2)
dev.off()
# On calcule les frequences des variables binaires
table(ecoli[,3])
table(ecoli[,4])
# On cree des variables qualitative a partir des variables binaires qui sont considerees comme quantitatives par R
x=as.character(ecoli[,3])
signal.freq=table(x)
y=as.character(ecoli[,4])
signal.freq2=table(y)
# On visualise les graphiques circulaires des deux variables binaires et on enregistre les graphiques en format png
png(filename = "/Users/Emeline/Desktop/pieecoli.png", width = 650, height = 250)
par(mfrow = c(1,2))
pie(signal.freq, col=c("light blue","light yellow"), labels=c("0,48 (97,02%)","1 (2,97%)"), main= "Camembert - Score du
signal", cex.main=1)
pie(signal.freq2, col=c("light blue","light yellow"), labels=c("0,5 (99,70%)","1 (0,30%)"), main= "Camembert - Présence
de charge", cex.main=1)
dev.off()
# On affiche la matrice de correlation
round(cor(ecoli[,c(1,2,5,6,7)]),2)
# On affiche tous les nuages de points possibles sur les variables et on enregistre le graphique en format png
png(filename = "/Users/Emeline/Desktop/pairsecoli.png", width = 500, height = 500)
pairs(ecoli[,c(1,2,5,6,7)], col=ecoli[,8])
dev.off()
# On fait une ACP
# On ne normalise pas les donnees en precisant scale.unit=FALSE
# On ajoute les variables 3, 4 et 8 en qualitatives supplementaires et la variable 5 en quantitative supplementaire
pca.e=PCA(ecoli, scale.unit=FALSE, quali.sup=c(3,4,8), quanti.sup=5)
# On affiche les valeurs propres
round(pca.e$eig,2)
# On cree le graphique du coude et on enregistre le resultat en format png
png(filename = "/Users/Emeline/Desktop/coudeecoli.png", width = 400, height = 400)
plot(pca.e$eig[,2], type='b', main="Graphique du coude", xlab="Valeurs propres", ylab="Pourcentage de variance",
cex=0.8)
dev.off()
# On affiche le graphique des variables en precisant choix=”var”
png("/Users/Emeline/Desktop/varecoli.png")
plot.PCA(pca.e, choix="var", new.plot=F)
dev.off()
# On affiche le graphique des individus en precisant choix=”ind”
# On colorie les individus en fonction de leur site de localisation cellulaire
png("/Users/Emeline/Desktop/indecoli.png")
plot.PCA(pca.e, choix="ind", habillage=8, cex=0.5, new.plot=F)
dev.off()
# On effectue une description automatique des axes
dimdesc(pca.e)
# On utilise la fonction VARIMAX pour nous aider a interpreter les axes
varimax(pca.e$var$cor[,1:2])
# On affiche les contributions des variables aux axes
round(pca.e$var$contrib[,1:2],2)
# On affiche les qualites de representation des variables
round(pca.e$var$cos[,1:2],2)
# On affiche le graphique des individus avec les sites seulement avec invisible= « ind »
png("/Users/Emeline/Desktop/invecoli.png")
plot.PCA(pca.e, choix="ind", habillage=8, cex=1, invisible="ind",new.plot=F)
dev.off()
# On effectue une HCPC
HCPC(pca.e)
# On applique l’algorithme kmeans
km=kmeans(ecoli[-8], centers=8, iter.max=20, nstart=10)
# On concatene les classes obtenues avec kmeans au jeu de donnees ecoli
x=cbind(ecoli,km$cluster)
# On fait l’ACP sur ce nouveau jeu de donnees pour pouvoir visualiser les classes obtenues sur le premier plan factoriel
pca.e=PCA(x, scale.unit=FALSE, quali.sup=c(3,4,8,9), quanti.sup=5)
png(filename = "/Users/Emeline/Desktop/kmecoli.png", width = 400, height = 400)
plot(pca.e, choix="ind", axes=1:2, habillage=9, cex=0.5, new.plot=F)
dev.off()
# On construit la matrice de confusion
table(x[,8],x[,9])
# Partie 3 : Classification dans la bio-­‐informatique # On importe le jeu de donnees
data = read.table("I2000.txt")
# On transpose le jeu de donnees
dataT = t(data)
# On effectue une procedure K-means sur notre jeu de donnees
# On precise qu’il y a deux classes (genes tumeur, genes normaux)
# On lance l’algorithme 10 fois avec le parametre nstart
# On precise que l’on veut 20 iterations avec le parametre iter.max, on en a pas besoin de plus car
l’algorithme converge
km=kmeans(dataT, centers=2, iter.max=20, nstart=10)
# On visualise les classes de l’algorithme k-means sur un plan
plot(dataT,col=km$cluster, main="Partition de l'algorithme K-means")
# On importe le fichier contenant les vraies classes
vt = read.table("/home/patrick/Bureau/projetFD/vt.txt")
# On construit la matrice de confusion
t = table(km$cluster,vt[,1])
# On effectue une CAH
# Pour cela on commence par calcule les matrices de dissimilarites avec la fonction dist()
# La fonction dist() calcule la distance euclidienne entre chaque paire de donnees
ddata = dist(dataT)
# On effectue une CAH avec le lien minimum
# On precise avec le parametre method que l’on utilise le lien minimum
hmin = hclust(ddata,method="single")
# On effectue une CAH avec le lien moyen
# On precise avec le parametre method que l’on utilise le lien moyen
hmed = hclust(ddata,method="average")
# On effectue une CAH avec le lien maximum
# On precise avec le parametre method que l’on utilise le lien maximum
hmax = hclust(ddata,method="complete")
# On effectue une CAH avec le critere de ward
# On precise avec le parametre method que l’on utilise le critere de ward
hward= hclust(ddata,method="ward")
# On enregistre les dendrogrammes correspondant dans un fichier png
png(filename = "/home/patrick/Bureau/projetFD/cah.png", width = 1000, height = 250)
par(mfrow = c(1,4))
plot(hmin,hang=-1,cex.main=1.8,main="Dendrogramme - lien minimum", xlab="The Colon data")
plot(hmed,hang=-1,cex.main=1.8,main="Dendrogramme - lien moyen", xlab="The Colon data")
plot(hmax,hang=-1,cex.main=1.8,main="Dendrogramme - lien maximum", xlab="The Colon data")
plot(hward,hang=-1,cex.main=1.8,main="Dendrogramme - Critere de Ward", xlab="The Colon data")
dev.off()
#
#
#
#
#
On visualise le nuage de points avec les classes predites par les 4 CAH
Avec la fonction cutree(), on “decoupe” l’arbre hierarchique en precisant le nombre de classes
La fonction cutree() cree un vecteur contenant la classe estimee de chaque individu
A partir de ce vecteur on visualise les classes predites sur le nuage des individus avec la fonction plot()
On precise que l’on veut colorer les individus en fonction des classes predites avec le parametre col
chmin = cutree(hmin,2)
chmed = cutree(hmed,2)
chmax = cutree(hmax,2)
chward = cutree(hward,2)
# On visualise les classes predites par chaque methode sur le nuage de points et on compare avec les vraies
png(filename = "/home/patrick/Bureau/projetFD/nuages.png", width = 1000, height = 700)
par(mfrow = c(2,3))
plot(dataT,cex.main=1.8,main="Vrai partition",col=vt[,1])
plot(dataT,cex.main=1.8,main="Partition de l'algortihme k-means",col=km$cluster)
plot(dataT,cex.main=1.8,main="Partition de la CAH avec le lien minimum",col=chmin)
plot(dataT,cex.main=1.8,main="Partition de la CAH avec le lien moyen",col=chmed)
plot(dataT,cex.main=1.8,main="Partition de la CAH avec le lien maximum",col=chmax)
plot(dataT,cex.main=1.8,main="Partition de la CAH avec le lien critère de ward",col=chward)
dev.off()
# On construit les matrices de confusions
# Pour cela on utilise la fonction table qui cree un tableau de contingence
tmin=table(chmin,vt[,1])
tmed=table(chmed,vt[,1])
tmax=table(chmax,vt[,1])
tward=table(chward,vt[,1])