Informations

Proposition de région d'intérêt dans Vision

Proposition de région d'intérêt dans Vision

En apprentissage automatique, la proposition de région d'intérêt (ROI) est une méthode de sous-échantillonnage d'une image pour identifier des sous-régions « intéressantes ». Un exemple canonique provient de Region Convolutional Neural Networks, où la tâche consiste à identifier des objets dans une scène :

Le point de la proposition de ROI ci-dessus est qu'elle rend la détection d'objets multiples ultérieure plus efficace puisque l'image entière n'a plus besoin d'être traitée et parce que la plupart des objets tomberont dans les sous-régions détectées. Pour être clair, la proposition de retour sur investissement est généralement effectuée à l'aide de méthodes de niveau inférieur, telles que l'examen des gradations de couleurs et l'estimation des limites des régions. De nos jours, la proposition de ROI se fait avec des couches convolutives, mais même celles-ci utilisent des noyaux de niveau assez bas pour proposer rapidement des régions. Je suis particulièrement intéressé par les approches convolutives, car elles semblent les plus pertinentes pour le cerveau.

Je me demande s'il existe des preuves d'une telle proposition de retour sur investissement dans la vision animale ? Plus précisément, quelle est notre compréhension actuelle de la façon dont le cerveau identifie plusieurs objets dans une scène complexe ? Avons-nous des raisons de croire qu'il ne s'agit pas seulement d'un balayage de gauche à droite et de haut en bas de l'image, mais quelque chose de plus efficace où les neurones de niveau inférieur proposent des sous-régions à explorer ?

Il a été difficile de rechercher ce sujet en ligne car il est principalement lié à la proposition de retour sur investissement pour les scanners cérébraux.


13.8.1. R-CNN¶

Les R-CNN extraits d'abord plusieurs (par exemple, 2000) propositions de région à partir de l'image d'entrée (par exemple, les boîtes d'ancrage peuvent également être considérées comme des propositions de région), en étiquetant leurs classes et les cadres de délimitation (par exemple, les décalages).

Ensuite, un CNN est utilisé pour effectuer une propagation vers l'avant sur chaque proposition de région pour extraire ses caractéristiques. Ensuite, les caractéristiques de chaque proposition de région sont utilisées pour prédire la classe et la boîte englobante de cette proposition de région.

La figure 13.8.1 montre le modèle R-CNN. Plus concrètement, le R-CNN se compose des quatre étapes suivantes :

Effectuer recherche sélective pour extraire plusieurs propositions de régions de haute qualité sur l'image d'entrée [Uijlings et al., 2013]. Ces régions proposées sont généralement sélectionnées à plusieurs échelles avec différentes formes et tailles. Chaque proposition de région sera étiquetée avec une classe et une boîte englobante de vérité terrain.

Choisissez un CNN pré-entraîné et tronquez-le avant la couche de sortie. Redimensionnez chaque proposition de région à la taille d'entrée requise par le réseau et affichez les caractéristiques extraites pour la proposition de région via la propagation vers l'avant.

Prenons l'exemple des caractéristiques extraites et de la classe étiquetée de chaque proposition de région. Entraînez plusieurs machines à vecteurs de support pour classer les objets, où chaque machine à vecteurs de support détermine individuellement si l'exemple contient une classe spécifique.

Prenons l'exemple des entités extraites et du cadre de délimitation étiqueté de chaque proposition de région. Entraînez un modèle de régression linéaire pour prédire la boîte englobante de vérité terrain.

Bien que le modèle R-CNN utilise des CNN pré-entraînés pour extraire efficacement les caractéristiques de l'image, il est lent. Imaginez que nous sélectionnions des milliers de propositions de régions à partir d'une seule image d'entrée : cela nécessite des milliers de propagations CNN vers l'avant pour effectuer la détection d'objets. Cette charge de calcul massive rend impossible l'utilisation à grande échelle des R-CNN dans des applications réelles.


Proposition de région d'intérêt en vision - Psychologie

Tous les articles publiés par MDPI sont rendus immédiatement disponibles dans le monde entier sous une licence en libre accès. Aucune autorisation particulière n'est requise pour réutiliser tout ou partie de l'article publié par MDPI, y compris les figures et les tableaux. Pour les articles publiés sous une licence Creative Common CC BY en accès libre, toute partie de l'article peut être réutilisée sans autorisation à condition que l'article original soit clairement cité.

Les articles de fond représentent la recherche la plus avancée avec un potentiel important d'impact élevé dans le domaine. Les articles de fond sont soumis sur invitation individuelle ou sur recommandation des éditeurs scientifiques et font l'objet d'un examen par les pairs avant publication.

