Université Paris 13 – Institut Galilée Département d'Informatique
Pôle de Recherche et d'Enseignement Supérieur
Sorbonne Paris Cité
M ASTER I NFORMATIQUE SPECIALITES EID
2, PLS
Master of Science in Informatics
T RAITEMENT N UMERIQUE DES D ONNEES
Digital data processing
Série d’exercices
www-galilee.univ-paris13.fr
NB : Les TP sont notés. Les étudiants (au plus en binôme) doivent sauvegarder le code de chaque exercice dans un fichier matlab et doivent présenter le résultat au chargé du TP.
Exercice 1 : Introduction à PRTools
PRTools est un toolbox entièrement consacré aux traitement des ensembles de données (ou d'objets) représentés par des vecteurs dans un espace de caractéristiques (« features »). Par la suite, on va utiliser cette convention : variable = feature ou caractéristique. La structure principale des ensembles de données est le dataset. Elle est composée d'une matrice de taille m x k ; où m sont les vecteurs lignes représentant les objets caractérisés par k variables. A cette matrice appartient aussi un ensemble de m étiquettes (qui peuvent être des chaînes de caractères ou des nombres), une pour chaque données et un ensemble k de noms de variables (également des chaînes ou des nombres), un nom pour chaque variable. En outre, un ensemble de probabilités a priori, un pour chaque classe, est stocké. Les données avec la même étiquette appartiennent à la même classe. Dans la plupart des fichiers help dans PRTools, un ensemble de données est représentée par A. La plupart des fonctions peuvent manipuler des objets multiclasses.
Voici quelques fonctions utiles pour manipuler les jeux de données:
Dataset Définit un ensemble de données à partir d’une matrice de données et d'étiquettes ; getdata Récupère les données à partir d’un jeu de données ;
getlab Récupère les étiquettes des objets ; getfeat Récupère les étiquettes des variables ;
seldat Sélectionne un sous-ensemble d'un jeu de données ; gendat Génère des étiquettes de données ;
setdat Défini un nouveau jeu de données à partir d'un ancien jeu de données en remplaçant ses données ;
renumlab Convertit les étiquettes en chiffres ;
Les ensembles d'objets peuvent être généré par l'une des fonctions de génération de données dans PRTools ou peuvent être fournis par le professeur. Les étiquettes peuvent être obtenues par les résultats d'une classification automatique ou peuvent être fournies avec l’ensemble de données.
Un ensemble de données contenant 10 objets avec 5 variables aléatoires peut être généré par:
>> data = rand(10,5);
>> a = dataset(data)
10 by 5 dataset with 0 classes: [10]
Dans cet exemple, aucune étiquette n’est fournie, par conséquent, une seule classe est détectée. Les étiquettes peuvent être ajoutés à l'ensemble de données par:
>> labs = [1 1 1 1 1 2 2 2 2 2]'; % labs should be a column vector
>> a = dataset(a,labs)
10 by 5 dataset with 2 classes: [5 5]
Notez que les étiquettes doivent être fournies sous forme d’un vecteur colonne. Une façon simple d'attribuer des étiquettes à un ensemble de données est d’utiliser la fonction genlab en combinaison avec la commande char de Matlab :
>> labs = genlab([4 2 4],char('apple','pear','banana'))
>> a = dataset(a,labs)
10 by 5 dataset with 3 classes: [4 4 2]
1.1 Utiliser les fonctions getlab et getfeat pour récupérer les étiquettes des objets et les étiquettes des variables de a.
Les champs d'un ensemble de données peuvent être visible en les convertissant en une structure, par exemple:
>> struct(a)
data: [10x5 double]
lablist: {2x4 cell}
nlab: [10x1 double]
labtype: 'crisp' targets: []
featlab: []
featdom: {}
prior: []
cost: []
objsize: 10 featsize: 5
ident: [1x1 struct]
version: {[1x1 struct] '30-Sep-2010 00:10:55'}
name: []
user: []
Notez que pour utiliser les fonctions de PRTools, les données doivent être représentées dans ce format (à l’aide de la fonction dataset)!!!
Analysez les champs de cette structure. La signification de ces champs est expliquée dans le help en ligne concernant les jeux de données (help datasets) ou dans le manuel PRTools).
Chaque champ peut être modifié par une instruction set-commande, par exemple :
>> b = setdata(a,rand(10,5));
Les valeurs des champs peuvent être récupérées par une instruction similaire get-commande, par exemple :
>> classnames = getlablist(a)
Dans le champ nlab, un index est stocké pour chaque objet correspondant à la liste des noms de étiquettes lablist. Notez que cette liste est triée par ordre alphabétique.
La taille d'un ensemble de données peut être trouvée en utilisant les deux commandes, size et getsize :
>> [m,k] = size(a);
>> [m,k,c] = getsize(a);
Le nombre d'objets est retourné dans m, le nombre de variables dans k, et le nombre de classes dans c.
Les probabilités de la classe a priori sont stockés dans le champ prob. Si le champ est vide,
les probabilités sont définies par les fréquences des classes. Les données dans l’ensemble de données lui-même peuvent être récupéré par la commande double(a) ou plus simple par +a.
1.2 Analysez le help en ligne de la commande seldat. Utilisez cette fonction pour extraire les données correspondant à l’étiquette banana et vérifiez le résultat avec +a.
Les ensembles de données peuvent être manipulés de plusieurs façons comparables aux matrices de Matlab. Donc, [a1; a2] concatène deux ensembles de données, à condition qu'ils aient le même nombre de variables. La concaténation de variables peut être obtenu par [a1 a2]
si a1 et a2 ont le même nombre d'objets.
1.3 Générez 3 nouveaux objets des classes « apple » et « pear » et rajoutez les a l'ensemble de données a.
1.4 Générez une nouvelle variable, la 6ième variable pour le jeu de données a.
Une autre façon d’analyser un ensemble de données est de tracer un diagramme de dispersion (scatterplot) des objets de l'ensemble de données respectif. Pour cela, il faut appliquer la fonction scatterd. Cette fonction permet de projeter chaque objet de l’ensemble de données dans un graphique 2D, en utilisant un marqueur de couleur lorsque les étiquettes des classes sont fournies. Lorsque plus de deux variables (caractéristiques) sont présentes dans l'ensemble de données, les deux premiers sont utilisés. Pour obtenir un diagramme de dispersion des autres variables, elles doivent être explicitement extraites, par exemple a1 = a (:, [2 5]);
Il est possible, également, de créer des graphiques 3D (analysez le help de scatterd).
1.5 Utilisez la fonction scatterd pour construire un diagramme de dispersion (scatterplot) des variables 2 et 5 du jeu de données a. Essayez aussi scatterdui. Utilisez les boutons ‘< >’ pour sélectionner les variables.
1.6 Faire un ‘scatterplot’ en dimension 3 en utilisant scatterd(a,3) et essayez de la faire tourner après avoir appuyé sur le bouton de la barre à droite.
Exercice 2 : Scatterplot
N.B. La base de données Iris est fournie par votre chargé de TP.
Chargez le jeu de données Iris (qui contient 4 dimensions) en utilisant la commande Iris = load(‘le chemin vers la base’). Pour pouvoir utiliser la commande load, les étiquettes de la base de données ont été modifiées de la manière suivante :
Iris-setosa = 1;
Iris-versicolor = 2;
Iris-virginica = 3;
Le jeu de données chargé dans Iris représente une matrice et non pas une structure de PRTools. Pour cela il faut transformer la matrice dans une structure.
Construisez une structure de données qui contient les champs suivants:
data – les données sans les étiquettes;
labels – les étiquettes;
class1 – les données de la classe 1;
class2 – les données de la classe 2;
class3 – les données de la classe 3;
Par la suite, utilisez la commande dataset pour rendre le jeu de données dans le format de PRTools.
Faire les ‘scatterplots’ de toutes les combinaisons de variables en utilisant l'option gridded de la fonction scatterd.
Tracez dans une figure séparée les densités unidimensionnelles de variables en utilisant plotf.
Identifier visuellement la meilleure combinaison de deux variables. Créer un nouvel ensemble de données b qui ne contient que ces deux variables. Construire une nouvelle figure à l’aide de la commande figure et tracer ici le ‘scatterplot’ de b.
Exercice 3 : La distance Mahalanobis
Utilisez la commande distmaha pour calculer les distances de Mahalanobis entre toutes les paires de classes de a. Répétez cette opération pour les deux meilleures variables que vous venez de sélectionner. Pouvez-vous trouver un moyen de tester si c'est vraiment la meilleure paire des variables selon la distance de Mahalanobis?
Exercice 4 : Générez votre propre jeu de données
Générez un ensemble de données 2-D qui est composé de deux classes d’objets répartis uniformément en utilisant la commande rand. Transformez les ensembles tels que, pour les intervalles [xmin xmax; ymax ymin] on a: [0 2; -1 1] pour la classe 1 et [1 3; 1,5 3,5] pour la classe 2. Générez 50 objets pour chaque classe. Un moyen facile est de faire cela pour les coordonnées x et y séparément et les combiner ensuite. Étiquetez les variables par «area» et
«perimeter».
Vérifiez le résultat obtenu en utilisant scatterd et en récupérant les étiquettes des données et les étiquettes des variables.
Exercice 5 : Agrandir un ensemble de données existantes
Générez un ensemble de données contenant 10 objets par classe en utilisant gendatb.
Agrandir cet ensemble de données à 100 objets par classe en générant plus de données en utilisant les commandes gendatk et gendatp. Comparer les ‘scatterplots’ avec un ‘scaterplot’
de 100 objets par classe directement générés par gendatb.
Exercice 6 : Estimation de densité
Les fonctions suivantes sont disponibles pour l’estimation de densité:
gaussm – Gausian estimation
parzenm – Parzen density estimation
knnm – K-nearest neighbor density estimation
Ils sont programmés comme un mapping. Les détails des mapping sont discutés plus tard.
Les deux étapes suivantes sont toujours essentielles pour un mapping : l'estimation est construite, ou apprise, en utilisant un ensemble d'apprentissage, par exemple par:
>> a = gauss(100)
Gaussian Data, 100 by 1 dataset with 1 class: [100]
Qui est une base de données unidimensionnelle composant 100 points normalement distribués avec la moyenne 0.
>> w = parzenm(a)
Parzen Density Estimation, 1 to 1 trained mapping --> parzen_map
Le mapping appris, w, contient maintenant toutes les informations nécessaires pour le calcul des densités de points donnés, par exemple :
>> b = [-2:0.1:2]';
Maintenant, sur les points définis par b nous allons mesurer la densité en fonction de w (qui est un estimateur de la densité basé sur l'ensemble de données a):
>> d = map(b,w)
41 by 1 dataset with 0 classes: []
Le résultat peut être affiché à l'écran par [+b +d] (les coordonnées et les densités) ou tracées par:
>> figure; plot(+b, +d)
Faire un plot de la densité estimée par parzenm et knnm dans des figures différentes.
>> w = knnm(a)
Exercice 7 : Density plots
Générez un jeu de données 2-dimensionnel à 2 classes de 50 points par classe en utilisant gendatb. Estimez les densités de chacune des trois méthodes présentées ci-dessus. Tracez dans trois figures le ‘scatterplot’ 2D en utilisant scatterd. Contrairement à l'exemple ci-dessus 1-dimensionnel, une fonction de traçage de densité existe, c’est plotm, elle peut être utilisée pour tracer des lignes d’« iso-densité » dans le ‘scatterplot’. Tracez chacune des trois estimations de densités dans les trois figures en utilisant plotm(w). Essayez aussi le 3D plot avec plotm(w,3). Notez que plotm a toujours besoin d'abord d’un ‘scatterplot’ pour trouver le domaine où la densité doit être calculée.
Exercice 8 : Nearest Neighbor Classification (k plus proches voisins)
Écrivez votre propre fonction pour l'estimation d'erreur de knn: e = nne(d), dans laquelle d est une matrice de distance (par exemple obtenus par d = distm(b, a) si a et b sont des ensembles de données). Une telle matrice est considérée à son tour comme un ensemble de données. Les objets de la matrice d sont les objets de b, dont les étiquettes peuvent être récupérées par object_lab=getlab(d). Les variables de la nouvelle matrice sont les distances de b à tous les objets de a. Leurs étiquettes sont trouvées par feat_lab=getfeat(d). Le nombre de différences entre les deux ensembles d'étiquettes peut être comptée par n=nlabcmp(object_lab, feat_lab).
Pour la règle du plus proche voisin, l'étiquette de chaque objet dans l'ensemble de test (ici b) doit être comparé avec l'étiquette de son plus proche voisin dans l'ensemble d'apprentissage (ici a).
La construction de la fonction nne contient donc les étapes suivantes :
8.1 Construire un vecteur L avec autant d'éléments que les lignes de d. Si j est l’indice du plus proche voisin (la plus petite distance d (i, j)) sur la ligne i (row_object i), alors L(i) = j.
Cette information peut être trouvée avec : [jj, j] = min (d (i ,:));
8.2 Utilisez nlabcmp pour compter les différences entre les vrais labels (étiquettes) des objets correspondant aux lignes données par object_lab et les étiquettes des plus proches
voisins feat_lab(L,:) ;
8.3 Normaliser et retourner l'erreur.
Si le jeu de données d’apprentissage a et le jeu de données de test b sont identiques (ex. d = distm(a, a)), nne devrait retourner 0 puisque chaque objet est son propre plus proche voisin.
Modifier votre fonction de façon qu'elle renvoie l'erreur leave-one-out si elle est appelée par e
= nne (d, ‘loo’). L'erreur leave-one-out est l'erreur calculée dans un ensemble d'objets, si pour chaque objet qu’on traite, l'objet lui-même est exclu de l'ensemble de données au moment où il est évalué. Dans ce cas, non pas la plus petite distance d(i, j) sur la ligne i doit être trouvée (qui devrait se trouver sur la diagonale), mais la deuxième plus petite.
Testez la fonction sur une base de donnés 2-D (utilisez votre fonction nne et scatterd).
Exercice 9 : Matrice de confusion
Dans une matrice de confusion C, un élément C(i, j) contient la confusion entre les classes i et j. Ces matrices sont particulièrement utiles dans les problèmes multi-classes pour analyser les similitudes entre les classes. En utilisant la fonction nne, une telle matrice peut être construite par une estimation de l'erreur entre toutes les paires des classes.
Pour calculer une matrice de confusion, construire la fonction conf(A) dans laquelle A est un ensemble de données multi-classe et qui a comme résultat la matrice de confusion C.
Les étapes suivantes sont nécessaires :
9.1 Trouver le nombre de classes en utilisant getsize.
9.2 Avec seldat, construire des ensembles de données temporaires pour chaque paire de classes (i, j).
9.3 Utiliser la fonction nne pour trouver l’erreur et la stocker dans C(i, j).
9.4 Afficher la matrice de confusion C.
Testez la fonction construite sur les bases de données Iris, Wine, Glass et Cancer.
Ces bases sont disponibles sur : http://www-lipn.univ-paris13.fr/~grozavu/TND/datasets/
Exercice 10 : Les classifieurs
10.1 Testez les fonctions de ces différents types de classification disponibles dans PRTools sur la base de données Iris:
fisherc Classifieur Fisher
qdc Classifieur quadratique en utilisant les densités normales
udc Classifieur quadratique en utilisant les densités normales non corrélées
ldc Classifieur linéaire en utilisant les densités normales avec des matrices de covariance égales
nmc Classifieur ‘Nearest mean’
parzenc Classifieur basé sur l’estimation des densités (avec parzen) knnc Classifieur k-plus proches voisins
treec Arbres de décision
svc Classifieur à support machine
lmnc Réseaux des neurones basé sur la règle de Levenberg-Marquardt
10.2 Visualisez le résultat de chaque classification avec des couleurs différents pour chaque classe (utilisez labeld pour obtenir les labels estimés par le classifieur).
10.3 Quelles sont les différences entre ces classifieurs ?
10.4 Calculez la sensibilité et la spécificité de chaque classifieur, puis projeter les résultats de chaque classifieur dans un espace ROC.
10.5 Utilisez la fonction « tic » et « toc » pour calculer le temps de calcul de chaque classifieur.
10.6 Quel est le meilleur classifieur pour Iris ?
10.7 Testez différents classifieur pour les bases de données Wine, Glass et Cancer, que remarquez vous ?
Cette série d’exercices est extraite de :
