Stage-le Anh Tuan

8/18/2019 Stage-le Anh Tuan

1/59

INSTITUT DE LA FRANCOPHONIE POUR L’INFORMATIQUE

RAPPORT DU STAGE

REDUCTION DE BASE DE DONNEES PAR LACLASSIFICATION AUTOMATIQUE

Sous la direction de

Pr. Georges HEBRAIL, ENST Paris

Réalisé par

LE Anh Tuan, IFI Hanoi

Décembre 2004


2/59

1

Remerciements

Je tiens à remercier mon encadrant du stage, Monsieur Georges Hébrail, le

professeur du département Informatique et Réseaux (INFRES), ENST Paris, pour sa

disponibilité, son soutient et son aide précieuse pendant toute la durée du stage.

Je voudrais également remercier chaleureusement Madame Sophie Bizart, le

secrétaire du département INFRES de m’avoir accueilli et son aide pendant le stage.

Un grand merci à l’IFI d’avoir bien préparé mon stage.

J’ai le plaisir de remercier tous les stagiaires au département INFRES, ENST

qui m’ont porté leur amitié.

J’exprime mon entière reconnaissance à ma famille et mes amis pour leurs

soutiens, leurs aides et leurs encouragements.


3/59

2

Table de matières

Résumé ..................................................................................................................... 4

Abstract..................................................................................................................... 4

Chapitre 1. Introduction............................................................................................. 5

Chapitre 2. Etat de l’art.............................................................................................. 7

1. Classification de données............................................................................... 7

2. Types de données et les mesures........................................................................ 8

1) Classification basée sur la taille de domaine :............................................. 8

2) Classification basée sur l’échelle de mesure : ............................................. 8

3. Méthodes de classification................................................................................11

1) Méthodes hiérarchiques (hierarchical clustering).......................................11

i. CURE ...................................................................................................13

2) Méthodes de partitionnement (partitional clustering):................................14

i. K-medoids ............................................................................................14

ii. K-means................................................................................................15

3) Méthodes basées sur la densité..................................................................18

i. DBSCAN..............................................................................................19ii. DENCLUE............................................................................................20

4) Méthodes basées sur la grille.....................................................................21

i. STING ..................................................................................................21

ii. WaveCluster .........................................................................................22

iii. CLIQUE...............................................................................................22

5) Algorithmes pour des données de haute dimension....................................23

i. Sélection d’attributs ..............................................................................23

ii. Réduction de dimensionnalité................................................................23

iii. Classification dans sous-espaces ...........................................................24

iv. Co-classification ...................................................................................25

6) Algorithmes pour les données qualitatives (catégorie)...............................25

i. ROCK...................................................................................................26ii. STIRR...................................................................................................26

iii. CACTUS..............................................................................................27

Chapitre 4. Classification sur le flux de données.......................................................29

1. Classification sur le flux de données .................... .........................................29

i. STREAM-LOCALSEARCH.................................................................30

ii. GenIc....................................................................................................31

2. Algorithmes BIRCH et CLUSTREAM .......... ...............................................32

1) BIRCH......................................................................................................32

i. Arbre des CFs .......................................................................................32

ii. Algorithme............................................................................................33

iii. Cluster Feature et la distance dans BIRCH............................................38

2) CLUSTREAM..........................................................................................42i. Maintenance en ligne des micros classes ...............................................43

ii. Création des macros classes ..................................................................44

iii. Analyse d’évolution des classes ................... .........................................45

Chapitre 3. Implémentation et expérimentation.........................................................46

1. Implémentation du BIRCH ...........................................................................46

2. Expérimentation du BIRCH..........................................................................51

Chapitre 4. Conclusion et perspectives .....................................................................52

Annexe 1. Sommaire des algorithmes de classification .............................................53


4/59

3

Annexe 2. Liste des figures.......................................................................................55

Références................................................................................................................56


5/59

4

Résumé

Aujourd’hui, il y a plus en plus des applications dont la base de données est

très grosse et les données apparaissent sous la forme d’un flux de données infini

comme des enregistrements de coup de téléphone, la surveillance de réseaux... Pource type de données, les systèmes de gestion de base de données (SGBDs) traditionnels

semblent ne pas convenables parce que ils ne traitent que des données à taille limitée.

Pour exploiter efficacement des données massives en utilisant un espace de stockage

limité, il faut trouver un traitement spécial qui réduit les données afin d’obtenir des

informations nécessaires appelées des résumés à partir de ces données. Il y a certaines

méthodes pour ce fait : échantillonnage, compression et classification. Parmi eux, la

classification est la solution la plus convenable.

Dans ce rapport, nous parlons des algorithmes de classification en général et

particulièrement de ceux qui sont pour le flux de données. Après avoir découvert

plusieurs algorithmes de classification, nous avons trouvé que l’algorithme BIRCH est

une solution de réduction de données très bonnes et le modèle CLUSTREAM permetde traiter efficacement les données sur un flux de données. Nous avons également

implémenté l’algorithme BIRCH pour tester sa performance.

Abstract

Today, there is more and more applications whose database is very large and

the data appear in the form of an infinite data stream like records of telephone call, the

monitoring of networks... For this type of data, the traditional database management

systems (DBMS) seem not suitable because they treat only data with limited size. To

exploit effectively massive data by using a space of limited storage, it is necessary to

find a special processing which reduces the data in order to obtain necessary

information called the summaries from these data. There are certain methods for this:

sampling, compression and clustering. Among them, clustering is the most suitable

solution.

In this report, we talk about the general clustering algorithms and particularly

about those which are for the data flow. After having studied several clustering

algorithms, we found that BIRCH algorithm is a very good data reduction solution

and the CLUSTREAM is a model which allows to effectively treating the data stream.

We also implemented algorithm BIRCH to test its performance.


6/59

5

Chapitre 1. Introduction

Aujourd’hui, il y a plusieurs applications qui ont besoin d’un autre modèle de

stockage des données que le modèle des SGBD (Système de Gestion de Base deDonnées) traditionnel. Un modèle de SGBD traditionnel stocke des jeux de données

finis et persistants, donc il n’est approprié qu’aux applications dont le volume de

données n’est pas gigantesque, dont des parties significatives de données sont souvent

requises et dont les mises à jour sont relativement peu fréquentes. On peut trouver de

telles nouvelles applications dans les télécommunications, la surveillance des réseaux,

les affaires, les marchés financiers, les flux de clics sur les pages web…Dans ces

applications, les données arrivent sous la forme d’un flux de données, i.e. un gros

volume de données qui arrive continuellement. Les données ne sont accessibles que

par ordre d’arrivée, les accès aléatoires ne sont pas permis. La mémoire réservée aux

données est relativement plus petite que le volume total du flux de données, donc il

n’y a qu’une petite quantité de données qui peut être gardée. Dans les

télécommunications, par exemple, les enregistrements d’appel sont continuellement

générés. Typiquement, la plupart de traitements sont faits en examinant un

enregistrement une seule fois. Après, il ne sera plus examiné.

Il existe des méthodes pour réaliser un compromis entre un gros volume de

données qui arrivent et un espace de stockage et petit. On peut échantillonner les

données qui arrivent et utiliser les échantillons obtenus dans les opérations de

l’application. Cette méthode perd beaucoup d’informations concernant le jeu entier de

données. Une autre méthode est de compresser les données et d’utiliser les données

compressées au lieu des données originales. Dans ce cas, les données compressées ne

peuvent pas être efficacement interprétées et directement utilisées sans être

décompressées. La classification automatique est aussi une technique de compression(réduction) de données mais les données sont bien compressées en sens que le jeu de

données peut être bien interprété en n’utilisant que les données compressées.

La classification automatique des données consiste à diviser un jeu de données

en sous-ensembles de données appelés classes pour que tous les individus dans même

une classe soient similaires et les individus de classes distinctes soient dissimilaires.

Typiquement, chaque classe est représentée par un individu qui s’appelle le centre de

la classe ou par certaines informations dérivées de tous les individus de la classe qui

sont suffisantes de décrire la classe.

Il y a plusieurs algorithmes de classification des données. Ils diffèrent par la

nature de données qu’ils traitent (données numériques ou données de catégorie, petit jeu de données ou gros jeu de données, données de dimension élevée ou moins élevée,

sur un flux de données ou pas…), par les méthodes de distribution des données en

classes, par la représentation des classes…

Ce stage de fin d’étude a eu lieu à l’Ecole Nationale Supérieure des

Télécommunications de Paris, France. J’ai travaillé sous la direction du professeur

Georges HEBRAIL. Mon travail dans ce stage est de découvrir tout d’abord le

domaine de classification de données en général. Ce travail consiste à faire


7/59

6

connaissance le concept de classification des données, les problèmes concernant du

domaine, une classification des algorithmes de classification différents afin de trouver

que l’algorithme BIRCH et le modèle CLUSTREAM est une bonne solution pour le

problème de classification sur le flux de données. Nous avons également implémenté

l’algorithme BIRCH et fait des expérimentations pour évaluer sa performance. Une

simulation simple de classification sur un flux de données est également réalisée en se

