Partager via

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

Table des matières

Résumé

image d’image

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 didacticiel.

R-CNN plus rapide est un algorithme de détection d’objets proposé par Shaoqing Ren, Kaiming He, Ross Girshick et Jian Sun en 2015. Le document de recherche est intitulé « Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks » et est archivé à l’adresse https://arxiv.org/abs/1506.01497. R-CNN plus 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, Plus rapide R-CNN emploie un réseau de propositions de région et ne nécessite pas de méthode externe pour les propositions de la région candidate.

Ce didacticiel est structuré en trois sections principales. La première section fournit une description concise de l’exécution de R-CNN plus rapide dans CNTK sur l’exemple de jeu de données fourni. La deuxième section fournit des détails sur toutes les étapes, notamment la configuration et le paramétrage de R-CNN plus rapide. La dernière section décrit les détails techniques de l’algorithme et du réseau de proposition de région, la lecture et l’augmentation des données d’entrée, ainsi que les différentes options d’entraînement pour R-CNN plus rapide.

Démarrage rapide

Cette section part du principe que votre système est configuré pour utiliser l’API Python CNTK. Nous partons du principe que vous utilisez Python 3.5 sur Windows ou 3.5/3.6 sur Linux. Pour obtenir une procédure pas à pas détaillée, reportez-vous aux instructions pas à pas. Pour exécuter R-CNN plus rapide, installez les packages supplémentaires suivants dans votre environnement Python cntk

pip install opencv-python easydict pyyaml

Exécuter l’exemple de toy

Nous utilisons un jeu de données de jeux de données de jeux d’images capturées à partir d’un réfrigérateur pour illustrer R-CNN plus rapide (comme pour l’exemple Fast R-CNN). Le 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 Examples/Image/Detection/FastRCNN :

python install_data_and_model.py

Après avoir exécuté le script, le jeu de données de toy est installé sous le Examples/Image/DataSets/Grocery dossier. Le modèle AlexNet sera téléchargé dans le PretrainedModels dossier. Nous vous recommandons de conserver les données téléchargées dans le dossier respectif, car les fichiers de configuration supposent cet emplacement par défaut.

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

python run_faster_rcnn.py

Les résultats de la formation de bout en bout sur l’épicerie à l’aide d’AlexNet comme modèle de base doivent ressembler à ceci :

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 FasterRCNN_config.py à partir du FasterRCNN dossier et définies

__C.VISUALIZE_RESULTS = True

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

Instructions pas à pas

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

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 R-CNN plus rapide. 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 Faster-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

