Mais conteúdo relacionado Semelhante a Bases de données image : structuration de l'espace des descripteurs et recherche par similarité (20) Mais de Guillaume MOCQUET (9) 1. NFE 205
Bases de données avancées (2)
Juin 2015
TP Bases de données image :
structuration de l'espace des
descripteurs et recherche par
similarité
Le CNAM
Centre d’enseignement de Paris
292, rue Saint-Martin
75003 Paris
Guillaume MOCQUET
contact@guillaumemocquet.com
Compte rendu
2. Table des matières
Index des figures.............................................................................................................3
2. Description des images ........................................................................................4
2.1 Travail réalisé....................................................................................................4
2.1.1 Reformulation du principe des histogrammes couleur et niveaux de gris.4
2.1.2 Fonctions de la classe JPictureNFE205........................................................6
3. Recherche par similarité.....................................................................................13
3.1 Travail réalisé..................................................................................................13
3.1.1 Reformulation du principe de recherche par similarité visuelle ainsi que
description des diagrammes précision / rappel ...............................................................13
3.1.2 Exemples de recherches par similarité .....................................................15
3.1.3 Calcul des diagrammes précision / rappel ................................................22
3.1.4 Calcul des courbes précision / rappel lorsque les classes de la vérité terrain
n'ont pas la même taille....................................................................................................25
4. Structuration des descripteurs par un M-Tree ..................................................25
4.2 Travail réalisé..................................................................................................25
4.2.1 Fonction rangeQuery.................................................................................25
4.2.2 Analyse de l’impact de la capacité du nœud ............................................27
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 2
3. Index des figures
Figure 1 - Quantification RGB 8x8x8 bins.......................................................................5
Figure 2 - Histogramme niveau de gris : image d'origine...............................................7
Figure 3 - Histogramme niveau de gris : représentation sur 256 niveaux.....................8
Figure 4 - Histogramme niveau de gris : vue dans Photoshop.......................................8
Figure 5 - Histogramme couleur RGB : image d'origine ..............................................10
Figure 6 - Histogramme couleur RGB : représentation sur 6x6x6 niveaux..................10
Figure 7 - Génération d'un damier d'échec rouge et vert............................................11
Figure 8 - RGB -> GBR : image d'origine .......................................................................12
Figure 9 - RGB -> GBR : image post traitement............................................................13
Figure 10 - Recherche par similarité effectuée à l'aide du descripteur HistGREY_256 :
résultats non pertinents...........................................................................................................15
Figure 11 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_6x6x6 :
résultats non pertinents...........................................................................................................16
Figure 12 - Recherche par similarité effectuée à l'aide du descripteur HistGREY_16 :
résultats peu pertinents...........................................................................................................17
Figure 13 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_4x4x4 :
résultats fortement pertinents ................................................................................................18
Figure 14 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_6x6x6 :
résultats moins pertinents que lors de l'utilisation du descripteur HistRGB_4x4x4 ...............19
Figure 15 - Recherche par similarité effectuée à l'aide du descripteur HistGREY_16 :
résultats 100% pertinents ........................................................................................................20
Figure 16 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_6x6x6 :
résultats 100% pertinents ........................................................................................................21
Figure 17 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_2x2x2 :
résultats peu pertinents...........................................................................................................22
Figure 18 - Courbes précision / rappel des histogrammes niveau de gris...................23
Figure 19 - Courbes précision / rappel des histogrammes couleur RGB......................23
Figure 20 - Courbes précision / rappel : Histogramme niveau de gris 256 bins VS
Histogramme couleur RGB 6x6x6 bins.....................................................................................24
Figure 21 - Analyse de la performance des descripteurs pour une valeur de rappel de
0.1.............................................................................................................................................24
Figure 22 - Analyse des performances MTree..............................................................27
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 3
4. 2. Description des images
2.1 Travail réalisé
2.1.1 Reformulation du principe des histogrammes couleur et niveaux de gris
L’histogramme couleur ou niveau de gris d’une image permet de représenter les
caractéristiques visuelles de celle-ci mathématiquement sous forme d’un vecteur à « n »
dimensions. Ce dernier est appelé « descripteur d’image ». Un descripteur d’image est plus ou
moins complexe et volumineux en fonction du niveau de qualité souhaité (cf. quantification).
Il s’agit d’un traitement réalisé au moment de l’indexation de l’image ou par un processus de
traitement par lots (cf. batch) : traitement hors ligne. Le temps de calcul requis pour calculer
chaque descripteur d’image peut être long, ceci ne pénalise nullement les performances lors
de la recherche.
La construction des histogrammes se base sur l’espace couleur choisi : RGB, HSV, YUV,
CIE Lab, … L’espace de couleur fréquemment utilisé lors de l’affichage des images en
informatique est RGB : acronyme anglais de Rouge, Vert, Bleu. Il s’agit d’un type additif dont
le principe repose sur l’exploitation des trois couleurs primaires : rouge, vert, bleu. La
multitude des couleurs est obtenue par l’ajout des trois couleurs primaires suivant différentes
proportions. La couleur noire représente l’absence de couleur primaire. A l’inverse, la couleur
blanche représente la somme des trois couleurs primaires à leurs maximales. Dans le cadre de
l’espace couleur RGB, chaque canal couleur est représenté sur 8 bits (1 octet) soit 256 valeurs
(2^8) – je parle uniquement des images qui ne prennent pas en charge la transparence tel le
format JPEG. Chaque information est codée de 0 (absence de couleur) à 255 (valeur
maximale). Cette méthode permet de représenter plus de 16 millions de couleurs : 256 * 256
* 256.
Un paramètre important à prendre en compte lors du calcul de l’histogramme couleur
ou niveaux de gris est le niveau de quantification. Il s’agit de définir des plages d’intervalles
réguliers – en anglais bins – plus ou moins grandes auxquelles on fait correspondre les valeurs
réelles des axes couleurs ou la luminance dans le cadre de l’histogramme en niveau de gris.
Cette opération transpose les valeurs de la dimension initiale – dans notre cas, l’espace
couleur RGB – dans une dimension de destination de taille différente – généralement plus
petite. Le principal objectif est de réduire les informations manipulées de chaque descripteur :
• Réduire le nombre de valeurs prises en compte afin de réduire le temps de calcul
nécessaire à la comparaison de l’ensemble des descripteurs de la base de données.
Réaliser en temps réel – opération online – lors de la comparaison avec l’ensemble
des descripteurs de la base de données, la somme de tous les calculs doit être la
plus faible possible : dans l’idéal inférieur à la seconde.
• Réduire l’espace nécessaire au stockage de l’ensemble des descripteurs de la base
de données.
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 4
5. Plus les intervalles sont grands, moins le descripteur comporte d’informations mais
moins celui-ci est précis. A l’inverse un descripteur trop riche peut s’avérer trop complexe lors
des calculs de similarités.
2.1.1.1 Histogramme couleur
L’histogramme couleur représente la distribution des couleurs au sein d’une image : il
s’agit du calcul de la fréquence d’apparition des couleurs. Dans l’espace de couleur RGB,
chaque pixel qui compose une couleur est représenté sous la forme d’un hyper cube à trois
dimensions : une dimension par axe couleur. Afin que les descripteurs d’histogramme couleur
soient de taille raisonnable (cf. § 2.1.1 - Reformulation du principe des histogrammes couleur
et niveaux de gris) il est important de bien choisir le niveau de quantification utilisé. Ci-
dessous, l’exemple de la quantification de chaque axe couleur sur 8 niveaux :
Figure 1 - Quantification RGB 8x8x8 bins
Couleur : (123, 23, 45) => Bins : (3, 0, 1)
Couleur : (123, 29, 50) => Bins : (4, 0, 1)
Dans l’exemple ci-dessus, les informations de l’image source codée 24 bits (16 millions
de couleur) sont transposées vers une représentation RGB codée sur 8 bits. Chaque axe
couleur possède 8 intervalles – bins –, soit la possibilité de représenter 512 couleurs (8x8x8).
Ce type de descripteur est représenté sous 512 dimensions.
2.1.1.2 Histogramme en niveau de gris
L’histogramme en niveau de gris est une version simplifiée de l’histogramme couleur.
Ce dernier compte une seule dimension : la fréquence / distribution des intensités lumineuses
de chaque pixel de l’image. La correspondance entre les valeurs des axes couleurs et la
luminance est donnée par la formule suivante :
Niveau de gris = 0.299 * Rouge + 0.587 * Vert + 0.114 * Bleue
Dans l’espace RGB, sans quantification, le nombre de niveau de gris est représenté sur
8 bits, soit 2^8 = 256 valeurs.
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 5
6. 2.1.1.3 Normalisation
Afin d’harmoniser l’ensemble des résultats – densité par pixel – ainsi que simplifier les
traitements futurs, l’ensemble des vecteurs qui composent un histogramme couleur ou niveau
de gris est normalisé. Comme vu précédemment, les valeurs de l’espace couleur RGB sont des
entiers compris entre 0 et 255 (inclus). La normalisation représente les données sous forme
de nombre à virgule flottante entre 0 et 1. La somme de l’ensemble des descripteurs relatifs
à une image est égale à 1.
2.1.2 Fonctions de la classe JPictureNFE205
2.1.2.1 Fonction ComputeGrayLevelHistogram
2.1.2.1.1 Code Java
/**
* Calcule de l'histogramme niveau de gris
*
* @param bins : nombre de bins
* @return double[] vecteurs de l'histogramme niveau de gris
*/
double[] ComputeGrayLevelHistogram(int bins) throws Exception {
// Dans l'espace couleur RGB, les valeurs de quantifications
// possibles sont comprises entre 1 et 256 (inclus)
if (bins < 1 || bins > 256) {
throw new Exception("La valeur de bins doit être comprise
entre 1 et 256");
}
// Initialisation de l'histogramme monodimentionnel niveau de gris
// Il s'agit d'un tableau temporaire
int histogram1D[] = new int[bins];
// Parcours de l'ensemble des pixels de l'image chargée en mémoire
for(int x = 0; x < width; ++x) {
for(int y = 0; y < height; ++y) {
// Calcul de l'intensité lumineuse du pixel
int grey = (int) Math.floor(
(
(0.299 * pixels[x][y][RED] )
+ (0.587 * pixels[x][y][GREEN] )
+ (0.114 * pixels[x][y][BLUE] )
) * bins
);
// Incrémentation de l'histogramme monodimensionnel
// niveau de gris
histogram1D[grey]++;
}
}
// Initialisation de l'histogramme niveau de gris
// tableau final
double[] histogramGrey = new double[bins];
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 6
7. // Initialisation du compteur de valeurs présentes dans l'histogramme
// niveau de gris
int iHistogram = 0;
// Calcule le nombre total de pixels de l'image
int pixelTot = width * height;
// Normalisation de l'histogramme
for (int iGrey = 0 ; iGrey < bins ; iGrey++) {
// Lecture du niveau de gris
int colorCount = histogram1D[iGrey];
// Normalisation de l'histogramme
histogramGrey[iHistogram] = (double) colorCount
/ (double) pixelTot;
// Incrémentation du nombre de valeurs qui composent
l'histogramme
iHistogram++;
}
// Stockage de l'histogramme niveau de gris dans l'attribut
// de la classe
this.histograms.put(HISTO_GREYSCALE, histogramGrey);
// Retourne l'histogramme niveau de gris sous forme d'un
// tableau de nombres en virgule flottante
return histogramGrey;
}
2.1.2.1.2 Exemple de résultat pour un niveau de quantification de 256
Figure 2 - Histogramme niveau de gris : image d'origine
Nombre de pixels dans l'image : 98304
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 7
8. Figure 3 - Histogramme niveau de gris : représentation sur 256 niveaux
2.1.2.1.3 Comparaison des résultats avec Photoshop
Ci-dessous, la même image que précédemment vue dans Photoshop :
Figure 4 - Histogramme niveau de gris : vue dans Photoshop
2.1.2.2 Fonction ComputeRGBHistogram
2.1.2.2.1 Code Java
/**
* Calcul de l'histogramme couleur RGB
*
* @param int rBins : nombre de bins à utiliser pour l'axe couleur rouge
* @param int gBins : nombre de bins à utiliser pour l'axe couleur vert
* @param int bBins : nombre de bins à utiliser pour l'axe couleur bleu
* @return double[] vecteurs de l'histogramme couleur RGB
*/
double[] ComputeRGBHistogram(int rBins,
int gBins,
int bBins) throws Exception {
// Dans l'espace couleur RGB, les valeurs de quantifications
// possibles sont comprises entre 1 et 256 (inclus)
if (
(rBins < 1 || rBins > 256)
|| (gBins < 1 || gBins > 256)
|| (bBins < 1 || bBins > 256)
) {
throw new Exception("La valeur de bins de chaque canal couleur
doit être comprise entre 1 et 256");
}
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 8
9. // Initialisation de l'histogramme tridimentionnel couleur RGB
// 1 dimension par couleur
// Il s'agit d'un tableau temporaire
int histogram3D[][][] = new int[rBins][gBins][bBins];
// Parcours de l'ensemble des pixels de l'image chargé en mémoire
for(int x = 0; x < width; ++x) {
for(int y = 0; y < height; ++y) {
// Quantification des couleurs en fonction de la valeur
// des bins de chaque couleur
int rBin = (int) Math.floor(pixels[x][y][RED] * rBins);
int gBin = (int) Math.floor(pixels[x][y][GREEN] * gBins);
int bBin = (int) Math.floor(pixels[x][y][BLUE] * bBins);
// Incrémentation de l'histogramme tridimensionnel
// couleur RGB
histogram3D[rBin][gBin][bBin]++;
}
}
// Calcul le nombre total de pixels de l'image
int pixelTot = width * height;
// Initialisation de l'histogramme couleur RGB
// tableau final
double histogramRGB[] = new double[rBins * gBins * bBins];
// Initialisation du compteur de valeurs présentes
// dans l'histogramme couleur RGB
int iHistogram = 0;
// Génération du descripteur RGB en fonction des bins
// de chaque canal couleur
for (int iR = 0 ; iR < rBins ; iR++) {
for (int iG = 0 ; iG < gBins ; iG++) {
for (int iB = 0 ; iB < bBins ; iB++) {
// Lecture de la couleur
int colorCount = histogram3D[iR][iG][iB];
// Normalisation de l'histogramme
histogramRGB[iHistogram] = (double) colorCount
/ (double) pixelTot;
// Incrémentation du nombre de valeurs
// qui composent l'histogramme
iHistogram++;
}
}
}
// Stockage de l'histogramme couleur RGB dans l'attribut de la classe
this.histograms.put(HISTO_RGB, histogramRGB);
// Retourne l'histogramme couleur RGB sous forme d'un
// tableau de nombres en virgule flottante
return histogramRGB;
}
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 9
10. 2.1.2.2.2 Exemple de résultat pour un niveau de quantification de 6x6x6
Figure 5 - Histogramme couleur RGB : image d'origine
Nombre de pixels dans l'image : 262144
Figure 6 - Histogramme couleur RGB : représentation sur 6x6x6 niveaux
2.1.2.3 Bonus
2.1.2.3.1 Damier d'échecs
2.1.2.3.1.1 Code Java
// Propriétés de l'image à générer.
int width = 400; // Largeur
int height = 400; // Hauteur
int blockSize = 2; // Nombre de pixels qui composent la largeur / hauteur
// d'un bloc. Exemple : blockSize = 2 donne
// un carré de 4 pixels
// Initialisation de l'image à générer aux dimensions souhaitées.
JPictureNFE205 p = new JPictureNFE205(width, height);
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 10
11. // Le premier bloc du damier est rouge
boolean red = true;
// Boucle pour parcourir l'ensemble des pixels suivant la largeur
for(int i = 0; i < width; i++) {
// Gestion de l'alternance des couleurs suivant la largeur
if (i % blockSize == 0) { red = !red; }
// Boucle pour parcourir l'ensemble des pixels suivant la hauteur
for(int j = 0; j < height; j++) {
// Gestion de l'alternance des couleurs suivant la hauteur
if (j % blockSize == 0) { red = !red ; }
if (red) {
// Création d'un pixel rouge
p.pixels[i][j][RED] = 1;
p.pixels[i][j][GREEN] = 0;
p.pixels[i][j][BLUE] = 0;
} else {
// Création d'un pixel vert
p.pixels[i][j][RED] = 0;
p.pixels[i][j][GREEN] = 1;
p.pixels[i][j][BLUE] = 0;
}
}
}
// Ecriture sur le disque de la nouvelle image
p.writeImageFile("assets/chess.jpg");
2.1.2.3.1.2 Résultat
Figure 7 - Génération d'un damier d'échec rouge et vert
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 11
12. 2.1.2.3.2 Inversement des trois plans de couleur RGB → GBR
2.1.2.3.2.1 Code Java
// Chargement en mémoire de l'image passée en paramètre
p = new JPictureNFE205("assets/RGB2.jpg");
// Copie de l'ensemble des pixels en vue de l'inversion de l'espace
// de couleur : RGB > GBR
float[][][] pixelsTmp = p.clonePixels(p.pixels);
for(int i = 0; i < p.width; ++i) {
for(int j = 0; j < p.height; ++j) {
// Nouvelle affectation des pixels :
// La valeur du pixel rouge prend celle du pixel bleu
p.pixels[i][j][RED] = pixelsTmp[i][j][BLUE];
// La valeur du pixel vert prend celle du pixel rouge
p.pixels[i][j][GREEN] = pixelsTmp[i][j][RED];
// La valeur du pixel bleu prend celle du pixel vert
p.pixels[i][j][BLUE] = pixelsTmp[i][j][GREEN];
}
}
// Ecriture sur le disque de la nouvelle image
p.writeImageFile("assets/GBR2.jpg");
2.1.2.3.2.2 Résultat
Figure 8 - RGB -> GBR : image d'origine
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 12
13. Figure 9 - RGB -> GBR : image post traitement
3. Recherche par similarité
3.1 Travail réalisé
3.1.1 Reformulation du principe de recherche par similarité visuelle ainsi que
description des diagrammes précision / rappel
3.1.1.1 Explication de la recherche par similarité visuelle
La recherche par similarité visuelle se base sur le paradigme de recherche par
l’exemple à partir d’une image requête. Celle-ci est utilisée comme donnée d’entrée du
système de recherche. Elle est analysée afin de calculer ses caractéristiques visuelles dans le
but de générer un descripteur d’image suivant l’algorithme choisi : histogramme niveau de
gris, histogramme couleur, descripteur SIFT, …
Le temps de recherche nécessaire au système de recherche est proportionnel au
nombre d’images contenues dans la base de données. La recherche consiste à classer
l’ensemble des images de la base de données en fonction de l’image requête. La principale
méthode pour ordonner les images s’appelle « L2 ». Celle-ci consiste à calculer les distances
de chaque image de la base de données avec l’image requête. Enfin, l’ensemble des résultats
est trié : plus la distance est faible, plus l’image de la base de données est proche de l’image
requête, donc pertinente pour l’utilisateur. Au contraire, plus la distance est élevée, moins
l’image de la base de données est pertinente pour l’utilisateur.
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 13
14. Le calcul de distance se base sur la somme des distances de chaque vecteur qui
compose les descripteurs de chaque image. A titre d’exemple, le descripteur d’un
histogramme couleur quantifié 2x2x2 est composé de 8 vecteurs.
Une fois l’ensemble des images de la base de données ordonné en fonction de l’image
requête, le système limite les images retournées à l’utilisateur aux « k » plus proche voisins.
Cette opération est abrégée en anglais « KNN » pour K-Nearest Neighbours.
3.1.1.2 Explication des diagrammes précision / rappel
Les courbes précision / rappel sont les principaux indicateurs qui permettent de
déterminer la performance du système de recherche :
• La précision évalue le nombre d’images qui intéressent l’utilisateur sur l’ensemble
des images retournées par le système de recherche.
• Le rappel évalue le nombre d’images qui intéressent l’utilisateur vis-à-vis de
l’ensemble des images de la base de données susceptible de l’intéresser.
Les données sont calculées à partir de différents jeux de données prédéterminés. On
regroupe manuellement un certain nombre d’images par similarité sémantique : paysages,
animaux sauvages, monuments touristiques, images de synthèse, … Chaque groupe d’images
représente une classe de vérité terrain. Si l’on sélectionne aléatoirement une image d’une
classe donnée, un système de recherche performant doit retourner – dans le cas idéal – en
premier lieu l’ensemble des autres images appartenant à cette même classe.
Il est possible de calculer la courbe Précision / Rappel de façon globale ou pour une
classe de vérité terrain donnée.
La courbe Précision / Rappel d’une classe est obtenue en moyennant l’ensemble des
paires de valeurs précision <-> rappel par rapport aux nombres d’images contenues dans la
classe. Pour chaque image de la classe, une recherche par similarité à l’aide d’un système de
recherche est effectuée sur les « k » plus proches voisins de façon itérative : recherche sur 1
image, puis 2, puis 3, puis 4, …. Puis N. N représente la taille de la base de données d’images.
A chaque itération, la paire précision <-> rappel est calculée.
Le calcul de la courbe Précision / Rappel globale est la moyenne de l’ensemble des
valeurs de toutes les classes de vérité terrain.
L’efficacité du système de recherche est maximale lorsque les valeurs précision et
rappel sont maximales : à chaque fois celui-ci retourne à l’utilisateur des images jugées
pertinentes par ce dernier. En réalité, plus le système retourne un nombre élevé d’images,
plus l’utilisateur a des chances de trouver des images qui ne l’intéressent pas.
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 14
15. 3.1.2 Exemples de recherches par similarité
3.1.2.1 Résultats de recherche non pertinents quel que soit le descripteur utilisé
Dans la situation ci-dessous, les images retournées par le système de recherche ne sont
pas pertinentes d’un point de vue sémantique. Même dans le cas de l’utilisation du
descripteur d’image RGB 6x6x6, les résultats sont relativement éloignés : aussi bien d’un point
de vue sémantique qu’au niveau des tons des images.
Figure 10 - Recherche par similarité effectuée à l'aide du descripteur HistGREY_256 : résultats non pertinents
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 15
16. Figure 11 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_6x6x6 : résultats non pertinents
3.1.2.2 Résultats de recherche performants en fonction du descripteur utilisé
Dans l’exemple ci-dessous, les images retournées par le système de recherche
d’images sont peu pertinentes dans le cas de l’utilisation des descripteurs niveau de gris.
Cependant les résultats retournés frôlent la perfection avec l’utilisation du descripteur
RGB_4x4x4. La performance du système chute légèrement lorsque l’on utilise le descripteur
HistRGB_6x6x6 : des images de verdure / champs sont retournées en lieu et place d’images
mettant en scène des chevaux.
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 16
17. Figure 12 - Recherche par similarité effectuée à l'aide du descripteur HistGREY_16 : résultats peu pertinents
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 17
18. Figure 13 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_4x4x4 : résultats fortement pertinents
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 18
19. Figure 14 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_6x6x6 : résultats moins pertinents que lors
de l'utilisation du descripteur HistRGB_4x4x4
3.1.2.3 Résultats de recherche performants quel que soit le descripteur utilisé
Ci-dessous, l’ensemble des descripteurs utilisés procure de très bons résultats de
recherche avec cependant un nombre significatif de mauvais résultats pour le descripteur
HistRGB_2x2x2.
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 19
20. Figure 15 - Recherche par similarité effectuée à l'aide du descripteur HistGREY_16 : résultats 100% pertinents
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 20
21. Figure 16 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_6x6x6 : résultats 100% pertinents
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 21
22. Figure 17 - Recherche par similarité effectuée à l'aide du descripteur HistRGB_2x2x2 : résultats peu pertinents
3.1.3 Calcul des diagrammes précision / rappel
Les courbes précision / rappel ci-dessous résultent du calcul de la précision moyenne
globale – en anglais Mean Average Précision : MAP. La base de données d’images utilisée est
composée de 10 000 images. Le jeu de données de la vérité terrain est composé de 30 classes
de 100 images. Pour arriver à ce résultat final, la précision moyenne de chaque classe – en
anglais Average Precisiona : AP – a été calculée.
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 22
23. Figure 18 - Courbes précision / rappel des histogrammes niveau de gris
Figure 19 - Courbes précision / rappel des histogrammes couleur RGB
0
0,1
0,2
0,3
0,4
0,5
0,6
0,7
0,8
0,9
1
0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 1
Précision
Rappel
Courbes précision / rappel des histogrammes niveau de gris.
Analyse des quantifications sur 16, 64 et 256 bins
16 bins 64 bins 256 bins
0
0,1
0,2
0,3
0,4
0,5
0,6
0,7
0,8
0,9
1
0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 1
Précision
Rappel
Courbes précision / rappel des histogrammes couleur RGB.
Analyse des quantifications sur 2x2x2, 4x4x4 et 6x6x6 bins
2x2x2 bins 4x4x4 bins 6x6x6 bins
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 23
24. Figure 20 - Courbes précision / rappel : Histogramme niveau de gris 256 bins VS Histogramme couleur RGB 6x6x6 bins
D’après l’analyse de l’ensemble des courbes précision / rappel, il en ressort que
le descripteur le plus performant est HistRGB_6x6x6. En effet, pour une valeur de rappel
donnée, il s’agit du descripteur qui permet de mettre en avant les résultats les plus pertinents
par rapport aux autres descripteurs. Le graphique ci-dessous illustre ces propos :
Figure 21 - Analyse de la performance des descripteurs pour une valeur de rappel de 0.1
0
0,1
0,2
0,3
0,4
0,5
0,6
0,7
0,8
0,9
1
0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 1
Précision
Rappel
Courbes précision / rappel :
Histogramme niveau de gris 256 bins VS Histogramme couleur
RGB 6x6x6 bins
Histogramme niveau de gris 256 bins Histogramme couleur RGB 6x6x6 bins
0
0,05
0,1
0,15
0,2
0,25
0,3
Descripteur
Précision
Analyse de la performance des descripteurs pour une valeur
de rappel de 0.1
Niveau de gris 16 bins Niveau de gris 64 bins Niveau de gris 256 bins
Couleur RGB 2x2x2 bins Couleur RGB 4x4x4 bins Couleur RGB 6x6x6 bins
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 24
25. 3.1.4 Calcul des courbes précision / rappel lorsque les classes de la vérité terrain
n'ont pas la même taille
Lorsque les classes de la vérité terrain sont de tailles différentes, il faut réaliser les
courbes précision / rappel de chaque image de chaque classe de vérité terrain
indépendamment les unes des autres. Le diagramme précision / rappel global est réalisé en
calculant la moyenne de l’ensemble des diagrammes calculé indépendamment (cf. jusque ici,
c’est la même procédure que lorsque celle-ci sont de taille identique). Les valeurs de rappel
absente du diagramme précision / rappel d’une classe de vérité terrain sont déterminées par
interpolation linéaire.
4. Structuration des descripteurs par un M-Tree
4.2 Travail réalisé
4.2.1 Fonction rangeQuery
4.2.1.1 Code Java
/**
* Recherche par similarité
*
* @param o objet requête
* @param distance distance maximale de recherche permettant
* de déterminer les objets similaires à la recherche
* @return liste des objets similaires à l'objet requête
* >> Possède une distance inférieure ou égale à la distance de
* recherche maximale "distance".
*/
public List<MTreeObject> rangeQuery(MTreeObject query, double distance) {
// Reinitialisation du compteur à 0
this.countDistanceFunctionCall.set(0);
// Retour les résultats
return this.nodeSearch(this.root, query, distance);
}
/**
* Recherche les objets similaires à l'objet requête
*
* @param node noeud à traiter (initialement, il s'agit de "this.root")
* @param query objet requête
* @param distance distance maximale de recherche permettant de déterminer
* les objets similaires à la recherche
* @return liste des objets similaires à l'objet requête
* >> Possède une distance inférieure ou égale à la distance de
* recherche maximale "distance".
*/
public List<MTreeObject> nodeSearch(MTreeNode node, MTreeObject query,
double distance) {
// Initialisation des résultats de sortie
List<MTreeObject> results = new ArrayList();
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 25
26. if(!node.isLeafNode) { // L'objet est un noeud
// Parcours l'ensemble des noeuds
for(MTreeObject o : node.objects) {
double distQ = o.distanceFromQuery;
double distP = o.distanceFromParent;
double radiusAndDist = o.radius + distance;
// Détermine si le noeud contient des données pertinentes
// ou non sans effectuer de calcul
if ( Math.abs(distQ - distP) <= radiusAndDist ) {
// Calcul de la distance entre le noeud courant
// et l'objet requête
double dist = this.distance(query, o);
if ( dist <= radiusAndDist ) {
// Le noeud contient potentiellement des
// informations pertinentes
// Rappelle la fonction nodeSearch en passant
// les noeuds fils de l'objet courant comme
// noeud de référence
List<MTreeObject> output =
this.nodeSearch(o.subtree, query, distance);
if (!output.isEmpty()) {
// Ajoute les éventuels objets du noeud
// ayant un potentiel d'objets //
pertinents aux données de sortie
results.addAll(output);
}
}
}
}
} else { // L'objet est une feuille
for(MTreeObject o : node.objects) {
double distQ = o.distanceFromQuery;
double distP = o.distanceFromParent;
// Détermine si l'objet est pertinent ou non sans
// effectuer de calcul
if ( Math.abs(distQ - distP) <= distance ) {
double dist = this.distance(query, o);
// Calcul de la distance entre l'objet courant est
// l'objet requête
if (dist <= distance) {
// L'objet est pertinent. Celui-ci est ajouté
// aux données de sortie
results.add(o);
}
}
}
}
// Retourne l'ensemble des résultats pertinents
return results;
}
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 26
27. 4.2.1.2 Explications
La fonction rangeQuery recherche tous les objets de la base de données d’images qui
se situent à une distance inférieure ou également au rayon de recherche de l’objet requête.
La valeur de rayon de recherche maximale est déterminée par tentatives successives grâce à
la fonction « getCountDistanceFunctionCall ».
4.2.2 Analyse de l’impact de la capacité du nœud
Ci-dessous, les résultats de l’étude de l’impact de la capacité des nœuds pour les
descripteurs HisoGREY_64 bins et HistRGB_4x4x4 sur le nombre d’appels à la fonction de
calcul de distance. Les capacités de nœuds étudiées sont : 10 000, 7 500, 5 000, 2 500, 2 000,
1 000, 500, 450, 400, 350, 300, 250, 200, 175, 150, 125, 100, 75, 50, 25, 20, 19, 18, 17, 16, 15,
14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2. La base de données d’images est composée de 10 000
images. Le calcul des valeurs Nd moyennes est basé sur une sélection de 100 images
sélectionnées aléatoirement parmi l’ensemble de la base de données d’images. Les 100
images sélectionnées composent le jeu d’images utilisé pour l’ensemble des calculs.
Figure 22 - Analyse des performances MTree
Les meilleurs résultats sont obtenus lorsque le nombre d’appels à la fonction de
distance est moindre : le temps de calcul de la distance entre chaque objet est coûteux.
Dans le cadre du descripteur HistGREY_64, le nombre d’appels à la fonction de calcul
de distance est minimal lorsque la taille des nœuds est de 2 000 objets. Pour le descripteur
HistRGB_4x4x4 la taille des nœuds optimale est de 2 500 objets. Ces données dépendent de
la distribution des données au sein de la base de données.
0
2000
4000
6000
8000
10000
12000
14000
16000
18000
20000
1 10 100 1000 10000
ValeurNdmoyenne
Capacité des noeuds
Analyse des performances MTree
HistGREY_64 Valeur Nd moyenne HistRGB_4x4x4 Valeur Nd moyenne
Capacité de noeud : 2000
Valeur Nd moyenne : 811,65
Capacité de noeud : 2500
Valeur Nd moyenne : 2087,48
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 27
28. Plus la taille des nœuds est faible, plus l’arbre MTree est haut : pour une requête
donnée, il y a énormément de sous nœuds à analyser, donc un nombre élevé d’appels à la
fonction de calcul de distance. La performance de l’algorithme est fortement dégradée
lorsque la taille des nœuds est très faible (inférieur à 10).
Dans le cas contraire, plus la taille des nœuds est grande, plus l’arbre MTree est large :
pour une requête donnée, il est difficile l’éliminer des portions de l’arbre. Pratiquement tous
les nœuds contiennent des informations potentiellement pertinentes or la majeure partie des
données analysées n’est pas pertinente. La performance de l’algorithme se retrouve une
nouvelle fois fortement dégradée lorsque la taille des nœuds approche la taille de la base de
données.
© Guillaume Mocquet - TP Bases de données image : « Compte rendu » 28