basant sur cet algorithme.

Ce rapport est organisé comme suivant : Le chapitre 2 décrit le problème de

classification de données en général et de différents algorithmes de classification. Le

chapitre 3 parle de l’algorithme BIRCH et CLUSTREAM. Le chapitre 4 décrit notre

implémentation et expérimentation de l’algorithme BIRCH. Le chapitre 5 est une

conclusion avec quelques perspectives.


8/59

7

Chapitre 2. Etat de l’art

1.

Classification de données

La classification est une méthode qui a pour but de grouper les individus d’une

population en des classes disjointes telles que dans une même classe, les membres

sont similaires et dans les classes différentes, les individus sont dissimilaires.

Il faut distinguer la classification (la classification non supervisée) avec le

classement (la classification supervisée) [1][3] :

- Classification supervisée: Etant donné un ensemble des classes déjà identifiéeset un individu, il s’agit de trouver la meilleure classe à laquelle cet individu

appartient.

- Classification non supervisée : Etant donné un ensemble des individus, ils’agit de structurer des classes pas encore identifiées qui groupent ces individus.

Nous nous intéressons à la classification non supervisée dans la fouille de

données dans laquelle les exigences principales sont la capacité de traitement d’un

gros jeu de données et la capacité de traitement des différents types de données.

Le processus de classification comprend les étapes suivantes [2] [3] : (1)

représentation des individus, (2) définition d’une mesure de similarité appropriée aux

données, (3) classification, (4) abstraction des données, (5) validation du résultat.

La représentation des individus (patterns) a pour but de déterminer les

informations concernant les données : le nombre de classes désiré, le nombre

d’individus disponibles, le nombre, le type et l’échelle des attributs de données. Ces

informations sont utilisées dans l’algorithme de classification. La proximité desindividus est souvent mesurée par une fonction de distance entre chaque pair

d’individus. De nombreuses mesures de proximité sont proposées, se basant sur la

nature de données. La classification est une phase de groupement des individus dans

les classes. Plusieurs algorithmes de classification sont proposés. La différence entre

eux est la manière dont ils groupent les individus telles que la méthode hiérarchique,

la méthode de partition…, le type de données qu’ils traitent comme des données

numériques, de catégorie, le flux de données…, la mesure de proximité des individus

et des classes qu’ils utilisent, telles que la distance euclidienne, la distance de

Minkowski, le lien simple ou le lien complet…ou le critère selon lequel on construit

des classes. L’abstraction des données est un processus d’extraction d’une

représentation simple et compacte pour un jeu de données. Typiquement, une

abstraction des données est une description compacte de chaque classe, souvent enterme de prototypes des classes ou d’individus représentatifs des classes comme le

centre des classes. La validation du résultat vise à déterminer si les classes fournies

sont significatives en utilisant un critère spécifique d’optimalité. Cependant, un tel

critère est souvent subjectif, donc il y a peu de manières standard pour valider la

classification sauf dans certains domaines bien décrits à priori.


9/59

8

La classification est utile dans une variété de domaines comme :

reconnaissance des formes, apprentissage, fouille de données, recherche de

documents, segmentation d’images…

2. Types de données et les mesures

Dans la classification, le type d’objets traités est divers (des personnes, desavis, des entités…). Ces objets doivent être soigneusement présentés en termes de

leurs caractéristiques. Ces caractéristiques sont les variables principales du problème

et leur choix influence considérablement sur les résultats d'un algorithme de

classification. Nous présentons une classification basée sur deux caractéristiques : la

taille de domaine et l’échelle de mesure [1][24].

1)

Classification basée sur la taille de domaine :Cette classification distingue des objets sur une variable en se basant sur la

taille de leur domaine, i.e. le nombre de valeurs distinctes de la variable.

- Un attribut est continu si son domaine n’est pas compté et infini, i.e. seséléments ne peuvent pas être mis dans une bijection avec l'ensemble de nombresentiers positifs. Cela signifie qu’entre deux valeurs quelconques de l'attribut, il existe

un nombre infini de valeurs.

- Un attribut est discret si son domaine est un ensemble fini, i.e. un ensembledont les éléments peuvent être mis dans une bijection avec un sous-ensemble fini des

nombres entiers positifs.

- Un attribut est binaire s’il est un attribut dont le domaine contient exactement2 valeurs.

2) Classification basée sur l’échelle de mesure :Cette classification distingue des attributs selon leur échelle de mesure.

Supposons que ),...,( 1 k x x x = , ),...,( 1 k y y y = et ),...,( 1 k z z z = sont des objets dans un

jeu de données D en k dimensions, xi, yi, zi sont des attributs, i = 1,…, k.

- Une échelle nominale distingue les catégories. Cela signifie que nous pouvons

seulement dire si ii y x = ou ii y x ≠ . Les valeurs ne peuvent pas être totalement

ordonnées. Elles sont simplement une généralisation des attributs binaires, avec un

domaine à plus de deux valeurs discrètes.

- Une échelle ordinale implique des attributs d’échelle nominale utilisant undispositif additionnel pour que leurs valeurs soient totalement mises en ordre, mais les

différences entre les valeurs ne peuvent pas être quantifiées. Par conséquent, au lieu

de dire ii y x = ou ii y x ≠ on peut dire ii y x < ou ii y x > .

- Une échelle d'intervalle mesure des valeurs dans l’échelle linéaire. Avecl’échelle d'intervalle nous pouvons dire non seulement si une valeur se trouve avant

ou après une autre, mais aussi à quelle distance avant ou après. Puisque des valeurs

sont mises sur une échelle linéaire, si ii y x > alors nous pouvons également indiquer

que x est différent deii

y x − unités de y pour l’attribut i.

- Une échelle de rapport est une échelle d'intervalle avec un point nulsignificatif.


10/59

9

Des attributs d’échelle nominale et ordinale s’appellent des attributs qualitatifs

(ou catégoriques), alors que l’échelle d'intervalle et de rapport s’appelle des attributs

quantitatifs.

Il est évident que des attributs quantitatifs sont mesurés en utilisant les unités

spécifiques, telles que des kilogrammes et des centimètres. Les unités de mesure

affectent les résultats d'analyse des classes, puisque, par exemple, les unitéschangeantes de mesure des kilogrammes à livres pour le poids, peuvent mener à un

résultat différent. Le remède à ce problème s'appelle la standardisation.

Etant donné un attribut i, k i ≤≤1 et n objets x1, x2, …, xn. Il s’agit de deux

phases dans la standardisation :

- Trouver la déviation absolue moyenne si de i, pour tous les objets :

( )ii

n

iiiii m xm xm xn

s −++−+−= ...1 21

, tels que xi1, xi

2, …, xi

n sont n

valeurs de l’attribut i dans n objets, et m i est la moyenne de l’attribut i.

- Déterminer la mesure standardisée :i

ii

j

ji s

m x z −

= , ni ≤≤1

Une fois que les caractéristiques des données ont été déterminées, nous

sommes confrontés au problème de trouver des moyens appropriés de décider à quelle

distance un objet se trouve de l’autre. Les calculs de proximité sont des mesures de la

ressemblance ou de l’association entre les paires d'objets de données. Un calcul de

proximité peut mesurer la similarité ou la dissimilarité : plus deux objets se

ressemblent, plus leur similarité est grande et plus leur dissimilarité est petite. La

dissimilarité peut être mesurée de différentes manières, l’une est la distance. Quant à

elle, la distance peut également être mesurée de plusieurs façons. Chaque mesure de

distance est dépendante des caractéristiques des données qu’on traite.

Les métriques sont les mesures de distance les plus importantes. Une métriquedoit satisfaire 4 conditions : non négative, définitive (la distance entre un objet et soi-

même doit être à zéro), symétrique et l’inéquation triangulaire. En conséquence, une

métrique est toujours une mesure mais l’inverse n’est pas toujours vrai.

Nous présentons une description brève de mesures pour chaque type d’attribut

de données :

- Attributs d’échelle d’intervalle: Après la standardisation, la dissimilaritéentre deux objets x et y peut être calculé par les métriques suivantes :

+ Distance de Minkowski :

qn

i

q

ii y x y xd

1

1),(

−= ∑=

+ Distance euclidienne : ( )

−= ∑

=

n

i

ii y x y xd 1

2),( (Minkowski, q = 2).

+ Distance de Manhattan : ∑=

−=

n

i

ii y x y xd 1

),( (Minkowski, q = 1).

+ Distance maximum: iiin y x y xd −= =1max),( . (Minkowski, ∞→ p ).


11/59

10

En cas où les attributs sont assignés à des poids, il faut transformer les

formules de distance en formules pondérées, e.g.: ∑=

−=k

i

iii y xw y xd

1

2)(),( , tel que

wi est le poids pour l’attribut i, i=1,…, k.

+ Distance de Mahanalobis :T

y x y x y xd ∑−

−−=1

)()(),( , tel que ∑ est unematrice de covariance d’échantillon ou une matrice de covariance connue du

processus de génération d’individus.

- Attributs binaires : Supposons que les attributs de 2 objets x et y n’aient queles valeurs 1 et 0.

+ Simple Matching Coefficient :τ

δ α +=),( y xd (x et y sont symétriques)

+ Jaccard Coefficient :γ β α

α

++=),( y xd (x et y sont asymétriques)

Tels que α est le nombre de valeurs d’attribut qui sont égales à 1 dans tous les deux

objets, β est le nombre de valeurs d’attribut qui sont égales à 1 dans x mais 0 dans y,γ est le nombre de valeurs d’attribut qui sont égales à 0 dans x mais 1 dans y, δ est le

nombre de valeurs d’attribut qui sont égales à 0 dans tous les deux objets,

δ γ β α τ +++=

- Attributs d’échelle nominale : p

m p y xd

−=),( , tels que m est le nombre

d’attributs dont la valeur est pareille dans tous les deux objets, p est le nombre total

d’attributs.

- Attributs d’échelle ordinale :

Ce type d’attributs peut être traité comme celui d’intervalle mais il a besoin

d’être converti en une forme convenable.

Supposons que i est un attribut d’échelle ordinale dont le domaine contient Mi

valeurs. Ces valeurs sont mises en ordre [1…M i], donc on peut remplacer chaque

valeur par son rang correspondant { }ii M r ,...,1∈ . Chaque attribut ordinal pourrait avoirune taille différente de domaine, donc il est souvent nécessaire de convertir chaque

valeur en une valeur se trouvant dans l’intervalle [0.0, 1.1] en utilisant la formule

suivante :1

1

−

−=

i

j

ii

j

M

r z

Après la transformation, on peut calculer la dissimilarité entre les objets par

les mesures des attributs d’intervalle en appliquant ces mesures sur les zi j.

- Attributs d’échelle de rapport :Il y a plusieurs méthodes pour calculer la dissimilarité entre ces attributs. Une

solution est d’appliquer une formule logarithmique sur chaque attribut. Le résultat

peut être traité comme un attribut d’intervalle. L’utilisation d’une transformation

dépend de la définition des attributs et de l’application.


12/59

11

- Attributs mélangés :

∑

∑

=

==

k

f

f

xy

k

f

f

xy

f

xy d

y xd

1

1),(

δ

δ

, tels que x et y sont des objets de

k attributs mélangés, f

xyδ signifie le degré de dissimilarité entre x et y à l’attribut f et f

xyd est la contribution de l’attribut f à la dissimilarité entre x et y.

3. Méthodes de classification

De nombreux algorithmes ont été inventés dans le domaine. Ils se diffèrent

grâce aux facteurs : le type d’attributs de données qu’ils traitent (numériques, de

catégorie, taxonomiques…) donc la structure de données utilisée est différente, la

capacité de traiter un gros jeu de données, la capacité de traiter des données en haute

dimension, la capacité de traiter des observations aberrantes, la complexité de

l’algorithme (temps de calcul), la dépendance de l’ordre des données qui arrivent, la

dépendance des paramètres prédéfinis par utilisateurs ou la connaissance a priori surles données…

Selon ces critères et leurs combinaisons, il y a plusieurs types d’algorithmes de

classification. Traditionnellement et souvent, les méthodes de classification sont

divisées en 2 catégories principales : Méthodes hiérarchiques et méthodes departitionnement selon la manière dont on construit les classes. Tandis que lespremières établissent graduellement les classes, les dernières apprennent directementles classes. C'est-à-dire qu’elles les découvrent en faisant bouger des points entre les

classes.

Ensuite, les algorithmes se diffèrent grâce aux autres critères comme le

nombre de passes d’accès aux données, le nombre de dimensions, le type de donnéestraitées, la forme des classes… Ces algorithmes sont soit hiérarchiques, soit de type

partitionnement, soit une combinaison de ces deux types, et ils utilisent différents

mécanismes d’organisation des données, de recherche, de construction des classes …

Faire une classification pour tous les critères n’est pas facile, donc ici nous ne faisons

qu’une distinction entre les 2 types fondamentaux et nous décrirons certaines familles

d’algorithmes qui jouent un rôle important dans la communauté de classification. Ce

sont [1] [2] [3] : Méthodes hiérarchiques, méthodes de partitionnement, méthodesbasant sur la grille, méthodes basant sur la densité, algorithmes pour les donnéesqualitatives (catégorie), algorithmes pour les données en haute dimension etalgorithmes pour le flux de données.

1)