Configuration et paramètres

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

  • Paramètres du détecteur (voir FasterRCNN/FasterRCNN_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_faster_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 parcourons le contenu de haut FasterRCNN_config.py en bas. La configuration utilise le EasyDict package qui permet un accès facile aux dictionnaires imbriqués.

# If set to 'True' training will be skipped if a trained model exists already
__C.CNTK.MAKE_MODE = False
# E2E or 4-stage training
__C.CNTK.TRAIN_E2E = True
# set to 'True' to use deterministic algorithms
__C.CNTK.FORCE_DETERMINISTIC = False
# set to 'True' to run only a single epoch
__C.CNTK.FAST_MODE = False
# Debug parameters
__C.CNTK.DEBUG_OUTPUT = False
__C.CNTK.GRAPH_TYPE = "png" # "png" or "pdf"
# Set to True if you want to store an eval model with native UDFs (e.g. for inference using C++ or C#)
__C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = False

Le premier bloc de paramètres contient des instructions de niveau supérieur concernant le processus d’entraînement. __C.CNTK.TRAIN_E2E permet de sélectionner le schéma d’entraînement de bout en bout ou de 4 étapes. Des détails sur les deux schémas de formation sont décrits ici. __C.CNTK.FAST_MODE = True n’exécute qu’une seule époque ; Il est utile de tester si le programme d’installation fonctionne et si tous les paramètres sont corrects. __C.CNTK.DEBUG_OUTPUT = True génère un message de débogage supplémentaire dans la sortie de la console. Il trace également les graphiques de calcul CNTK pour les modèles d’entraînement et d’évaluation (notez les exigences de traçage des graphiques CNTK). Les graphiques résultants sont stockés dans le FasterRCNN/Output dossier. __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = True stocke un deuxième modèle d’évaluation qui utilise uniquement du code natif (pas de couches Python). Ce modèle peut être chargé et évalué à partir de C++ ou C# par exemple.

# Learning parameters
__C.CNTK.L2_REG_WEIGHT = 0.0005
__C.CNTK.MOMENTUM_PER_MB = 0.9
# The learning rate multiplier for all bias weights
__C.CNTK.BIAS_LR_MULT = 2.0

# E2E learning parameters
__C.CNTK.E2E_MAX_EPOCHS = 20
__C.CNTK.E2E_LR_PER_SAMPLE = [0.001] * 10 + [0.0001] * 10 + [0.00001]

Le deuxième bloc contient les paramètres d’apprentissage. Il s’agit principalement de paramètres d’apprentissage CNTK standard. La seule exception est __C.CNTK.BIAS_LR_MULT, c’est-à-dire le multiplicateur de taux d’apprentissage utilisé pour tous les biais du réseau. Il entraîne essentiellement les biais avec deux fois le taux d’apprentissage actuel, qui est également effectué dans le code R-CNN plus rapide d’origine. Le nombre d’époques et le taux d’apprentissage par échantillon sont spécifiés séparément pour les deux schémas d’apprentissage différents (paramètres de 4 étapes omis ci-dessus).

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

# Sigma parameter for smooth L1 loss in the RPN and the detector (DET)
__C.SIGMA_RPN_L1 = 3.0
__C.SIGMA_DET_L1 = 1.0

# NMS threshold used to discard overlapping predicted bounding boxes
__C.RESULTS_NMS_THRESHOLD = 0.5
# all bounding boxes with a score lower than this threshold will be considered background
__C.RESULTS_NMS_CONF_THRESHOLD = 0.0

# Enable plotting of results generally / also plot background boxes / also plot unregressed boxes
__C.VISUALIZE_RESULTS = False
__C.DRAW_NEGATIVE_ROIS = False
__C.DRAW_UNREGRESSED_ROIS = False
# only for plotting results: boxes with a score lower than this threshold will be considered background
__C.RESULTS_BGR_PLOT_THRESHOLD = 0.1

__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.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.

# 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

# RPN parameters
# IOU >= thresh: positive example
__C.TRAIN.RPN_POSITIVE_OVERLAP = 0.7
# IOU < thresh: negative example
__C.TRAIN.RPN_NEGATIVE_OVERLAP = 0.3
# If an anchor statisfied by positive and negative conditions set to negative
__C.TRAIN.RPN_CLOBBER_POSITIVES = False
# Max number of foreground examples
__C.TRAIN.RPN_FG_FRACTION = 0.5
# Total number of examples
__C.TRAIN.RPN_BATCHSIZE = 256
# NMS threshold used on RPN proposals
__C.TRAIN.RPN_NMS_THRESH = 0.7
# Number of top scoring boxes to keep before apply NMS to RPN proposals
__C.TRAIN.RPN_PRE_NMS_TOP_N = 12000
# Number of top scoring boxes to keep after applying NMS to RPN proposals
__C.TRAIN.RPN_POST_NMS_TOP_N = 2000
# Proposal height and width both need to be greater than RPN_MIN_SIZE (at orig image scale)
__C.TRAIN.RPN_MIN_SIZE = 16

__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). Pour les paramètres rpn, reportez-vous aux commentaires en regard de leur définition ou consultez le document de recherche original pour plus d’informations. Pour les paramètres de détecteur suivants :

# Detector parameters
# Minibatch size (number of regions of interest [ROIs]) -- was: __C.TRAIN.BATCH_SIZE = 128
__C.NUM_ROI_PROPOSALS = 128
# Fraction of minibatch that is labeled foreground (i.e. class > 0)
__C.TRAIN.FG_FRACTION = 0.25
# Overlap threshold for an ROI to be considered foreground (if >= FG_THRESH)
__C.TRAIN.FG_THRESH = 0.5
# Overlap threshold for an ROI to be considered background (class = 0 if
# overlap in [LO, HI))
__C.TRAIN.BG_THRESH_HI = 0.5
__C.TRAIN.BG_THRESH_LO = 0.0

# Normalize the targets using "precomputed" (or made up) means and stdevs
__C.BBOX_NORMALIZE_TARGETS = True
__C.BBOX_NORMALIZE_MEANS = (0.0, 0.0, 0.0, 0.0)
__C.BBOX_NORMALIZE_STDS = (0.1, 0.1, 0.2, 0.2)

Exécuter plus rapidement R-CNN 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_faster_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_faster_rcnn.pyde . Attention à ce que la formation peut prendre un certain temps.

Exécuter R-CNN plus rapidement sur vos propres données

La préparation de vos propres données et leur annotation avec des rectangles englobants de vérité au sol sont décrites dans la détection d’objets à l’aide de Fast R-CNN. 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 utils\configs suivant les exemples existants, comme dans cet extrait de code :

...

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

...