L'article de fond peut être soit un article de recherche original, soit une nouvelle étude de recherche substantielle qui implique souvent plusieurs techniques ou approches, ou un article de synthèse complet avec des mises à jour concises et précises sur les derniers progrès dans le domaine qui passe systématiquement en revue les avancées les plus passionnantes dans le domaine scientifique. Littérature. Ce type d'article donne un aperçu des orientations futures de la recherche ou des applications possibles.

Les articles du Choix de l'éditeur sont basés sur les recommandations des éditeurs scientifiques des revues MDPI du monde entier. Les rédacteurs en chef sélectionnent un petit nombre d'articles récemment publiés dans la revue qui, selon eux, seront particulièrement intéressants pour les auteurs ou importants dans ce domaine. L'objectif est de fournir un aperçu de certains des travaux les plus passionnants publiés dans les différents domaines de recherche de la revue.


Résumé

Le surpeuplement, généralement défini comme l'influence délétère des contours proches sur la discrimination visuelle, est omniprésent dans la vision spatiale. Le surpeuplement nuit à la capacité de reconnaître les objets encombrés. Il a été largement étudié au cours des 80 dernières années environ, et une grande partie de l'intérêt renouvelé est l'espoir que l'étude de l'encombrement peut conduire à une meilleure compréhension des processus impliqués dans la reconnaissance d'objets. Le surpeuplement a également des implications cliniques importantes pour les patients atteints de dégénérescence maculaire, d'amblyopie et de dyslexie.

Les théories du surpeuplement ne manquent pas, des modèles de champ réceptif de bas niveau à l'attention de haut niveau. L'image actuelle est que l'encombrement représente un goulot d'étranglement essentiel pour la perception des objets, altérant la perception des objets dans la vision périphérique, amblyope et éventuellement en développement. Le surpeuplement n'est ni un masquage ni une suppression surround. Nous pouvons localiser l'encombrement dans le cortex, peut-être dès V1, cependant, il existe un consensus croissant pour un modèle d'encombrement en deux étapes dans lequel la première étape implique la détection de caractéristiques simples (peut-être en V1), et une deuxième étape est requis pour l'intégration ou l'interprétation des caractéristiques en tant qu'objet au-delà de la V1. Il existe des preuves d'effets descendants dans le surpeuplement, mais le rôle de l'attention dans ce processus reste incertain. Le fort effet de l'apprentissage sur la réduction de l'étendue spatiale de l'encombrement impose de fortes contraintes sur les modèles possibles d'encombrement et de reconnaissance d'objets.

Le but de cette revue est d'essayer de fournir une revue large, équilibrée et succincte qui organise et résume les études diverses et éparses du surpeuplement, et aide également à l'expliquer au non-spécialiste. Une compréhension complète de l'encombrement peut nous permettre de comprendre ce goulot d'étranglement à la reconnaissance d'objets et les règles qui régissent l'intégration des caractéristiques dans les objets.


Masque R-CNN

Mask R-CNN (He et al., 2017) étend Faster R-CNN à la segmentation d'image au niveau du pixel. Le point clé est de découpler les tâches de classification et de prédiction de masque au niveau du pixel. Basé sur le framework Faster R-CNN, il a ajouté une troisième branche pour prédire un masque d'objet en parallèle avec les branches existantes pour la classification et la localisation. La branche de masque est un petit réseau entièrement connecté appliqué à chaque RoI, prédisant un masque de segmentation de pixel à pixel.

Fig. 8. Mask R-CNN est un modèle R-CNN plus rapide avec segmentation d'image. (Source de l'image : He et al., 2017)

Étant donné que la segmentation au niveau du pixel nécessite un alignement beaucoup plus fin que les cadres de délimitation, le masque R-CNN améliore la couche de regroupement de RoI (appelée « couche RoIAlign ») afin que la RoI puisse être meilleure et plus précisément mappée aux régions de l'image d'origine.

Fig. 9. Prédictions par Mask R-CNN sur l'ensemble de test COCO. (Source de l'image : He et al., 2017)

RoIAign

La couche RoIAlign est conçue pour corriger le désalignement de l'emplacement causé par la quantification dans le pool RoI. RoIAlign supprime la quantification de hachage, par exemple, en utilisant x/16 au lieu de [x/16], afin que les caractéristiques extraites puissent être correctement alignées avec les pixels d'entrée. L'interpolation bilinéaire est utilisée pour calculer les valeurs d'emplacement à virgule flottante dans l'entrée.

Fig. 10. Une région d'intérêt est cartographiée avec précision de l'image d'origine sur la carte des caractéristiques sans arrondir à des nombres entiers. (Source de l'image : lien)

Fonction de perte

La fonction de perte multi-tâches de Mask R-CNN combine la perte de masque de classification, de localisation et de segmentation : (mathcal = mathcal_ exte + mathcal_ exte + mathcal_ exte), où (mathcal_ exte) et (mathcal_ exte) sont les mêmes que dans Faster R-CNN.

