TP2 : analyse discriminante linéaire et quadratique

Master 2 MSS
Apprentissage supervisé
2016-2017
TP2 : analyse discriminante linéaire et quadratique
Exercice 1. Les objectifs :
— Programmer l’analyse discriminante linéaire et quadratique.
— Découvrir les fonctions lda et qda du package MASS.
Reprendre les jeux de données synth_train.txt et synth_test.txt déjà utilisées dans le TP1. On a
Y ∈ {1, 2} et X ∈ R2 . On dispose de 100 données d’apprentissage et 200 données test.
1. Charger le jeu de données d’apprentissage.
train <- read.table(file="synth_train.txt", header=TRUE)
X <- train[,-1]
Y <- train$y
plot(X, pch=Y, col=Y)
legend("topleft", legend=c("classe1", "classe2"), pch=1:2, col=1:2)
0.0
0.5
1.0
1.5
x2
2.0
2.5
3.0
classe1
classe2
−2
−1
0
1
x1
2. Implémenter la classification par analyse discriminante quadratique (on pourra commencer par
créer une fonction adq_estim qui estime les paramètres, puis créer une fonction adq_pred qui
étant donnés les paramètres estimés est capable de prédire la classe et les probabilités à posteriori
de nouvelles observations données sous forme de matrice).
3. Tester les fonctions : appliquer la fonction adq_estim avec l’échantillon d’apprentissage, puis utiliser la fonction adq_pred pour prédire les classes les points de coordonnées (0,1) et (-2,2) ainsi
que les probabilités à posteriori.
1
4. Prédire les classes les points de coordonnées (0,1) et (-2,2) ainsi que les probabilités à posteriori
avec la fonction qda du package MASS.
5. Charger le jeu de données test. Prédire les données test et calculer le taux d’erreur test.
6. On veut maintenant visualiser la frontière de décision. Représenter graphiquement cette frontière
en constuisant une grille de points (cf. TP1) et en prédisant les classes de ces points.
1.5
0.0
0.5
1.0
grille[,2]
2.0
2.5
3.0
classe 1
classe 2
−2
−1
0
1
grille[,1]
7. Avec la fonction lda du package MASS, construire le classifieur d’ADL sur les données d’apprentissage, prédire les données test et calculer le taux d’erreur test. Enfin représenter la frontière de
décision de ce classifieur en utilisant une grille de points.
Exercice 2. Les objectifs :
— Faire de la reconnaissance automatique de caractères manuscrits.
Récupérer le jeux de données d’apprentissage zip_train.txt. L’objectif est d’identifier dans une image
noir et blanc de 16 × 16 pixels un chiffre de 0 à 9. A chaque pixel d’une image est associé un nombre réel
entre −1 (noir) et 1 (blanc). On a Y ∈ {0, . . . , 9} et X ∈ [−1, 1]256 .
1. Charger les données. Représenter quelques images de l’ensemble d’apprentissage pour chacune
des classes. Utiliser pour cela la fonction image avec l’échelle de couleurs gray, attention cette
fonction prend en entrée un nombre entre 0 (noir) et 1 (blanc). Pensez également à retourner l’axe
des ordonnées avec l’option ylim.
# on trace les 16 premiers chiffres de l'echantillon d'apprentissage
par(mfrow=c(4,4), mar=c(2, 2, 2, 2) + 0.1)
for (i in 1:16){
image(matrix(Z_zip[i,], 16,16), col=gray(1:100/100), ylim=c(1.05,-0.05))
}
2
0.8
0.2
1.0
0.4
0.8
0.0
0.4
0.8
0.6
1.0
0.6
0.2
1.0
0.6
0.2
1.0
0.6
0.2
0.6
1.0
0.2
0.6
1.0
0.4
0.8
0.0
0.4
0.8
0.0
0.4
0.8
0.2
0.4
1.0
0.6
1.0
0.2
0.6
1.0
0.2
0.6
1.0
0.6
0.2
0.0
0.0
0.0
0.6
0.8
0.8
0.8
0.8
1.0
0.4
0.4
0.4
0.4
0.2
0.0
0.0
0.0
0.0
0.6
0.8
0.8
0.8
1.0
0.4
0.4
0.4
0.2
0.0
0.0
0.0
0.6
0.8
0.8
1.0
0.4
0.4
0.2
0.0
0.0
0.2
0.8
1.0
0.6
0.2
1.0
0.6
0.2
0.6
1.0
0.4
0.2
0.0
2. Appliquer la classification par analyse discriminante linéaire. Prédire les données de l’ensemble
d’apprentissage, comparer avec les vraies classes et calculer le taux d’erreur d’apprentissage.
3. Afficher sous forme d’image les valeurs moyennes estimées pour chaque classe k = 0, . . . , 9.
4. Prédire les données de l’ensemble test, et calculer le taux d’erreur test.
Exercice 3.
Les objectifs :
— Faire une Analyse en Composantes Principales (ACP) des données "Desbois".
— Comparer les performances des classifieurs ADL et ADQ sur ces données .
— Sélectionner les variables discriminantes en ADL.
Les données concernent n = 1260 exploitations agricoles réparties en K = 2 groupes : le groupe des
exploitations saines et le groupe des exploitations défaillantes. On veut construire un score de détection
du risque financier applicable aux exploitations agricoles. Pour chaque exploitation agricole on a mesuré
une batterie de p = 30 crières économiques et financiers pour construire le score. La variable qualitative
3
à expliquer est donc la variable difficulté de paiement (1=sain et 0=défaillant). Une étude de cas de
ces données est disponible à l’adresse suivante : http://publications-sfds.fr/index.php/csbigs/
article/view/351/331
1. Récuperez le jeu de données Desbois_complet.rda et les charger dans R.
2. Faire une ACP des données avec la fonction PCA du package FactoMineR. Visualisez les plans principaux intéressant en habillant les points en fonction de leur classe (sain ou défaillant). Interprétez
les résultats.
1.0
Plan principal 1−2
défaillant
sain
R37
R3
R4
R1
R30
R32
0.0
Dim 2 (16.79%)
0
R14
R8
R17
R28
R5
R18
R21
R22 R19
R6
R2
−0.5
−5
Dim 2 (16.79%)
0.5
5
R24
R12
R11
R7
−1.0
−10
R36
−5
0
5
10
15
−1.0
Dim 1 (46.66%)
−0.5
0.0
0.5
1.0
Dim 1 (46.66%)
3. Créez un découpage aléatoire des données en 945 observations d’apprentissage et 315 observations
test. Constuire le classifieur d’ADL sur les données d’apprentissage et prédire le score (probabilité
à posteriori d’être défaillant) des 315 données test. Visualisez la courbe ROC et la courbe du TBC.
Vous semble-t’il judicieux de modifier le seuil du classifieur d’ADL ?
4. Quelles stratégies peuvent être envisagées pour comparer correctement les classifieurs lda et qda ?
Choisir deux stratégies et comparer les taux d’erreur et les auc d’ADL et de ADQ.
## [1] statégie 1 : validation LOO
##
Tx erreur
AUC
## LDA
0.120 0.950
## QDA
0.179 0.923
## [1] statégie 2 : ensemble test B fois
AUC test pour 50 decoupages
0.08
0.88
0.10
0.90
0.12
0.14
0.92
0.16
0.94
0.18
0.20
0.96
0.22
Erreurs test pour 50 decoupages
lda
qda
lda
4
qda
5. La fonction greedy.wilks du package klaR effectue une sélection de variable pas à pas ascendante
en ADL. Testez cette méthode avec le code ci-dessous. Combien de variables sont sélectionnées,
quel est le taux d’erreur de ce classifieur sur les données test ?
tr <- sample(1:nrow(data),945)
train <- data[tr,]
test <- data[-tr,]
library(klaR)
?greedy.wilks
# lda avec selection de variables pas à pas ascendante
g <- greedy.wilks(DIFF~.,data=train,niveau=0.05)
g$formula
## DIFF ~ R1 + R32 + R14 + R17 + R2 + R3 + R36 + R21
## <environment: 0x7fccb09402a8>
#prediction des donnees test
pred_wilks <- predict(lda(g$formula,data=train),test)$class
6. Constuire le classifieur qui sera finalement utilisé pour prédire si de nouvelles exploitations sont
saines ou défaillantes.
7. Pour finir, regarder l’aide sur la fontion stepclass du package klar et résumer ce que permet de
faire cette fonction.
5