• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Clustering efficace avec les divergences de bregman
 

Clustering efficace avec les divergences de bregman

on

  • 834 views

Document : Stage Recherche Universite la Rochelle - MAster 1 Traitement des Images

Document : Stage Recherche Universite la Rochelle - MAster 1 Traitement des Images

Statistics

Views

Total Views
834
Views on SlideShare
834
Embed Views
0

Actions

Likes
1
Downloads
10
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Clustering efficace avec les divergences de bregman Clustering efficace avec les divergences de bregman Document Transcript

    • RAPPORT DE STAGE CLUSTERING EFFICACE AVEC LES DIVERGENCES DE BREGMAN Master 1 Sciences pour l’Ingénieur Mention Ingénierie Mathématiques et Image Université de La RochelleMIMBELA, MEDALITHTUTEUR : SAINT-JEAN, CHRISTOPHE
    • Clustering efficace avec les Divergences de Bregman 2011CONTENIDOObjectifs du Stage .............................................................................................................. 3Introduction ....................................................................................................................... 3Contexte scientifique ......................................................................................................... 4 Algorithme K-Means ....................................................................................................... 4 Divergences de Bregman ................................................................................................. 5 Divergences de Bregman – Hard...................................................................................... 6 Divergences de Bregman – Soft ....................................................................................... 7Implementation générique ................................................................................................. 8 Contexte ......................................................................................................................... 8 Schéma de Classes .......................................................................................................... 8 Classe Member ............................................................................................................ 9 Classe matrix_member .............................................................................................. 10 Classe vector_member ............................................................................................... 11 Fonction TEMPLATE<CLASS T> ALGBregman ................................................................ 12 Exécution du Programme Bregman.cpp - Résultats ..................................................... 14Conclusions ..................................................................................................................... 15Références Bibliographiques ............................................................................................ 16ANNEXE 1- CODE C++/MEX ............................................................................................. 17ANNEXE 2 – CODE MATLAB DEMO VECTEUR ..................................................................... 24ANNEXE 3 – CODE MATLAB DEMO MATRICES ................................................................... 25 2 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011OBJECTIFS DU STAGE L’objectif de ce stage est Produire des implémentations efficaces de deux algorithmes de clustering disponibles dans le papier ”Clustering with Bregman Divergences” [5]. Il s’agit de généralisations des algorithmes K-MeansINTRODUCTIONLe clustering décrit des méthodes de classification de données en sous ensembles quecorrespondent les pus suivant à des notions de proximité que lon définit en introduisantdes mesures et fonctions de distance entre objets.Pour obtenir un bon partitionnement, il convient [8]: - Minimiser linertie intra-classe pour obtenir des grappes (cluster en anglais) les plus homogènes possibles. - Maximiser linertie inter-classe afin dobtenir des sous-ensembles bien différenciés.On peut trouver différents types de clustering [7] : - Algorithmes hiérarchiques : décomposition/composition hiérarchique de clusters (CURE, BIRCH) - Algorithmes par partitionnement : regroupement itérative avec amélioration par replacement des objets (k-means) - Fonctions de densité (cluster avec forme arbitraire) : clusters grandissent aussi longtemps que la densité des objets dans leur voisinage est supérieure à une borne (DBSCAN, OPTICS) - Grilles : l’espace est divisé en cellules qui forment une grille (STING, CLIQUE) - Modèles : chaque cluster est supposé suivre un modèle : trouver la meilleure correspondance entre les modèles et les données (COBWEB)L’algorithme de partitionnement K-Means c’est l’algorithme de base pour ce projet, avecune généricité pour qu’il soit exécuté avec les divergences de Bregman.La Divergence est utilisée pour minimiser les différences entre un model donné et l’espaceobservé. Les mesures de Divergence sont utilisées pour résoudre des problèmesd’ingénierie pour montrer les différences entre deux objets et minimiser les coûts de lafonction en utilisant des contraints. 3 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011Les Divergences de Bregman (dФ) sont un type de mesure de distorsion suivant utilisédans le domaine de l’optimisation et le traitement de signal.Dans ce document on va traiter dans la première partie la théorie de base pourl’algorithme K-Means et les divergences de Bregman dans ses deux implémentations :Hard et Soft, aussi on va montrer les différents types de dФ par rapport à la nature desobjets à traiter. Dans la deuxième partie on va aborder la partie de programmationC++/MEX dans laquelle on montrera le schéma de classes et le choix des structures dedonnées pour le classement des individus. Finalement les conclusions du travail réalisépendant le stage, des applications de l’algorithme et aussi des améliorations suggérées.CONTEXTE SCIENTIFIQUEALGORITHME K-MEANSLe principe de lalgorithme K-Means est repartir N objets en K ensembles disjoints.La partition des classes est modifiée avec chaque affectation dun individu xi de X.Les individus sont géométriquement représentés dans lespace vectoriel P muni dunedistance notée d.  Entrées: X= {xi} i=1 … N, , {νi} i=1 … N, K  Initialiser {µk} k=1 … K  Répéter jusqu’à convergence o Calcul des clusters 2 hi  a rgmi nx i  μ k t Calcul des nouveaux centres: k o  k 1  i / h k i t i  t 1   x i / hi  k i i k  t 1 k o Retourner µk *La Complexité du K-Means : K*N*Itérations 4 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011Options d’Initialisation de µk : - Aléatoirement dans lintervalle de définition des xi - Aléatoirement dans lensemble des xi. Des initialisations différentes de peuvent mener à des Clusters différents (problèmes de minima locaux) Méthode générale pour obtenir des clusters "stables" : - On répète lalgorithme It fois (nombre des itérations) - On regroupe ensemble les xi qui se retrouvent toujours dans les mêmes clusters.Critères d’arrêt: - Lorsquon fixe un critère darrêt tel que le nombre maximal ditérations. - Lorsque les itérations successives conduisent à un même cluster.DIVERGENCES DE BREGMANLes divergences de Bregman (1967) sont une mesure de distorsion correspondant à desfonctions strictement convexes  (x) [3]Dans le cas général les divergences Bregman est définie par [5]: d (x , y)   (x)   (y)  x  y ,  (y)Par exemple pour la distance euclidienne la fonction  ( x)  x , x est strictementconvexe et différentiable en Rd [5]: d : S  ri(S)  0,  d (x , y)  x , x  y , y  x  y ,  (y)  x , x  y , y  x  y ,2y  x  y, x  y  x  y 2Exemples des divergences de Bregman pour dimensions finies: - Vecteur (distance euclidienne dimension n) :  (x)  x  d (x , y)  x  y 2 2 - Perte exponentiel :  (x)  e x  d (x , y)  e x  e y  (x  y)e y 5 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 - Perte Logistique :  (x)  x l ogx  (1  x)l og(  x) 1 x 1 x  d (x , y)  x l og   (1  x)l og y   1 y       - Matrices (distance de Mahalanobis) : pour A définie positive  (x)  xT Ax  d  (x  y)T A(x  y) - Distance de Kullback-Leiber  xj   (x)   j 1 x j l og2 x j  d   j 1 x j l og2   d d  yj   DIVERGENCES DE BREGMAN – HARDL’algorithme a la même structure que celui vu dans le K-means, seulement il y a deuxdifférences la divergence de Bregman pour le type d’objet mathématique et le calcul decluster avec dФ.Dans les divergences de Bregman on doit noter les opérations qu’on a besoin de faireentre les objets et aussi avec des scalaires pour le calcul de distances et des nouveauxcentres.Il faut faire attention que µk est un objet du même type que Xi.  Entrées: X= {xi} i=1 … N, {νi} i=1 … N, K, dФ  Initialiser {µk} k=1 … K  Répéter jusqu’à convergence o Calcul des clusters hi  a rgmi n d (xi , k ) t k o Calcul des nouveaux centres:  k 1  i / h k i t i k 1  t  x i / hi  k i i  t 1 k o Retourner µk 6 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011DIVERGENCES DE BREGMAN – SOFTDans la version SOFT de l’algorithme des divergences de Bregman on a remplacé les poidsdes individus pour la probabilité d’appartenance du Xi individu dans le cluster k.  Entrées: X= {xi} i=1 … N, {νi} i=1 … N, K, dФ  Initialiser {µk} k=1 … K  Répéter jusqu’à convergence o Calcul des clusters  k exp(d (xi , k )) t t p(k xi )   K k 1  k exp(d (xi , k )) t t o Calcul des nouveaux centres: 1 n  k 1  t  p(k xi ) n i 1  n p(k xi )xi  t 1  i 1  k n i 1 p(k xi ) o Retourner µk, πk 7 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011IMPLEMENTATION GENER IQUECONTEXTENotations : - Type o 0: vecteur double o 1: matrice double - D: taille de matrice ou vecteur, pour chaque individu - K: nombre de clusters - Xi: individu - N: quantité des individus - X: ensemble des individus - UH: centres des clusters (sortie) - Xh: clusters - Pih: Poids des individus - H_IN: Matrice (2xN) de groupe pour chaque individu (premier ligne : indice du groupe, deuxième ligne: distance)L’implémentation a été faite avec Borland C++ et Matlab. Le choix de C++ c’était surtoutpour avoir la possibilité d’avoir de classes virtuelles et fonctions Template.SCHEMA DE CLASSES Member <virtual Class> Private : - Type - D matrix_Member vector_Member <Implementation> <Implementation> Private : Private : - Double **Xi - Double *Xi 8 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011CLASSE MEMBERConstructeurs: - Member() {type=0; D=0;} - Member(unsigned int type,unsigned int D) {this->type=type; this->D=D;}Fonctions de conversion: - double *returnXi(); o Fonction pour faire la conversion du type T en double *, cette fonction est nécessaire pour retourner les centre après le calcul. - void setObject(Member &O1); - void setDouble(double *Xi_IN,unsigned int type,unsigned int D); o Fonction pour faire la conversion d’un vecteur double * en type T.Fonction distance: - double dPhi(Member &O1); o Fonction principale avec l’implémentation de la divergence de Bregman par rapport au type d’individu.Fonctions pour des opérations entre objets - void reset(); - Member& operator + (const Member &B); - Member& operator = (const Member &B);Fonctions pour des opérations mathématiques avec un scalaire : Utile surtout pour lecalcul de nouveaux centres. - Member& operator / (const double &d); - Member& operator * (const double &d);Autres fonctions: - unsigned int getType(){return this->type;} - unsigned int getD(){return this->D;} - double getXi(unsigned int i,unsigned int j);Tous les fonctions sont de type virtuelle pure, ça veut dire qu’ils doivent être implémentésobligatoirement dans chaque sous classe par rapport à la nature de l’objet avec lequel onva faire le calcul de l’algorithme.Pour le projet de Stage on a fait deux implémentation pour le calcule des divergences deBregman entre matrices et vecteurs.La surcharge des operateurs en c++ nous permet faire des calculs plus transparents dansla fonction AlgBregman après. 9 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011CLASSE MATRIX_MEMBERDans la classe on va déclarer le type qu’on a besoin dans ce cas là on va déclarer undouble **Xi, lequel sera initialisé par les constructeurs ou la fonction de conversion.Fonctions de conversion pour le type matrice :void setDouble(double *Xi_IN,unsigned int type,unsigned int D) { this->type=type; this->D=D; Xi = (double **) malloc(D *sizeof(double*)); for(unsigned int n=0;n<D;n++){ Xi[n] = (double *) malloc(D *sizeof(double)); for(unsigned int m=0;m<D;m++) Xi[n][m]=Xi_IN[n+D*m]; } } void setObject(matrix_Member &O1) { this->type=O1.type; this->D=O1.D; this->Xi = new double* [D]; for(unsigned int n=0;n<D;n++){ this->Xi[n] = new double[D]; for(unsigned int m=0;m<D;m++) this->Xi[n][m]=O1.Xi[m][n]; } } double *returnXi(){ // matrice sous la forme dun vecteur double *Xv; Xv=(double *) malloc(D*D *sizeof(double)); for(unsigned int n=0;n<D;n++){ for(unsigned int m=0;m<D;m++) 10 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 Xv[m+D*n]=Xi[n][m]; } return Xv; }CLASSE VECTOR_MEMBERDans la classe on va déclarer le type qu’on a besoin dans ce cas là on va déclarer undouble *Xi (vecteur), lequel sera initialisé par les constructeurs ou la fonction deconversion.class vector_Member: public Member{private: double *Xi;public:Fonction dPhi pour le calcul de distance euclidienne dans le cas général dimensión D :double dPhi(vector_Member &O1){ double dist=0.0; for(unsigned int n=0;n<this->D;n++){ dist=dist+pow(this->Xi[n]-O1.getXi(n,0),2); } return sqrt(dist); }Fonctions de conversion pour le type vecteur :void setDouble(double *Xi_IN,unsigned int type,unsigned int D) { this->type=type; this->D=D; Xi = (double *) malloc(D *sizeof(double)); memcpy(Xi,Xi_IN,this->D*sizeof(double)); } void setObject(vector_Member &O1) { this->type=O1.type; this->D=O1.D; Xi = (double *) malloc(D *sizeof(double)); memcpy(Xi,O1.Xi,this->D*sizeof(double)); } ~vector_Member(){ free(Xi); } double *returnXi(){ return this->Xi; } 11 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011FONCTION TEMPLATE<CLASS T> ALGBREGMANLes entrées pour l’exécution de l’algorithme : - double X_IN[]: matrice de taille Nxp avec l’ensemble des individus. - unsigned int N: quantité des individus. - unsigned int p: taille de colonnes de X. - unsigned int type: code d’objet, 0= vector_Member, 1 =matrix_Member. - unsigned int K, nombre de clusters. - double *Pih: vecteur de taille N avec - double H_IN[]: matrice 2 x N avec l’indice du cluster pour chaque individu et dans la deuxième ligne distance par rapport au centre du cluster. - double UH_IN[]: matrice K x p pour la sortie des centres. - bool retUH: option pour retourner ou pas les centres des clusters - unsigned int It: critère de convergence, nombre des itérations.Dans la fonction Bregman d’abord on déclare toutes les variables qu’on aura besoin pourle calcul.Ensemble des indivus en type TT *X;X= new T[N];Après on fait la validation et conversion du type d’objet double * en type T.Déclaration et initialisation des centres du cluster, déclaration de la structure vecteur-listde taille K pour assigner l’indice des individus en chaque cluster.T *uh;vector< list<unsigned int> > Xh(K); uh=initializeUh<T>(X,K,N);Après on aura le boucle des répétitions jusqu’à la convergence que dans cette cas est lenombre des Itérations.Dans cette boucle on fait le remplissage du H_IN, et de la structure de donnés Xh.A la fin on fait la conversion du type T en double *.do{ mexPrintf("n-->Iteracion #:%in",count); for(n=0;n<N;n++){ mexPrintf("n=%i-> .... n",n); k=0; mexPrintf("%d : %d = ",n,k); ds=X[n].dPhi(uh[k]); H_IN[2*n]=k; 12 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 H_IN[1+2*n]=ds; for(k=1;k<K;k++){ mexPrintf("%d : %d = ",n,k); ds=X[n].dPhi(uh[k]); if(ds<H_IN[1+2*n]){ H_IN[2*n]=k; H_IN[1+2*n]=ds; } } Xh.at(H_IN[2*n]).push_back(n); //Affectation de Xi dans le groupe K } list<unsigned int>::iterator j; double cant; for(k=0;k<K;k++){ cant=0; (*sum).reset(); for(j = Xh[k].begin();j != Xh[k].end(); j++) { (*sum)=(*sum)+(X[*j]*Pih[*j]); cant=cant+Pih[*j]; } if(cant!=0) uh[k]=(*sum)/(double) cant; } count++; }while(count<It); delete sum; double *temp; if(retUH==true){ for(k=0;k<K;k++){ temp=(uh[k].returnXi()); for(int i=0;i<p;i++) { UH_IN[k+K*i]=temp[i]; } } } 13 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011EXECUTION DU PROGRAMME BREGMAN.CPP - RESULTATSOn a fait des tests avec 450 points 2D (type=0), dans l’ANNEXE 2 on a le code pourl’exécution:Pour des matrices la Démo 2 dans l’ANNEXE 3 nous donne l’ensemble des centres et aussile vecteur H (indice de cluster par individu) 14 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011CONCLUSIONSLes divergences de Bregman sont une généralisation de l’algorithme K-Means., aveclequel on peut obtenir de résultats pour n’importe quel type d’objet mathématique qui estdans les conditions de Bregman.Grace à la généricité, pour ajouter un nouveau type dans le code on a des pas définis:Faire une sous classe de Member : - Implémenter les fonctions de conversion (double * ↔ T). - Implémentation de la divergence de Bregman (dФ ). - Appel dans la fonction Principale de l’algorithme avec le type d’objet.Un travail sur le parallèlisation reste à faire (OpenMP) car la structure de l’algorithme abesoin de beaucoup des itérations, donc les coûts des exécutions pour des grandsdonnées par exemple de grands matrices 15 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011REFERENCES BIBLIOGRAPHIQUES [1] Bodo Manthey, Heiko Roglin. The Netherlands .Worst-Case and Smoothed Analysis of k-Means Clustering with Bregman Divergences, 2010 [2] Pascal Getreuer. Wrtiting MATLAB C/MEX code, 2010 [3] Aurélie Fischer. LSTA, Université Pierre et Marie Curie. Quantification et Clustering avec des Divergences de Bregman. 2009 [4] Shun-ichi Amari, RIKEN Brain Science Institute, Hirosawa 2-1, Wako-shi, Saitama 351-0198, Japan. Divergence, Optimization and Geometry. 2009 [5] Arindam Banerjee, Srujana Merugu, Inderjit S. Dhillon, and Joydeep Ghosh. Clustering with bregman divergences. Journal of Machine Learning Research, 6:1705–1749, 2005. [6] Ted Jensen. Apuntadores y Arreglos en C, 2000 [7] Bernd Amann. Classification de données (ségmentation, clustering) BDWA-M2 UPMC [8] Philippe Leray. Le clustering en 3 leçons. INSA Rouen -Département ASI - Laboratoire PSI, 2007 16 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011ANNEXE 1- CODE C++/MEX/* Auteur: Medalith Mimbela Estrada Université de la Rochelle Master 1 Ingenierie Mathematique et Image Stage: Implementation de Clustering avec Divergences de Bregman, MEX etC++ */#include <math.h>#include <string.h>#include <iostream>#include <stdlib.h>#include <stdio.h>#include <time.h>#include <list>#include <vector>using namespace std;#include "mex.h"#ifndef mwSize#define mwSize int#endif//const int It=3;/*Type 0: vecteur double 1: matrice double D: taille de matrice ou vecteur, pour chaque individu K: nombre de clusters Xi: individu N: quantité des individus X: ensemble des individus µh: centres des clusters Xh: clusters Pih: Poids des individus H_IN: Matrice (2xN) de groupe pour chaque individu (premier lignegroup,deuxieme ligne distance) */class Member{protected: unsigned int type; unsigned int D;public: Member() {type=0; D=0;} Member(unsigned int type,unsigned int D) {this->type=type; this->D=D;} double *returnXi(); double dPhi(Member &O1); void reset(); void setObject(Member &O1); void setDouble(double *Xi_IN,unsigned int type,unsigned int D); Member& operator + (const Member &B); Member& operator = (const Member &B); Member& operator / (const double &d); Member& operator * (const double &d); unsigned int getType(){return this->type;} unsigned int getD(){return this->D;} 17 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 double getXi(unsigned int i,unsigned int j);};class matrix_Member: public Member{private: double **Xi;public: matrix_Member(){type=0;D=0;} matrix_Member(unsigned int type,unsigned int D) { this->type=type; this->D=D; Xi = (double **) malloc(D *sizeof(double*)); for( unsigned int n=0;n<D;n++){ Xi[n] = (double *) malloc(D *sizeof(double)); for( unsigned int m=0;m<D;m++) Xi[n][m]=0; } } void setDouble(double *Xi_IN,unsigned int type,unsigned int D) { this->type=type; this->D=D; Xi = (double **) malloc(D *sizeof(double*)); for(unsigned int n=0;n<D;n++){ Xi[n] = (double *) malloc(D *sizeof(double)); for(unsigned int m=0;m<D;m++) Xi[n][m]=Xi_IN[n+D*m]; } } void setObject(matrix_Member &O1) { this->type=O1.type; this->D=O1.D; this->Xi = new double* [D]; for(unsigned int n=0;n<D;n++){ this->Xi[n] = new double[D]; for(unsigned int m=0;m<D;m++) this->Xi[n][m]=O1.Xi[m][n]; } } ~matrix_Member(){ for(unsigned int n=0;n<D;n++) free(Xi[n]); free(Xi); } double *returnXi(){ // matrice sous la forme dun vecteur double *Xv; Xv=(double *) malloc(D*D *sizeof(double)); for(unsigned int n=0;n<D;n++){ for(unsigned int m=0;m<D;m++) Xv[m+D*n]=Xi[n][m]; } return Xv; } double dPhi(matrix_Member &O1){ double dist=0.0; unsigned int i,j; for(j=0; j<this->D; j++) { for (i=0; i<this->D; i++) { dist=dist+ (this->Xi[j][i]- O1.Xi[j][i])*(this->Xi[j][i]-O1.Xi[j][i]); } 18 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 } mexPrintf(" %lf n",dist); return sqrt(dist); } void reset(){ for(unsigned int n=0;n<this->D;n++){ for(unsigned int m=0;m<this->D;m++) this->Xi[n][m]=0; } } matrix_Member& operator + (const matrix_Member &B){ for(unsigned int n=0;n<this->D;n++){ for(unsigned int m=0;m<this->D;m++) this->Xi[n][m]=this->Xi[n][m]+B.Xi[n][m]; } return *this; } matrix_Member& operator = (const matrix_Member &B){ this->type=B.type; this->D=B.D; for(unsigned int n=0;n<this->D;n++){ for(unsigned int m=0;m<this->D;m++) this->Xi[n][m]=B.Xi[n][m]; } return *this; } matrix_Member& operator / (const double &d){ for(unsigned int n=0;n<D;n++){ for(unsigned int m=0;m<D;m++) this->Xi[n][m]= this->Xi[n][m]/d; } return *this; } matrix_Member& operator * (const double &d){ for(unsigned int n=0;n<D;n++){ for(unsigned int m=0;m<D;m++) this->Xi[n][m]= this->Xi[n][m]*d; } return *this; } double getXi(unsigned int i,unsigned int j){ return Xi[i][j]; }};class vector_Member: public Member{private: double *Xi;public: vector_Member(){type=0;D=0;} vector_Member(unsigned int type,unsigned int D) { this->type=type; this->D=D; Xi = (double *) malloc(this->D *sizeof(double)); for(unsigned int n=0;n<D;n++) Xi[n]=0; } void setDouble(double *Xi_IN,unsigned int type,unsigned int D) { this->type=type; this->D=D; 19 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 Xi = (double *) malloc(D *sizeof(double)); memcpy(Xi,Xi_IN,this->D*sizeof(double)); } void setObject(vector_Member &O1) { this->type=O1.type; this->D=O1.D; Xi = (double *) malloc(D *sizeof(double)); memcpy(Xi,O1.Xi,this->D*sizeof(double)); } ~vector_Member(){ free(Xi); } double *returnXi(){ return this->Xi; } double dPhi(vector_Member &O1){ double dist=0.0; for(unsigned int n=0;n<this->D;n++){ dist=dist+pow(this->Xi[n]-O1.getXi(n,0),2); } return sqrt(dist); } void reset(){ for(unsigned int n=0;n<this->D;n++) Xi[n]=0; } vector_Member& operator + (const vector_Member &B){ for(unsigned int n=0;n<this->D;n++) this->Xi[n]=this->Xi[n]+B.Xi[n]; return *this; } vector_Member& operator = (const vector_Member &B){ this->type=B.type; this->D=B.D; for(unsigned int m=0;m<this->D;m++) this->Xi[m]=B.Xi[m]; return *this; } vector_Member& operator / (const double &d){ for(unsigned int n=0;n<this->D;n++) { this->Xi[n]=this->Xi[n]/d; } return *this; } vector_Member& operator * (const double &d){ for(unsigned int n=0;n<this->D;n++) { this->Xi[n]=this->Xi[n]*d; } return *this; } double getXi(unsigned int i,unsigned int j){ return this->Xi[i]; }};template<class T>T* initializeUh(T *X_IN,unsigned int K,unsigned int N){ T *uh; int r; 20 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 srand(time(NULL)); unsigned int D=X_IN[0].getD(); unsigned int TYPE=X_IN[0].getType(); uh = (T *) malloc(K *sizeof(T)); for(int k=0;k<K;k++){ r=rand()%N; uh[k].setObject(X_IN[r]); } return uh;}template<class T> void algBregman(double X_IN[],unsigned int N,unsignedint p,unsigned int type,unsigned int K,double *Pih,double H_IN[],doubleUH_IN[],bool retUH,unsigned int It){ unsigned int count=0; double ds=0.0; unsigned int k=0,n=0,m=0; unsigned int D; T *X; X= new T[N]; if(type==0){ double *temp; temp =new double[p]; D=p; for(n=0;n<N;n++){ for (m=0;m<p;m++) temp[m]=X_IN[n + N*m]; X[n].setDouble(temp,type,p); } } if(type==1){ double *temp; temp =new double[p]; D=(unsigned int)sqrt(p); for(n=0;n<N;n++){ for (m=0;m<p;m++) temp[m]=X_IN[n + N*m]; X[n].setDouble(temp,type,D); } } T *uh; vector< list<unsigned int> > Xh(K); uh=initializeUh<T>(X,K,N); T *sum; sum=new T(type,D); do{ mexPrintf("n-->Iteracion #:%in",count); for(n=0;n<N;n++){ mexPrintf("n=%i-> .... n",n); k=0; mexPrintf("%d : %d = ",n,k); ds=X[n].dPhi(uh[k]); H_IN[2*n]=k; H_IN[1+2*n]=ds; for(k=1;k<K;k++){ mexPrintf("%d : %d = ",n,k); ds=X[n].dPhi(uh[k]); if(ds<H_IN[1+2*n]){ 21 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 H_IN[2*n]=k; H_IN[1+2*n]=ds; } } Xh.at(H_IN[2*n]).push_back(n); mexPrintf("Affectation de %i dans %f (dist =%f)n",n,H_IN[2*n],H_IN[1+2*n]); //Affectation de Xi dans le groupe K } list<unsigned int>::iterator j; double cant; for(k=0;k<K;k++){ cant=0; (*sum).reset(); for(j = Xh[k].begin();j != Xh[k].end(); j++) { (*sum)=(*sum)+(X[*j]*Pih[*j]); cant=cant+Pih[*j]; } if(cant!=0) uh[k]=(*sum)/(double) cant; } count++; }while(count<It); delete sum; double *temp; if(retUH==true){ for(k=0;k<K;k++){ temp=(uh[k].returnXi()); for(int i=0;i<p;i++) { UH_IN[k+K*i]=temp[i]; } } }}void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray*prhs[]){#define H_OUT plhs[0]//#define DIST_OUT plhs[1]#define UH_OUT plhs[1]#define X_IN prhs[0]#define PX_IN prhs[1]#define K_IN prhs[2]#define TYPE_IN prhs[3]#define IT_IN prhs[4] double *X, *PX; double *H; double *UH; unsigned int K,TYPE,n,m,k; bool retUH=true; X =(double*)mxGetPr(X_IN); PX =(double *)mxGetPr(PX_IN); K=(unsigned int)mxGetScalar(K_IN); TYPE=(unsigned int)mxGetScalar(TYPE_IN); unsigned const int It= (unsigned int)mxGetScalar(IT_IN); 22 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011 unsigned const int N=mxGetM(X_IN); unsigned const int p=mxGetN(X_IN); mexPrintf("Nombre elements=%i ",N); mexPrintf("taille element=%i ",p); mexPrintf("K=%in",K); if(nrhs >5) mexErrMsgTxt("Too many input arguments."); else if(nlhs>2) mexErrMsgTxt("Too many output arguments."); else if(nlhs==1) retUH=false; else if(TYPE==1 && (sqrt(p)-(int)sqrt(p))!=0) mexErrMsgTxt("Pour le type Matrice, la taille des individus doitêtre un carrée parfait"); else if(K>N) mexErrMsgTxt("La quantité de clusters doit être mineur auquantité des individus"); H_OUT = mxCreateDoubleMatrix(2,N,mxREAL); UH_OUT= mxCreateDoubleMatrix(K,p,mxREAL); H=mxGetPr(H_OUT); UH=mxGetPr(UH_OUT); if(TYPE==0) algBregman<vector_Member>(X,N,p,TYPE,K,PX,H,UH,retUH,It); if(TYPE==1) algBregman<matrix_Member>(X,N,p,TYPE,K,PX,H,UH,retUH,It); return;} 23 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011ANNEXE 2 – CODE MATLAB DEMO VECTEURload(dif.txt);X=dif(:,2:end);PX(1:450)=1;K=5;TYPE=0;IT=4;[H,UH]=bregman(X,PX,K,TYPE,IT);H(1,:)=H(1,:)+1;[N,p]=size(X);[x,k1]=find(H(1,:)==1);[x,k2]=find(H(1,:)==2);[x,k3]=find(H(1,:)==3);[x,k4]=find(H(1,:)==4);[x,k5]=find(H(1,:)==5);title(K-Means 2D);hold on;plot(X(k1,1),X(k1,2),*r);hold on;plot(X(k2,1),X(k2,2),*b);hold on;plot(X(k3,1),X(k3,2),*g);hold on;plot(X(k4,1),X(k4,2),*c);hold on;plot(X(k5,1),X(k5,2),*y);hold onplot(UH(:,1),UH(:,2),kx,MarkerSize,12,LineWidth,2)plot(UH(:,1),UH(:,2),ko,MarkerSize,12,LineWidth,2);legend(Cluster 1,Cluster 2,Cluster 3,Cluster 4,Cluster5,Centroids,Location,NW); 24 Université de La Rochelle – M1 IMI
    • Clustering efficace avec les Divergences de Bregman 2011ANNEXE 3 – CODE MATLAB DEMO MATRICESfor i=1:21if i<11Xm(i,:)=rand(1,9);elseXm(i,:)=randn(1,9);endendPXm(1:21)=1;K=3;It=4;TYPE=1; %matrice[Hm,UHm]=bregman(Xm,PXm,K,TYPE,It); 25 Université de La Rochelle – M1 IMI