Méthodes hiérarchiques (hierarchical clustering)Ces méthodes construisent les classes graduellement sous une forme

hiérarchique, autrement dit, un arbre des classes qui est appelé un dendrogramme.

Elles sont divisées en 2 sous-types : Agglomération (ascendant) et division(descendant).

- Agglomération : On commence en considérant chaque point comme uneclasse et on essaye de fusionner deux ou plusieurs classes appropriées (selon une


13/59

12

similarité) pour former une nouvelle classe. Le processus est itéré jusqu’à ce que tous

les points se trouvent dans une même classe ou bien jusqu’à ce qu’on l’arrête.

- Division : En considérant tous les points comme une seule classe au début, ondivise successivement les classes en classes plus raffinées. Le processus marche

jusqu’à ce que chaque classe contienne un seul point ou bien si l’on atteint un nombre

de classes désiré.

Les méthodes hiérarchiques ont les avantages: La flexibilité pour le niveau de

granularité (on peut atteindre une classe la plus fine ou la plus épaisse comme

souhait), la capacité de traiter n’importe quelle mesure de similarité ou distance et

l’application sur n’importe quel type d’attributs. A côté, elles ont les inconvénients :

la critère de terminaison est souvent vague et le besoin de multi accès aux données.

La plupart des méthodes hiérarchiques utilisent le lien simple (single-link),

lien complet (complete-link) ou le lien moyen pour mesurer la similarité entre les

classes [1] [3]:

- Dans le lien simple, la distance entre 2 classes est la valeur minimum desdistances entre toutes les paires d’individus, l’un de la première classe, l’autre de la

deuxième.- Dans le lien complet, la distance entre 2 classes est la valeur maximum desdistances entre toutes les paires d’individus

- Dans le lien moyen, la distance entre 2 classes est la valeur moyenne desdistances entre toutes les paires d’individus, l’un de la première classe, l’autre de la

deuxième.

Figure 1: Classification de lien simple (gauche) et complet (droite) d’objets contenant

2 classes 1 et 2 avec le brut *.

L'algorithme de lien complet produit des classes étroitement liées ou

compactes. En revanche, l'algorithme de lien simple souffre d'un effet

d'enchaînement. Il a une tendance de produire des classes qui sont prolongées (Voir

la figure ci-dessus). Cependant l'algorithme de lien simple est plus souple que

l'algorithme de lien complet. D’un point de vue pragmatique, on a observé que

l'algorithme de lien complet produit des hiérarchies plus utiles dans beaucoupd'applications que l'algorithme de lien simple [3].

Il y a de nombreux algorithmes qui sont proposés. Les algorithmes

hiérarchiques les plus connus sont CURE, COBWEB, CACTUS, BIRCH. Nousdécrirons COBWEB et CACTUS dans la section algorithmes pour les donnéesqualitatives, et BIRCH dans une section propre.


14/59

13

i. CURECURE (Clustering Using REpresentatives) a été proposé par Guha, Rastagi et

Sim [20]. Il est une approche hybride : utiliser tous les points de données et ainsi un

un centroid pour former les classes) : Il représente une classe par un nombre constant

de points de représentation appelés les représentants. Pour obtenir ces points, tout

d’abord, on choisit les points qui s’éparpillent bien autour d’une classe. Ensuite on les

fait rétrécir vers le centroid de la classe par une fraction quelconque. Ces pointséparpillés après le rétrécissement seront utilisés comme les représentants de la classe.

Les représentants visent à capturer la forme et l’ampleur de la classe. Le

rétrécissement des points éparpillés vers le mean de la classe par un facteur a pour but

de débarrasser les surfaces anormales et diminuer les effets des points aberrants.

L’idée est basée sur le fait que les aberrants se trouvent normalement loin du centre de

la classe. En conséquence, le rétrécissement pourrait fait déplacer les aberrants plus

vers le centre tandis que les représentants sont moins déplacés. Le grand déplacement

des aberrants peut réduire de mauvaises fusions des classes.

La distance entre deux classes utilisée dans le processus d’agglomération n’est

ni le lien simple ni lien moyen. Seuls les points de représentants sont utilisés pour la

calculer. La distance est définie comme le minimum de distances entre deux

représentants de deux classes.

CURE est conçu pour traiter de gros jeux de données. Pour ce faire, on divise

l’algorithme en 2 passes. Dans la première, l’algorithme utilise des échantillonnages

aléatoires qui sont retirés du jeu de données et classifié pour former des partitions

partielles. Après, ces partitions partielles sont classifiées pendant la deuxième passe

pour former les classes désirées.

Pour chaque classe, on stocke son mean, un ensemble de représentants pour le

calcul de la distance entre elle et une autre classe et la classe la plus proche d’elle.

L’algorithme commence en considérant chaque point d’entrée comme une

