Rapport du projet IN104

Classi ation automatique de

données

Elaboré par : MGUIDICH A hraf

MNIF Wael

En adré par : Mme SASSI HIDRI Minyar

Mme ALOUANE Sonia

Année universitaire : 2014-2015

Remer iements

Nous tenons à remer ier nos enseignants SASSI HIDRI Minyar et

ALOUANE Sonia qui nous ont été d'une aide pré ieuse.
Nous tenons à remer ier aussi nos ollègues qui nous ont aidé en fournis-
sant des idées réatives.
Table des gures

2.1 Stru ture de données . . . . . . . . . . . . . . . . . . . . . . . 5

2.2 Use Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3.1 Plante d'Iris . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.2 Les patients an éreux . . . . . . . . . . . . . . . . . . . . . . 12
3.3 Mammographi masses . . . . . . . . . . . . . . . . . . . . . . 12
3.4 Test personnel . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4.1 Les in ludes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.2 Fon tion de le ture de données . . . . . . . . . . . . . . . . . . 18
4.3 Fon tion d'inisialisation des entres de lusters . . . . . . . . . 19
4.4 Fon tion d'appartenan e . . . . . . . . . . . . . . . . . . . . . 20
4.5 Fon tion de CMF . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.6 Fon tion de la ompa ité globale CP . . . . . . . . . . . . . . 22
4.7 Fon tion de la séparation globale SP . . . . . . . . . . . . . . 22
Table des matières

Introdu tion 1

1 Spé i ation 2

2 Con eption 4
2.1 Les stru tures . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Cas d'utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3 Démar he de réalisation 7
3.1 Les stru tures . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 Le ture du  hier . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.3 Initialisation des entres des Clusters . . . . . . . . . . . . . . 8
3.4 L'algorithme de CMF . . . . . . . . . . . . . . . . . . . . . . . 9
3.5 Évaluation globale . . . . . . . . . . . . . . . . . . . . . . . . 9
3.6 Évaluation lo ale . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.7 Fusionnement de mauvais luster . . . . . . . . . . . . . . . . 11
3.8 Tests sur des diérents exemples . . . . . . . . . . . . . . . . . 11
TABLE DES MATIÈRES

4 Les di ultés ren ontrées 14

Con lusion 16

Annexe 17
Introdu tion

Après avoir maîtriser le langage C lors du ours d'IN101, nous avons eu la

han e d'appliquer nos ompéten es en programmation C par la réalisation
un programme de lassi ation automatique de données. La lassi ation
automatique est la atégorisation algorithmique d'objets. Elle onsiste à at-
tribuer une lasse ou atégorie à haque objet (ou individu) à lasser, en se
basant sur des données statistiques. Elle fait ouramment appel à l'appren-
tissage automatique et est largement utilisée en re onnaissan e de formes.
Nous nous intéressons dans notre projet à la méthode de lassi ation non
supervisée (ou lustering), 'est-à-dire les lasses (ou luster) possible ne
sont pas onnues à l'avan e et les exemples disponibles ne sont pas étiquetés.
Il existe diérentes te hniques de lustering tels que l'appro he as endante,
l'appro he des endante, l'appro he binaire, l'appro he oue. . .

1
Chapitre 1

Spé i ation

On s'intéresse dans le adre de notre projet sur l'appro he des endante.

h√
Cette appro he onsiste à démarrer ave E N lusters ave N est le
i

nombre de données fournie par l'utilisateur dans un  hier. Cha une de es

données possèdent M ara téristiques. Ensuite, ette appro he utilise l'al-
gorithme de C-Moyennes Floues (CMF) qui va on aténer su essivement
les lusters jusqu'à e qu'un ritère d'arrêt soit satisfait par l'itération entre
deux étapes : Dans la première étape, haque donnée est ae tée au entre
de luster (appelé aussi prototype) le plus pro he (distan e minimale). Puis
dans la se onde étape, haque prototype de haque luster est re al ulé à
partir des nouvelles données asso iées à e luster. Ces deux étapes sont ré-
pétées jusqu'à e qu'au un hangement ne soit produit, ou si la fon tion de
ritère de onvergen e est réalisée.
Par la suite, ette opération se répéte pour her her le nombre optimale

2
CHAPITRE 1. SPÉCIFICATION

de lusters en suivant deux types d'évaluation : l'évaluation globale qui per-

met de juger sur la qualité de la partition obtenue pour haque itération et
l'évaluation lo ale qui permet de juger sur les mauvais lusters à fusionner.
On obtient enn un nombre optimale de lusters de entres Vj .

3
Chapitre 2

Con eption

Avant de se pen her sur la programmation, il faut d'abord dénir les

représentations internes des données par des stru tures et représenter le dia-
gramme des as d'utilisation.