__C.CNTK.PROPOSAL_LAYER_SCALES est utilisé dans generate_anchors() (voir utils/rpn/generate_anchors.py). À partir d’une taille de base de 16 trois ancres avec des proportions et 2.0 sont créées 0.5, 1.0 en conséquence (8 x 24, 16 x 16, 24 x 8). Ceux-ci sont multipliés par chaque échelle de couche de proposition, ce qui entraîne neuf ancres (64 x 192, ... , 768 x 256). Il s’agit de coordonnées de pixel absolues w.r.t. l’image d’entrée. Toutes les ancres sont appliquées à chaque position spatiale de la carte de caractéristiques convolutionnelles pour générer des régions candidates d’intérêt. Adaptez ces échelles de couche de proposition en fonction des tailles d’objet de votre jeu de données et de la taille de l’image d’entrée que vous utilisez. Par exemple, pour le jeu de données Épicerie que nous utilisons __C.DATA.PROPOSAL_LAYER_SCALES = [4, 8, 12] et une taille d’image d’entrée ( 850 x 850 voir utils/configs/Grocery_config.py).

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

from utils.configs.MyDataSet_config import cfg as dataset_cfg

et exécutez python run_faster_rcnn.py.

Détails techniques

Comme la plupart des détecteurs d’objets basés sur DNN Plus rapide R-CNN utilise l’apprentissage de transfert. Il commence à partir d’un modèle de base qui est un modèle entraîné pour la classification d’images. Le modèle de base est coupé en deux parties, la première étant toutes les couches convolutionnelles jusqu’à (et à l’exclusion) de la dernière couche de regroupement et la deuxième partie est le reste du réseau depuis (et à l’exclusion) de la dernière couche de regroupement jusqu’à (à nouveau à l’exclusion) de la couche de prédiction finale. La sortie de la première partie est parfois appelée carte de caractéristiques convolutionnelles. Il est utilisé comme entrée de la couche de regroupement de rois, qui effectue une opération de regroupement sur une partie du mappage d’entrée qui correspond aux propositions de région dans l’image d’origine. Les propositions de la région sont une deuxième entrée dans la couche de regroupement de rois. Dans R-CNN plus rapide, ces propositions sont générées par un petit sous-réseau appelé réseau de proposition de région (RPN, voir la section suivante).

La sortie de la couche de regroupement roi aura toujours la même taille fixe, car elle regroupe toutes les entrées (carte de caractéristiques convolutionnelles + proposition de région) à la même taille de sortie. Notez que la taille d’entrée, c’est-à-dire la taille de la carte de caractérisation convolutionnelle et, par conséquent, la taille de l’image d’entrée peut être arbitraire. Pour entraîner l’algorithme utilise quatre fonctions de perte, deux pour le RPN et deux pour le détecteur (voir également la section suivante). La méthode suivante est contenue et FasterRCNN_train.py montre la construction de haut niveau du modèle R-CNN plus rapide. Reportez-vous au FasterRCNN_train.py code complet.utils/rpn/rpn_helpers.py

def create_faster_rcnn_model(features, scaled_gt_boxes, dims_input, 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)

    # RPN and prediction targets
    rpn_rois, rpn_losses = create_rpn(conv_out, scaled_gt_boxes, dims_input, cfg)
    rois, label_targets, bbox_targets, bbox_inside_weights = \
        create_proposal_target_layer(rpn_rois, scaled_gt_boxes, cfg)

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

    return loss, pred_error

Après l’entraînement du réseau est converti en modèle d’évaluation en supprimant toutes les parties qui ne sont pas requises pour l’évaluation, par exemple, les fonctions de perte. Le modèle d’évaluation final comporte trois sorties (voir create_faster_rcnn_eval_model() pour FasterRCNN_train.py plus d’informations) :

  • rpn_rois - coordonnées de pixels absolues des rois candidats
  • cls_pred - probabilités de classe pour chaque roi
  • bbox_regr - coefficients de régression par classe pour chaque roi

Pour utiliser le modèle d’évaluation à partir de Python, vous pouvez l’utiliser FasterRCNN_EvaluatorFasterRCNN_eval.py. Vous pouvez charger le modèle une seule fois, puis évaluer des images uniques au fur et à mesure. La process_image() méthode de l’évaluateur prend un chemin d’accès à une image en tant qu’argument, évalue le modèle sur cette image et applique la régression de cadre englobant aux URI résultants. Elle retourne les ROIs régressés et les probabilités de classe correspondantes :

    evaluator = FasterRCNN_Evaluator(model, cfg)
    regressed_rois, cls_probs = evaluator.process_image(img_path)

Réseau de propositions de région