classe et successivement fusionne chaque paire de classes les plus proches.

Initialement, les représentants d’une classe sont les points dans la classe. Chaque

classe est fusionnée avec sa classe la plus proche en faisant simplement une union des

points de deux classes. Dans la nouvelle classe, les représentants sont calculés en tout

d’abord choisissant par itérations les points bien éparpillés et après en les rétrécissant

vers le centre de la classe. Dans la première itération, le point le plus loin du centre

dans la classe est choisi comme le premier point éparpillé. Dans chaque itération

suivante, le point le plus loin des points éparpillés précédents est choisi. Après avoir

choisi les points bien éparpillés, les représentants sont obtenus par rétrécissement de

ces points par une fraction vers le centre de la classe.

L’algorithme utilise un arbre kd (kd-tree) où sont stockés les points

représentants des classes qui sont pris pour calculer la classe la plus proche d’une

classe. La complexité de temps du pire cas est O (n2log n). Si la dimension des

données est petite, la complexité de temps peut être réduite à O (n2) [20]. La

complexité d’espace est O (n).


15/59

14

2) Méthodes de partitionnement (partitional clustering):

Ces méthodes produisent une seule partition des données au lieu d’une

structure des classes. Elles créent les classes en optimisant une fonction objective qui

est définie d’une façon locale (sur un sous-ensemble des données) ou globale (sur

toutes les données) [3]. Le coût de construction des classes est cher, donc des

heuristiques sont utilisées pour l’optimisation d’itérations sous la forme de mécanismede réallocation qui réaffectent les points entre les classes. Ces méthodes raffinent

graduellement les classes et donc peuvent donner les classes de meilleure qualité. En

fait, les algorithmes ont besoin d’exécuter plusieurs fois avec différents états initiaux

afin d’obtenir un meilleur résultat.

Une approche est d’utiliser un point de vue conceptuel pour identifier les

classes en supposant que les données viennent d’un mélange de certaines populations

Une autre approche travaille avec une fonction objective définie sur chaque

classe. Dépendant de la représentation d’une classe, on classifie ces types

d’algorithmes en deux : k-medoids et k-means.

i. K-medoidsDans ces algorithmes, une classe est représentée par un de ses points, qui

s’appelle medoid. Une telle représentation nous donne deux avantages : elle s’adapte à

n’importe quel type d’attributs, et le médoid est choisi comme une fraction des points

prédominants dans une classe, donc il n’est pas sensible aux aberrants. Si les médoids

sont choisis, les classes sont définies comme les sous-ensembles de points proches du

médoid correspondant. Et la fonction objective sera définie comme la distance (ou

d’autres mesures de dissimilarité) moyenne entre un point et le medoid.

Les algorithmes les plus connus sont PAM, CLARA et CLARANS [1] [2] [10]

[11]

- PAM (Partitioning around Medoids) a été développé par Kaufman andRousseeuw [12]. PAM recherche les medoids des classes. Initialement, PAM choisit k

points représentatifs à partir des données de N points (k est le nombre de classes, N

est le nombre total de points). Ensuite, N-k points restants sont classifiés en se basant

sur leur distance aux medoids : chaque point restant appartient à une classe si la

distance entre ce point et le medoid de cette classe est la plus petite. Puis, PAM

échange 2 points : l’un de l’ensemble de medoids, et l’autre de l’ensemble de non-

medoids. Le critère de la sélection est que la somme de distance de tous les points à

leur medoid correspondant doit diminuer et avoir la décroissance la plus forte. PAM

calcule le changement de la distance après un échange pour toutes les paires (medoid

et non-medoid). Il choisira le pair dont la valeur de changement est la plus petite(cette valeur est toujours négative). S’il n’y a plus de paires dont le changement est

négatif, cela signifie que la classe courante est bonne, donc que PAM s’arrête et

renvoie k medoids. Les classes seront formées en calculant les distances entre les

points et ces medoids.

La complexité d’une seule itération (un échange) de PAM est O (k (N-k) 2

).

Donc le coût total de calcul est vraiment cher car il a de plus besoin de nombreuses

itérations avant de terminer.


16/59

15

- CLARA (Clustering LARge Applications) est aussi développé par Kaufmanet Rousseeuw [12]. L’amélioration de CLARAN par rapport de PAM est qu’il ne se

base pas sur l’ensemble entier de points, il travaille sur les échantillons des points. On

prend une petite partie de données pour les représenter et k medoids sont déterminés

en appliquant PAM sur cet échantillon. Si cet échantillon est choisi d’une manière

aléatoire, alors il représente bien les données entières, donc les medoids sontsimilaires à ceux qui sont créés à partir des données tout entières. L’algorithme est

exécuté sur plusieurs échantillons pour obtenir le meilleur résultat. En conséquence,

CLARA peut traiter un plus gros jeu de données que PAM. La complexité d’une

itération est O (kS2+k (n-k)) avec S est la taille d’un échantillon. Les auteurs ont

indiqué, suite à leurs expérimentations, que la taille d’un échantillon de 40+2k donne

un bon résultat. Un inconvénient de cet algorithme est qu’un point qui serait le

meilleur medoid n’apparaît dans aucun échantillon, alors CLARA ne trouvera jamais

le meilleur résultat.

- CLARANS (Clustering Large Applications based on RANdomized Search)est une combinaison de PAM et CLARA. Il a été développé par Raymon Ng et Jiawei

Han [12]. Dans cet algorithme, les auteurs ont utilisé une abstraction de graphe pourreprésenter le problème de recherche des k meilleurs medoids. On construit un graphe

dont chaque nœud est un ensemble de k points (intuitivement, ce sont k medoids).

Deux nœuds sont dits voisinages s’ils ne diffèrent que par un seul point. En

conséquence, le problème de déterminer un ensemble de k meilleurs medoids devient

le problème de recherche dans ce graphe du meilleur nœud. Le critère pour estimer

qu’un nœud est meilleur qu’un autre est comme dans le PAM : on minimise le

changement dans la distance si un medoid est remplacé par un point non medoid en

parcourant d’un nœud à un nœud voisin. Ce changement est appelé le coût différentiel

de remplacement d’un medoid par un point non medoid. PAM le fait en parcourant

tous les nœuds voisins d’un nœud donc c’est trop cher. CLARAN le fait en parcourant

un sous graphe. En conséquence, cela ne donne pas toujours un bon résultat car il

travaille sur une région localisée. CLARANS est une combinaison des deux

algorithmes. C’est à dire à partir d’un nœud dans le graphe, il n’examine pas tous les

voisinages. Il choisit un nombre (donné comme un paramètre de l’algorithme) de

voisins aléatoires (ce n’est pas tous les voisins) pour rechercher un voisin dont le coût

de remplacement de ce nœud par son voisin est minimisé. Si ce coût est négatif, i.e. le

remplacement ne peut optimiser plus le résultat, le nœud trouvé est le meilleur

résultat, et le processus peut s’arrêter.

Théoriquement, la complexité de CLARA est O (k 3+nk) pour chaque itération,

tandis que celle de CLARANS est linéaire par rapport au nombre de points, donc le

deuxième est théoriquement meilleur que le premier. L’expérimentation des auteurs

prouve également que CLARANS est meilleur que CLARA dans tous les cas [12]

ii.

K-meansCet algorithme est le plus connu dans la communauté de classification des

données. Dans cet algorithme, chaque classe est représentée par la moyenne (mean)

ou la moyenne pondérée qui est nommée le centroid. K-means est un algorithme

itératif. Il commence avec un ensemble de k points de référence (centroid) choisi par

l’utilisateur. Au début, les points de données sont partitionnés dans k classes : Un

point appartient à une classe si le point de référence de cette classe est le plus proche


17/59

16

de lui. La mise à jour des points de référence et l’affectation des points de données

aux classes sont réalisées pendant les itérations successives.

Il y a plusieurs versions de k-means. On peut les distinguer selon deux

critères : la différence dans la mise à jour des classes et le critère pour faire cette mise

à jour.

Pour le premier critère, les algorithmes de ce type diffèrent dans le détail de la

génération et de l’ajustement des classes. Il y a 3 algorithmes de base de ce type :

Standard K-means, l’algorithme de Lloyd, et continuous K-means qui a été proposé

par McQueen en 1967 [15].

- L’algorithme de Lloyd : L’initialisation de l’algorithme est similaire à ladescription ci-dessus. Les ajustements sont réalisés en calculant le centroid pour

chaque classe et en utilisant ces centroids comme les points de référence dans

l’itération suivante pour tous les points de données. La mise à jour des centroids n’est

faite qu’après une itération.

- Standard k-means: Cet algorithme est meilleur que celui de Lloyd en termede l’utilisation plus efficace de l’information à chaque pas d’itération. C’est à dire la

mise à jour des centroids est faite pendant et après une itération. Si un pointappartient à une classe et que pour lui, le centroid de cette classe est le point de

référence le plus proche, alors il n’y aura aucun ajustement. Mais si après avoir

affecté un point x à une classe A, on trouve qu’il y a une autre classe B dont le

centroid est le point de référence plus proche de x que celui de A, alors il faut