2.1 Les stru tures

On va représenter l'ensemble des données par une liste linéaire hainée
puisque on ne sait pas le nombre des données. Chaque donnée est dénit par
ses ara téristiques qui sont implémentées à leurs tours dans une liste linéaire
hainée. On modélise ainsi les données par une liste orthogonale omme elle
le montre la gure suivante :

4
CHAPITRE 2. CONCEPTION

Figure 2.1  Stru ture de données

2.2 Cas d'utilisation

Les as d'utilisation permet de donner une vision globale du omporte-
ment fon tionnel de notre programme en dé rivant les exigen es fon tion-
nelles. Ils tentent d'éviter tout jargon te hnique et essayent au ontraire
d'adopter le langage de l'utilisateur nal ou de l'expert du domaine.

5
CHAPITRE 2. CONCEPTION

Figure 2.2  Use Cases

6
Chapitre 3

Démar he de réalisation

3.1 Les stru tures

On ommen e d'abord par la dénition des diérentes stru tures. On
a préféré que tout soit dynamique, 'est-à-dire le programme ne sait pas
d'avan e le nombre de données et le nombre de ara téristiques et ça a l'avan-
tage de lire n'importe quel  hier de données sans hanger les paramètres du
programme ou demander à haque fois à l'utilisateur d'introduire es para-
mètres.
• La stru ture de l'ensemble des données

stru t data_d

float n;

stru t data_d ∗s ;

7
CHAPITRE 3. DÉMARCHE DE RÉALISATION

};

typedef s t r u t data_s data ;

• La stru ture de l'ensemble des ara téristiques

stru t data_s

stru t data_s ∗ next ;

stru t data_d ∗ ar ;

};

typedef s t r u t data_d data1 ;

3.2 Le ture du  hier

void l e t u r e ( data ∗∗ x , i n t ∗N , i n t ∗ N1 ) ;

Cette fon tion permet d'ouvrir et de lire le  hier de données tout en

remplissant la liste linéaire hainée.

3.3 Initialisation des entres des Clusters

void i n i t ( data ∗∗ v , i n t N, int N1 , int );

h√
Cette fon tion permet d'initialiser E N entres des lusters et de rem-
i

plir aléatoirement leurs ara téristiques ave la fon tion rand () qui doit être

8
CHAPITRE 3. DÉMARCHE DE RÉALISATION

pré édée par srand(time(NULL)) qui permet de hanger la sortie de rand

() à haque exé ution.

3.4 L'algorithme de CMF

void mf ( d a t a ∗ x , d a t a ∗∗ v , i n t N, int , data ∗∗ app , i n t N1 ) ;

Cette fon tion permet de al uler le degré d'appartenan e de haque don-

née et de mettre à jour les entres de lusters par l'utilisation du ritère JCM F
d'une manière itérative qui permet de minimiser les distan es intra- lusters
et de maximiser les distan es inter- luster tout en tenant ompte des degrés
d'appartenan e des données.

3.5 Évaluation globale

L'évaluation globale se fait par le al ul de deux mesures de ompa ité et
de séparation globale.
• La ompa ité globale CP est al ulée par la fon tion suivante :
float al ul_ p_g ( int k , data ∗ x , d a t a ∗ v , d a t a ∗ app , i n t N, int N1 ) ;

Pour al uler la ompa ité globale, ette fon tion a besoin de nombre de
lusters singuliers k al ulé par la fon tion suivante :

void s i n g u l i e r ( data ∗∗ v , d a t a ∗∗ app , i n t , int ∗ r ) ;

• La séparation globale SP est al ulée par la fon tion suivante :

9
CHAPITRE 3. DÉMARCHE DE RÉALISATION

float al ul_sp_g ( int , data ∗v , i n t N1 ) ;

• Le nombre optimal de lusters copt est obtenu quand la séparation-

ompa ité globale SC est maximale. Ce ritère est donné par la fon -
tion suivante :

float al ul_s _g ( int k, int , int N, int N1 , d a t a ∗x , data

∗ v , d a t a ∗ app , d a t a ∗ v 1 ) ;

3.6 Évaluation lo ale

Dans la stratégie des endante, nous hoisissons le luster le plus mauvais
pour le fusionner. Chaque donnée appartenant à e luster sera alors pla-
ée dans le plus pro he luster. Enn, les entres de tous les lusters seront
ajustés. Pour e fait, On emploie les mesures de séparation spj et de om-
pa ité cpj pour l'évaluation lo ale des diérents lusters. Puis on al ul la
séparation- ompa ité lo ale scj en utilisant la fon tion suivante :

float al ul_s _l ( int i , int , int N, int N1 , data ∗x ,

data ∗ v , d a t a 1 ∗ v1 , d a t a 1 ∗ a p p 1 ) ;