R-CNN plus rapide utilise un soi-disant projet de proposition de région netwrok (RPN) qui génère des régions candidates d’intérêt (ROIs) en fonction de l’image d’entrée. Cela s’oppose à Fast R-CNN qui exige que les propositions régionales soient fournies par une source externe. Le RPN est essentiellement construit par trois couches de convolution et une nouvelle couche appelée couche de proposition. Les nouvelles couches sont réalisées en tant que fonction définie par l’utilisateur (UDF) dans Python ou C++ (voir les détails ci-dessous). Le code Python qui crée le RPN dans CNTK est dans utils/rpn/rpn_helpers.py, les nouvelles couches telles que la couche de proposition sont toutes dans le utils/rpn dossier.

L’entrée du RPN est la carte de caractéristiques convolutionnelles, identique à l’entrée de la couche de regroupement roi. Cette entrée est alimentée dans la première couche de convolution du RPN et le résultat est propagé aux deux autres couches de convolution. L’un des derniers prédit les scores de classe pour chaque région candidate, c’est-à-dire pour chaque ancre à chaque position spatiale (9 ancres x 2 scores x largeur x hauteur). Les deux scores sont convertis (à l’aide d’un nœud softmax) en scores d’objet par candidat qui sont interprétés comme la probabilité d’une région candidate pour contenir un objet de premier plan ou non. L’autre couche convolutionnelle prédit les coefficients de régression pour la position réelle du ROI, à nouveau pour chaque candidat (9 ancres x 4 coefficients x largeur x hauteur).

Les coefficients de régression et les scores d’objectivité (probabilités au premier plan et en arrière-plan) sont alimentés dans la couche de proposition. Cette couche applique d’abord les coefficients de régression aux ancres générées, extrait le résultat aux limites de l’image et filtre les régions candidates trop petites. Il trie ensuite les candidats par probabilité de premier plan, applique une suppression non maximale (NMS) pour réduire le nombre de candidats et enfin échantillonne le nombre souhaité de ROIs pour sa sortie.

Pendant l’entraînement R-CNN plus rapide, deux nouvelles couches supplémentaires sont nécessaires : la couche cible d’ancrage et la couche cible de la proposition. La couche cible d’ancrage génère les valeurs cibles pour le score d’objectness et les coefficients de régression RPN utilisés dans les fonctions de perte du RPN. De même, la couche cible de proposition génère les étiquettes de classe cible pour les ROIs et les coefficients de régression cibles par classe pour le détecteur final qui sont utilisés dans les fonctions de perte du détecteur.

Pendant l’évaluation, seule la couche de proposition est requise (car aucune cible pour les fonctions de perte n’est nécessaire). La couche de proposition dans CNTK est disponible en Python et en C++, les couches cibles sont actuellement disponibles uniquement dans Python. Par conséquent, l’entraînement R-CNN plus rapide doit être effectué à partir de l’API Python. Pour stocker un modèle d’évaluation après l’entraînement qui utilise le jeu __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = Trued’implémentation de couche de proposition native.

Source lecteur et minibatch

Lorsque nous mettons à l’échelle des images ou retournez des images pour l’augmentation des données, nous devons également appliquer les mêmes transformations aux annotations de vérité au sol. (Le découpage doit également être appliqué aux propositions mises en cache dans une formation en 4 étapes, voir la section suivante.) Étant donné que ces transformations jointes d’images et d’annotations ne sont actuellement pas prises en charge par les lecteurs CNTK intégrés, nous utilisons un lecteur Python personnalisé et un UserMinibatchSource pour R-CNN plus rapide. Celles-ci sont contenues utils/od_reader.py et utils/od_mb_source.py respectivement.

Formation en E2E et en 4 étapes

Le document de recherche R-CNN plus rapide décrit deux méthodes pour former le réseau. L’entraînement de bout en bout entraîne l’ensemble du réseau dans une seule formation à l’aide de la fonction de perte de quatre (perte de régression rpn, perte d’objet rpn, perte de régression du détecteur, perte de classe détecteur). Nous utilisons l’entraînement de bout en bout par défaut, vous pouvez choisir entre les deux en définissant __C.CNTK.TRAIN_E2E en conséquence .FasterRCNN_config.py

Le schéma d’entraînement en 4 étapes alterne entre l’entraînement uniquement le réseau de proposition de région (maintien du détecteur fixe) et l’entraînement uniquement du détecteur (fixation des poids RPN). Ce schéma de formation est implémenté dans train_faster_rcnn_alternating()FasterRCNN_train.py. Il est légèrement plus élaboré et utilise fréquemment des parties de clonage du modèle pour permettre la congélation et les poids d’entraînement de manière sélective. En outre, dans la formation en 4 étapes, les propositions du RPN sont mises en mémoire tampon après les phases 1 et trois et utilisées dans la phase suivante.

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_faster_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.

  • Last updated on