réaffecter x à la classe B et recalculer les centroids de toutes les deux classes, et les

points de référence de ces deux classes se déplacent aux nouveaux centroids.

- Continuous k-means: Cet algorithme diffère au standard k-means par le

choix des points de référence initiaux et la sélection des points pour la mise à jour des

classes. Dans la première différence, pas comme dans Lloyd ou standard k-means où

les points de référence initiaux sont arbitrairement choisis, dans cet algorithme, ces

points sont choisis comme un échantillon aléatoire de la population entière des points.

Si l’échantillon est assez gros, alors la distribution des points de référence initiaux

pourrait refléter celle des points de la population. La deuxième différence,

contrairement au standard k-means où tous les points sont séquentiellement examinés,

cet algorithme n’examine qu’un échantillon aléatoire des points. Si le jeu de données

est gros et l’échantillon est représentatif du jeu de données, alors l’algorithme peut

converger plus vite qu’un algorithme qui doit examiner séquentiellement tous les

points.

Pour le deuxième, il y a deux versions de l’optimisation itérative de k-means [1]:

- L’algorithme de Forgy, est similaire à l’algorithme EM et ses itérationsdisposent de deux pas : réaffecter tous les points à leur centroid le plus proche et

recalculer les centroids des nouveaux groupes créés. Les itérations continuent jusqu’à

ce qu’on atteigne un critère de terminaison (par exemple, il n’y a plus de réaffection).

Les avantages sont la capacité de travailler sur toutes les normes Lp, la facilité de

paralléliser, l’insensibilité à l’ordre des données.


18/59

17

- L’algorithme d’optimisation itérative réaffecte les points en se basant surune analyse plus détaillée des effets sur la fonction objective quand un point est

déplacé de sa classe à une classe potentielle. Si l’effet est positif, ce point sera

réaffecté et deux centroids seront recalculés. L’expérimentation prouve que la version

classique est souvent meilleure que celle de Forgy [4].

K-means est populaire et beaucoup utilisé grâce à sa simplicité. En fait, il apas mal des inconvénients : Le résultat est vraiment dépendant des centroids initiaux,

l’optimum local calculé est trop différent de la valeur globale, il n’est pas facile de

déterminer un bon nombre de classes utilisé pour l’algorithme, le processus est

sensible aux aberrants, l’algorithme n’est pas extensible et l’algorithme ne travaille

que sur les données numériques.

Pour remédier à ces inconvénients, certaines améliorations et extensions sont

proposées comme ISODATA qui permet de déterminer automatiquement un bon

nombre de classes utilisé pour donner un bon résultat, k-modes, k-prototypes pour

manipuler sur les données catégorie [5] ou l’accélération de k-means par l’inéquation

triangulaire, single pass k-means pour travailler sur un gros jeu de données [6]…

- ISODATA : Comme on a vu, le nombre de classes K est toujours déterminé àpriori pour k-means. ISODATA a été proposé pour remédier à cet inconvénient. Il

intercale des phases de fusion et d’éclatement de groupes dans k-means [14] :

fusionner 2 classes si la distance entre elles est faible (inférieure à un seuil) et éclater

une classe en 2 classes si son inertie est trop grande (supérieure à un seuil).

Initialement, on donne un nombre k assez grand comme l’entrée du nombre de classes

de k-means. Après avoir appliqué k-means sur ces données, on fait la fusion et

l’éclatement pour trouver un bon nombre de classes. La difficulté est que l’on a besoin

déterminer deux seuils pour la phase supplémentaire.

- K-modes, k-prototypes sont développés par Z. Huang [5]. On sait que K-means ne travaille que sur les données numériques sur lesquelles on utilise la distance

euclidienne pour calculer la dissimilarité entre les points ou les classes. Pour que cet

algorithme puisse marcher avec les données catégoriques, Z. Huang a proposé deux

extensions de k-means en définissant une mesure de dissimilarité pour comparer les

objets de données. En conséquence, on utilise les modes au lieu des means et une

méthode basée sur la fréquence pour mettre à jour les modes.

Etant donnés 2 objets de type catégorie, la dissimilarité entre eux est définie

comme le nombre d’attributs différents correspondants entre ces deux objets.

∑=

=

n

i

ii y x y xd 1

),(),( δ Tel que

≠

==

ii

ii

ii y xsi

y xsi y x

1

0),(δ

Le mode d’une classe est l’objet qui apparaît le plus dans la classe.

L’algorithme k-modes a pour but de traiter seulement les données catégorie, k-

prototypes vise à manipuler les données mélangées (numérique et catégorie) en

additionnant la distance euclidienne pour les attributs numériques avec la distance

décrite ci-dessus pour les attributs catégoriques avec un poids (la somme pondérée) :


19/59

18

cn d d d .λ += , tels que dn est la distance numérique et dc est la distance catégorique,

λ est un poids qui équilibre la domination des attributs catégorie sur les attributsnumériques. Cette distance est utilisée dans l’algorithme k-means.

- Single pass k-means (Scalable k-means): Cet algorithme a été développé parBradley, Fayyad et Reina [6]. Il vise à augmenter l’extensibilité de k-means pour de

gros jeux de données. L’idée de cet algorithme est basée sur la notion que lessolutions effectives de classification peuvent être obtenues en sélectionnant et

stockant des parties importantes de données et résumant les autres. Il est capable

d’identifier les régions de données qui sont compressibles, les régions qui doivent être

gardées dans la mémoire et les régions qui peuvent être supprimées.

Pour représenter un groupe de données (une sous-classe) sous une forme

compressée, l’algorithme utilise un triplet de statistique (SUM, SQUAREDSUM, N)

tels que SUM est la somme linéaire de tous les points dans le groupe,

SQUAREDSUM est la somme des écarts carrés des points au centroid, et N est le

nombre de points dans ce groupe. Il a besoin de 3 types de jeu de données stockés

dans la mémoire : DS- jeu de données supprimées, CS- jeu de données compressées et

RS- jeu de données gardées. Notons que DS et CS stocke les statistiques de données.

L’algorithme comprend 2 étapes de compression : la compression primaire a

pour but de déterminer les données qui sont supprimées (donc stockées dans DS). La

compression secondaire vise à compresser les données qui ne sont pas supprimées

dans la première phase (le résultat est stocké dans CS). Les données qui ne sont pas

traitées dans ces 2 étapes de compression sont stockées dans RS. Les points qui sont

supprimés dans la première étape sont ceux qui ne se déplacent quasiment jamais à

une autre classe. Cette tâche est effectuée en utilisant le seuillage d’un rayon de

Mahalanobis autour du centre d’une classe. Les points se trouvent dans ce rayon sont

compressés. Chaque classe a un jeu de données supprimées représenté par le triplet ci-

dessus pour représenter tous les points appartenant à cette classe. La première étapetrouve les régions denses (les sous-classes) qui ne sont pas compressées par la

première étape en appliquant l’algorithme k-means avec un nombre de classes k’ > k.

Après avoir trouvé k’ sous-classes, on applique un critère de compacité (dense) sur

ces k’ classes comme un filtre: une sous-classe dont la covariance est inférieure à un

seuil est passée ce filtre. Les sous-classes filtrées sont fusionnées avec celles stockées

dans CS et les autres points par une classification hiérarchique d’agglomération.

- Accélération de k-means : En utilisant l’inégalité triangulaire, Elkan aproposé une amélioration qui permet de diminuer le coût de calcul des distances dans

k-means [13]. L’idée est basée sur le fait que la plupart des calculs de distance sont

redondants. Si un point se trouve très loin d’un centre, alors ce n’est pas nécessaire de

calculer la distance exacte entre lui et ce centre afin de savoir si ce point peut êtreaffecté à ce centre. En plus, si un point est vraiment plus proche d’un centre que tous

les autres centres, on n’a pas besoin de calculer les distances exactes pour décider si le

point appartient à ce centre.

3) Méthodes basées sur la densité

C’est des méthodes hiérarchiques dans lesquelles les classes sont considérées

comme des régions en haute densité qui sont séparées par des régions en faible


20/59

19

densité. La densité est représentée par le nombre d’objets de données dans le

voisinage. C’est pourquoi ces méthodes sont capables de chercher des classes de

forme arbitraire. Elles ne travaillent que dans un espace métrique, donc elles sont

utilisées dans la classification de données spatiales. Pour réduire le coût de calcul lors

de la classification, les données sont indexées, par exemple R*-tree (cf. section

Méthodes de recherche de voisinage), donc elles ne sont efficaces qu’avec les données

en basse dimension.

Il y a deux approches dans ce type de classification, l’une est basée sur la

connectivité de densité, l’autre est basée sur la fonction de densité.

Les algorithmes les plus connus de ce type sont DBSCAN (connectivité de

densité) et DENCLUE (fonction de densité).

i. DBSCANDBSCAN (Density Based Spatial Clustering of Applications with Noise) est

un algorithme très populaire dans ce type d’algorithme de classification [2] [18]. Pour

chaque objet, il cherche le voisinage qui contient un nombre minimum d’objets. Une