La branche masque génère un masque de dimension m x m pour chaque RoI et chaque classe K classes au total. Ainsi, la sortie totale est de taille (K cdot m^2). Étant donné que le modèle essaie d'apprendre un masque pour chaque classe, il n'y a pas de concurrence entre les classes pour générer des masques.

(mathcal_ exte) est défini comme la perte d'entropie croisée binaire moyenne, n'incluant que le k-ième masque si la région est associée à la classe de vérité terrain k.

où (y_) est l'étiquette d'une cellule (i, j) dans le vrai masque pour la région de taille m x m (hat_^k) est la valeur prédite de la même cellule dans le masque appris pour la classe de vérité terrain k.


1. Identifiez un domaine d'intérêt

La première étape du processus de recherche consiste à choisir un domaine d'intérêt. La recherche psychologique peut être très variée et, par conséquent, il peut être difficile de restreindre vos intérêts pour trouver un sujet spécifique sur lequel concentrer votre recherche. La sélection d'un sujet de recherche peut être intimidante au début, mais c'est une excellente occasion d'explorer vos intérêts personnels et de vous motiver pour votre projet de recherche. Le processus de sélection d'un sujet peut différer légèrement en fonction de votre diplôme inscrit, mais les étapes générales suivantes devraient vous aider à guider votre processus de prise de décision.

Chaque jour apporte de nouveaux choix -Marthe Beck


2 — Détection d'objets

La tâche de définir des objets dans les images implique généralement la sortie de cadres de délimitation et d'étiquettes pour des objets individuels. Cela diffère de la tâche de classification / localisation en appliquant la classification et la localisation à de nombreux objets au lieu d'un seul objet dominant. Vous n'avez que 2 classes de classification d'objets, ce qui signifie des cadres de délimitation d'objets et des cadres de délimitation de non-objets. Par exemple, dans la détection de voitures, vous devez détecter toutes les voitures d'une image donnée avec leurs cadres de délimitation.

Si nous utilisons la technique de la fenêtre coulissante comme la façon dont nous classons et localisons les images, nous devons appliquer un CNN à de nombreuses cultures différentes de l'image. Étant donné que CNN classe chaque culture en tant qu'objet ou arrière-plan, nous devons appliquer CNN à un grand nombre d'emplacements et d'échelles, ce qui est très coûteux en calcul !

Pour y faire face, les chercheurs en réseaux de neurones ont proposé d'utiliser Régions à la place, où l'on trouve des régions d'image « blobby » qui sont susceptibles de contenir des objets.

C'est relativement rapide à exécuter. Le premier modèle qui a donné le coup d'envoi a été R-CNN(Réseau neuronal convolutif basé sur la région). Dans un R-CNN, nous analysons d'abord l'image d'entrée à la recherche d'objets possibles à l'aide d'un algorithme appelé Recherche sélective, générant

2000 propositions de régions. Ensuite, nous gérons un CNN au-dessus de chacune de ces propositions de région. Enfin, nous prenons la sortie de chaque CNN et l'alimentons dans un SVM pour classer la région et une régression linéaire pour resserrer la boîte englobante de l'objet.

Essentiellement, nous avons transformé la détection d'objets en un problème de classification d'images. Cependant, il y a quelques problèmes - la formation est lente, beaucoup d'espace disque est requis et l'inférence est également lente.

Un descendant immédiat de R-CNN est R-CNN rapide, ce qui améliore la vitesse de détection grâce à 2 augmentations : 1) effectuer une extraction de caractéristiques avant de proposer des régions, n'exécutant ainsi qu'un seul CNN sur l'ensemble de l'image, et 2) remplacer SVM par une couche softmax, étendant ainsi le réseau de neurones pour les prédictions au lieu de créer un nouveau modèle.

Fast R-CNN a donné de bien meilleurs résultats en termes de vitesse, car il n'entraîne qu'un seul CNN pour l'ensemble de l'image. Cependant, l'algorithme de recherche sélective prend encore beaucoup de temps pour générer des propositions de région.

Ainsi vient l'invention de R-CNN plus rapide, qui est désormais un modèle canonique pour la détection d'objets basée sur l'apprentissage en profondeur. Il remplace l'algorithme de recherche sélective lente par un réseau de neurones rapide en insérant un Réseau de propositions de région (RPN) pour prédire des propositions à partir de fonctionnalités. Le RPN est utilisé pour décider « où » chercher afin de réduire les exigences de calcul du processus d'inférence global. Le RPN scanne rapidement et efficacement chaque emplacement afin d'évaluer si un traitement supplémentaire doit être effectué dans une région donnée. Il le fait en sortant k propositions de cadre englobant chacune avec 2 scores représentant la probabilité d'objet ou non à chaque emplacement.

