web-dev-qa-db-fra.com

Meilleure stratégie pour réduire les faux positifs: la nouvelle API de détection d'objets de Google sur l'imagerie satellite

J'installe la nouvelle API de détection d'objets Tensorflow pour trouver de petits objets dans de grandes zones d'imagerie satellite. Cela fonctionne assez bien - il trouve les 10 objets que je veux, mais j'obtiens également 50 à 100 faux positifs [des choses qui ressemblent un peu à l'objet cible, mais qui ne le sont pas].

J'utilise exemple de configuration du tutoriel 'pets' , pour affiner le faster_rcnn_resnet101_coco modèle qu'ils proposent. J'ai commencé petit, avec seulement 100 exemples de formation de mes objets (juste 1 classe). 50 exemples dans mon jeu de validation. Chaque exemple est une image de 200x200 pixels avec un objet étiqueté (~ 40x40) au centre. Je m'entraîne jusqu'à ce que mes courbes de précision et de perte atteignent leur plateau.

Je suis relativement nouveau dans l'utilisation du deep learning pour la détection d'objets. Quelle est la meilleure stratégie pour augmenter ma précision? par exemple. Exploitation minière dure-négative? Augmenter la taille de mon jeu de données d'entraînement? Je n'ai pas encore essayé le modèle le plus précis qu'ils proposent faster_rcnn_inception_resnet_v2_atrous_coco car j'aimerais maintenir une certaine vitesse, mais je le ferai si nécessaire.

L'extraction minière dure semble être une étape logique. Si vous êtes d'accord, comment puis-je l'implémenter sans configurer le fichier tfrecord pour mon jeu de données de formation? Disons que je fais des images 200x200 pour chacun des 50-100 faux positifs:

  • Dois-je créer des fichiers xml "annotation" pour chacun, sans élément "objet"?
  • ... ou dois-je étiqueter ces négatifs durs comme une seconde classe?
  • Si j'ai alors 100 négatifs à 100 positifs dans mon ensemble d'entraînement - est-ce un bon ratio? Combien de négatifs puis-je inclure?
machine-learningtensorflowcomputer-visiondeep-learningobject-detection
18
christian

J'ai revu ce sujet récemment dans mon travail et j'ai pensé que je mettrais à jour mes connaissances actuelles pour tous ceux qui visiteront à l'avenir.

Le sujet est apparu sur Suivi des problèmes de repo des modèles de Tensorflow . SSD vous permet de définir le rapport entre le nombre d'exemples négatifs: positifs et les miens (max_negatives_per_positive: 3), mais vous pouvez également définir un nombre minimum d'images sans postives (min_negatives_per_image: 3). Les deux sont définis dans la section de configuration model-ssd-loss.

Cela dit, je ne vois pas la même option dans la configuration du modèle Faster-RCNN. Il est mentionné dans le numéro que models/research/object_detection/core/balanced_positive_negative_sampler.py contient le code utilisé pour Faster-RCNN.

Une autre option discutée dans le problème consiste à créer une deuxième classe spécifiquement pour les sosies. Pendant la formation, le modèle tentera d'apprendre les différences de classe qui devraient aider à atteindre votre objectif.

Enfin, je suis tombé sur ce article sur les réseaux d'amplificateurs de filtre (FAN) qui peut être instructif pour votre travail sur l'imagerie aérienne.

================================================== =================

L'article suivant décrit l'extraction négative dure dans le même but que vous décrivez: Formation des détecteurs d'objets basés sur la région avec l'extraction en ligne d'un exemple dur

Dans la section 3.1, ils décrivent l'utilisation d'une classe de premier plan et d'arrière-plan:

RoIs d'arrière-plan. Une région est étiquetée fond (bg) si son IoU maximum avec la vérité du sol est dans l'intervalle [bg lo, 0,5). Un seuil inférieur de bg lo = 0,1 est utilisé par FRCN et SPPnet, et est supposé dans [14] pour approximer grossièrement l'extraction négative dure; l'hypothèse est que les régions avec un certain chevauchement avec la vérité du terrain sont plus susceptibles d'être confuses ou difficiles. Nous montrons dans la section 5.4 que bien que cette heuristique aide à la convergence et à la précision de détection, elle est sous-optimale car elle ignore certaines régions d'arrière-plan peu fréquentes, mais importantes, difficiles. Notre méthode supprime le seuil bg lo.

En fait, cet article est référencé et ses idées sont utilisées dans le code loss.py de détection d'objets de Tensorflow pour l'extraction matérielle:

class HardExampleMiner(object):
"""Hard example mining for regions in a list of images.
Implements hard example mining to select a subset of regions to be
back-propagated. For each image, selects the regions with highest losses,
subject to the condition that a newly selected region cannot have
an IOU > iou_threshold with any of the previously selected regions.
This can be achieved by re-using a greedy non-maximum suppression algorithm.
A constraint on the number of negatives mined per positive region can also be
enforced.
Reference papers: "Training Region-based Object Detectors with Online
Hard Example Mining" (CVPR 2016) by Srivastava et al., and
"SSD: Single Shot MultiBox Detector" (ECCV 2016) by Liu et al.
"""

Basé sur votre fichier de configuration de modèle, le HardMinerObject est renvoyé par loss_builder.py dans ce morceau de code:

def build_hard_example_miner(config,
                            classification_weight,
                            localization_weight):
"""Builds hard example miner based on the config.
Args:
    config: A losses_pb2.HardExampleMiner object.
    classification_weight: Classification loss weight.
    localization_weight: Localization loss weight.
Returns:
    Hard example miner.
"""
loss_type = None
if config.loss_type == losses_pb2.HardExampleMiner.BOTH:
    loss_type = 'both'
if config.loss_type == losses_pb2.HardExampleMiner.CLASSIFICATION:
    loss_type = 'cls'
if config.loss_type == losses_pb2.HardExampleMiner.LOCALIZATION:
    loss_type = 'loc'

max_negatives_per_positive = None
num_hard_examples = None
if config.max_negatives_per_positive > 0:
    max_negatives_per_positive = config.max_negatives_per_positive
if config.num_hard_examples > 0:
    num_hard_examples = config.num_hard_examples
hard_example_miner = losses.HardExampleMiner(
    num_hard_examples=num_hard_examples,
    iou_threshold=config.iou_threshold,
    loss_type=loss_type,
    cls_loss_weight=classification_weight,
    loc_loss_weight=localization_weight,
    max_negatives_per_positive=max_negatives_per_positive,
    min_negatives_per_image=config.min_negatives_per_image)
return hard_example_miner

qui est retourné par model_builder.py et appelé par train.py. Donc, fondamentalement, il me semble que générer simplement vos véritables étiquettes positives (avec un outil comme LabelImg ou RectLabel) devrait être suffisant pour que l'algorithme de train trouve des négatifs durs dans les mêmes images. La question connexe donne une excellente procédure pas à pas .

Dans le cas où vous souhaitez alimenter des données qui n'ont pas de vrais positifs (c'est-à-dire que rien ne devrait être classé dans l'image), ajoutez simplement l'image négative à votre tfrecord sans boîtes de délimitation.

12
Tyler