classe est formée par tous les objets qui sont transitivement connectés par leurs

voisinages. Un voisinage de rayon Eps contenant au moins MinPts objets d’un objet

est appelé le voisinage Eps-MinPts de cet objet.

On utilise la notion connecté-densité pour former des classes :

- Un objet est dit directement accessible-densité Eps-MinPts d’un autre objet

s’il se trouve dans le voisinage Eps-MinPts de cet objet.

- Un objet est dit accessible-densité Eps-MinPts d’un autre objet s’il y a une

chaîne d’objets entre eux dont tous les 2 objets successifs sont directement accessible

densité Eps-MinPts.

- Un objet est dit connecté-densité Eps-MinPts d’un autre objet s’il y a un objet

duquel tous les deux objets sont accessibles-densité.

Une classe avec Eps et MinPts prédéfinis est définie comme un ensemble non

vide d’objets qui satisfait 2 conditions, l’une est la condition de connectivité, i.e. tous

les objets de la classe doivent être connectés-densité, l’autre est la condition de

maximum, i.e. tous les objets qui se trouvent dans le voisinage Eps-MinPts d’un objet

de la classe doivent appartenir à cette classe.

Le bruit est défini comme un ensemble d’objets qui n’appartiennent à aucune

classe.

Il y a deux objets différents qui sont pris en compte dans la classification :

l’objet de noyau et non noyau. Un objet de noyau est celui qui a un voisinage Eps-MinPts. Un objet non noyau est celui qui n’a pas un tel voisinage. Un objet non noyau

peut être un objet de frontière ou un bruit.

L’algorithme commence en prenant en compte d’un objet arbitraire et cherche

tous les objets accessibles densité. S’il est objet de noyau, alors cette phase forme une

classe. S’il est un objet de frontière et qu’il n’y a aucun objet qui est accessible densité

depuis lui, alors c’est un bruit, l’algorithme passe à un autre objet.


21/59

20

Normalement, la complexité de la recherche du voisinage est O(N2). Pour

accélérer cette recherche, on peut utiliser certaines méthodes d’accès spatial comme

l’arbre R* ou l’arbre M pour obtenir une complexité de O (N logN). On les verra dans

la section de Méthodes de recherche d’un voisinage.

DBSCAN peut chercher les classes de forme arbitraire. Il est insensible à

l’ordre d’entrée des objets. Il est incrémental car un nouvel objet qui arrive peutaffecter certains voisinages. A côté, l’algorithme a des inconvénients : il est difficile à

préciser le rayon Eps et le seuil de la cardinalité d’un voisinage et la performance peut

être diminuée pour les données de haute dimension.

ii. DENCLUEDENCLUE (DENsity CLUstEring) est une approche de classification basée

sur la densité mais travaille d’une manière plus formelle que DBSCAN en modélisant

la densité globale d'un ensemble de points comme somme des fonctions d’influence de

densité associées à chaque point. La fonction de densité globale aura des maxima

locaux de densité, ces maxima peuvent être choisis pour définir des classes d'une

manière simple.

Typiquement la fonction d'influence est symétrique (i.e. elle est la même dans

toutes les directions) et sa valeur (contribution) diminue si la distance du point au

centre augmente. Une fonction d’influence très connue est la fonction gaussienne

2

2

2

),(tan

)( σ y xcedis

e xK

−

=

Figure 2 : La fonction d’influence gaussienne, un jeu de points

et la fonction de densité globale

DENCLUE a deux étapes, une étape de prétraitement et une étape de

classification. Dans l'étape de prétraitement, une grille pour les données est créée en

divisant l’hyper rectangle englobant minimal en hyper rectangles d dimensionnels

avec la longueur d’arête égale à σ 2 . Les cellules de grille qui contiennent des pointssont alors déterminées (seulement les cellules occupées de grille doivent être

construites). Les cellules de grille sont numérotées selon une origine particulière (sur

une arête de l’hyper rectangle englobant) et les clefs sont stockées dans un arbre de

recherche pour fournir un accès efficace au traitement ultérieur. Pour chaque cellule

de grille, le nombre de points, la somme des points dans la cellule, et des connexions

aux cellules voisines sont également stockés.


22/59


23/59

22

ii. WaveClusterC’est un algorithme qui est conçu pour travailler sur des données spatiales.

Dans l’algorithme, on considère les données spatiales comme les signaux

multidimensionnels et on applique une technique de traitement de signal qui s’appelle

la transformation wavelet pour transformer l’espace de données vers un domaine de

fréquence [16]. L’idée est basée sur le fait que les parties de haute fréquence du signal

correspondent aux régions de l’espace spatial de données où il y a un changementbrusque dans la distribution des objets. Ce sont les frontières des classes. Au

contraire, les parties de basse fréquence du signal correspondent aux régions de

l’espace de données où les objets sont concentrés. Autrement dit, ce sont les classes.

Tout d’abord, l’algorithme quantifie l’espace de données (divise l’espace en

cellules) et affecte les objets aux cellules. Ensuite, il applique la transformation

wavelet pour l’espace quantifié afin d’obtenir un espace transformé. Puis il cherche

les composantes connectées (les classes) dans les sous bandes (l’espace transformé est

un espace de fréquence). Deux composantes sont dites connectées si le nombre

d’objets de chacune dans l’espace transformé est supérieur à un seuil et si elles sont

epsilons voisins (la distance entre eux est inférieure à epsilon). Enfin, il étiquette les

cellules et réaffecte les objets à leurs classes correspondantes.

WaveCluster est capable de traiter efficacement les gros jeux de données

spatiales donc en basse dimension. Il peut découvrir des classes de forme arbitraire et

bien traiter le bruit. En plus, grâce au traitement du signal appliqué, WaveCluster nous

donne la multi résolution, i.e. il peut donner des classes de différent niveau du détail.

La complexité de la phase de quantification est O (N) et celle de la phase de

transformation wavelet est au plus de O (4/3K) tel que K est le nombre de cellules

[16].

iii. CLIQUE

Au lieu de construire les classes dans l’espace original comme les autresalgorithmes, CLIQUE (CLustering In QUEst) le fait dans des sous-espaces en

dimension la plus haute si possible [2] [17]. L’idée est basée sur le fait que si une

collection de points S est une classe dans un espace de k dimensions, alors S est ainsi

une partie d’une classe dans n’importe quelle projection en k-1 dimensions de cet

espace.

L’algorithme travaille en niveaux. Tout d’abord, il détermine toutes les unités

denses en 1 dimension en balayant une fois les données. Après avoir déterminé les

unités denses en (k-1) dimensions, il détermine les unités denses candidates en k

dimensions en utilisant une procédure qui génère les unités candidates.

La procédure de génération utilise l’ensemble de toutes les unités denses en k-1 dimensions Dk-1. Elle joint Dk-1 avec elle-même sous une condition où les unités qui

sont jointes partagent les premières k-2 dimensions pour obtenir un ensemble de

candidates Ck . On supprimera les unités denses de Ck qui ont une projection en k

dimensions qui ne sont pas incluse dans Ck-1. L’algorithme se termine lorsqu’il n’y a

plus de candidatures générées.

CLIQUE est une solution pour la classification de données en haute

dimension. Il est insensible à l’ordre des données. Cependant, sa complexité est


24/59

23

exponentielle. Supposons que k est le nombre le plus haut de dimensions du sous-

espace auquel l’algorithme se termine, m est la cardinalité du jeu de données,

l’algorithme doit accéder au jeu de données k fois. La complexité est O (ck + mk) où c

est une constante.

5) Algorithmes pour des données de haute dimension

Les objets utilisés dans la classification peuvent disposer de centaines

attributs. La classification dans un tel espace de haute dimensionnalité est

extrêmement difficile. Le calcul de similarité devient très coûteux. Un problème très

connu sous le nom de malédiction de dimensionnalité (dimensionnality curse), quiest le manque de propriétés de données dans un espace de haute dimension. Par

exemple, dans un espace bidimensionnel, un cercle peut être approximé par un carré

englobant minimum et le rapport des régions est 1 / 4 ≈π tandis que dans un espacede 100 dimensions, le rapport des volumes est approximativement 4,2. 10

39 [21]. Cela

signifie que la plupart du volume d’un hyper cube de 100 dimensions est hors de la

plus grande hyper sphère inscrite, autrement dit, les hyper cubes sont de mauvaises

approximations des hyper sphères. Or, la plupart de structures de recherche du voisin

le plus proche (utilisées dans la classification) divisent l’espace de recherche en hyper

cubes où hyper rectangles. En entrant à un espace de dimensionnalité plus haute, les

données deviennent plus clairsemées. Un autre problème peut survenir dans un espace

de haute dimension, c’est la présence d’attributs non pertinents qui affectent

négativement les mesures de proximité et donc peuvent menacer l’existence des

classes dans la classification. En fait, ce phénomène peut figurer avec des données de

basse dimension, mais la possibilité de présence et le nombre des attributs non

pertinents augmentent avec la dimensionnalité.

Il y a certaines techniques pour résoudre les problèmes ci-dessus, on peut