Une fois que nous avons nos propositions de région, nous les introduisons directement dans ce qui est essentiellement un Fast R-CNN. Nous ajoutons une couche de pooling, des couches entièrement connectées et enfin une couche de classification softmax et un régresseur de boîte englobante.

Dans l'ensemble, Faster R-CNN a atteint des vitesses bien meilleures et une précision plus élevée. Il convient de noter que bien que les futurs modèles aient beaucoup fait pour augmenter les vitesses de détection, peu de modèles ont réussi à surpasser Faster R-CNN par une marge significative. En d'autres termes, Faster R-CNN n'est peut-être pas la méthode la plus simple ou la plus rapide pour la détection d'objets, mais c'est toujours l'une des plus performantes.

Les tendances majeures de la détection d'objets ces dernières années ont évolué vers des systèmes de détection plus rapides et plus efficaces. Cela était visible dans des approches telles que You Only Look Once (YOLO), Single Shot MultiBox Detector (SSD) et Region-Based Fully Convolutional Networks (R-FCN) dans le but de partager le calcul sur une image entière. Ainsi, ces approches se différencient des sous-réseaux coûteux associés aux 3 techniques R-CNN. La principale raison derrière ces tendances est d'éviter que des algorithmes distincts se concentrent isolément sur leurs sous-problèmes respectifs, car cela augmente généralement le temps de formation et peut réduire la précision du réseau.


Architecture typique

L'architecture de détection d'objets dont nous allons parler aujourd'hui se décompose en deux étapes :

  1. Proposition de région : Étant donné une image d'entrée, trouvez tous les endroits possibles où les objets peuvent être localisés. La sortie de cette étape doit être une liste de cadres de délimitation des positions probables des objets. Celles-ci sont souvent appelées propositions de région ou régions d'intérêt. Il existe plusieurs méthodes pour cette tâche, mais nous n'allons pas en parler dans cet article.
  2. Classement final : pour chaque proposition de région de l'étape précédente, décidez si elle appartient à l'une des classes cibles ou à l'arrière-plan. Ici, nous pourrions utiliser un réseau convolutif profond.

Pipeline de détection d'objets avec regroupement de régions d'intérêt

Habituellement, dans la phase de proposition, nous devons générer un grand nombre de régions d'intérêt. Pourquoi? Si un objet n'est pas détecté lors de la première étape (proposition de région), il n'y a aucun moyen de le classer correctement lors de la deuxième phase. C'est pourquoi il est extrêmement important que les propositions de la région aient un taux de rappel élevé. Et cela est réalisé en générant un très grand nombre de propositions (par exemple, quelques milliers par image). La plupart d'entre eux seront classés en arrière-plan dans la deuxième étape de l'algorithme de détection.
Certains problèmes avec cette architecture sont :

  • La génération d'un grand nombre de régions d'intérêt peut entraîner des problèmes de performances. Cela rendrait la détection d'objets en temps réel difficile à mettre en œuvre.
  • C'est sous-optimal en termes de vitesse de traitement. Plus à ce sujet plus tard.
  • Vous ne pouvez pas faire de formation de bout en bout, c'est-à-dire que vous ne pouvez pas former tous les composants du système en une seule fois (ce qui donnerait de bien meilleurs résultats)

C'est là qu'intervient la mise en commun des régions d'intérêt.


Proposition de région d'intérêt en vision - Psychologie

Aucune définition trouvée dans ce fichier.

