Partager via

Détection d’objets à l’aide de Fast R-CNN

Table des matières

Résumé

image d’image

Ce tutoriel explique comment utiliser Fast R-CNN dans l’API Python CNTK. R-CNN rapide utilisant BrainScript et cnkt.exe est décrit ici.

Les exemples ci-dessus sont des exemples d’images et d’annotations d’objet pour le jeu de données d’épicerie (à gauche) et le jeu de données Pascal VOC (à droite) utilisé dans ce tutoriel.

Fast R-CNN est un algorithme de détection d’objets proposé par Ross Girshick en 2015. Le document est accepté à ICCV 2015, et archivé à https://arxiv.org/abs/1504.08083. R-CNN rapide s’appuie sur des travaux précédents pour classifier efficacement les propositions d’objets à l’aide de réseaux convolutionnels profonds. Par rapport au travail précédent, Fast R-CNN utilise une région de regroupement d’intérêts qui permet de réutiliser les calculs des couches convolutionnelles.

Programme d’installation

Pour exécuter le code dans cet exemple, vous avez besoin d’un environnement Python CNTK (voir ici pour obtenir de l’aide sur la configuration). Installez les packages supplémentaires suivants dans votre environnement Python cntk

pip install opencv-python easydict pyyaml dlib

Fichiers binaires précompilés pour la régression de cadre englobant et la suppression non maximale

Le dossier Examples\Image\Detection\utils\cython_modules contient des fichiers binaires précompilés requis pour l’exécution de Fast R-CNN. Les versions actuellement contenues dans le référentiel sont Python 3.5 pour Windows et Python 3.5, 3.6 pour Linux, toutes les versions 64 bits. Si vous avez besoin d’une autre version, vous pouvez la compiler en suivant les étapes décrites à l’adresse

Copiez les fichiers binaires générés cython_bbox et cpu_nms (et/ougpu_nms) à $CNTK_ROOT/Examples/Image/Detection/utils/cython_modulespartir de $FRCN_ROOT/lib/utils .

Exemple de modèle de base et de données