trouver la technique de sélection d’attributs, la réduction de dimensionnalité, la

classification dans des sous-espaces et la co-classification.

i. Sélection d’attributsAvant la classification, il est possible qu’on sache à priori que seul un petit

nombre de variables ont de l'intérêt. Dans ce cas, ces variables peuvent être choisies,

et les autres être jetées, de ce fait réduisant la dimensionnalité du jeu de données. Plus

généralement, l'analyse de données (classification ou autre) est souvent précédée par

une étape de choix des caractéristiques qui essaye d'enlever les caractéristiques non

pertinentes. Ceci peut être accompli en jetant les caractéristiques qui montrent peu de

variation ou qui sont fortement corrélés avec d'autres caractéristiques (La méthode de

sélection un sujet compliqué).

ii.

Réduction de dimensionnalitéDans ce type de méthodes, il y a deux techniques principales. Ce sont la

transformation des attributs et la décomposition de domaine.

- Les transformations des attributs sont des fonctions simples des attributs

existants. Dans la statistique multi variable, on utilise l’analyse de composantes

principales (ACP). Dans la récupération d’information, c’est la décomposition de

valeur singulière. On reverra ces techniques en détail dans la section de recherche du

voisin le plus proche.


25/59

24

- La décomposition de domaine vise à diviser un ensemble de données en sous-

ensembles, en fait, ce sont des classes, appelés les verrières (canopies en anglais) [22]

en utilisant certaines mesures de similarité peu coûteuses pour que le calcul de haute

dimension a lieu sur les jeux de données plus petits. La dimensionnalité est pareille

mais le coût de calcul est réduit. Cette approche cible à la situation de haute

dimension, de gros jeu de données et beaucoup de classes.

iii. Classification dans sous-espacesLes approches de réduction de caractéristiques et de réduction de

dimensionnalité basées sur PCA ou SVD peuvent être inadéquates si les différentes

classes se situent dans de différents sous-espaces. En effet, on souligne que pour

beaucoup de jeux de données de dimension élevée, il est probable que les classes se

situent seulement dans les sous-ensembles du plein espace. Ainsi, beaucoup

d'algorithmes pour classifier des données de dimension élevée trouvent

automatiquement des classes dans les sous-espaces du plein espace.

On peut trouver l’algorithme CLIQUE décrit ci-dessus est un algorithme ne

fait pas la classification dans l’espace original, mais dans les sous espaces.

Il y a un autre algorithme qui s’appelle MAFIA (Merging of Adaptive Finite

Intervals) [23]. C’est une technique pour le calcul adaptative des intervalles finis

(appelés les casiers, bins en anglais) en chaque dimension qui sont fusionnés pour

explorer les classes en haute dimension. En conséquence, les auteurs utilisent les

grilles adaptatives pour réduire le calcul et améliorer la qualité des classes en

concentrant sur les parties de l’espace de données qui ont plus de points donc elles ont

probablement des classes se trouvant dedans. L’algorithme ascendant (bottom-up)

pour la classification dans sous-espaces calcule les unités denses sur toutes les

dimensions et combine ces unités pour générer les unités denses en plus haute

dimension. MAFIA est aussi un algorithme basé sur la densité.

MAFIA construit les classes de la même manière que CLIQUE. La différence

principale et aussi une amélioration) entre MAFIA et CLIQUE est que dans CLIQUE,

on utilise la taille des unités en chaque dimension est constante. Par conséquent, on

néglige la distribution de données au long de chaque dimension. Les régions denses et

clairsemées sont toutes les deux représentées par les mêmes tailles de grille. MAFIA

utilise une taille d’intervalle adaptative pour diviser chaque dimension dépendant de

la distribution de données dans la dimension. En utilisant un histogramme construit

par une passe sur les données, on détermine le nombre minimum de casiers

(intervalles) pour chaque dimension. Les casiers contigus avec un histogramme

similaire sont combinés pour former un casier plus large. Les casiers et les cellules

dont la densité de données est faible sont supprimés pour diminuer le nombre d’unités

denses candidates, donc réduire le coût de calcul. Les frontières des casiers ne sontpas rigides comme dans le cas des casiers de taille uniforme, donc elles sont capables

de tracer plus exactement les frontières des classes.


26/59

25

Figure 3: Grille de taille uniforme (a) et Grille de taille adaptative (b)

Une autre différence entre 2 algorithmes est dans la phase de génération des

unités candidates. Pour construire une unité candidate de k dimensions, CLIQUE

combine deux unités de k-1 dimensions qui partagent k-2 premières dimensions,

tandis que dans MAFIA, ce sont deux unités de k-1 dimensions qui partagent

n’importe quel k-2 dimensions. Cela crée plus d’unités candidates.

La complexité de MAFIA est O (ck + kn) tels que c est un constant, n est lenombre de points de données est k est le nombre maximum de dimension des sous-

espaces. L’expérimentation des auteurs de l’algorithme prouve que la performance et

la qualité de MAFIA atteignent 40 fois d’amélioration que CLIQUE [23].

iv. Co-classificationLe co-classification est la classification simultanée des points et leurs attributs

tous les deux. Elle inverse une lutte : afin d’améliorer la classification des points en se

basant sur leurs attributs, elle essaie de faire la classification les attributs en se basantsur les points. Si un jeu de données est représenté par une matrice donc les lignes

expriment les points et les colonnes expriment les attributs. Au lieu de grouper

seulement les lignes, on groupe également les colonnes.

6) Algorithmes pour les données qualitatives (catégorie)

Les algorithmes de classification visent à diviser un jeu de données en des

partitions (classes) pour que les points qui sont situés dans une même partition soient

plus semblables que les points dans différentes partitions. Pour le faire, il faut utiliser

une mesure qui permet de définir et calculer la similarité ou la dissimilarité entre les

points et les partitions. La mesure qu’on utilise dans la classification est toujours

définie en basant sur les caractéristiques des données. Pas comme les données

numériques, les données de catégorie n’ont pas toujours de caractéristiques

géographiques inhérentes. Donc la classification de données de catégorie est vraiment

compliquée que celle de données numériques. En fait, pour les données numériques, iln’est pas difficile de définir la similarité de la position géographique des données,

tandis que pour les données de catégorie, ce n’est pas facile.

La mesure de similarité de données catégories dépendant fortement de leurs

caractéristiques et l’application. A côté des algorithmes k-modes, k-prototypes que

nous avons présentés dans la section de l’algorithme k-means, il existe assez

d’algorithmes qui permettent de traiter des données catégories. Parmi eux, ROCK,

CACTUS, STIRR sont les plus connus.


27/59


28/59

27

domaine de j-ième attribut est Di, alors le nombre de nœuds dans le graphe est ∑i

i D .

Pour chaque uplet dans la base de données, un arc représente un ensemble de nœuds

qui participent à ce uplet. Ainsi un uplet est représenté une collection de nœuds

chaque type d'attribut. L'ensemble de poids de tous les nœuds définit une

configuration de cette structure. Les poids initiaux de nœuds peuvent être assignés

uniformément, aléatoirement ou par une technique quelconque.

Figure 4: Une base de données et sa représentation de graphe

STIRR change itérativement la configuration en mettant à jour le poids de

n'importe quel nœud simple (single node). Le nouveau poids d’un nœud est calculé

en basant sur une fonction de combinaison, qui combine les poids d'autres nœuds

participant à n'importe quel uplet avec le nœud donné pour lequel le poids doit être

mis à jour. C’est-à-dire qu’il se déplace d'une configuration à une autre jusqu'à ce

qu'il atteigne un point stable, appelé comme bassin. La convergence dépend de la

fonction de combinaison. L'analyse de la stabilité est dure. Cependant, pour le

combinateur simple fonctionne comme la somme ou la multiplication, le système

converge certainement à un point fixe. Il est facile de voir que, pour des attributs

catégoriques, les valeurs qui sont connexes par les uplets communs s'influencent

pendant la modification de poids. C’est la raison pour laquelle on n'exige vraiment

d'aucune définition de similarité métrique pour des attributs de catégorie. Une choseest intéressante dans STIRR est que, afin de grouper l'ensemble d’uplets, l’algorithme

maintient les copies multiples des poids. Quand le point fixe est atteint, les poids dans

un ou plusieurs bassins isolent deux groupes de valeurs d'attribut sur chaque attribut :

le premier avec de grands poids positifs et la seconde avec de petits poids négatifs.

Les nœuds avec de grands poids positifs et grands poids négatifs sont groupés pour

déterminer des classes. Ces groupes correspondent intuitivement aux projections des

classes sur l'attribut. Cependant, l'identification automatique de tels ensembles de

valeurs d'attribut à partir de leurs poids exige une étape non triviale de post-

traitement; une telle étape de post-traitement n'a pas été adressée dans leur travail.

D'ailleurs, l'étape de post-traitement déterminera également quelles sont les classes

qui seront créées. L’algorithme requis une seule passe sur les données. Sa complexité

est O (n).

iii. CACTUSCACTUS (Clustering Categorical Data Using Summaries) fait la classification

sur les données de catégorie. L'idée centrale de CACTUS est que l'information