à partir des collections importer OrderedDict
torche d'importation
de torche import nn
torche d'importation. nn. fonctionnel comme F
de la vision aux flambeaux. ops importe misc en tant que misc_nn_ops
de la vision aux flambeaux. opérations d'importation MultiScaleRoIAlign
de .. utils import load_state_dict_from_url
de . generalized_rcnn import GeneralizedRCNN
de . rpn import AnchorGenerator , RPNHead , RegionProposalNetwork
de . roi_heads importer des RoIHeads
de . transformer import GeneralizedRCNNTransform
de . backbone_utils importer resnet_fpn_backbone
__tous__ = [
"FasterRCNN" , "fasterrcnn_resnet50_fpn" ,
]
classe FasterRCNN ( GeneralizedRCNN ):
"""
Implémente Faster R-CNN.
L'entrée du modèle devrait être une liste de tenseurs, chacun de forme [C, H, W], un pour chaque
image, et devrait être dans la plage 0-1. Différentes images peuvent avoir différentes tailles.
Le comportement du modèle change selon qu'il est en mode d'apprentissage ou d'évaluation.
Lors de l'apprentissage, le modèle attend à la fois les tenseurs d'entrée, ainsi qu'une cible (liste de dictionnaire),
contenant :
- cases (FloatTensor[N, 4]) : les cases de vérité terrain au format [x1, y1, x2, y2], avec des valeurs de x
entre 0 et W et valeurs de y entre 0 et H
- labels (Int64Tensor[N]): l'étiquette de classe pour chaque boîte de vérité terrain
Le modèle renvoie un Dict[Tensor] pendant l'apprentissage, contenant la classification et la régression
pertes pour le RPN et le R-CNN.
Pendant l'inférence, le modèle ne nécessite que les tenseurs d'entrée et renvoie le post-traité
prédictions sous forme de List[Dict[Tensor]], une pour chaque image d'entrée. Les champs du Dict sont comme
suit :
- cases (FloatTensor[N, 4]) : les cases prédites au format [x1, y1, x2, y2], avec des valeurs de x
entre 0 et W et valeurs de y entre 0 et H
- labels (Int64Tensor[N]) : les labels prédits pour chaque image
- scores (Tensor[N]) : les scores ou chaque prédiction
Arguments:
backbone (nn.Module) : le réseau utilisé pour calculer les caractéristiques du modèle.
Il doit contenir un attribut out_channels, qui indique le nombre de sorties
canaux que chaque carte de caractéristiques possède (et cela devrait être le même pour toutes les cartes de caractéristiques).
Le backbone doit renvoyer un seul Tensor ou et OrderedDict[Tensor].
num_classes (int) : nombre de classes de sortie du modèle (y compris l'arrière-plan).
Si box_predictor est spécifié, num_classes doit être None.
min_size (int) : taille minimale de l'image à redimensionner avant de la transmettre au backbone
max_size (int) : taille maximale de l'image à redimensionner avant de la transmettre au backbone
image_mean (Tuple[float, float, float]) : valeurs moyennes utilisées pour la normalisation des entrées.
Ce sont généralement les valeurs moyennes du jeu de données sur lequel le backbone a été formé
au
image_std (Tuple[float, float, float]) : valeurs std utilisées pour la normalisation des entrées.
Ce sont généralement les valeurs std de l'ensemble de données sur lequel le backbone a été formé sur
rpn_anchor_generator (AnchorGenerator) : module qui génère les ancres pour un ensemble de fonctionnalités
Plans.
rpn_head (nn.Module) : module qui calcule les deltas d'objectivité et de régression à partir du RPN
rpn_pre_nms_top_n_train (int) : nombre de propositions à conserver avant d'appliquer NMS pendant la formation
rpn_pre_nms_top_n_test (int) : nombre de propositions à conserver avant d'appliquer NMS lors des tests
rpn_post_nms_top_n_train (int) : nombre de propositions à conserver après application NMS pendant la formation
rpn_post_nms_top_n_test (int) : nombre de propositions à conserver après application du NMS lors des tests
rpn_nms_thresh (float) : seuil NMS utilisé pour le post-traitement des propositions RPN
rpn_fg_iou_thresh (float) : IoU minimum entre l'ancre et le boitier GT afin qu'ils puissent être
considéré comme positif lors de la formation de l'IAA.
rpn_bg_iou_thresh (float) : IoU maximum entre l'ancre et le boitier GT pour qu'ils puissent être
considéré comme négatif lors de la formation de l'IAA.
rpn_batch_size_per_image (int) : nombre d'ancres échantillonnées lors de l'apprentissage du RPN
pour le calcul de la perte
rpn_positive_fraction (float) : proportion d'ancres positives dans un mini-lot lors de l'entraînement
de la RPN
box_roi_pool (MultiScaleRoIAlign) : le module qui recadre et redimensionne les feature maps dans
les emplacements indiqués par les cadres de délimitation
box_head (nn.Module) : module qui prend les cartes de caractéristiques recadrées en entrée
box_predictor (nn.Module) : module qui prend la sortie de box_head et retourne le
les logits de classification et les deltas de régression de boîte.
box_score_thresh (float) : lors de l'inférence, ne retourne que les propositions avec un score de classification
supérieur à box_score_thresh
box_nms_thresh (float) : seuil NMS pour la tête de prédiction. Utilisé pendant l'inférence
box_detections_per_img (int) : nombre maximum de détections par image, pour toutes les classes.
box_fg_iou_thresh (float) : IoU minimum entre les propositions et la box GT afin qu'elles puissent être
considéré comme positif lors de la formation du chef de classement
box_bg_iou_thresh (float) : IoU maximum entre les propositions et la box GT afin qu'elles puissent être
considéré comme négatif lors de la formation du chef de classement
box_batch_size_per_image (int) : nombre de propositions échantillonnées lors de la formation du
chef de classement
box_positive_fraction (float) : proportion de propositions positives dans un mini-lot lors de la formation
du chef de classement
bbox_reg_weights (Tuple[float, float, float, float]) : poids pour l'encodage/décodage du
cadres de délimitation
Exemple::
>>> importer la torche
>>> importer torchvision
>>> de torchvision.models.detection importer FasterRCNN
>>> de torchvision.models.detection.rpn importer AnchorGenerator
>>> # charger un modèle pré-entraîné pour la classification et le retour
>>> # uniquement les fonctionnalités
>>> backbone = torchvision.models.mobilenet_v2(pretrained=True).features
>>> # FasterRCNN a besoin de connaître le nombre de
>>> # canaux de sortie dans une épine dorsale. Pour mobilenet_v2, c'est 1280
>>> # nous devons donc l'ajouter ici
>>> backbone.out_channels = 1280
>>>
>>> # faisons en sorte que le RPN génère 5 x 3 ancres par espace
>>> # emplacement, avec 5 tailles différentes et 3 aspects différents
>>> # rapports. Nous avons un Tuple[Tuple[int]] parce que chaque fonctionnalité
>>> # la carte peut avoir différentes tailles et
>>> # rapports d'aspect
>>> anchor_generator = AnchorGenerator(tailles=((32, 64, 128, 256, 512),),
>>> aspect_ratios=((0,5, 1,0, 2,0)))
>>>
>>> # définissons quelles sont les cartes de caractéristiques que nous allons
>>> # utiliser pour effectuer le recadrage de la région d'intérêt, ainsi que
>>> # la taille du recadrage après redimensionnement.
>>> # si votre backbone renvoie un Tensor, featmap_names devrait
>>> # être [Ɔ']. Plus généralement, le backbone doit retourner un
>>> # OrderedDict[Tensor], et dans featmap_names vous pouvez choisir lequel
>>> # cartes de caractéristiques à utiliser.
>>> roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[Ɔ'],
>>> taille_sortie=7,
>>> sampling_ratio=2)
>>>
>>> # assembler les pièces dans un modèle FasterRCNN
>>> modèle = FasterRCNN(épine dorsale,
>>> num_classes=2,
>>> rpn_anchor_generator=anchor_generator,
>>> box_roi_pool=roi_pooler)
>>> modèle.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> prédictions = modèle(x)
"""
def __init__ ( self , backbone , num_classes = None ,
# paramètres de transformation
taille_min = 800 , taille_max = 1333 ,
image_mean = Aucun , image_std = Aucun ,
# paramètres RPN
rpn_anchor_generator = Aucun , rpn_head = Aucun ,
rpn_pre_nms_top_n_train = 2000 , rpn_pre_nms_top_n_test = 1000 ,
rpn_post_nms_top_n_train = 2000 , rpn_post_nms_top_n_test = 1000 ,
rpn_nms_thresh = 0.7 ,
rpn_fg_iou_thresh = 0.7 , rpn_bg_iou_thresh = 0.3 ,
rpn_batch_size_per_image = 256 , rpn_positive_fraction = 0.5 ,
# Paramètres de la boîte
box_roi_pool = Aucun , box_head = Aucun , box_predictor = Aucun ,
box_score_thresh = 0,05 , box_nms_thresh = 0,5 , box_detections_per_img = 100 ,
box_fg_iou_thresh = 0.5 , box_bg_iou_thresh = 0.5 ,
box_batch_size_per_image = 512 , box_positive_fraction = 0.25 ,
bbox_reg_weights = Aucun ):
sinon hasattr ( backbone , "out_channels" ):
augmenter ValueError (
"backbone doit contenir un attribut out_channels "
"spécifier le nombre de canaux de sortie (supposé être le "
"même pour tous les niveaux)" )
assert isinstance ( rpn_anchor_generator , ( AnchorGenerator , type ( None )))
assert isinstance ( box_roi_pool , ( MultiScaleRoIAlign , type ( None )))
si num_classes n'est pas None :
si box_predictor n'est pas None :
raise ValueError ( "num_classes doit être None lorsque box_predictor est spécifié" )
autre :
si box_predictor vaut None :
augmenter ValueError ( "num_classes ne doit pas être None lorsque box_predictor "
" n'est pas spécifié" )
out_channels = épine dorsale . out_channels
si rpn_anchor_generator vaut None :
taille_ancre = (( 32 ,), ( 64 ,), ( 128 ,), ( 256 ,), ( 512 ,))
aspect_ratios = (( 0.5 , 1.0 , 2.0 ),) * len ( anchor_sizes )
rpn_anchor_generator = AnchorGenerator (
tailles_ancres , rapports d'aspect
)
si rpn_head vaut None :
rpn_head = RPNHead (
out_channels , rpn_anchor_generator . num_ancres_per_location ()[ 0 ]
)
rpn_pre_nms_top_n = dict ( training = rpn_pre_nms_top_n_train , testing = rpn_pre_nms_top_n_test )
rpn_post_nms_top_n = dict ( training = rpn_post_nms_top_n_train , testing = rpn_post_nms_top_n_test )
rpn = RegionProposalNetwork (
rpn_anchor_generator , rpn_head ,
rpn_fg_iou_thresh , rpn_bg_iou_thresh ,
rpn_batch_size_per_image , rpn_positive_fraction ,
rpn_pre_nms_top_n , rpn_post_nms_top_n , rpn_nms_thresh )
si box_roi_pool vaut None :
box_roi_pool = MultiScaleRoIAlign (
featmap_names = [ Ɔ' , Ƈ' , ƈ' , Ɖ' ],
taille_sortie = 7 ,
échantillonnage_ratio = 2 )
si box_head vaut None :
résolution = box_roi_pool . taille_sortie [ 0 ]
taille_représentation = 1024
box_head = TwoMLPHead (
out_channels * résolution ** 2 ,
taille_représentation )
si box_predictor vaut None :
taille_représentation = 1024
box_predictor = FastRCNNPredictor (
taille_représentation ,
nombre_classes )
roi_heads = RoIHeads (
# Boîte
box_roi_pool , box_head , box_predictor ,
box_fg_iou_thresh , box_bg_iou_thresh ,
box_batch_size_per_image , box_positive_fraction ,
bbox_reg_weights ,
box_score_thresh , box_nms_thresh , box_detections_per_img )
si image_mean vaut None :
moyenne_image = [ 0,485 , 0,456 , 0,406 ]
si image_std vaut None :
image_std = [ 0,229 , 0,224 , 0,225 ]
transform = GeneralizedRCNNTransform ( taille_min , taille_max , image_mean , image_std )
super ( FasterRCNN , soi ). __init__ ( backbone , rpn , roi_heads , transformer )
classe TwoMLPHead ( nn . Module ):
"""
Têtes standard pour modèles basés sur FPN
Arguments:
in_channels (int): nombre de canaux d'entrée
representation_size (int) : taille de la représentation intermédiaire
"""
def __init__ ( self , in_channels , representation_size ):
super ( TwoMLPHead , soi ). __init__ ()
soi . fc6 = nn . Linéaire ( in_channels , representation_size )
soi . fc7 = nn . Linéaire ( taille_représentation , taille_représentation )
def forward ( self , x ):
x = x . aplatir ( start_dim = 1 )
x = F . relu ( self . fc6 ( x ))
x = F . relu ( self . fc7 ( x ))
retourner x
classe FastRCNNPredictor ( nn . Module ):
"""
Classification standard + couches de régression de la zone de délimitation
pour Fast R-CNN.
Arguments:
in_channels (int): nombre de canaux d'entrée
num_classes (int): nombre de classes de sortie (y compris l'arrière-plan)
"""
def __init__ ( self , in_channels , num_classes ):
super ( FastRCNNPredictor , self ). __init__ ()
soi . cls_score = nn . Linéaire ( in_channels , num_classes )
soi . bbox_pred = nn . Linéaire ( in_channels , num_classes * 4 )
def forward ( self , x ):
si x. dim () == 4 :
assert list ( x . shape [ 2 :]) == [ 1 , 1 ]
x = x . aplatir ( start_dim = 1 )
scores = soi. cls_score ( x )
bbox_deltas = soi . bbox_pred ( x )
renvoyer les scores , bbox_deltas
model_urls = <
'fasterrcnn_resnet50_fpn_coco' :
'https://download.pytorch.org/models/fasterrcnn_resnet50_fpn_coco-258fb6c6.pth',
>
def plus rapidercnn_resnet50_fpn ( pré-entraîné = False , progress = True ,
num_classes = 91 , pretrained_backbone = True , trainable_backbone_layers = 3 , ** kwargs ):
"""
Construit un modèle R-CNN plus rapide avec une dorsale ResNet-50-FPN.
L'entrée du modèle devrait être une liste de tenseurs, chacun de forme ``[C, H, W]``, un pour chaque
image, et devrait être dans la plage ``0-1``. Différentes images peuvent avoir différentes tailles.
Le comportement du modèle change selon qu'il est en mode d'apprentissage ou d'évaluation.
Lors de l'apprentissage, le modèle attend à la fois les tenseurs d'entrée, ainsi qu'une cible (liste de dictionnaire),
contenant :
- boxes (``FloatTensor[N, 4]``) : les box de vérité terrain au format ``[x1, y1, x2, y2]``, avec des valeurs de ``x``
entre ``0`` et ``W`` et valeurs de ``y`` entre ``0`` et ``H``
- labels (``Int64Tensor[N]``): le label de classe pour chaque boîte de vérité terrain
Le modèle renvoie un ``Dict[Tensor]`` pendant l'entraînement, contenant la classification et la régression
pertes pour le RPN et le R-CNN.
Pendant l'inférence, le modèle ne nécessite que les tenseurs d'entrée et renvoie le post-traité
prédictions sous forme de ``List[Dict[Tensor]]``, une pour chaque image d'entrée. Les champs du ``Dict`` sont comme
suit :
- cases (``FloatTensor[N, 4]``) : les cases prédites au format ``[x1, y1, x2, y2]``, avec des valeurs de ``x``
entre ``0`` et ``W`` et valeurs de ``y`` entre ``0`` et ``H``
- labels (``Int64Tensor[N]``) : les labels prédits pour chaque image
- scores (``Tensor[N]``) : les scores ou chaque prédiction
Faster R-CNN est exportable vers ONNX pour une taille de lot fixe avec des images d'entrée de taille fixe.
Exemple::
>>> modèle = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
>>> # Pour la formation
>>> images, cases = torch.rand(4, 3, 600, 1200), torch.rand(4, 11, 4)
>>> labels = torch.randint(1, 91, (4, 11))
>>> images = liste(image pour l'image dans les images)
>>> cibles = []
>>> pour i dans la plage (len(images)):
>>> d = <>
>>> d['boîtes'] = boîtes[i]
>>> d['étiquettes'] = étiquettes[i]
>>> cibles.append(d)
>>> sortie = modèle (images, cibles)
>>> # Pour l'inférence
>>> modèle.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> prédictions = modèle(x)
>>>
>>> # en option, si vous souhaitez exporter le modèle vers ONNX :
>>> torch.onnx.export(modèle, x, "faster_rcnn.onnx", opset_version = 11)
Arguments:
pretrained (bool): Si True, renvoie un modèle pré-entraîné sur COCO train2017
progress (bool): Si True, affiche une barre de progression du téléchargement vers stderr
pretrained_backbone (bool) : si True, renvoie un modèle avec un backbone pré-entraîné sur Imagenet
num_classes (int): nombre de classes de sortie du modèle (y compris l'arrière-plan)
trainable_backbone_layers (int): nombre de couches resnet pouvant être entraînées (non gelées) à partir du bloc final.
Les valeurs valides sont comprises entre 0 et 5, 5 signifiant que toutes les couches de backbone peuvent être entraînées.
"""
assert trainable_backbone_layers <= 5 et trainable_backbone_layers >= 0
# ne pas geler les calques si le modèle ou le backbone pré-entraîné n'est pas utilisé
sinon ( pretrained ou pretrained_backbone ):
trainable_backbone_layers = 5
si préformé :
# pas besoin de télécharger le backbone si pré-entraîné est défini
pretrained_backbone = Faux
backbone = resnet_fpn_backbone ( 'resnet50' , pretrained_backbone , trainable_layers = trainable_backbone_layers )
model = FasterRCNN ( backbone , num_classes , ** kwargs )
si préformé :
state_dict = load_state_dict_from_url ( model_urls [ 'fasterrcnn_resnet50_fpn_coco' ],
progrès = progrès)
maquette . load_state_dict ( state_dict )
modèle de retour

