pontiac firebird transam 81

INF442 : Traitement des données massives
A2 : Le regroupement plat et le regroupement hiérarchique
Frank Nielsen
X2013
15 avril 2015
Administratif
dernier dépôt des TDs : le dimanche soir à 23h59m59s suivant le
mercredi du TD
élection du délégué de cours : ? ? ?
TD1 : ok, félicitations !
TD2 commence par l’exercice MPI du TD1.
tutorat langage C++ mis en place par la DE.
Deux créneaux : le mardi et le jeudi de 18h à 20h (Ivan Ustinov)
Voir les planches du memento C++ sous moodle
Rassurez-vous, TD 3 (détecteur de pourriels) et TD 4 (chiffrement de
Hill) sont bien moins copieux !
Projet informatique
responsable PIs : Claudia D’Ambrosio
[email protected]
3 choix pour le 20 avril 2015
PI validé le 23 avril 2015
Date de remise sous Moodle : ≤ 22 mai 2015
Soutenance PI : entre le 1er juin et le 12 juin 2015
Sujets/difficultés (* : facile , ** : moyen, *** : difficile) :
442-1
442-2
442-3
*
*
**
Lancer de rayon (image de synthèse)
PageRank (matrices)
CASP : Assessment Protein Structure Prediction
442-4
442-5
442-6
442-7
**
***
***
?
Graphes & arbres recouvrants (most vital edge)
Détecteur de Viola Jones (vision)
Repliement des protéines (biologie)
Projet au choix, sujet à rédiger et valider
S. Redon
P.L. Poirion
A. Héliou
& P. Chassignet
S. Toubaline
J.-B. Bordes
P. Chassignet
?
442-7 : Projet au choix en C++ (sans MPI) également possible.
HPC : quelques cas pour le Super-Computing (SC)
HPC = on recherche l’ efficacité !
Utiliser des modèles pour de la simulation parce que sinon c’est
difficile à construire (souffleries)
cher à construire (crash d’avion/voiture)
lent à attendre (évolution du climat, galaxies)
dangereux (armes, drogues, pollutions, épidémies)
Avoir des résultats rapides voire en ligne
on-line, incremental :
trop
trop
trop
trop
valeur temporelle du résultat (météo)
être le premier à avoir le résultat (bourse, trading HFT)
être le premier à avoir “une analyse” (incluant le coût de dévelopement)
Données massives, le Big Data :
analyse du génome/d’une famille de génomes
recherche d’intelligence extraterrestre (SETI)
Accélération, efficacité et scalabilité
tseq
tP
t1
:
:
:
temps écoulé par le programme séquentiel
... par programme parallèle sur P proc.
... par le programme parallèle exécuté en séquentiel, P = 1
bien sûr, t1 ≥ tseq sinon on aurait un meilleur algo. séquentiel
tseq
tseq
tP , souvent tP
tseq
speedup(P)
= P×t
P
P
Accélération : speedup(P) =
Efficacité : e(P) =
par rapport au speed-up linéaire, e(P) = 1 ⇔ tP =
Speed-up, efficiency
t1
tP
tseq
P
Loi d’Amdahl (1967) : un frein au parallélisme ?
gain de performance idéal :
α = fraction du code parallèlisable
αseq = fraction du code non-parallèlisable
avec αseq + α = 1
speedup(P) =
(αseq + α )t1
1
t1
=
=
α
tn
(αseq + P )t1
αseq +
lim speedup(P) =
P→∞
α
P
1
1
=
αseq
1 − α
⇒ accélération bornée par la fraction de code αseq non-parallèlisable (celle
qui est intrinséquement séquentielle)
Loi d’Amdahl : comportement asymptotique
20
18
16
14
speed−up
12
10
8
6
4
0.75
0.9
0.95
2
0
1
4
16
64
256
1024
nombre de processeurs (P)
4096
16384
65536
Loi d’Amdahl : un exemple visuel pour concrétiser
αseq = 20% et donc α = 80%
P =1
P=2
P=4
P →∞
P=8
seq
...
Temps
par
S=1
S=
5
3
S=
2
5
lim speedup(P) =
P→∞
S=
10
3
1
=⇒ speedup ≤ ×5
αseq
Est-ce alors intéressant d’avoir des grands clusters de machines ?
S=5
Loi de Gustafson : scale speed-up, à la rescousse !
Simulation : taille des mailles d’une grille 2D/3D = fonction de P
Vidéo : SD, HD, 4K, 8K, etc.
Concept = Charge de travail (workload) grandit linéairement avec P
n n’est pas fixé ! (= cas d’Amdahl)
t1 (P) = αseq tP + P × (α × tP )
speedupGustafson (P) = αseq + P × (1 − αseq )
Gustafson = parallélisme de données
.
Loi de Gustafson : un exemple visuel
Loi de Gustafson : speedup(P) = αseq + P × α . scale speed-up
P =1
P =2
P =4
P =8
seq
temps
par
n
2n
4n
8n
la taille des données n augmente
speedup(P) = 0.2 + 0.8 × P
Parfois, en pratique, on obtient un speed-up super-linéaire (hyper-linéaire),
qui s’explique par le cache hiérarchique des données
Pensez au cheminement complexe des données vers le processeur dans le
matériel !
Comparaison des lois d’Amdahl et de Gustafson
Amdahl : tP est une fonction de (t1 , α , P)
Gustafson : t1 est une fonction de (tP , α , P)
efficacité(P) =
accélération(P)
P
efficacité asymptotique d’Amdahl : limP→∞ eAmdahl (P) = 0.
Accélération toujours bornée .
efficacité asymptotique de Gustafson : limP→∞ eGustafson (P) = α .
Accélération non-bornée asymptotiquement.
... pas de contradiction car αseq de Gustafson = αseq d’Amdahl.
Loi de Moore (1975)
En fait, une loi empirique , une conjecture... que l’industrie essaye de
satisfaire !
nombre de transistors des processeurs double tous les 18 mois
Cluster de machines : une architecture à mémoire
distribuée
espace mémoire local associé à chaque processeur
processeurs connecté par un réseau d’interconnexion
accès mémoire aux autres processeurs explicite par échanges de
messages sur le réseau
le réseau d’interconnexion détermine la vitesse d’accès aux données
caractéristiques du réseau :
transmission avec modèle de coût α + τ × Longueur(message) :
latence : temps pour initier une communication (α)
bande passante : vitesse de transfert des données (τ )
topologie : architectures physique (matériel) et logique (utilisé par les
algorithmes //)
Processus
Les systèmes d’exploitation modernes sont multi-tâches : plusieurs
applications non-bloquantes peuvent tourner en “même temps” (time-slicing).
un seul processus en cours d’exécution sur le CPU à un instant donné,
un ordonnanceur de tâches qui alloue les processus aux CPUs/cœurs,
état d’un processus : en cours d’exécution, prêt en attente de CPU,
bloqué (suspendu/attente de réveil).
Cadre théorique : un processus tourne sur un processeur (mono-cœur) qui
constitue un nœud du cluster. P/Proc. (= processus, = processeur)
Tâches (jobs) sous UNIX
[ france ~] $ sleep 10000 &
[1] 12027
[ france ~] $ sleep 15000 &
[2] 12065
[ france ~] $ jobs
[1] - Running
[2]+ Running
[ france ~] $ kill %1
[1] - T e r m i n a t e d
[ france ~] $ fg %2
sleep 15000
sleep 10000 &
sleep 15000 &
sleep 10000
On suspend une tâche avec Ctrl-Z , et on la fait passer dans le fond avec bg
% (background)
Une tâche peut lancer plusieurs processus (souvent c’est un seul)
Tâches (jobs) sous UNIX : tuer une tâche
[ france ~] $ ps
PID TTY
TIME
10241 pts /0
00:00:00
12167 pts /0
00:00:00
[ france ~] $ sleep 10000
[1] 12169
[ france ~] $ ps -F
UID
PID PPID C
11234
10241 10240 0
11234
12169 10241 0
11234
12170 10241 0
[ france ~] $ kill 12169
[1]+ Terminated
CMD
bash
ps
&
SZ
1236
953
1132
RSS PSR STIME TTY
1456
6 10:08 pts /0
472
1 10:50 pts /0
900
1 10:50 pts /0
sleep 10000
TIME
00:00:00
00:00:00
00:00:00
CMD
- bash
sleep 10000
ps -F
Programmer avec la Message Passing Interface (MPI)
Multiple Program Multiple Data : MPMD
Single Program Multiple Data : SPMD
R 3).
Taxonomie de Flynn (1972). SPMD (GPU), MPMD (Playstation
MPI : le standard/la bibliothéque
Outre les calculs locaux sur chaque processus, on a aussi :
des mouvements de données via des envois et réceptions de messages
(broadcast, scatter, gather, all-to-all, etc.),
de la synchronisation (barrière où tous les processus s’attendent avant
de pouvoir continuer),
du calcul global (comme des opérations de sommes cumulées, reduce et
scan ou parallel prefix).
MPI : Les communications collectives usuelles
Concernent tous les processus d’un groupe de communication (souvent
WORLD)
P1
P2
P3
M
processus appelant
P0
message
M
diffusion
personnalisée
scatter
Mi
M
diffusion
broadcast
M
M
M1
M2
M3
Mi
messages personnalisés M1 , M2 , M3 à envoyer
M1
M2
M3
rassemblement
gather
M1
M2
M3
Mi
messages personnalisés M1 , M2 , M3 reçus
2
3
1
réduction
reduce
2
3
6
AVANT
APRÈS
1
MPI : Les communications collectives
un à tous (one-to-all) :
tous à un (all-to-one) :
La diffusion, Broadcast : MPI Bcast, message entier
La difusion personnalisée, Scatter : MPI Scatter, message partitionné en
morceaux
La réduction, Reduce : MPI Reduce, opération comme MPI SUM, etc.
Le rassemblement, Gather : MPI Gather, assemble le message à partir des
messages par morceaux
tous à tous (all-to-all, total exchange), le commérage : MPI Alltoall
MPI : les deux opérations de base send et receive
Communications bloquantes
send(&data, n, Pdest) :
Envoie n données pointées par &data au processeur Pdest
receive(&data,n, Psrc) :
Reçoit n données à l’adresse pointée par &data du processeur Psrc
Que se passe t’il dans ce petit exemple ?
P0
...
a=442;
send(&a, 1, P1);
a=0;
P1
...
receive(&a, 1, P0);
cout << a << endl;
Communications bloquantes (non-bufferisées)
⇒ provoque de l’attente (idling)
Envoyeur ou receveur doivent s’attendre mutuellement (hand-shaking).
M P I I n i t (& a r g c ,& a r g v ) ;
MPI Comm size (MPI COMM WORLD,& numprocs ) ;
MPI Comm rank (MPI COMM WORLD,& myid ) ;
t a g =442; s o u r c e =0; d e s t i n a t i o n =1; c o u n t =1;
i f ( myid == s o u r c e ) {
b u f f e r =2015;
MPI Send(& b u f f e r , cou n t , MPI INT , d e s t i n a t i o n , tag ,
MPI COMM WORLD) ;
p r i n t f ( ” Le p r o c e s s e u r %d a e n v o y e %d\n” , myid ,
buffer ) ;
}
i f ( myid == d e s t i n a t i o n ) {
MPI Recv(& b u f f e r , count , MPI INT , s o u r c e , tag ,
MPI COMM WORLD,& s t a t u s ) ;
p r i n t f ( ” Le p r o c e s s e u r %d a r e c u %d\n” , myid ,
buffer ) ;
}
...
t a g =442; s o u r c e =0; d e s t i n a t i o n =1; c o u n t =1;
i f ( myid == s o u r c e ) {
b u f f e r =2015;
MPI Send(& b u f f e r , cou n t , MPI INT , d e s t i n a t i o n , tag ,
MPI COMM WORLD) ;
p r i n t f ( ” Le p r o c e s s e u r %d a e n v o y e %d\n” , myid ,
buffer ) ;
}
i f ( myid == d e s t i n a t i o n ) {
MPI Recv(& b u f f e r , count , MPI INT , s o u r c e , tag ,
MPI COMM WORLD,& s t a t u s ) ;
p r i n t f ( ” Le p r o c e s s e u r %d a r e c u %d\n” , myid ,
buffer ) ;
}
...
Le processeur 0 a envoye 2015
Le processeur 1 a recu 2015
Minimiser les temps d’attente
Pour des communications bloquantes, on cherche donc à minimiser le temps
d’attente (on verra plus tard l’équilibrage de charge, le load balancing).
Temps d’attente pour le receveur
Receveur prêt avant l’envoyeur (communications bloquantes)
MPI : les situations de blocages (deadlocks)
Que se passe t’il dans cet exemple ?
P0
send(&a, 1, P1);
receive(&b, 1, P1);
P1
send(&a, 1, P0);
receive(&b, 1, P0);
Envoyeur P0 attend le “OK pour envoi” de P1
Envoyeur P1 attend le “OK pour envoi” de P0
Ça bloque. On est en situation de deadlock !
(Ctrl-C pour tuer le programme...)
Programmer avec MPI peut-être complexe à déboguer
MPI : les blocages (deadlocks)
Les communications bloquantes sont nécessaires pour assurer la
consistence (sémantique) des programmes mais font apparaı̂tre des
situations indésirables de blocage.
Pour le send, on peut pré-allouer un espace mémoire “buffer données”
(Data buffer, DB) à chaque processus, puis envoyer les données en deux
temps :
Envoi sur le Data Buffer DB,
Sur le processeur receveur, recopie le DB à l’endroit &data,
Implanté soit matériellement soit par un protocole logiciel.
Néanmoins, il subsiste toujours une situation de blocage lorsque le buffer
de données DB devient plein
MPI : les blocages (deadlocks)
Même si on gère bien les appels send, le problème du deadlock subsiste.
Le problème des receive...
P0
receive(&a, 1, P1);
send(&b, 1, P1);
⇒ blocage
P1
receive(&a, 1, P0);
send(&b, 1, P0);
MPI : Send/Receive non-bloquantes et non-bufferisées
Comment envoyer/recevoir des messages avec des communications
non-bloquantes...
L’envoyeur poste un message “Demande d’envoi” (pending message) et
continue l’exécution de son programme,
Le receveur poste un “OK pour envoi”, et le transfert de données
s’effectue,
Quand le transfert de données est fini, un check status indique qu’on
peut toucher aux données sans danger
⇒ communications non-bloquantes
commnonbloq442.cpp
M P I S t a t u s s t a t u s ; M PI Request r e q u e s t ;
M P I I n i t (& a r g c ,& a r g v ) ;
MPI Comm size (MPI COMM WORLD,& numprocs ) ;
MPI Comm rank (MPI COMM WORLD,& myid ) ;
t a g =442; s o u r c e =0; d e s t i n a t i o n =1; c o u n t =1;
r e q u e s t=MPI REQUEST NULL ;
i f ( myid == s o u r c e ) {
b u f f e r =2015;
M P I I s e n d (& b u f f e r , cou n t , MPI INT , d e s t i n a t i o n , tag ,
MPI COMM WORLD,& r e q u e s t ) ;
}
i f ( myid == d e s t i n a t i o n ) {
M P I I r e c v (& b u f f e r , cou n t , MPI INT , s o u r c e , tag ,
MPI COMM WORLD,& r e q u e s t ) ;
}
MPI Wait(& r e q u e s t ,& s t a t u s ) ;
p r i n t f ( ” [ p r o c %d ] s t a t u s de MPI WAIT : %d\n” , myid ,
status ) ;
i f ( myid == s o u r c e ) {
p r i n t f ( ” Le p r o c e s s e u r %d
buffer ) ;
}
i f ( myid == d e s t i n a t i o n ) {
p r i n t f ( ” Le p r o c e s s e u r %d
, buffer ) ;
}
a e n v o y e %d\n” , myid ,
a b i e n r e c u %d\n” , myid
attente avec MPI_WAIT ...
attente avec MPI_WAIT ...
[ proc 0] status de MPI_WAIT : 0
Le p r o c e s s e u r 0 a envoye 2015
[ proc 1] status de MPI_WAIT : 0
Le p r o c e s s e u r 1 a bien recu 2015
MPI : Les six routines standards sont...
procédures , types de données et constantes sont préfixées par MPI
(fichier mpi.h)
100+ procédures dont les six principales sont :
Initialisation de la bibliothèque
MPI Init
MPI Finalize Termine l’utilisation de MPI
MPI Comm size Donne le nombre de processus
MPI Comm rank Étiquette du processus appelant
Envoi un message (bloquant)
MPI Send
Reçoit un message (bloquant)
MPI Recv
Ces procédures retournent MPI SUCCESS en cas de succès, sinon un code
d’erreur.
Quelques hypothèses sur la concurrence
le processeur (ou PE) peut effectuer plusieurs “choses” en même temps
Par exemple, on peut supposer
il faut donc que ces 3 opérations soient indépendantes !
MPI IRecv(), non-bloquant
MPI ISend(), non-bloquant
+ calcul local
donc on ne peut pas envoyer le résultat du calcul
on ne peut pas forwarder = envoyer ce que l’on reçoit
en pseudo-code, on note les activités concurrentes par ||
(une double barre)
Activité1 ||Activité2 ||Activité3
MPI : Les types de données enMPI
Ce qu’on envoie/reçoı̂t... MPI_Commande(&buffer,count,MPI_INT, ...)
Type MPI
MPI CHAR
MPI SHORT
MPI INT
MPI LONG
MPI UNSIGNED CHAR
MPI UNSIGNED SHORT
MPI UNSIGNED
MPI UNSIGNED LONG
MPI FLOAT
MPI DOUBLE
MPI LONG DOUBLE
MPI BYTE
MPI PACKED
Type dans le langage C
signed char
signed short int
signed int
signed long int
unsigned char
unsigned short int
unsigned int
unsigned long int
float
double
long double
MPI : La primitive send
https://www.open-mpi.org/doc/v1.4/man3/MPI_Send.3.php
Syntaxe en C :
#i n c l u d e <mpi . h>
i n t MPI Send ( v o i d ∗ buf , i n t count , M PI D a t a t y p e
d a t a t y p e , i n t d e s t , i n t tag , MPI Comm comm)
Syntaxe en C++ (plus mis à jour depuis MPI-2) :
#i n c l u d e <mpi . h>
v o i d Comm : : Send ( c o n s t v o i d ∗ buf , i n t count , c o n s t
D a t a t y p e& d a t a t y p e , i n t d e s t , i n t t a g ) c o n s t
tag : Message tag (integer), utile pour la filtration et l’appariemment des
opérations send/receive. Par défault, tag=0
On utilise la syntaxe d’appel en C du MPI dans nos programmes C++
MPI : les communications non-bloquantes (C API) “I”
i n t M P I I s e n d ( v o i d ∗ buf , i n t count , M PI D a t a t y p e
d a t a t y p e , i n t d e s t , i n t tag , MPI Comm comm ,
M P I Request ∗ r e q )
i n t M P I I r e c v ( v o i d ∗ buf , i n t count , M PI D a t a t y p e
d a t a t y p e , i n t s r c , i n t tag , MPI Comm comm ,
M P I Request ∗ r e q )
L’objet MPI Request est utilisé dans les routines suivantes :
Retourne *flag=1 si l’opération *req est finie, 0 sinon
i n t MPI Test ( M PI Request ∗ req , i n t ∗ f l a g , M P I S t a t u s
∗ status )
Attend jusqu’à ce que l’opération associée avec *req soit finie.
i n t MPI Wait ( M PI Request ∗ req , M P I S t a t u s ∗ s t a t u s )
MPI : les groupes de communication, communicators
Défini le cadre des opérations de communication,
Chaque processus inclus dans un communicator a un rang associé,
Par défaut, MPI COMM WORLD inclut tous les p processus, rang de 0 à
p − 1,
On peut créer des communicators pour des groupes de processus,
int MPI Comm size(MPI Comm comm, int *size) et int
MPI Comm rank(MPI Comm comm, int *size)
Barrière de synchronisation : MPI Barrier
MPI Barrier : Bloque jusqu’à temps que tous les processus arrivent à cette
routine = synchronisation !
Barrière de synchronisation
Barrière de synchronisation
Mesurer le temps sous MPI : MPI Wtime
double start, end;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Barrier(MPI_COMM_WORLD); /* IMPORTANT */
start = MPI_Wtime();
/* faire le calcul ici */
calculINF442();
MPI_Barrier(MPI_COMM_WORLD); /* IMPORTANT */
end = MPI_Wtime();
MPI_Finalize();
if (rank == 0) {cout<< end-start <<endl;}
Ou alors utiliser MPI Reduce() pour calculer les temps minima/maxima (et
autres statistiques) des processus...
MPI : Calcul globaux Reduce
C:
#i n c l u d e <mpi . h>
i n t MPI Reduce ( v o i d ∗ s e n d b u f , v o i d ∗ r e c v b u f , i n t count
, M PI D a t a t y p e d a t a t y p e , MPI Op op , i n t r o o t ,
MPI Comm comm)
https://www.open-mpi.org/doc/v1.5/man3/MPI_Reduce.3.php
Arbre de réduction (dépend de la topologie)
(+ 1 2 3 4)
(+ (+ 1 2) (+ 3 4))
MPI : Reduce, opérations de calcul prédéfinies
Opérateur binaire associatif et commutatif
Nom
MPI MAX
MPI MIN
MPI SUM
MPI PROD
MPI LAND
MPI BAND
MPI LOR
MPI BOR
MPI LXOR
MPI BXOR
MPI MAXLOC
MPI MINLOC
Signification
maximum
minimum
sum
product
logical and
bit-wise and
logical or
bit-wise or
logical xor
bit-wise xor
max value and location
min value and location
Calcul de la factorielle...factoriellempireduce442.cpp
i n t i , moi , n p r o c s ;
i n t nombre , g l o b a l F a c t =−1, l o c a l F a c t ;
M P I I n i t (& a r g c ,& a r g v ) ;
MPI Comm size (MPI COMM WORLD,& n p r o c s ) ;
MPI Comm rank (MPI COMM WORLD,& moi ) ;
nombre=moi +1;
// dans l e s argum e nts , s e r a p p e l e r l ’ o r d r e ( s o u r c e , d e s t i n a t i o n )
MPI Reduce(&nombre ,& g l o b a l F a c t , 1 , MPI INT , MPI PROD , 0 ,MPI COMM WORLD) ;
i f ( moi==0)
{ p r i n t f ( ” f a c t o r i e l l e a v e c r e d u c e p o u r %d p r o c e s s u s = %d\n ” , n p r o c s , g l o b a l F a c t ) ; }
l o c a l F a c t =1; f o r ( i =0; i <n p r o c s ; i ++) { l o c a l F a c t ∗=( i +1) ; }
i f ( moi==0)
{ p r i n t f ( ” f a c t o r i e l l e l o c a l e : %d\n ” , l o c a l F a c t ) ; }
MPI Finalize () ;
MPI : Les commandes Scan/ Préfixe parallèle
i n t MPI Scan ( v o i d ∗ s e n d b u f , v o i d ∗ r e c v b u f , i n t count ,
M P I D a t a t y p e d a t a t y p e , MPI Op op , MPI Comm comm )
processus
entrée (vi )
sortie
P0
1
1
P1
2
3 (= 1 + 2)
P2
3
6 (= 1 + 2 + 3)
P3
4
10 (= 1 + 2 + 3 + 4)
a+b+c+d
P0
a
b
P1
b
c
c
P2
c
a+b+c+d
P3
d
d
P3
d
a+b+c+d
P0
a0
b0
c0
P1
a1
b1
c1
P2
a2
b2
c2
P0
a
P1
b
P2
a+b+c+d
reduce
scan
Allreduce
a+b+c+d
a0
b0
c0
a0 + a 1
b0 + b1
c0 + c1
a0 + a 1 + a 2
b0 + b1 + b 2
c0 + c1 + c2
Algorithme parallèle pour les
k-moyennes
Frank Nielsen
Parallel k-means
MPI
4.k-moyennes sous MPI
A2-47
Parallélisation : propriété de composition du centroı̈de
Soit X et X deux jeux de données pondérés avec leurs sommes des poids
totaux W et W (X ∩ X = ∅). Alors on a la règle de composition :
x̄(X ∪ X ) =
W
W
x̄(X
)
+
x̄ (X )
W + W
W +W
Très utile pour partager le calcul des données sur plusieurs processeurs...
On fait des paquets X1 , ..., Xp équilibrés de taille pn
Propriété forte de la géométrie Euclidienne (pas vrai en géométrie
hyperbolique)
Frank Nielsen
4.k-moyennes sous MPI
A2-48
Règle de composition : preuve élémentaire
Prenons X ∩ X = ∅.
x̄(X ∪ X ) =
W
W
x̄(X ) +
x̄ (X )
W +W
W +W
x̄(X ) =
1 x
|X |
x∈X
1
x̄(X ∪ X ) =
|X | + |X |
x∈X
x = |X |x̄(X ),
x+
x∈X
x
x ∈X x = |X |x̄(X )
x ∈X W = |X | et W = |X |, idem pour des poids arbitraires W et W .
Frank Nielsen
4.k-moyennes sous MPI
A2-49
Parallélisation de l’heuristique de Lloyd
Soit p processeurs P0 , ..., Pp−1 , tous les processeurs lisent leurs
(tient dans la mémoire vive, RAM).
Utilisons
la propriété de décomposition des centroı̈des :
1
x̄(X ) = p−1
i =0 p x̄(Xp ).
n
p
données
Un des processeurs, disons P0 s’occupe de l’initialisation des centroides,
puis diffuse (broadcast) cette initialisation à tous les autres processeurs.
En MPI, commande MPI Bcast.
Chaque processeur Pr s’occupe d’ un paquet de pn données
Xr = {xr np ...x(r +1) np −1 } en calculant la distance minimale de ses xi aux
centres. On met à jour la fonction de coût et on calcule les centroı̈des et
cardinalité indépendamment dans chaque paquet : G1 (r ), ..., Gk (r ) avec
n1 (r ) = |G1 (r )|, ..., nk (r ) = |Gk (r )|.
Puis on réduit (opération reduce) tous les cj (r ) et nj (r ) en faisant la
somme (opération dédiée de MPI) : MPI Allreduce
On répéte jusqu’à convergence (ou lorsque la décroissance de la fonction
de coût passe sous un seuil donné).
Frank Nielsen
4.k-moyennes sous MPI
A2-50
Frank Nielsen
4.k-moyennes sous MPI
A2-51
Les k-moyennes en MPI : analyse de la complexité
Algorithme séquentiel : O(dnks), s : nombre d’itérations (Lloyd).
Les opérations élémentaires comme Reduce, Bcast, etc. dépendent de la
topologie du réseau d’interconnexion .
Initialisation des centroı̈des par le processeur P0 en temps O(dk)
Coût total :
O dk + Bcast(p, dk) + s
dkns
dn
+ Reduce(p, dk)
∼n>>k,d O
p
p
→ Facteur d’accélération
rapport du temps séquentiel sur le
(speed-up,
= O(p).
temps parallèle) α = O dkns
dkns
p
Philosophie différente de MapReduce (Hadoop) : Autre modèle de calcul
distribué simple.
Frank Nielsen
4.k-moyennes sous MPI
A2-52
Les k-moyennes : Un clustering
par partition
= clustering plat
vs
Regroupement hiérarchique
Frank Nielsen
5.Regroupement
A2-53
Trouver des liens de proximité entre les données
Mazda RX4
Mazda RX4 Wag
Datsun 710
Hornet 4 Drive
Hornet Sportabout
Valiant
Duster 360
Merc 240 D
Merc 230
Merc 280
Merc 280 C
Merc 450 SE
Merc 450 SL
Merc 450 SLC
Cadillac Fleetwood
Lincoln Continental
Chrysler Imperial
Fiat 128
Honda Civic
Toyota Corolla
Toyota Corona
Dodge Challenger
AMC Javelin
Camaro Z28
Pontiac Firebird
Fiat X1 -9
Porsche 914 -2
Lotus Europa
Ford Pantera L
Ferrari Dino
Maserati Bora
Volvo 142 E
Frank Nielsen
mpg cyl disp hp drat
wt qsec vs am gear carb
21.0
6 160.0 110 3.90 2.620 16.46 0 1
4
4
21.0
6 160.0 110 3.90 2.875 17.02 0 1
4
4
22.8
4 108.0
93 3.85 2.320 18.61 1 1
4
1
21.4
6 258.0 110 3.08 3.215 19.44 1 0
3
1
18.7
8 360.0 175 3.15 3.440 17.02 0 0
3
2
18.1
6 225.0 105 2.76 3.460 20.22 1 0
3
1
14.3
8 360.0 245 3.21 3.570 15.84 0 0
3
4
24.4
4 146.7
62 3.69 3.190 20.00 1 0
4
2
22.8
4 140.8
95 3.92 3.150 22.90 1 0
4
2
19.2
6 167.6 123 3.92 3.440 18.30 1 0
4
4
17.8
6 167.6 123 3.92 3.440 18.90 1 0
4
4
16.4
8 275.8 180 3.07 4.070 17.40 0 0
3
3
17.3
8 275.8 180 3.07 3.730 17.60 0 0
3
3
15.2
8 275.8 180 3.07 3.780 18.00 0 0
3
3
10.4
8 472.0 205 2.93 5.250 17.98 0 0
3
4
10.4
8 460.0 215 3.00 5.424 17.82 0 0
3
4
14.7
8 440.0 230 3.23 5.345 17.42 0 0
3
4
32.4
4 78.7 66 4.08 2.200 19.47 1 1
4
1
30.4
4 75.7 52 4.93 1.615 18.52 1 1
4
2
33.9
4 71.1 65 4.22 1.835 19.90 1 1
4
1
21.5
4 120.1
97 3.70 2.465 20.01 1 0
3
1
15.5
8 318.0 150 2.76 3.520 16.87 0 0
3
2
15.2
8 304.0 150 3.15 3.435 17.30 0 0
3
2
13.3
8 350.0 245 3.73 3.840 15.41 0 0
3
4
19.2
8 400.0 175 3.08 3.845 17.05 0 0
3
2
27.3
4 79.0 66 4.08 1.935 18.90 1 1
4
1
26.0
4 120.3
91 4.43 2.140 16.70 0 1
5
2
30.4
4 95.1 113 3.77 1.513 16.90 1 1
5
2
15.8
8 351.0 264 4.22 3.170 14.50 0 1
5
4
19.7
6 145.0 175 3.62 2.770 15.50 0 1
5
6
15.0
8 301.0 335 3.54 3.570 14.60 0 1
5
8
21.4
4 121.0 109 4.11 2.780 18.60 1 1
4
2
5.Regroupement
A2-54
Frank Nielsen
50
100
Ferrari Dino
Honda Civic
Toyota Corolla
Fiat 128
Fiat X1−9
Mazda RX4
Mazda RX4 Wag
Merc 280
Merc 280C
Merc 240D
Lotus Europa
Merc 230
Volvo 142E
Datsun 710
Toyota Corona
Porsche 914−2
Maserati Bora
Hornet 4 Drive
Valiant
Merc 450SLC
Merc 450SE
Merc 450SL
Dodge Challenger
AMC Javelin
Chrysler Imperial
Cadillac Fleetwood
Lincoln Continental
Ford Pantera L
Duster 360
Camaro Z28
Hornet Sportabout
Pontiac Firebird
0
hauteur
150
200
250
Regroupement hierarchique (distance moyenne)
5.Regroupement
A2-55
Les sciences du vivant adorent le regroupement
hiérarchique !
Gene expression patterns of breast carcinomas distinguish tumor subclasses
with clinical implications http://www.pnas.org/content/98/19/10869.figures-only
Frank Nielsen
5.Regroupement
A2-56
Le regroupement hiérarchique : reconnaissance de visages
Hierarchical Clustering With Prototypes via Minimax Linkage, 2011.
Frank Nielsen
5.Regroupement
A2-57
Le clustering/regroupement hiérarchique ascendant
On part des données X = {x1 , ..., xn } qui sont des feuilles et on fusionne
iérativement au fur et à mesure les sous-arbres jusqu’à ne plus qu’avoir un
seul arbre. Les feuilles initiales forment une forêt d’arbres à une feuille, puis
on fait de la fusion d’arbres...
Plusieurs critères pour la fusion de deux sous-arbres (dont les sous-ensembles
de données Gi et Gj sont stockées dans leurs feuilles). On calcule Δ(Gi , Gj )
la distance entre deux sous-ensembles.
stratégie du saut minimum :ΔSL → Single Linkage (SL)
stratégie du saut maximum (ou diamètre) : ΔCL → Complete Linkage
(CL)
stratégie du saut moyen : ΔGA → Group Average (GA)
⇒ algorithme glouton : Choix itératif de la meilleure paire de groupes (avec
tie-breaking rule)
Frank Nielsen
5.Regroupement
A2-58
Pour se fixer une idée : saut moyen, Single Linkage (SL)
Fonction de chaı̂nage entre deux groupes
Δ(Gi , Gj ) =
min
xi ∈Gi ,xj ∈Gj
D(xi , xj )
où D(x, y ) est une distance élémentaire .
⇒ regroupement hiérarchique agglomératif avec un saut minimum
(nearest-neighbor clustering)
Frank Nielsen
5.Regroupement
A2-59
Quelle distance élémentaire entre deux données ?
On doit toujours avoir bien entendu Δ({xi }, {xj }) = D(xi , xj ).
Exemples de distances élémentaires :
d
2
Distance Euclidienne (L2 ) : D(p, q) =
i =1 (pi − qi )
d
Distance de Manhattan (city block, L1 ) : D1 (p, q) =
i =1 |pi − qi |
Distance de Minkowski induite par Lp :
Dp (p, q) =
d
p1
|pi − qi |p
i =1
Distance de Mahalanobis :
DΣ (p, q) = (p − q) Σ−1 (p − q) = D(L p, L q),
avec Σ−1 = L L provenant de la factorisation de Cholesky
Métrique, non-métrique, distance & similarité, etc.
Frank Nielsen
5.Regroupement
A2-60
Le clustering par agglomération
Hierarchical Cluster Analysis (HCA) : regroupement hiérarchique
Initialiser xi dans un cluster singleton Gi = {xi }
Tant qu’il reste au moins deux clusters :
Choisir Gi et Gj tel que Δ(Gi , Gj ) soit minimal
Fusionner Gi ,j = Gi ∪ Gj (ajouter Gi ,j et retirer Gi et Gj )
Retourner le dernier nœud comme la racine de l’arbre de fusion
⇒ le résultat d’un regroupement hiérarchique est un arbre binaire appelé
dendrogramme . On fusionne n − 1 fois (les étapes de fusion).
Différent d’un algorithme de partitionnement comme les k-moyennes :
Clustering hiérarchique = not Clustering plat (par partition)
Ici, pas de fonction de coût globale à optimiser mais un algorithme de fusion
Frank Nielsen
5.Regroupement
A2-61
Distance de chaı̂nage Δ(Gi , Gj )
Single Linkage
saut minimum
Complete Linkage
saut maximum
diamètre
Group Average
saut moyen
Algorithme glouton :
arg min Δ(Gi , Gj )
i ,j=i
⇒ les groupes Gi et Gj sont voisins réciproques !
Gi = PPVG (Gj ) = arg minG ∈G Δ(Gj , G ).
Gj = PPVG (Gi ) = arg minG ∈G Δ(Gi , G ).
PPV = Plus Proche Voisin. G : ensemble des groupes.
Frank Nielsen
5.Regroupement
A2-62
Dessinons un dendrogramme...
Par exemple, choisissons la hauteur comme le nombre d’ étapes de fusion :
hauteur :
nombre de fusions
3
I,N,F,4,4,2
I, N
1
0
4, 4, 2 nœuds internes
I, N, F
2
I
4, 4
N
F
4
4
2
feuilles
Dendrogramme = Graphique d’un arbre binaire, enraciné et plongé dans le
plan.
Frank Nielsen
5.Regroupement
A2-63
Autre visualisation de la hiérarchie par inclusion
I,N,F,4,4,2
I, N, F
4, 4, 2
I, N
I
4
F
2
4
4, 4
N
I
N
F
4
4
2
nested clusters
Frank Nielsen
5.Regroupement
A2-64
Le clustering hiérarchique : single linkage (SL)
Δ(Gi , Gj ) =
min
xi ∈Gi ,xj ∈Gj
D(xi , xj )
Répeter tant que toutes les données xi ne soient pas contenues dans un seul
cluster, on fusionne les deux groupes les plus proche. À chaque instant tous
les sous-arbres forment une forêt (partitition de X ).
Single linkage → nearest-neighbor clustering
S’il existe plus d’une paire de groupes donnant le Δ minimal, on choisit
un ordre (lexicographique). Si on fait une permutation sur les données, on
n’obtiendra pas le même dendrogramme : unicité .
Problème de chaı̂nage (artefact) dans le clustering final
Complexité : naı̈f O(n3 ), algorithme SLINK en O(n2 ) (1973), temps
quadratique et espace linéaire en utilisant l’arbre recouvrant de poids
minimal (MST : Minimum Spanning Tree, 1969).
Frank Nielsen
5.Regroupement
A2-65
Frank Nielsen
20
40
Ford Pantera L
Duster 360
Camaro Z28
Chrysler Imperial
Cadillac Fleetwood
Lincoln Continental
Hornet Sportabout
Pontiac Firebird
Merc 450SLC
Merc 450SE
Merc 450SL
Dodge Challenger
AMC Javelin
Hornet 4 Drive
Valiant
Ferrari Dino
Honda Civic
Toyota Corolla
Fiat 128
Fiat X1−9
Merc 240D
Mazda RX4
Mazda RX4 Wag
Merc 280
Merc 280C
Lotus Europa
Merc 230
Datsun 710
Volvo 142E
Toyota Corona
Porsche 914−2
0
hauteur
Maserati Bora
60
80
Regroupement hierarchique (saut minimum)
5.Regroupement
A2-66
Le clustering hiérarchique : Complete Linkage
Complete linkage (CL) : CLINK in O(n2 ) (1977)
ΔCL (Gi , Gj ) =
max
xi ∈Gi ,xj ∈Gj
D(xi , xj ) ,
appelé aussi diamètre .
Problème du diamètre : si un point artefact (outlier) est très éloigné des
autres, la distance inter-groupe devient grande (et n’est pas significative).
Complete linkage → furthest-neighbor clustering
Frank Nielsen
5.Regroupement
A2-67
Frank Nielsen
100
Maserati Bora
Chrysler Imperial
Cadillac Fleetwood
Lincoln Continental
Ford Pantera L
Duster 360
Camaro Z28
Hornet Sportabout
Pontiac Firebird
Hornet 4 Drive
Valiant
Merc 450SLC
Merc 450SE
Merc 450SL
Dodge Challenger
AMC Javelin
Honda Civic
Toyota Corolla
Fiat 128
Fiat X1−9
Ferrari Dino
Lotus Europa
Merc 230
Volvo 142E
Datsun 710
Toyota Corona
Porsche 914−2
Merc 240D
Mazda RX4
Mazda RX4 Wag
Merc 280
Merc 280C
0
hauteur
200
300
400
Regroupement hierarchique (saut maximum)
5.Regroupement
A2-68
Le clustering hiérarchique : Average Linkage
Average Linkage (AL) : O(n2 ) (1984)
ΔAL (Gi , Gj ) =
1 D(xi , xj )
ni nj
xi ∈Gi xj ∈Gj
La moyenne de toutes les paires de distance !
Frank Nielsen
5.Regroupement
A2-69
Frank Nielsen
50
100
Ferrari Dino
Honda Civic
Toyota Corolla
Fiat 128
Fiat X1−9
Mazda RX4
Mazda RX4 Wag
Merc 280
Merc 280C
Merc 240D
Lotus Europa
Merc 230
Volvo 142E
Datsun 710
Toyota Corona
Porsche 914−2
Maserati Bora
Hornet 4 Drive
Valiant
Merc 450SLC
Merc 450SE
Merc 450SL
Dodge Challenger
AMC Javelin
Chrysler Imperial
Cadillac Fleetwood
Lincoln Continental
Ford Pantera L
Duster 360
Camaro Z28
Hornet Sportabout
Pontiac Firebird
0
hauteur
150
200
250
Regroupement hierarchique (distance moyenne)
5.Regroupement
A2-70
Frank Nielsen
5.Regroupement
A2-71
Critère de fusion de Ward : la variance
Variance = somme des distances euclidiennes au carré par rapport au
centroı̈de :
1 x − c(X )2 , c(X ) =
x
v (X ) =
|X |
x∈X
x∈X
Distance entre clusters (critère de Ward) pour Gi (ni = |Gi |) et Gj
(nj = |Gj |) :
Δ(Gi , Gj ) = v (Gi ∪ Gj ) − (v (Gi ) + v (Gj ))) =
ni nj
c(Gi ) − c(Gj )2 ≥ 0
ni + nj
Δ({xi }, {xj }) = D(xi , xj ) = xi − xj 2
Quand on fusionne deux groupes, la variance ne peut pas diminuer !
Quand on rajoute des clusters, la somme pondérée des variances diminue
Δ(Gi , Gj ) = k-moyennes(Gi ∪ Gj ) − (k-moyennes(Gi ) + k-moyennes(Gj ))
Frank Nielsen
5.Regroupement
A2-72
50
hauteur
Frank Nielsen
Honda Civic
Toyota Corolla
Fiat 128
Fiat X1−9
Merc 240D
Lotus Europa
Merc 230
Volvo 142E
Datsun 710
Toyota Corona
Porsche 914−2
Ferrari Dino
Mazda RX4
Mazda RX4 Wag
Merc 280
Merc 280C
Hornet 4 Drive
Valiant
Merc 450SLC
Merc 450SE
Merc 450SL
Dodge Challenger
AMC Javelin
Maserati Bora
Ford Pantera L
Duster 360
Camaro Z28
Chrysler Imperial
Cadillac Fleetwood
Lincoln Continental
Hornet Sportabout
Pontiac Firebird
Hornet 4 Drive
Valiant
Merc 450SLC
Merc 450SE
Merc 450SL
Dodge Challenger
AMC Javelin
Chrysler Imperial
Cadillac Fleetwood
Lincoln Continental
Ford Pantera L
Duster 360
Camaro Z28
Hornet Sportabout
Pontiac Firebird
0
Honda Civic
Toyota Corolla
Fiat 128
Fiat X1−9
Mazda RX4
Mazda RX4 Wag
Merc 280
Merc 280C
Merc 240D
Lotus Europa
Merc 230
Volvo 142E
Datsun 710
Toyota Corona
Porsche 914−2
100
500
hauteur
1000
150
1500
Maserati Bora
Ferrari Dino
0
2000
200
2500
250
Regroupement hierarchique (distance moyenne)
Regroupement hierarchique (Ward)
x
INF442 (voitures)
x
INF442 (voitures)
Average Group
Critère de Ward
5.Regroupement
A2-73
Le clustering descendant hiérarchique par division
Version top-down : on part d’un cluster contenant toutes les données X
et on divise récursivement jusqu’à temps qu’on obtienne les n feuilles
qui contiennent les données individuelles.
Pour casser un cluster en deux, on utilise un algorithme de clustering par
partitionnement pour k = 2 (comme celui des k-moyennes par exemple)
En général, plus coûteux qu’un regroupement hiérarchique agglomératif
(bottom-top)
Frank Nielsen
5.Regroupement
A2-74
Frank Nielsen
87
7
51
19
73
85
9
33
94
8
22
63
11
4
31
18
21
86
44
25
20
40
48
39
93
92
15
83
5
32
12
89
30
53
27
38
17
62
23
69
16
2
76
43
50
59
96
90
41
36
34
49
61
70
68
56
55
95
14
24
67
28
35
99
84
74
75
54
58
3
65
81
45
98
46
52
72
37
91
100
88
1
29
6
97
47
71
66
60
78
79
57
77
10
13
42
80
26
64
82
0.0
0.5
1.0
1.5
hauteur
2.0
2.5
Dendrogramme : obtenir des partitions à partir du
dendrogramme
Pour k ∈ [n] = {1, ..., n}, on peut extraire des partitions en k-sous-ensembles
de X .
Regroupement hierarchique
5.Regroupement
INF442
x
A2-75
Convertir un clustering hiérarchique en une partition
Si on ne choisit pas k mais une valeur de seuillage...
Parcourir récursivement l’arbre et on arrête la récursivité quand
Δ(nœud) = Δ(nœudfils gauche , nœudfils droit ) ≤ seuil
saut maximum (CL, diamètre) : les clusters ont un diamètre ≤ seuil
(hauteur constante)
chaı̂nage de Ward : les clusters ont une variance ≤ seuil (hauteur pas
constante car inversions)
Frank Nielsen
Δ < Δ∗
Δ < Δ∗
5.Regroupement
A2-76
Convertir un clustering hiérarchique en une partition
Si on veut choisir k...
Clustering hiérarchique → Clustering plat (partition)
On choisit une hauteur pour trouver une partition en k clusters
Meilleure hauteur par Programmation Dynamique. Meilleure hauteur pour
T (X ) à k sous-ensembles :
Fit(T = (L, R), k) =
min
k1 ,k2 k1 +k2 =k
Fit(L, k1 ) + Fit(R, k2 )
Pour les k-moyennes (clustering plat, NP-dur en général) on obtient une
k-partition optimale à partir d’un clustering hierarchique (facile à
calculer, SL) sous l’hypothèse de satisfaire un critère de séparabilité.
Frank Nielsen
5.Regroupement
A2-77
Distances : métriques et ultra-métriques
Une distance d(·, ·) est :
métrique si elle satisfait les axiomes :
d(x, y ) ≥ 0 avec égalité pour x = y seulement
d(x, y ) = d(y , x) symétrie
d(x, y ) ≤ d(x, z) + d(z, y ), inégalité triangulaire
ultra-métrique si elle satisfait les axiomes :
Frank Nielsen
d(x, y ) ≥ 0 avec égalité pour x = y seulement
d(x, y ) = d(y , x) symétrie
d(x, y ) ≤ max(d(x, z), d(z, y ))
5.Regroupement
A2-78
Distance et évolution (horloge)
Dans les arbres phylogénétiques, la distance entre deux espèces impose des
restrictions sur la fonction distance.
Arbre additif (additive tree) : poids sur chaque arête tel que pour
chaque paire de feuilles, la distance est la somme des distances des arêtes
les reliant.
Arbre ultramétrique : distances entre deux feuilles Gi et Gj et leur
ancêtre commun Gk sont égales : di ,k = dj,k .
hk = 12 di ,j (hauteur) correspond au temps écoulé
permet de définir une horloge globale sur l’axe vertical
Frank Nielsen
5.Regroupement
A2-79
Dendrogrammes et arbres phylogénétiques
Frank Nielsen
5.Regroupement
A2-80
Regroupement hiérarchique avec l’algorithme UPGMA
UPGMA : Unweighted Pair Group Method using arithmetic Averages
Clustering hiérarchique avec la distance de chaı̂nage Average Linkage
(AL) :
Δ(Gi , Gj ) =
1 D(xi , xj ) = Δi ,j
ni nj
xi ∈Gi xj ∈Gj
UPGMA garantie de produire un arbre ultramétrique
Frank Nielsen
5.Regroupement
A2-81
Regroupement hiérarchique par UPGMA
Initialise xi a son cluster Ci et positionne ce nœud à hauteur t = 0.
Tant qu’il reste plus de deux clusters :
Trouver les clusters Ci et Cj qui ont la distance Δi ,j minimale
Définir un nouveau cluster Ck = Ci ∪ Cj et calculer la distance Δk,l pour
tout l
Ajouter un nœud k avec les fils Ci et Cj et positionner le à hauteur
tk = 12 Δi ,j
Retirer Ci et Cj de la liste des clusters, et continuer jusqu’à temps d’avoir
deux clusters
Pour les deux derniers clusters Ci , and Cj , placer la racine à hauteur
1
2 Δ(Ci , Cj )
Frank Nielsen
5.Regroupement
A2-82
Regroupement hiérarchique par UPGMA
Théorème
Si les données sur les distances sont ultramétriques (vérifiable sur la matrice
des distances), alors il existe un unique arbre ultramétrique et l’algorithme
UPGMA le construit.
... malheureusement les données (bruitées) ne sont pas ultramétriques en
général !
Tester si une matrice de distances est ultramétrique : naı̈vement en O(n3 ).
Frank Nielsen
5.Regroupement
A2-83
Dissimilarité, similarité et inversions
similarité entre deux groupes : S(Xi , Xj ) = −Δ(Xi , Xj ). Ainsi si on a
Δ(Gi , Gk ) > Δ(Gi , Gj ) alors on a l’ordre inverse S < S(Gi , Gj )
pour un chemin du dendrogramme d’une feuille à la racine, séquence de
fusion monotone ssi. la similarité décroit quand on se rapproche de la
racine : S1 ≥ S2 ≥ ... ≥ Sracine . Autrement dit, la valeur du critère de
fusion augmente quand on va vers la racine.
non-monotone s’il existe au moins une inversion Si < Si +1 sur un chemin
du dendrogramme. Cela veut dire que deux groupes peuvent être plus
similaire à l’étape i + 1 que les deux groupes fusionnés à l’étape i .
critère de Ward ne garantie pas la monotonie (inversions). Par
contre, Single Linkage, Complete Linkage et Average Linkage garantissent
la monotonie.
Frank Nielsen
5.Regroupement
A2-84
Inversion possible pour le critère de Ward
x3
x1
S({x1 }, {x2 })
S({x1 , x2 }, {x3 })
x2
x1
x2
x3
Inversion car un nœud parent se trouve “plus bas” que les deux nœuds fils.
Frank Nielsen
5.Regroupement
A2-85
C++ : Contenu des méthodes à l’extérieur des classes
#i n c l u d e <i o s t r e a m >
u s i n g namespace s t d ;
c l a s s CEntier
{
public : int val ;
C E n t i e r ( i n t v ) { t h i s −>v a l=v ; }
v o i d a j o u t e ( i n t v2 ) ;
};
// Définition à l’extérieur de class
v o i d C E n t i e r : : a j o u t e ( i n t v2 ) { v a l+=v2 ; }
i n t main ( )
{ C E n t i e r ∗ e1=new C E n t i e r ( 5 ) ;
cout<<e1−>v a l <<e n d l ;
return 0;}
Frank Nielsen
e1−>a j o u t e ( 8 ) ;
5.Regroupement
A2-86
Structures de données abstraites
Défini une interface pour accéder aux données.
Peut-être codé du plusieurs manières différentes.
les piles (Last In First Out, LIFO)
les files (First In First Out,FIFO)
les arbres
les graphes
les matrices creuses
etc.
Par exemple, les piles et files peuvent être implanté soit avec des tableaux soit
avec des listes chaı̂nées.
Frank Nielsen
5.Regroupement
A2-87
c l a s s CNoeud{C++ :
// la classe nœud
p u b l i c : CNoeud ∗ gauche , ∗ d r o i t ;
int val ;
public :
CNoeud ( i n t v ) { t h i s −>v a l=v ; ga uche=d r o i t=NULL ; }
CNoeud ( i n t v a l , CNoeud∗ A rbre1 , CNoeud∗ A r b r e 2 )
{ t h i s −>v a l=v a l ; ga uche=A r b r e 1 ; d r o i t=A r b r e 2 ; }
st ring Print ()
{ c h a r b u f f e r [ 2 0 ] ; s t r i n g s v a l=s t r i n g ( i t o a ( v a l , b u f f e r
,10) ) ;
s t r i n g s ga uche , s d r o i t ;
i f ( ga u ch e==NULL) s g a u c h e=” n i l ” ;
e l s e s g a u c h e=gauche−>P r i n t ( ) ;
i f ( d r o i t==NULL) s d r o i t=” n i l ” ;
e l s e s d r o i t=d r o i t −>P r i n t ( ) ;
r e t u r n ” ( ”+s v a l+” , ”+s g a u c h e+” , ”+s d r o i t+” ) ” ;
}};
Frank Nielsen
5.Regroupement
A2-88
...
CNoeud ∗ A r b r e 4 4 2=new CNoeud ( 3 , new CNoeud ( 2 ) ,
new CNoeud ( 1 , new CNoeud ( 4 ) , new CNoeud ( 5 ) ) ) ;
cout<<A rb re442 −>P r i n t ( )<<e n d l ;
Exécution donne à la console :
(3,(2,nil,nil),(1,(4,nil,nil),(5,nil,nil)))
Frank Nielsen
5.Regroupement
A2-89
C++ : récupération de la mémoire
tilde ∼, un seul destructeur par classe C++
˜CNoeud ( )
{
i f ( ga uche !=NULL)
d e l e t e ga uche ;
i f ( d r o i t !=NULL)
delete droit ;
c e r r <<” d e l e t e ”<<v a l <<e n d l ;
}
(3,(2,nil,nil),(1,(4,nil,nil),(5,nil,nil)))
delete 2
delete 4
delete 5
delete 1
delete 3
Frank Nielsen
5.Regroupement
A2-90
Différences principales entre C++ et Java
null en Java et NULL en C++
this.variable en Java/C++ (référence) et this->variable en C++
(pointeur)
class INF442{} en Java et class INF442{}; en C++
On peut rajouter le corps des méthodes en C++ après sa déclaration
dans la classe : void CNoeud::Addition(int v)
ajouter un destructeur dans la classe en C++
array.length en Java. On utilise la classe vector de la STL C++ et
.size()
import en Java et include en C++ (STL) etc.
En C++ dans les classes, mettre explicitement public (sinon on est
private par défaut)
Frank Nielsen
5.Regroupement
A2-91
Résumé A2
HPC : accélération, loi d’Amdahl et loi de Gustafson
MPI :
les communications bloquantes, les situations de blocage, les
communications non-bloquantes, les barrières de synchronisation
les calculs collaboratifs : réduction (somme, reduce & Allreduce), et les
opérations de préfixe parallèle (scan)
Science des données :
les k-moyennes avec MPI
regroupement hiérarchique vs. regroupement plat.
arbre ultramétrique et chaı̂nage par saut moyen (average link).
C++ : les classes objets. Lire le memento C++ sur la page Moodle !
Pour la prochaine fois : lire le chapitre 8 et relire le chapitre 2 du
polycopié
Frank Nielsen
5.Regroupement
A2-92