Une faible valeur de scj indique le plus mauvais luster à fusionner. Cette
valeur est al ulé grâ e à la fon tion suivante

int re her he_l ( data1 ∗v , i n t );

10
CHAPITRE 3. DÉMARCHE DE RÉALISATION

3.7 Fusionnement de mauvais luster

Après avoir al uler la valeur de séparation- ompa ité lo ale scj , on sup-
prime le plus mauvais luster de la liste de entres de lusters et de la liste
d'appartenan e à l'aide de ette fon tion :

void supprimer1 ( int b , data ∗∗ v , i n t ) ;

3.8 Tests sur des diérents exemples

Figure 3.1  Plante d'Iris

11
CHAPITRE 3. DÉMARCHE DE RÉALISATION

Figure 3.2  Les patients an éreux

Figure 3.3  Mammographi masses

12
CHAPITRE 3. DÉMARCHE DE RÉALISATION

Figure 3.4  Test personnel

13
Chapitre 4

Les di ultés ren ontrées

Dans un premier temps, on a trouvé quelques di ultés pour bien om-
prendre le problème de lassi ation et surtout l'appro he des endante. Et
ça nous a pris des heures de le ture pour bien omprendre e que nous devons
faire.
Lors de la programmation, on a eu aussi quelques di ultés. Par exemple,
on ne savait pas omment réer un  header le  ar on été habitué à faire
de simple programme dont on n'a pas besoin du  header le .
De plus, on a eu problème lors du al ul de SC globale ar parfois e
nombre est très faible (de l'ordre de 10−7 ) de façon que le programme le
manipule omme un zéro. Alors pour résoudre e problème on a faite la
multipli ation de tous les nombre petits par 10−7 pour pouvoir hoisir le
nombre SC le plus grand.
Enn, les  hiers qui nous ont été fournie présentent tous un nombre de

14
CHAPITRE 4. LES DIFFICULTÉS RENCONTRÉES

lusters optimale égale à 2 e qui nous permet pas de vérier onvenablement

le bon fon tionnement de notre programme. Don , on a rée un  hier qui
omporte 80 données et qui par onstru tion a 4 omme nombre optimale de
lusters. Lorsqu'on a testé notre programme ave e  hier, il a donné 4.

15
Con lusion

C'est la première fois qu'on réalise un projet de programmation qui nous

permet de mettre en pratique nos onnaissan es a quise en informatique.
Ce projet nous a permis d'avoir une idée sur les te hniques de développe-
ment en maitrisant les règles de programmation et les méthodes d'analyse
de problèmes ainsi que leur informatisation. Nous avons appris aussi om-
ment réaliser la modélisation fon tionnelle et opérationnelle du projet pour
fa iliter le travail.

16
Annexe

#in lude <s t d i o . h>

#in lude <s t d l i b . h>
#in lude <math . h>
#in lude <m a l l o . h>
#in lude <s t r i n g . h>
#in lude <time . h>
#in lude " t y p e s . h"

Figure 4.1  Les in ludes

17
ANNEXE

void l e t u r e ( data ∗∗ x , int ∗N, int ∗N1)

{
FILE ∗ f p ; data ∗ q ; data1 ∗ z , ∗ y ; int l , i , b , b1 ;
/ ∗ ∗∗∗∗∗∗∗ o u v e r t u r e du fi hier ∗∗∗∗∗∗∗∗∗ ∗ /
f p=fopen ( " t e s t 2 . t x t " , " r " ) ;
i f ( ( f p=fopen ( " t e s t 2 . t x t " , " r " ) ) == NULL ) p r i n t f ( "
e r r e u r d ' o u v e r t u r e de f i h i e r \n" ) ;
else { p r i n t f ( " o u v e r t u r e ok du f i h i e r \n" ) ;
/∗ ∗∗∗∗∗∗∗∗ r e m p l i s s a g e d e s données ∗∗∗∗∗∗∗ ∗ /
b1=∗N; har l i n e [ 128 ℄ ;
har s1 [ 2 0 ℄ ;
while ( f g e t s ( l i n e , sizeof l i n e , f p ) != NULL ) {
l =0; q=(data ∗ ) m a l l o ( sizeof ( data ) ) ;
y=NULL; b=0;
while ( l i n e [ l ℄ != ' \0 ' ) {
i =0;
memset ( s1 , 0 , sizeof ( s1 ) ) ;
while ( ( l i n e [ l ℄ != ' , ' ) && ( l i n e [ l ℄ != ' \0 ' ) ) {
s1 [ i ℄= l i n e [ l ℄ ; l ++; i ++;
}
i f ( l i n e [ l ℄ == ' , ' ) {
z=(data1 ∗ ) m a l l o ( sizeof ( data1 ) ) ;
z−>n=a t o f ( s1 ) ; z−>s=y ;
y=z ;
b++;
}
i f ( l i n e [ l ℄ != ' \0 ' ) l ++;
}
q−> a r=y ; q−>next=∗x ; ∗ x=q ; b1++;
}
p r i n t f ( "EXTRACTION : DONE ! \n" ) ;
}
∗ N1=b ; ∗N=b1 ;
}

Figure 4.2  Fon tion de le ture de données

18
ANNEXE

void i n i t ( data ∗∗ v , int N, int N1 , int )

{
data1 ∗ p , ∗m;
data ∗ q ;
int j , i ;
srand ( time (NULL) ) ;
for ( i =0; i < ; i ++)
{
q=( data ∗ ) m a l l o ( sizeof ( data ) ) ;
m=NULL;
for ( j =0; j<N1 ; j ++)
{
p=(data1 ∗ ) m a l l o ( sizeof ( data1 ) ) ;
p−>n=rand ( ) % ( 1 0 0 0 0 0 ) ;
p−>s=m; m=p ;
}
q−> a r=m;
q−>next=∗v ;
∗ v=q ;
}
p r i n t f ( " INITIALISATION : DONE ! \n" ) ;
}

Figure 4.3  Fon tion d'inisialisation des entres de lusters

19
ANNEXE

void appartenan e ( data ∗ x , data ∗ v , int N, int , data ∗∗

app , int N1)
{
int i , j ;
float b ;
data1 ∗ v1 , ∗ x1 , ∗ m, ∗ p ;
data ∗ vj , ∗ xi , ∗ q ;
v j=v ;
for ( i =0; i < ; i ++)
{
x i=x ;
v1=vj −> a r ;
m=NULL;
q=( data ∗ ) m a l l o ( sizeof ( data ) ) ;
for ( j =0; j <N; j ++)
{
x1=xi −> a r ;
p=(data1 ∗ ) m a l l o ( sizeof ( data1 ) ) ;
i f ( d i s t a n e ( x1 , v1 , N1)==0)
i f ( i==j ) b=1;
else b=0;
else b=somme( x1 , v1 , v , , N1) ;
p−>n=b ;
p−>s=m;
m=p ;
x i=xi −>next ;
}
i n v e r s e r (&m) ;
q−> a r=m;
q−>next=∗app ;
∗ app=q ;
v j=vj −>next ;
}
i n v e r s e r 1 (&∗ app ) ;
}

Figure 4.4  Fon tion d'appartenan e

20
ANNEXE

void mf ( data ∗ x , data ∗∗ v , int N, int , data ∗∗ app , int N1)

{
data ∗w;
data ∗ q , ∗ p ;
float max , k ;
int i ;
do {
/∗ ∗∗∗∗∗∗∗∗∗∗∗ a l u l d e l ' a p p a r t e n a n e ∗∗∗∗∗∗∗∗∗ ∗ /
appartenan e ( x , ∗ v , N, ,& ∗ app , N1) ;

/∗ ∗∗∗∗ m e t t r e à jour des entres de lusteurs ∗∗∗∗ ∗ /

w=∗v ;
mise_a_jour(&∗ v , N, N1 , , x , ∗ app ) ;

/ ∗ ∗∗∗∗∗∗∗∗∗∗ r e h e r h e du max ∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗ /

q=w;
p=∗v ;
max=d i s t a n e ( q−> ar , p−> ar , N1) /norme ( p−> a r ) ;
p=p−>next ;
q=q−>next ;
for ( i =1; i < ; i ++) {
k=d i s t a n e ( q−> ar , p−> ar , N1) /norme ( p−> a r ) ;
i f ( k>max) max=k ;
p=p−>next ;
q=q−>next ;
}
}
while (max>0.005) ;
}

Figure 4.5  Fon tion de CMF

21
ANNEXE

float al ul_ p_g ( int k , data ∗ x , data ∗ v , data ∗ app , int N

, int N1)
{
int i ;
float s =0;
data ∗ p=app , ∗ q=v ;
for ( i =0; i <k ; i ++)
{
s+=somme_ p1 ( x , p−> ar , q−> ar , N, N1) /somme_ p2 ( p−> ar ,N) ;
p=p−>next ;
q=q−>next ;
}
s=k/ s ;
return ( s ) ;
}

Figure 4.6  Fon tion de la ompa ité globale CP

float al ul_sp_g ( int , data ∗ v , int N1)

{
int i ;
data ∗ q=v ;
float s =0;
for ( i =0; i < ; i ++)
{
s+=minimum( v , q−> ar , i , , N1) ;
q=q−>next ;
}
s=pow ( s / , 2 ) ;
return ( s ) ;
}

Figure 4.7  Fon tion de la séparation globale SP

22