Vous ne pouvez pas effectuer cette action pour le moment.

Vous vous êtes connecté avec un autre onglet ou une autre fenêtre. Recharger pour rafraîchir votre session. Vous vous êtes déconnecté dans un autre onglet ou une autre fenêtre. Recharger pour rafraîchir votre session.


L'attention sélective contribue au traitement global de la vision

Le traitement de l'information est plus efficace dans les régions surveillées du champ visuel et la taille de la région surveillée est variable. Cette observation est en conflit avec l'hypothèse, utilisée pour mesurer l'étendue spatiale de l'intégration globale d'orientations locales cohérentes, selon laquelle une sensibilité optimale aux informations de texture est immédiatement disponible dans un champ récepteur neuronal de taille appropriée. En utilisant des modèles étendus qui nécessitent un traitement global pour détecter la présence d'une structure d'orientation cohérente, nous avons constaté que la taille et la topologie de la région d'intégration des repères visuels locaux ne sont pas fixes. L'intégration peut se produire sur un rayon d'au moins 10 degrés, une zone (314 degrés carrés) beaucoup plus grande qu'on ne le supposait auparavant, et peut être contrainte à être annulaire en plus des ouvertures circulaires. L'utilisation de telles ouvertures spatiales s'est avérée être médiée par l'attente de l'observateur. Le traitement des informations de texture disponibles dans des zones sélectionnées est optimisé grâce à l'exclusion du bruit en dehors des régions d'intérêt.


Voir la vidéo: Excel Pivot Tables from scratch to an expert for half an hour + dashboard! (Novembre 2021).