Embed Size (px)
Citation preview
Université de Québec À Montréal Département d’Informatique
Document d’utilisation : Environnement Weka
H. Yazid
Dirigé par : Prof . Hakim Lounis
Environnement Weka Page 2 sur 28 26/01/2006
Table des matières
I. Introduction ..............................................................................................................................3
I.1 Description globale de Weka ..................................................................................................3
I.2 Composants de l’environnement Weka ..................................................................................5
I.3 Préparation de l’ensemble des données d’apprentissage et de test (dataset) .........................5
II. Explorer .......................................................................................................................................7
II.1 Phase de prétraitement...........................................................................................................7
II.2 Application d’un algorithme d’apprentissage........................................................................9
III. Experimenter ............................................................................................................................14
III.1 Description globale de la phase d’initialisation des paramètres d’expérimentation ..........15
III.2 Phase d’exécution...............................................................................................................17
III.3 Phase d’analyse ..................................................................................................................19
IV. KnowledgeFlow environment..................................................................................................22
IV.1 Structure de KnowledgeFlow environnement....................................................................22
IV.2 Comment utiliser cet outil? ................................................................................................23
V. Conclusion.................................................................................................................................28
VI. Références................................................................................................................................28
Environnement Weka Page 3 sur 28 26/01/2006
I. Introduction Ce document se veut une présentation de l’environnement Weka et de son utilisation illustrée à
travers des exemples. Dans cette section, nous allons donner une description sommaire de
l’environnement Weka en commençant par sa définition, son rôle et ses différentes
fonctionnalités assurées par ses différents composants.
Avant d’utiliser cet environnement dans différentes expérimentations, il est nécessaire que les
données utilisées à cet effet-la soient transcrites selon un format; une mise en forme des données.
En d’autres termes, les données doivent être conformes aux formats de données disponibles au
niveau de l’environnement Weka.
Nous avons choisi différents datasets inclus dans le package Weka pour les trois outils Explorer,
Experimenter et KnowledgeFlow environment pour explorer les différentes facettes de
l’environnement Weka.
Ce document est structuré principalement en trois grandes parties qui représentent les trois outils
fournis par l’environnement Weka à savoir l’Explorer, l’Experimenter et le KnowledgeFlow.
Ainsi, la première section sera consacrée à l’outil Explorer en définissant son rôle et ses
fonctionnalités qui seront illustrées à travers un exemple. La seconde décrira le rôle et les
différentes étapes de l’exécution d’une expérimentation par l’outil Experimenter. Ces étapes sont
expliquées aussi via un exemple illustrant les différentes fonctionnalités de cet outil. La dernière
section présentera l’outil KnowledgeFlow, son rôle et ses différentes fonctionnalités. Dans cette
même section, nous présenterons comment construire un schéma de flux de connaissances en
utilisant les composants de Weka présents dans la barre des outils.
I.1 Description globale de Weka
Weka (Waikato Environment for Knowledge Analysis) est un environnement de fouille de
données développé par le groupe de recherche "machine learning" du département d’informatique
de l’université de Waikato en Nouvelle-Zélande. Il est utilisé dans le domaine de la recherche, de
l’éducation et de l’industrie. Il est écrit dans le langage Java et testé sur plusieurs plateformes tels
Environnement Weka Page 4 sur 28 26/01/2006
que Linux et Windows. Cet environnement est un logiciel "open source" et est disponible sur le
site du groupe de recherche "machine learning" du département d’informatique de l’université de
Waikato [3].
Weka est une collection d'algorithmes d’apprentissage dont le but est de réaliser des tâches de
fouille de données. Les algorithmes peuvent être appliqués directement à un ensemble de données
ou appelés via un programme Java. Weka contient les outils pour le prétraitement de données, la
classification, la régression, le groupement (clustering), les règles d'association et la visualisation.
En effet, Weka permet d’effectuer un prétraitement sur un ensemble de données, d’appliquer un
algorithme d’apprentissage, et d’analyser les résultats et les performances d’un classificateur. Il
est aussi bien adapté pour intégrer de nouveaux algorithmes d’apprentissage.
La version utilisée dans ce document est la plus récente : la version 3.4.6 (figure 1). Cette
dernière présente de nouvelles fonctionnalités surtout au niveau de l’outil KnowledgeFlow par
rapport à la version 3.4.
Figure 1 Environnement Weka
Environnement Weka Page 5 sur 28 26/01/2006
I.2 Composants de l’environnement Weka
Weka possède plusieurs composants à savoir :
- Explorer : ce module regroupe tous les packages importants de Weka à savoir le
prétraitement, les algorithmes d’apprentissage, le groupement (clustering), les
associations, la sélection des attributs et la visualisation.
- Experimenter : permet d’exécuter plusieurs algorithmes d’apprentissage en mode lot
(batch) et de comparer leurs résultats.
- KnowledgeFlow environment : fournit les mêmes fonctionnalités que le composant
"Explorer". Ces fonctionnalités sont représentées sous forme graphique et sont utilisées
pour construire un schéma de flux de connaissances via une interface drag-and-drop.
I.3 Préparation de l’ensemble des données d’apprentissage et de test
(dataset) Cette opération est requise pour l’utilisation de tout outil de l’environnement Weka et c’est pour
cette raison que l’on a préféré la décrire avant d’entamer la description des outils de Weka.
Généralement, d’après la littérature, les données servant à l’expérimentation dans n’importe quel
domaine sont stockées dans des fichiers Excel et le format des données utilisées par les tâches de
fouille de données est "arff". Avant d’appliquer donc les algorithmes d’apprentissage, ces
données doivent être transformées en un fichier de données avec l’extension "arff" pour être lu
soit par Explorer, Experimenter ou KnowledgeFlow. Les transformations consistent à :
- Sauvegarder le fichier de données d’apprentissage et de test au niveau de l’outil Excel
sous la forme .csv (comma separated value);
- Lire le fichier avec l’extension "csv" dans un éditeur;
- Ajouter en entête du fichier les informations nécessaires au module "Explorer";
o Définition des données d’apprentissage par une relation sous forme de : @relation
nom-des-données-d’apprentissage (Dataset), e.g., @relation iris (figure 2).
Environnement Weka Page 6 sur 28 26/01/2006
o Définition des attributs du dataset avec leur type, e.g., @attribute petalwidth
REAL (figure 2).
o Fermeture de ces ajouts par le mot réservé @data.
- Transformer toutes les virgules par le point et tous les points virgule par la virgule. Ces
deux petites tâches doivent être faites dans l’ordre;
- Sauvegarder le fichier transformé des données sous l’extension "arff".
Voici un exemple de fichier de données sous le format "arff".
Figure 2 Extrait du fichier ".arff" de iris
Une fois les transformations effectuées, le processus de fouille de données est déclenché. Il est
illustré via un exemple utilisant le dataset iris de la collection des données de l’environnement
Weka.
Environnement Weka Page 7 sur 28 26/01/2006
II. Explorer
Cet outil permet à un utilisateur de réaliser certaines étapes du processus de fouille de données à
savoir le prétraitement, l’application d’un algorithme d’apprentissage et l’analyse. Pour ce faire,
Explorer regroupe plusieurs packages tels que les filtres, les classificateurs, les clusters, les règles
d’association, la sélection des attributs et un composant de visualisation. Cet outil permet donc
de réaliser les expérimentations, en utilisant des moyens tels que les classificateurs, les clusters et
les règles d’association, qui nécessitent au préalable un traitement des données. Dans ce
document, on se concentre uniquement sur le prétraitement et l’application d’un algorithme
d’apprentissage (classificateur). Ce prétraitement est présenté et une illustration du
fonctionnement de l’outil Explorer est fournie.
II.1 Phase de prétraitement
Cet outil peut être activé en cliquant sur l’option Explorer de la figure 1. La sélection de cette
option fait apparaître la fenêtre représentée par la figure 3.
Figure 3 Fenêtre Explorer
Environnement Weka Page 8 sur 28 26/01/2006
Dans la fenêtre de prétraitement, nous trouvons :
- Dans la partie supérieure, les trois possibilités d’ouverture d’un fichier de données
d’apprentissage qui sont "Open file", "Open URL" et "Open DB";
- Le choix du filtre en cas de nécessité, d’information sur la relation et l’attribut
sélectionné, d’une partie où tous les attributs sont affichés et une zone de visualisation en
forme d’histogrammes de la distribution de l’attribut sélectionné.
La figure 4 nous montre le contenu de la fenêtre de prétraitement après chargement du fichier de
données de l’expérimentation via l’activation de l’option "Open file".
Figure 4 Chargement de l’ensemble des données
Dans la partie gauche, nous avons dans le premier cadre les informations sur les données de
l’expérimentation chargées qui sont définies par une relation iris, ayant 150 instances et 5
attributs (4 variables indépendantes et la variable dépendante class). Tous les attributs sont
affichés dans le cadre attributs. La sélection de la variable class dans la liste des attributs fait
apparaître dans la partie droite les informations sur cette variable tels que le nom et le type. Avec
Environnement Weka Page 9 sur 28 26/01/2006
la sélection de la variable à visualiser dans la partie droite, un histogramme des valeurs prises est
affiché.
II.2 Application d’un algorithme d’apprentissage Avant d’appliquer un algorithme d’apprentissage sur des données, un certain nombre de choix
doivent être faits :
- choisir l’algorithme d’apprentissage;
- choisir le type de test :
o utiliser l’ensemble d’apprentissage comme ensemble de test,
o fournir l’ensemble de test,
o appliquer la validation croisée avec le choix du nombre de partitions (fold) de
l’ensemble des données (dans nos exemples, on a opté pour ce choix),
o appliquer "percentage split" (partage de l’ensemble de données en un ensemble de
données d’apprentissage et un ensemble de données test) ; le cas par défaut est 2/3
des données pour l’apprentissage et 1/3 des données pour le test.
- sélectionner d’autres options si nécessaire;
- sélectionner la variable à prédire (class pour notre exemple schématisé par les différentes
figures);
- lancer l’exécution de l’algorithme en activant le bouton "start".
La figure suivante montre les résultats obtenus par l’application de l’algorithme J48 (une
implantation de C4.5) sur le dataset iris. Les résultats sont structurés en trois volets : un volet
résultats sommaires, un volet résultats par classes et un volet matrice de confusion. Les résultats
sommaires donnent le nombre total d’instances classifiées correctement et incorrectement, la
valeur de kappa, l’erreur absolue moyenne, l’erreur racine carrée moyenne, l’erreur relative
absolue et l’erreur racine carrée relative. Le choix d’un ou de plusieurs de ces critères dépend de
l’intérêt que leur porte l’utilisateur final. Les résultats par classes nous fournissent le taux
d’instances classifiées correctement et incorrectement via les taux TP (true positif) et FP (false
positif), la précision et d’autres informations statistiques. Quant à la matrice de confusion, cette
table nous donne plus de précision concernant le nombre d’instances correctement et
incorrectement classifiées correspondants aux taux TP et FP pour chaque classe. Les éléments de
la diagonale de la matrice représentent les instances correctement classifiées (exemple : 49
Environnement Weka Page 10 sur 28 26/01/2006
instances pour Iris-setosa) et les autres éléments des colonnes sont les instances faux positifs (1
instance au total pour Iris-setosa). Par contre, la somme des nombres pour chaque ligne donne le
nombre d’instances de chaque classe (50 instances pour Iris-setosa).
Figure 5 Résultats de l’algorithme J48
D’autres possibilités sont offertes en cliquant sur le bouton droit de la souris et en pointant sur le
nom de l’algorithme dans le champ "result list" (partie gauche). La figure 6 présente toutes les
possibilités.
Environnement Weka Page 11 sur 28 26/01/2006
Figure 6 Les possibilités de visualisation
La liste des possibilités est divisée en trois catégories. La première concerne l’affichage des
résultats. L’utilisateur a le choix entre afficher les résultats dans la fenêtre principale, une fenêtre
séparée ou sauvegarder les résultats dans une mémoire tampon. La deuxième catégorie est pour
charger un modèle ou le sauvegarder. La dernière catégorie considère la visualisation des erreurs,
du modèle, et des courbes de marge et de seuil. Ainsi, si on choisit de visualiser l’arbre de
décision dans la dernière catégorie, on obtient l’arbre affiché dans la fenêtre suivante (Figure 7).
Environnement Weka Page 12 sur 28 26/01/2006
Figure 7 Visualisation de l’arbre de décision généré par J48
Une autre possibilité qui est très intéressante est la visualisation des nombres d’instances
correctement et incorrectement classifiées, par classe. Cette possibilité est fournie par l’option
"visualize classifier errors" qui nous permet d’avoir un graphe du nombre d’erreurs par classe en
termes de nombre d’instances correctement classifiées. L’intérêt de cette option réside dans le fait
que l’utilisateur peut déterminer exactement quelles sont les instances qui sont incorrectement
classifiées et par la suite faire les corrections sur la répartition entre classes pour exécuter les
expérimentations ultérieurement.
La figure 8 montre le graphe mettant en relation l’attribut sepallength et le nombre d’instances
par classe. Dans ce schéma, les classes sont distinguées par différentes couleurs; exemple : les
classes Iris-setosa, Iris-versicolor et Iris-virginica sont respectivement associées aux couleurs
bleu foncé, rouge et vert. Les instances modélisées par une croix sont des instances correctement
classifiées et celles modélisées par un carré sont des instances incorrectement classifiées. En
pointant sur un de ces carrés, les informations sur l’instance en question sont affichées. La figure
9 montre les informations d’une instance incorrectement classifiée.
Environnement Weka Page 13 sur 28 26/01/2006
Figure 8 Graphe des erreurs du classificateur
Figure 9 Information sur une instance incorrectement classifiée
Environnement Weka Page 14 sur 28 26/01/2006
III. Experimenter
Experimenter est un outil qui nous permet de créer, d’exécuter et d’analyser des
expérimentations. Une expérimentation est la mise en œuvre d’un test où plusieurs algorithmes
d’apprentissage peuvent être appliqués sur plusieurs datasets en mode lot (batch). Pour remplir
ses fonctionnalités, Experimenter fournit trois mécanismes Setup, Run et Analyse. Ainsi, un
utilisateur de cet outil doit définir tout d’abord les attributs de l’expérimentation (en terme
simple, les données d’entrée). Une fois ces données fournis à Experimenter, l’utilisateur passe à
la phase d’exécution c’est-à-dire la génération de modèles. La dernière phase consiste en
l’analyse des résultats obtenus. Nous allons détailler ces trois composants dans les sections
suivantes.
En résumé, Experimenter traduit les trois phases du processus de l’expérimentation à savoir les
phases d’initialisation, de l’exécution et de l’analyse. De plus, l’utilisateur peut toujours revenir
en arrière pour modifier son expérimentation en changeant soit les paramètres de la phase
d’initialisation ou du test (phase d’analyse). Cette partie sera structurée selon ces trois phases.
En premier, cet outil est lancé en cliquant sur l’option Experimenter dans la fenêtre de démarrage
de l’environnement Weka (figure 1). La figure suivante présente l’outil Experimenter au
lancement.
Environnement Weka Page 15 sur 28 26/01/2006
Figure 10 L’outil Experimenter
III.1 Description globale de la phase d’initialisation des paramètres
d’expérimentation
Comme on le remarque dans la figure 10, la fenêtre de lancement correspond à la première phase.
Pour effectuer une expérimentation, l’utilisateur doit rentrer dans le système toutes les données
demandées; c’est une opération d’initialisation des paramètres de l’expérimentation.
Cette interface est structurée en plusieurs panneaux. Le premier panneau nous permet de
sélectionner le mode de configuration de l’expérimentation soit simple ou avancé, et l’une des
options open, save et new. L’option open est utilisée dans le cas où l’expérimentation existe déjà
et qu’on veut modifier certains paramètres. L’option save est considérée lorsqu’on désire
sauvegarder une nouvelle expérimentation ou les modifications portées à une expérimentation
déjà existante. L’option new est choisie pour créer une nouvelle expérimentation.
En se basant sur notre expérience, on note que les deux modes de configuration simple et avancé
ne présentent pas de différences majeures. Dans nos expérimentations, on va considérer le
Environnement Weka Page 16 sur 28 26/01/2006
premier mode (mode simple) qui est largement suffisant. Le mode avancé nécessite de
l’utilisateur plus de connaissances approfondies sur la nature de l’application, exemple le nom de
l’hôte dans le cas où l’application est distribuée.
Le deuxième panneau permet de choisir le type des données en sortie en .arff, CVS ou JDBC et
de donner un nom au fichier qui contiendra les résultats. Il est suivi de deux panneaux type
d’expérimentation et l’itération de contrôle. Le type de l’expérimentation consiste à choisir la
technique de validation, qui peut être soit une validation croisée ou un split avec tirage aléatoire
(ou non) des données, le nombre de partitions ("number fold") et l’objectif de l’apprentissage qui
est soit une classification ou une régression. Le contrôle des itérations (panneau "iteration
control") sont généralement par défaut 10 et passe en premier par les données (d’apprentissage et
de test). Et en dernier, on a deux panneaux pour sélectionner les datasets qui font l’objet de
l’expérimentation et les algorithmes à appliquer.
Pour mieux illustrer cette phase, on considère une expérimentation qui consiste à appliquer les
algorithmes d’apprentissage J48, Logistic et MultiPerceptron sur deux datasets iris et weather du
répertoire data de l’environnement Weka.
Les étapes suivies lors de la création de cette nouvelle expérimentation sont :
• Le choix donc du mode d’expérimentation simple et puis sélectionner l’option New pour
créer une nouvelle expérimentation.
• Sélectionner le type des données .arff et donner le nom test1 au fichier résultats.
• Sélectionner le type de l’expérimentation qui consiste en une validation croisée avec le
nombre de partitions ("number fold") égal à 10 et en dernier l’objectif qui est une
classification.
• Le contrôle des itérations (panneau "iteration control") est considéré par défaut.
• Sélectionner les datasets iris et weather qui font l’objet de l’expérimentation et les
algorithmes à appliquer J48, Logistic et MultiPerceptron.
Environnement Weka Page 17 sur 28 26/01/2006
• En dernier, sauvegarder les paramètres de l’expérimentation en cliquant sur l’option save
et en donnant le nom exp2 à l’expérimentation.
Ces différentes étapes de la phase d’initialisation sont visualisées dans la figure suivante :
Figure 11 Phase d’initialisation d’une nouvelle expérimentation exp2
III.2 Phase d’exécution
Cette phase consiste à exécuter l’expérimentation qui se traduit par l’application des algorithmes
sélectionnés sur les différents datasets choisis. La fenêtre de l’exécution (Run) est organisée en
trois panneaux (figure 12). Le premier donne la possibilité de lancer ou de stopper une exécution.
Le deuxième panneau affiche la trace de l’exécution ("log"). En dernier, on a un panneau état qui
nous permet de suivre l’évolution de l’exécution de l’expérimentation et donc donne l’état de
l’exécution à un moment donné. La figure suivante nous montre l’état d’exécution de
l’expérimentation à un moment donné.
Environnement Weka Page 18 sur 28 26/01/2006
Figure 12 Exécution d’une expérimentation à un moment donnée
Dans cette figure, on remarque dans le panneau Status que l’exécution est à l’itération 6 dans la
génération du classificateur 3 produit par l’application de l’algorithme d’apprentissage
MultiPerceptron sur le dataset iris. Une fois que tous les classificateurs sont générés et qu’aucune
erreur n’est apparue, le résultat final, qui est la trace de l’exécution, est visualisé dans le panneau
"log". La figure 13 montre le résultat final d’une exécution qui se termine normalement.
Environnement Weka Page 19 sur 28 26/01/2006
Figure 13 Exécution normale d’une expérimentation
Cette phase a donc pour résultat la génération des différents modèles (ou classificateurs) qui vont
faire l’objet d’une analyse dans la phase suivante.
III.3 Phase d’analyse Cette phase est le cœur de cet outil et permet de comparer les différents résultats obtenus par les
classificateurs générés dans la phase précédente. Dans le panneau "Test output", les différents
classificateurs générés à chaque itération sont visualisés en cliquant sur l’option "Experiment"
qui permet de charger les résultats disponibles (figure 14).
Environnement Weka Page 20 sur 28 26/01/2006
Figure 14 Différents classificateurs générés par la phase d’exécution
Cette interface analyse est composée de quatre panneaux :
• Le premier nous permet de spécifier la source des résultats qui peut être soit un fichier
que l’on charge, une base de données sur laquelle on a stocké les résultats ou
"Experiment" qui permet de charger les résultats obtenus lors de l’expérimentation en
cours (dans notre exemple exp2, voir figure 11).
• Le deuxième panneau "configure test" permet à l’utilisateur de choisir les critères de test
de comparaison des différents classificateurs. Nous allons donner un sommaire de ces
critères :
o Row (lignes) : permet de définir les entités à afficher comme lignes, dans le cas de
la figure suivante on a les ensembles datasets iris et weather.
o Column (colonnes) : permet d’indiquer les composants d’une colonne de la
matrice résultats. Dans la figure 15, les composants sont la catégorie des
algorithmes d’apprentissage à laquelle appartient l’algorithme J48 ("trees"), le
nom J48 et les paramètres de ce dernier.
Environnement Weka Page 21 sur 28 26/01/2006
o "Comparaison test" : l’utilisateur peut sélectionner le critère sur lequel se base
l’analyse comme exemple, le pourcentage d’instances correctement classifiées.
o Signification : chaque test est effectué selon la méthode T-test qui permet
d’évaluer la différence des moyennes de deux échantillons [1]. La valeur 0.05,
nommée aussi p-value, est le seuil qui permet de différencier entre deux datasets.
Si p-value <0.05 alors les deux datasets sont significativement différents. Dans le
cas contraire, les deux datasets ne le sont pas [2].
o "Displayed column" : représente les classificateurs que l’on désire visualiser.
o "Show std. Deviations" : il peut être intéressant dans certaines applications de
connaître l’écart-type de chaque modèle généré.
o "Output format" : l’utilisateur peut choisir le format de sortie.
o "Perform test" et "save output" : permettent de lancer le test et de sauvegarder les
résultats de comparaison.
• Un panneau "Test output" est un espace réservé à la visualisation des résultats de
l’analyse.
Figure 15 Résultats de l’analyse de l’expérimentation exp2
Environnement Weka Page 22 sur 28 26/01/2006
IV. KnowledgeFlow environment Weka fournit aussi un outil graphique, nommé KnowledgeFlow environment; une alternative
intéressante à l’outil Explorer. Cet outil dispose de presque tous les services fournis par Explorer
sous forme graphique (figure 16). De plus, il permet d’exécuter des diagrammes de flux de
connaissances en mode lot (batch) ou incrémental. Il est à mentionner que cet outil à sa version
3.4.6 connaît beaucoup d’améliorations par rapport aux versions antérieures. Par exemple dans la
version 3.4, si le fichier ".arff" n’est pas localisé dans le répertoire data de Weka, le fichier ne
peut pas être chargé par le composant "arff loader" de "Datasources". Ce qui n’est pas le cas avec
la version 3.4.6.
IV.1 Structure de KnowledgeFlow environnement Le lancement de cet outil (figure 16) se fait en cliquant sur l’option "knowledgeFlow
environment" présente dans la fenêtre de l’environnement Weka (figure 1).
Figure 16 Environnement KnowledgeFlow
Environnement Weka Page 23 sur 28 26/01/2006
Cet outil est constitué essentiellement, comme on le remarque, de deux zones : une barre de
services et une zone de tracé. La barre est composée à son tour de deux menus, le menu supérieur
est formé par les différentes fonctionnalités tels que les sources de données, les filtres, et les
classificateurs. Le menu inférieur contient tous les composants pour assurer une fonctionnalité,
exemple "Datasources"(figure 16). La zone de tracé est réservée à la construction du diagramme
représentant le processus de fouille de données suivi pour appliquer un classificateur spécifique
sur un dataset donné. Cette construction se fait selon le principe "drag-and-drop".
Les composants graphiques posés verticalement gauche et droite sont utilisés respectivement
pour pouvoir vider la zone de tracé, sauvegarder le diagramme de flux de connaissances et
charger un diagramme de flux de connaissance, faire appel à une aide et arrêter toutes les
exécutions.
IV.2 Comment utiliser cet outil? Nous allons illustrer l’utilisation de l’outil KnowledgeFlow environment à travers un exemple.
Considérons le dataset segment fourni par l’outil Weka et l’algorithme d’apprentissage Logistic.
Pour réaliser le diagramme de flux de connaissances de cet exemple, nous allons passer par
plusieurs étapes :
1- On commence par sélectionner le type de la source de données et format des données en
cliquant respectivement sur "Datasources" et puis "Arff loader" qui est le plus couramment
utilisé (figure 17). Il est à remarquer que d’autres composants "loaders" peuvent être choisis
dépendant du format des données à charger.
Environnement Weka Page 24 sur 28 26/01/2006
Figure 17 Sélection d’une source de données
2- Dans la deuxième étape, nous pouvons éventuellement ajouter un composant pour nous
permettre de visualiser la distribution des données du dataset segment. Pour ce faire, ces deux
composants doivent être connectés (figure 18).
Figure 18 Connexion de deux composants
Environnement Weka Page 25 sur 28 26/01/2006
La visualisation de la distribution des données est donnée par la figure suivante.
Figure 19 Distribution des données du dataset segment
3- En troisième étape, il est nécessaire de sélectionner le type de techniques utilisées par le
classificateur concernant les données à savoir la validation croisée, utilisation d’un dataset
pour l’apprentissage et un autre pour le test, ou la technique "percentage split" où
généralement on utilise 2/3 pour l’apprentissage et 1/3 pour le test.
4- Dans cette étape, il faut spécifier éventuellement le type de prétraitement (filtre) à
appliquer sur les données. Si les données ne subissent pas de prétraitement, il faudra alors
choisir le classificateur à appliquer. Ce dernier peut être configurer selon les besoins (figure
20).
Environnement Weka Page 26 sur 28 26/01/2006
Figure 20 Configuration des paramètres d’un classificateur
5- La dernière étape consiste à ajouter un ou plusieurs composants afin de visualiser les
performances du modèle généré. Dans notre cas, on a sélectionné deux composants
classifier_PerformanceEvaluator et TextViewer. Après, on lance le processus de génération
du modèle qui consiste en l’exécution du diagramme du flux de données conçu, c’est-à-dire,
le chargement des données, la validation croisée et l’application de l’algorithme J48 (figure
21) en cliquant sur l’option "start loading".
Environnement Weka Page 27 sur 28 26/01/2006
Figure 21 Diagramme de notre application
6- Une fois ces différentes étapes accomplies, nous pouvons visualiser les résultats du
modèle généré en sélectionnant l’option "show results" de TextWiewer (figure 22).
Figure 22 Résultats d’exécution du diagramme conçu
Environnement Weka Page 28 sur 28 26/01/2006
V. Conclusion L’environnement Weka est un environnement de fouille de données, "open source" et complet,
offrant une multitude de services à travers ces trois composants Explorer, Experimenter et
knowledgeFlow. Ces services permettent à un utilisateur de réaliser des expérimentations en
passant communément par un certain nombre de phases : prétraitement, application d’un
algorithme d’apprentissage et l’analyse indépendamment de l’outil utilisé Explorer, Experimenter
ou KnowledgeFlow. Ces outils présentent différentes facettes intéressantes de l’environnement
Weka. Explorer, qui le plus complet et le plus utilisé, permet de définir une expérimentation,
d’appliquer des filtres et des algorithmes, d’analyser et de visualiser différents résultats sous le
format la plus complète. Experimenter permet par contre de réaliser plusieurs expérimentations
en même temps et une comparaison entre les différents classificateurs générés à partir de
différents datasets. KnowledgeFlow est une interface purement graphique, très ergonomique et
fournit à un utilisateur un ensemble de composants graphiques pouvant être connectés ensemble
pour monter un schéma de flux de connaissances. Tous ces outils se caractérise par leur facilité
d’utilisation en dépit du manque de documentation.
VI. Références [1] StatSoft, Inc. (2004). Electronic Statistics Textbook. Tulsa, OK: StatSoft. Site
http://www.statsoft.com/textbook/stathome.html)
[2] Masse, D. Some background on t-tests & which test to use. Site
http://users.wfu.edu/massd2/T_test.htm
[3] Witten, I.H., Frank, E. (2000). Data Mining: Practical Machine Learning Tools and
Techniques with Java Implementation. Morgan Kaufmann Publishers, San Francisco, California,
2000.
[4] Yazid, H. (2005). Élaboration de modèles d’estimation de qualité du logiciel et intelligence
artificielle. Thèse de maîtrise en génie logiciel, École de technologie supérieure, Août 2005.