résumée formée à partir de l'ensemble entier de données est suffisante pour découvrir

des classes. L’hypothèse est que l'information résumée peut être mise dans la


29/59

28

mémoire centrale, et qu'elle peut être construite efficacement par une seule passe sur

les données.

Intuitivement, une classe sur un ensemble d'attributs numériques identifie une

région dense dans l'espace d'attributs. En général, la classe des régions rectangulaires

peut être exprimée comme un produit cartésien des intervalles. Puisque des domaines

des attributs de catégorie ne sont pas ordonnés, le concept d'un intervalle n'existe pas.Cependant, on peut considérer un intervalle dans le domaine de catégorie comme un

ensemble de valeurs d'attribut.

CACTUS définit une région d’intervalle comme un produit croisé des

ensembles de valeurs d’attribut. Un uplet est dit appartenir à une région si la valeur de

tous les attributs de ce uplet se trouve dans le domaine correspondant de la région. Le

support d’un pair de valeurs d’attribut est le nombre d’uplets (objets) dans le jeu de

données alors que ces deux valeurs apparaissent à la fois. Le support d’une région

d’intervalle est le nombre de uplets dans le jeu de données qui appartiennent à cette

région. Deux valeurs d’attribut est appelées fortement connectées (strongly connected)

si le support de ce pair de valeurs est supérieur α fois à l’espérance des supports de

tous pairs de valeurs dans les domaines correspondants.

En basant sur les concepts ci-dessus, l’algorithme comprend 3 phases :

- La phase de réduction : Il y a deux types de résumé : le résumé d’inter attribut

compte tous les pairs de valeurs d’attribut qui sont fortement connectées dans de

différents attributs. Le résumé d’intra attribut calcule les similarités entre les valeurs

d’attribut du même attribut. On suppose que ces résumés peuvent être mis

complètement dans la mémoire.

- La phase de classification : Il y a deux étapes dans cette phase. Tout d’abord,

on calcule les projections des classes sur les attributs en basant sur le fait que une

classe sur un ensemble d’attributs induit une sous classe sur un pair d’attribut (l’idée

est comme celle des algorithmes de classification dans les sous espaces). Cette étape a

pour but de déterminer les classes candidates sur un pair d’attributs et les projections

sont calculées en basant sur les deux résumés obtenus de la première phase. L’étape

suivante vise à construire des classes en faisant l’intersection des projections de

classes sur un attribut calculées dans la première étape en jointant ces projections

successivement sur plusieurs attributs.

- La phase de validation : l'algorithme identifie les classes candidates fausses en

vérifiant si le support de chaque classe candidate est plus grand qu’un seuil exigé.

CACTUS est un algorithme extensible (scalable algorithm) puisqu'il exige

seulement un passage du jeu de données. Le deuxième passage est nécessaire pour la

phase de validation, sans aucune implication sur l’extensibilité. Les auteurs présentent

les résultats expérimentaux suffisants qui prouvent une meilleure exécution comparéeà STIRR, en termes de période et nombre d'attributs.


30/59

29

Chapitre 4. Classification sur le flux de données

1.

Classification sur le flux de données

Le modèle du flux de données a récemment attiré l'attention pour son

applicabilité à de nombreux types de données, y compris des données decommunications téléphoniques, des documents web et des navigations sur Internet

(clickstream). Pour l'analyse de telles données, on a besoin de traiter les données dans

un passage simple, ou d’un nombre limité de passages et d’un espace limité [25].

Un flux de données est intuitivement une séquence d’éléments de données x1 ,

x2 ,…,xi,…qui peuvent être lus une seule fois en ordre croissant des indices i [53].

L’accès aléatoire aux données n’est pas permis. En général, le jeu de données sur un

flux est souvent gros et les éléments de données arrivent continuellement. Les flux de

données diffèrent d’autres modèles de stockage des données sur les caractéristiques

suivantes [54]:

- Les éléments de données sur un flux de données arrivent en ligne.

- Il est impossible de contrôler l’ordre d’arrivée des éléments.- Les flux de données sont potentiellement illimités en taille.- Une fois qu’un élément de données sur le flux est traité, il est soit archivé soit

écarté.

Le traitement en général et la classification en particulier sur un flux de

données doit satisfaire 2 restrictions: une seule passe ou peu de passes d’accès aux

données et une mémoire limitée. Par conséquent, le calcul sur un flux de données doit

être simple à cause de ces restrictions. En plus, puisque la quantité de données

dépasse beaucoup l’espace de mémoire disponible pour le traitement, il est impossible

de se souvenir de tous les éléments de données lus dans le passé. La pénurie d’espace

nécessite de nouveaux algorithmes qui ne sauvegardent qu’un résumé de données du

passé et laissent suffisamment d’espace au traitement des données dans le futur. Il

existe plusieurs types de résumé des données, un centre de gravité, par exemple, d’une

classe est un résumé des éléments de données qui se groupent dans cette classe

comme dans les algorithmes de type k-means, un élément représentatif des classes est

aussi un résumé de la classe, comme dans les algorithmes de type k-medoids…

Un flux de données est une séquence ordonnée de points de données qui ne

peuvent être accédés que séquentiellement et une seule fois (balayage linéaire). En

général, un jeu de données dans un flux est vraiment gros donc il est impossible de le

mettre en mémoire. Il est souvent stocké dans un dispositif de stockage secondaire.

Puisque les jeux de données sont gros, il faut utiliser un balayage linéaire pour

économiser le coût d’accès aux dispositifs de stockage secondaires qui sont toujoursplus lents que la mémoire centrale. Puisque la mémoire est limitée, les algorithmes de

classification sur les flux de données ne peuvent pas se souvenir de beaucoup de

données accédées dans le passé. Des algorithmes de classification spécifiques ont été

développés pour répondre à cette demande en ne stockant que des résumés de

données du passé qui sont toujours plus petits que les données elles-mêmes afin

d’avoir suffisamment d’espace pour les données du futur.


31/59

30

Dans la recherche des algorithmes de classification ci-dessus, nous trouvons

que le concept de vecteur de CF (Cluster Feature) de l’algorithme BIRCH est un bon

résumé d’une classe, car il stocke non seulement le centre de la classe mais aussi

d’autres informations concernant tous les éléments de la classe qui permettent de

facilement calculer la compacité d’une classe, l’ampleur d’une classe…qui ne

peuvent pas être calculées en utilisant le centre d’une classe tout seul.

Plusieurs algorithmes de classification sur un flux de données ont été

proposés. La plupart d’entre eux sont simplement une extension d’un algorithme en

une seule passe (single pass algorithm) qui calcule les classes sur toutes les données

du flux. Bien que ces algorithmes s’attaquent à l’extensibilité du problème de

classification (la capacité d’un algorithme de traiter un gros jeu de données), ils ne

considèrent pas l’évolution des données, donc la qualité des classes produites devient

mauvaise quand les données évoluent considérablement dans le temps et ils ne

permettent pas aux utilisateurs de découvrir et exploiter efficacement les classes sur

différentes parties du flux de données. En analysant certains algorithmes de

classification sur le flux de données, nous avons trouvé que le modèle CLUSTREAM

est le modèle qui est le plus approprié aux exigences de notre problème.

Avant tout, nous présentons deux algorithmes de classification développés

pour faire de la classification sur le flux de données STREAM-LOCALSEARCH et

GenIc. Après, nous parlerons en détail à l’algorithme BIRCH et CLUSTREAM.

i. STREAM-LOCALSEARCHC’est un algorithme qui s’appelle STREAM développé par O’Callaghan,

Mishra, Meyerson, Guha et Motwani [30] dans lequel on utilise une procédure

nommée LOCALSEARCH.

Dans cet algorithme, on suppose que les données arrivent sous forme de n

morceaux Xi, chacun peut être complètement mis en mémoire (on peut découpern’importe quel flux de données comme un flux de morceaux en attendant

suffisamment de données qui arrivent).

L’idée principale de l’algorithme est qu’on fait tout d’abord la classification

sur chaque morceau de données en utilisant une procédure qui s’appelle

LOCALSEARCH. De chaque morceau, on obtient k centres pondérés des classes

trouvées par LOCALSEARCH. Après, on applique LOCALSEARCH sur l’ensemble

des centres pondérés qu’on obtient de tous les morceaux du flux, pour produire k

centres de classes de tout le flux de données.

Pour chaque morceau, on le représente sous forme d’un jeu de données

pondérées dans lequel chaque point de données distingué apparaît une seule fois avecun poids qui indique la fréquence d’apparition de ce point dans le morceau. Cette

représentation requiert un temps O (nq) tels que n est le nombre de morceaux, q est le

nombre de points distingués, donc on souhaite créer une telle représentation

seulement si les données sont vraiment redondantes, i.e. q est petit. Pour décider dans

quelle situation on crée une telle représentation, on a prouvé une réclamation dans

laquelle on dit que si un ensemble de données N contient l > k valeurs distinctes du


32/59

31

poi

Stage-le Anh Tuan

Documents

Transcript of Stage-le Anh Tuan