Nous utilisons un modèle AlexNet préentraîné comme base pour l’entraînement Fast-R-CNN (pour VGG ou d’autres modèles de base voir Utilisation d’un modèle de base différent. L’exemple de jeu de données et le modèle AlexNet préentraîné peuvent être téléchargés en exécutant la commande Python suivante à partir du dossier FastRCNN :

python install_data_and_model.py

Exécuter l’exemple de toy

Pour entraîner et évaluer l’exécution fast R-CNN

python run_fast_rcnn.py

Les résultats de l’entraînement avec 2 000 ROIs sur l’épicerie à l’aide d’AlexNet comme modèle de base doivent ressembler à ceux-ci :

AP for          gerkin = 1.0000
AP for          butter = 1.0000
AP for         joghurt = 1.0000
AP for          eggBox = 1.0000
AP for         mustard = 1.0000
AP for       champagne = 1.0000
AP for          orange = 1.0000
AP for           water = 0.5000
AP for         avocado = 1.0000
AP for          tomato = 1.0000
AP for          pepper = 1.0000
AP for         tabasco = 1.0000
AP for           onion = 1.0000
AP for            milk = 1.0000
AP for         ketchup = 0.6667
AP for     orangeJuice = 1.0000
Mean AP = 0.9479

Pour visualiser les rectangles englobants et les étiquettes prédits sur les images ouvertes FastRCNN_config.py à partir du FastRCNN dossier et définies

__C.VISUALIZE_RESULTS = True

Les images sont enregistrées dans le FastRCNN/Output/Grocery/ dossier si vous exécutez python run_fast_rcnn.py.

Entraîner sur Pascal VOC

Pour télécharger les données Pascal et créer les fichiers d’annotation pour Pascal au format CNTK, exécutez les scripts suivants :

python Examples/Image/DataSets/Pascal/install_pascalvoc.py
python Examples/Image/DataSets/Pascal/mappings/create_mappings.py

Modifiez la dataset_cfgget_configuration() méthode de run_fast_rcnn.py

from utils.configs.Pascal_config import cfg as dataset_cfg

Vous êtes maintenant configuré pour effectuer l’apprentissage sur les données Pascal VOC 2007 à l’aide python run_fast_rcnn.pyde . Attention à ce que la formation peut prendre un certain temps.

Effectuer l’apprentissage sur vos propres données

Préparer un jeu de données personnalisé

Option n° 1 : Outil visual Object Tagging Tool (recommandé)

L’outil Visual Object Tagging Tool (VOTT) est un outil d’annotation multiplateforme pour le balisage des ressources vidéo et d’image.

Capture d’écran Vott

VOTT fournit les fonctionnalités suivantes :

  • Balisage assisté par ordinateur et suivi d’objets dans des vidéos à l’aide de l’algorithme de suivi Camshift.
  • Exportation d’étiquettes et de ressources au format CNTK Fast-RCNN pour entraîner un modèle de détection d’objet.
  • Exécution et validation d’un modèle de détection d’objet CNTK entraîné sur de nouvelles vidéos pour générer des modèles plus forts.

Comment annoter avec VOTT :

  1. Télécharger la dernière version
  2. Suivez le fichier Lisez-moi pour exécuter un travail d’étiquetage
  3. Après l’étiquetage des balises Exporter vers le répertoire du jeu de données

Option n° 2 : Utilisation de scripts d’annotation

Pour entraîner un modèle CNTK Fast R-CNN sur votre propre jeu de données, nous fournissons deux scripts pour annoter des régions rectangulaires sur des images et affecter des étiquettes à ces régions. Les scripts stockent les annotations dans le format approprié, selon les besoins de la première étape de l’exécution de Fast R-CNN (A1_GenerateInputROIs.py). Tout d’abord, stockez vos images dans la structure de dossiers suivante

  • <your_image_folder>/negative - images utilisées pour l’entraînement qui ne contiennent aucun objet
  • <your_image_folder>/positive - images utilisées pour l’entraînement qui contiennent des objets
  • <your_image_folder>/testImages - images utilisées pour les tests qui contiennent des objets

Pour les images négatives, vous n’avez pas besoin de créer d’annotations. Pour les deux autres dossiers, utilisez les scripts fournis :

  • Exécuter C1_DrawBboxesOnImages.py pour dessiner des zones englobantes sur les images.
    • Dans le jeu imgDir = <your_image_folder> de scripts (/positive ou /testImages) avant l’exécution.
    • Ajoutez des annotations à l’aide du curseur de la souris. Une fois que tous les objets d’une image sont annotés, le fait d’appuyer sur la touche 'n' écrit le fichier .bboxes.txt, puis passe à l’image suivante, 'u' annule (c’est-à-dire supprime) le dernier rectangle et 'q' quitte l’outil d’annotation.
  • Exécutez C2_AssignLabelsToBboxes.py pour affecter des étiquettes aux zones englobantes.
    • Dans le jeu imgDir = <your_image_folder> de scripts (/positive ou /testImages) avant l’exécution...
    • ... et adapter les classes du script pour refléter vos catégories d’objets, par exemple classes = ("dog", "cat", "octopus").
    • Le script charge ces rectangles annotés manuellement pour chaque image, les affiche un par un et demande à l’utilisateur de fournir la classe d’objet en cliquant sur le bouton correspondant à gauche de la fenêtre. Les annotations de vérité de base marquées comme « indécidées » ou « exclure » sont entièrement exclues du traitement ultérieur.

Effectuer l’apprentissage sur un jeu de données personnalisé

Après avoir stocké vos images dans la structure de dossiers décrite et les annoter, exécutez

python Examples/Image/Detection/utils/annotations/annotations_helper.py

après avoir modifié le dossier de ce script vers votre dossier de données. Enfin, créez un MyDataSet_config.py dossier en utils\configs suivant les exemples existants :

__C.CNTK.DATASET == "YourDataSet":
__C.CNTK.MAP_FILE_PATH = "../../DataSets/YourDataSet"
__C.CNTK.CLASS_MAP_FILE = "class_map.txt"
__C.CNTK.TRAIN_MAP_FILE = "train_img_file.txt"
__C.CNTK.TEST_MAP_FILE = "test_img_file.txt"
__C.CNTK.TRAIN_ROI_FILE = "train_roi_file.txt"
__C.CNTK.TEST_ROI_FILE = "test_roi_file.txt"
__C.CNTK.NUM_TRAIN_IMAGES = 500
__C.CNTK.NUM_TEST_IMAGES = 200
__C.CNTK.PROPOSAL_LAYER_SCALES = [8, 16, 32]

Notez qu’il __C.CNTK.PROPOSAL_LAYER_SCALES n’est pas utilisé pour Fast R-CNN, uniquement pour Faster R-CNN.

Pour entraîner et évaluer Fast R-CNN sur vos données, modifiez la dataset_cfgget_configuration() méthode de run_fast_rcnn.py

from utils.configs.MyDataSet_config import cfg as dataset_cfg

et exécutez python run_fast_rcnn.py.

Détails techniques

L’algorithme R-CNN rapide est expliqué dans la section Détails de l’algorithme , ainsi qu’une vue d’ensemble générale de la façon dont il est implémenté dans l’API Python CNTK. Cette section se concentre sur la configuration de Fast R-CNN et sur l’utilisation de différents modèles de base.

Paramètres

Les paramètres sont regroupés en trois parties :

  • Paramètres du détecteur (voir FastRCNN/FastRCNN_config.py)
  • Paramètres du jeu de données (voir par exemple utils/configs/Grocery_config.py)
  • Paramètres du modèle de base (voir par exemple utils/configs/AlexNet_config.py)

Les trois parties sont chargées et fusionnées dans la get_configuration() méthode dans run_fast_rcnn.py. Dans cette section, nous allons aborder les paramètres du détecteur. Les paramètres de jeu de données sont décrits ici, les paramètres du modèle de base ici. Dans ce qui suit, nous passons par les paramètres les plus importants dans FastRCNN_config.py. Tous les paramètres sont également commentés dans le fichier. La configuration utilise le EasyDict package qui permet un accès facile aux dictionnaires imbriqués.

# Number of regions of interest [ROIs] proposals
__C.NUM_ROI_PROPOSALS = 200 # use 2000 or more for good results
# the minimum IoU (overlap) of a proposal to qualify for training regression targets
__C.BBOX_THRESH = 0.5

# Maximum number of ground truth annotations per image
__C.INPUT_ROIS_PER_IMAGE = 50
__C.IMAGE_WIDTH = 850
__C.IMAGE_HEIGHT = 850

# Use horizontally-flipped images during training?
__C.TRAIN.USE_FLIPPED = True
# If set to 'True' conv layers weights from the base model will be trained, too
__C.TRAIN_CONV_LAYERS = True

Les propositions de retour sur investissement sont calculées à la volée dans la première époque à l’aide de l’implémentation sélective de la recherche à partir du dlib package. Le nombre de propositions générées est contrôlé par le __C.NUM_ROI_PROPOSALS paramètre. Nous vous recommandons d’utiliser environ 2 000 propositions. La tête de régression n’est entraînée que sur les ROIs qui ont un chevauchement (IoU) avec une boîte de vérité au sol d’au moins __C.BBOX_THRESH.

__C.INPUT_ROIS_PER_IMAGE spécifie le nombre maximal d’annotations de vérité au sol par image. CNTK nécessite actuellement de définir un nombre maximal. S’il y a moins d’annotations, elles seront complétées en interne. __C.IMAGE_WIDTH et __C.IMAGE_HEIGHT sont les dimensions utilisées pour redimensionner et remplir les images d’entrée.

__C.TRAIN.USE_FLIPPED = True augmente les données d’apprentissage en retournant toutes les images toutes les autres époques, c’est-à-dire que la première époque a toutes les images régulières, la seconde a toutes les images retournées, etc. __C.TRAIN_CONV_LAYERS détermine si les couches convolutionnelles, de l’entrée à la carte de caractéristiques convolutionnelles, sont entraînées ou fixes. La fixation des pondérations de couche conv signifie que les poids du modèle de base sont pris et non modifiés pendant l’entraînement. (Vous pouvez également spécifier le nombre de couches conv que vous souhaitez entraîner, voir la section Utilisation d’un autre modèle de base).

# NMS threshold used to discard overlapping predicted bounding boxes
__C.RESULTS_NMS_THRESHOLD = 0.5

# If set to True the following two parameters need to point to the corresponding files that contain the proposals:
# __C.DATA.TRAIN_PRECOMPUTED_PROPOSALS_FILE
# __C.DATA.TEST_PRECOMPUTED_PROPOSALS_FILE
__C.USE_PRECOMPUTED_PROPOSALS = False

__C.RESULTS_NMS_THRESHOLD est le seuil NMS utilisé pour ignorer les zones englobantes prédites qui se chevauchent dans l’évaluation. Un seuil inférieur génère moins de suppressions et, par conséquent, des rectangles englobants prédits dans la sortie finale. Si vous définissez __C.USE_PRECOMPUTED_PROPOSALS = True le lecteur, les rois précalculés sont lus à partir de fichiers texte. Il s’agit, par exemple, d’une formation sur les données VOC Pascal. Les noms __C.DATA.TRAIN_PRECOMPUTED_PROPOSALS_FILE de fichiers et __C.DATA.TEST_PRECOMPUTED_PROPOSALS_FILE sont spécifiés dans Examples/Image/Detection/utils/configs/Pascal_config.py.

# The basic segmentation is performed kvals.size() times. The k parameter is set (from, to, step_size)
__C.roi_ss_kvals = (10, 500, 5)
# When doing the basic segmentations prior to any box merging, all
# rectangles that have an area < min_size are discarded. Therefore, all outputs and
# subsequent merged rectangles are built out of rectangles that contain at
# least min_size pixels. Note that setting min_size to a smaller value than
# you might otherwise be interested in using can be useful since it allows a
# larger number of possible merged boxes to be created
__C.roi_ss_min_size = 9
# There are max_merging_iterations rounds of neighboring blob merging.
# Therefore, this parameter has some effect on the number of output rectangles
# you get, with larger values of the parameter giving more output rectangles.
# Hint: set __C.CNTK.DEBUG_OUTPUT=True to see the number of ROIs from selective search
__C.roi_ss_mm_iterations = 30
# image size used for ROI generation
__C.roi_ss_img_size = 200

Les paramètres ci-dessus configurent la recherche sélective de dlib. Pour plus d’informations, consultez la page d’accueil dlib. Les paramètres supplémentaires suivants sont utilisés pour filtrer les ROIs générés w.r.t. longueur minimale et maximale côté, zone et proportion.

# minimum relative width/height of an ROI
__C.roi_min_side_rel = 0.01
# maximum relative width/height of an ROI
__C.roi_max_side_rel = 1.0
# minimum relative area of an ROI
__C.roi_min_area_rel = 0.0001
# maximum relative area of an ROI
__C.roi_max_area_rel = 0.9
# maximum aspect ratio of an ROI vertically and horizontally
__C.roi_max_aspect_ratio = 4.0
# aspect ratios of ROIs for uniform grid ROIs
__C.roi_grid_aspect_ratios = [1.0, 2.0, 0.5]

Si la recherche sélective retourne plus de ROIs que demandé, ils sont échantillonné de manière aléatoire. Si moins de ROIs sont renvoyés des ROIs supplémentaires sont générés sur une grille normale à l’aide de la valeur spécifiée __C.roi_grid_aspect_ratios.

Utilisation d’un autre modèle de base

Pour utiliser un modèle de base différent, vous devez choisir une configuration de modèle différente dans la get_configuration() méthode de run_fast_rcnn.py. Deux modèles sont pris en charge immédiatement :

    # for VGG16 base model use:         from utils.configs.VGG16_config import cfg as network_cfg
    # for AlexNet base model use:       from utils.configs.AlexNet_config import cfg as network_cfg

Pour télécharger le modèle VGG16, utilisez le script de téléchargement dans <cntkroot>/PretrainedModels:

    python download_model.py VGG16_ImageNet_Caffe

Si vous souhaitez utiliser un autre modèle de base différent, vous devez copier, par exemple, le fichier utils/configs/VGG16_config.py de configuration et le modifier en fonction de votre modèle de base :

# model config
__C.MODEL.BASE_MODEL = "VGG16"
__C.MODEL.BASE_MODEL_FILE = "VGG16_ImageNet_Caffe.model"
__C.MODEL.IMG_PAD_COLOR = [103, 116, 123]
__C.MODEL.FEATURE_NODE_NAME = "data"
__C.MODEL.LAST_CONV_NODE_NAME = "relu5_3"
__C.MODEL.START_TRAIN_CONV_NODE_NAME = "pool2" # __C.MODEL.FEATURE_NODE_NAME
__C.MODEL.POOL_NODE_NAME = "pool5"
__C.MODEL.LAST_HIDDEN_NODE_NAME = "drop7"
__C.MODEL.FEATURE_STRIDE = 16
__C.MODEL.RPN_NUM_CHANNELS = 512
__C.MODEL.ROI_DIM = 7

Pour examiner les noms de nœud de votre modèle de base, vous pouvez utiliser la plot() méthode à partir de cntk.logging.graph. Notez que les modèles ResNet ne sont actuellement pas pris en charge, car le regroupement de rois dans CNTK ne prend pas encore en charge le regroupement moyen roi.

Détails de l’algorithme

R-CNN rapide

Les R-CNN pour la détection d’objets ont été présentés en 2014 par Ross Girshick et al., et ont été montrés à des approches antérieures de pointe sur l’un des principaux défis de reconnaissance d’objets dans le domaine : Pascal VOC. Depuis lors, deux documents de suivi ont été publiés qui contiennent des améliorations significatives de vitesse : Fast R-CNN et Faster R-CNN.

L’idée de base de R-CNN est de prendre un réseau neuronal profond qui a été initialement formé pour la classification d’images à l’aide de millions d’images annotées et de le modifier à des fins de détection d’objets. L’idée de base du premier document R-CNN est illustrée dans la figure ci-dessous (tirée du papier) : (1) Compte tenu d’une image d’entrée, (2) lors d’une première étape, un grand nombre de propositions régionales sont générées. (3) Ces propositions régionales, ou régions d’intérêts (ROIs), sont ensuite envoyées indépendamment par le biais du réseau, ce qui génère un vecteur de valeurs à virgule flottante 4096 pour chaque roi. Enfin, (4) un classifieur est appris qui prend la représentation 4096 de retour sur investissement flottant comme entrée et génère une étiquette et une confiance à chaque retour sur investissement.

Image

Bien que cette approche fonctionne bien en termes de précision, il est très coûteux de calculer, car le réseau neuronal doit être évalué pour chaque retour sur investissement. R-CNN rapide résout cet inconvénient en évaluant uniquement la plupart du réseau (pour être spécifique : les couches de convolution) une seule fois par image. Selon les auteurs, cela conduit à une accélération de 213 fois pendant les tests et une accélération de 9x pendant l’entraînement sans perte de précision. Pour ce faire, utilisez une couche de regroupement de retours sur investissement qui projette le retour sur la carte des caractéristiques convolutionnelles et effectue un regroupement maximal pour générer la taille de sortie souhaitée attendue par la couche suivante. Dans l’exemple AlexNet utilisé dans ce tutoriel, la couche de regroupement roi est placée entre la dernière couche convolutionnelle et la première couche entièrement connectée. Dans le code de l’API Python CNTK illustré ci-dessous, il est réalisé en clonant deux parties du réseau, le conv_layers et le fc_layers. L’image d’entrée est ensuite normalisée d’abord, poussée à travers la conv_layerscouche, la roipooling couche et enfin fc_layers les têtes de prédiction et de régression qui prédisent respectivement l’étiquette de classe et les coefficients de régression par retour sur investissement candidat.

def create_fast_rcnn_model(features, roi_proposals, label_targets, bbox_targets, bbox_inside_weights, cfg):
    # Load the pre-trained classification net and clone layers
    base_model = load_model(cfg['BASE_MODEL_PATH'])
    conv_layers = clone_conv_layers(base_model, cfg)
    fc_layers = clone_model(base_model, [cfg["MODEL"].POOL_NODE_NAME], [cfg["MODEL"].LAST_HIDDEN_NODE_NAME], clone_method=CloneMethod.clone)

    # Normalization and conv layers
    feat_norm = features - Constant([[[v]] for v in cfg["MODEL"].IMG_PAD_COLOR])
    conv_out = conv_layers(feat_norm)

    # Fast RCNN and losses
    cls_score, bbox_pred = create_fast_rcnn_predictor(conv_out, roi_proposals, fc_layers, cfg)
    detection_losses = create_detection_losses(...)
    pred_error = classification_error(cls_score, label_targets, axis=1)

    return detection_losses, pred_error

def create_fast_rcnn_predictor(conv_out, rois, fc_layers, cfg):
    # RCNN
    roi_out = roipooling(conv_out, rois, cntk.MAX_POOLING, (6, 6), spatial_scale=1/16.0)
    fc_out = fc_layers(roi_out)

    # prediction head
    cls_score = plus(times(fc_out, W_pred), b_pred, name='cls_score')

    # regression head
    bbox_pred = plus(times(fc_out, W_regr), b_regr, name='bbox_regr')

    return cls_score, bbox_pred

L’implémentation Caffe originale utilisée dans les documents R-CNN est disponible sur GitHub : RCNN, Fast R-CNN et Faster R-CNN.

Entraînement SVM et NN

Patrick Buehler fournit des instructions sur l’apprentissage d’une machine virtuelle SVM sur la sortie CNTK Fast R-CNN (à l’aide des fonctionnalités 4096 de la dernière couche entièrement connectée) ainsi qu’une discussion sur les avantages et les inconvénients ici.

La recherche sélective est une méthode permettant de trouver un grand ensemble d’emplacements d’objets possibles dans une image, indépendamment de la classe de l’objet réel. Il fonctionne en clustering des pixels d’image en segments, puis en effectuant un clustering hiérarchique pour combiner des segments du même objet en propositions d’objets.

imageimage image

Pour compléter les ROIs détectés à partir de la recherche sélective, nous ajoutons des ROIs qui couvrent l’image à différentes échelles et proportions. L’image de gauche montre un exemple de sortie de la recherche sélective, où chaque emplacement d’objet possible est visualisé par un rectangle vert. Les ROIs trop petits, trop volumineux, etc. sont ignorés (milieu) et enfin les ROIs qui couvrent uniformément l’image sont ajoutées (à droite). Ces rectangles sont ensuite utilisés en tant que régions d’intérêts (ROIs) dans le pipeline R-CNN.

L’objectif de la génération de retour sur investissement est de trouver un petit ensemble de ROIs qui couvrent toutefois étroitement autant d’objets dans l’image que possible. Ce calcul doit être suffisamment rapide, tout en recherchant des emplacements d’objets à différentes échelles et proportions. La recherche sélective a été montrée pour s’exécuter correctement pour cette tâche, avec une bonne précision pour accélérer les compromis.

NMS (suppression non maximale)

Les méthodes de détection d’objet génèrent souvent plusieurs détections qui couvrent entièrement ou partiellement le même objet dans une image. Ces URI doivent être fusionnés pour pouvoir compter les objets et obtenir leurs emplacements exacts dans l’image. Cette opération s’effectue traditionnellement à l’aide d’une technique appelée Suppression non maximale (NMS). La version de NMS que nous utilisons (et qui a également été utilisée dans les publications R-CNN) ne fusionne pas les ROIs, mais tente plutôt d’identifier les ROIs qui couvrent le mieux les emplacements réels d’un objet et ignore toutes les autres ROIs. Cette opération est implémentée en sélectionnant de manière itérative le retour sur investissement avec la plus grande confiance et en supprimant toutes les autres URI qui chevauchent considérablement ce roi et sont classés comme appartenant à la même classe. Le seuil de chevauchement peut être défini dans PARAMETERS.py (détails).

Résultats de la détection avant (gauche) et après (droite) Suppression non maximale :

image d’image

mAP (moyenne précision moyenne)

Une fois entraîné, la qualité du modèle peut être mesurée à l’aide de différents critères, tels que la précision, le rappel, la précision, la zone sous-courbe, etc. Une métrique courante utilisée pour le défi de reconnaissance d’objet VOC Pascal consiste à mesurer la précision moyenne (AP) pour chaque classe. La description suivante de Average Precision est extraite d’Everingham et. al. La moyenne de précision moyenne (mAP) est calculée en prenant la moyenne sur les adresses IP de toutes les classes.

Pour une tâche et une classe donnée, la courbe de précision/rappel est calculée à partir de la sortie classée d’une méthode. Le rappel est défini comme la proportion de tous les exemples positifs classés au-dessus d’un rang donné. La précision est la proportion de tous les exemples ci-dessus qui proviennent de la classe positive. L’AP récapitule la forme de la courbe de précision/rappel et est définie comme précision moyenne à un ensemble de onze niveaux de rappel également espacés [0,0,1, . . . ,1]:

image

La précision à chaque niveau de rappel r est interpolée en prenant la précision maximale mesurée pour une méthode pour laquelle le rappel correspondant dépasse r :

image

où p( ̃r) est la précision mesurée au rappel ̃r. L’intention d’interpoler la courbe de précision/de rappel de cette façon consiste à réduire l’impact des « lunettes » dans la courbe de précision/rappel, provoquée par de petites variations dans le classement des exemples. Il convient de noter que pour obtenir un score élevé, une méthode doit avoir une précision à tous les niveaux de rappel : cela pénalise les méthodes qui récupèrent uniquement un sous-ensemble d’exemples avec une haute précision (par exemple, des vues latérales des voitures).

  • Last updated on