Compartir a través de

Detección de objetos mediante R-CNN más rápida

  • Artículo

Tabla de contenido

Resumen

imagen de imagen

Los anteriores son ejemplos de imágenes y anotaciones de objetos para el conjunto de datos de comestibles (izquierda) y el conjunto de datos Pascal VOC (derecha) usado en este tutorial.

R-CNN más rápido es un algoritmo de detección de objetos propuesto por Kaiming Ren, Kaiming He, Ross Girshick y Jian Sun en 2015. El documento de investigación se denomina "Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks", y se archiva en https://arxiv.org/abs/1506.01497. R-CNN más rápido se basa en el trabajo anterior para clasificar eficazmente las propuestas de objetos mediante redes convolucionales profundas. En comparación con el trabajo anterior, Faster R-CNN emplea una red de propuestas de región y no requiere un método externo para las propuestas de región candidatas.

Este tutorial se estructura en tres secciones principales. En la primera sección se proporciona una descripción concisa de cómo ejecutar Faster R-CNN en CNTK en el conjunto de datos de ejemplo proporcionado. En la segunda sección se proporcionan detalles sobre todos los pasos, incluida la configuración y la parametrización de Faster R-CNN. En la sección final se describen los detalles técnicos del algoritmo y la red de propuestas de región, la lectura y el aumento de los datos de entrada, así como diferentes opciones de entrenamiento para R-CNN más rápido.

Inicio rápido

En esta sección se supone que tiene el sistema configurado para usar la API de Python de CNTK. Se supone que usa Python 3.5 en Windows o 3.5/3.6 en Linux. Para ver un tutorial detallado, consulte las instrucciones paso a paso. Para ejecutar R-CNN más rápido, instale los siguientes paquetes adicionales en el entorno de Python de cntk.

pip install opencv-python easydict pyyaml

Ejecutar el ejemplo de toy

Usamos un conjunto de datos toy de imágenes capturadas desde un refrigerador para demostrar Faster R-CNN (lo mismo que para el ejemplo fast R-CNN). Tanto el conjunto de datos como el modelo de AlexNet previamente entrenado se pueden descargar ejecutando el siguiente comando de Python desde la carpeta Examples/Image/Detection/FastRCNN:

python install_data_and_model.py

Después de ejecutar el script, el conjunto de datos de toy se instalará en la Examples/Image/DataSets/Grocery carpeta . El modelo AlexNet se descargará en la PretrainedModels carpeta . Se recomienda mantener los datos descargados en la carpeta correspondiente, ya que los archivos de configuración asumen esa ubicación de forma predeterminada.

Para entrenar y evaluar la ejecución de R-CNN más rápida

python run_faster_rcnn.py

Los resultados del entrenamiento de un extremo a otro en Grocery con AlexNet como modelo base deben ser similares a estos:

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

Para visualizar los cuadros de límite previstos y las etiquetas en las imágenes abiertas FasterRCNN_config.py desde la FasterRCNN carpeta y establecer

__C.VISUALIZE_RESULTS = True

Las imágenes se guardarán en la FasterRCNN/Output/Grocery/ carpeta si ejecuta python run_faster_rcnn.py.

Instrucciones paso a paso

Configurar

Para ejecutar el código en este ejemplo, necesita un entorno de Python de CNTK (consulte aquí para obtener ayuda para la instalación). Instale los siguientes paquetes adicionales en el entorno de Python de cntk.

pip install opencv-python easydict pyyaml

Archivos binarios compilados previamente para la regresión del rectángulo de selección y la supresión no máxima

La carpeta Examples\Image\Detection\utils\cython_modules contiene archivos binarios compilados previamente que son necesarios para ejecutar Faster R-CNN. Las versiones que se encuentran actualmente en el repositorio son Python 3.5 para Windows y Python 3.5, 3.6 para Linux, todo 64 bits. Si necesita una versión diferente, puede compilarla siguiendo los pasos descritos en .

Copie los archivos binarios generados cython_bbox y cpu_nms (o gpu_nms) de $FRCN_ROOT/lib/utils a $CNTK_ROOT/Examples/Image/Detection/utils/cython_modules.

Ejemplo de datos y modelo de línea base

Usamos un modelo AlexNet entrenado previamente como base para el entrenamiento de Faster-R-CNN (para VGG u otros modelos base, consulte Uso de un modelo base diferente. Tanto el conjunto de datos de ejemplo como el modelo de AlexNet previamente entrenado se pueden descargar ejecutando el siguiente comando de Python desde la carpeta FastRCNN :

python install_data_and_model.py

Configuración y parámetros

Los parámetros se agrupan en tres partes:

  • Parámetros del detector (consulte FasterRCNN/FasterRCNN_config.py)
  • Parámetros del conjunto de datos (vea por ejemplo utils/configs/Grocery_config.py)
  • Parámetros del modelo base (vea por ejemplo utils/configs/AlexNet_config.py)

Las tres partes se cargan y combinan en el get_configuration() método en run_faster_rcnn.py. En esta sección se tratarán los parámetros del detector. Los parámetros del conjunto de datos se describen aquí, los parámetros del modelo base aquí. A continuación, se recorre el contenido de FasterRCNN_config.py de arriba abajo. La configuración usa el EasyDict paquete que permite un acceso sencillo a diccionarios anidados.

# 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

El primer bloque de parámetros contiene instrucciones de nivel superior sobre el proceso de entrenamiento. __C.CNTK.TRAIN_E2E permite seleccionar el esquema de entrenamiento de un extremo a otro o de 4 fases. Aquí se describen detalles sobre los dos esquemas de entrenamiento. __C.CNTK.FAST_MODE = True ejecuta solo una época; resulta útil probar si el programa de instalación funciona y todos los parámetros son correctos. __C.CNTK.DEBUG_OUTPUT = True genera un mensaje de depuración adicional en la salida de la consola. También traza gráficos de cálculo de CNTK para los modelos de entrenamiento y eval (tenga en cuenta los requisitos para trazar gráficos de CNTK). Los gráficos resultantes se almacenan en la FasterRCNN/Output carpeta . __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = True almacenará un segundo modelo de evaluación que use solo código nativo (sin capas de Python). Este modelo se puede cargar y evaluar desde C++ o C# por ejemplo.

# 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]

El segundo bloque contiene los parámetros de aprendizaje. Estos son principalmente parámetros de aprendizaje de CNTK normales. La única excepción es __C.CNTK.BIAS_LR_MULT, que es el multiplicador de velocidad de aprendizaje que se usa para todos los sesgos de la red. Básicamente entrena los sesgos con dos veces la velocidad de aprendizaje actual, que también se realiza en el código R-CNN original. El número de épocas y velocidad de aprendizaje por muestra se especifica por separado para los dos esquemas de aprendizaje diferentes (parámetros de 4 fases omitidos anteriormente).

# 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 especifica el número máximo de anotaciones de verdad de suelo por imagen. Actualmente, CNTK requiere establecer un número máximo. Si hay menos anotaciones, se rellenarán internamente. __C.IMAGE_WIDTH y __C.IMAGE_HEIGHT son las dimensiones que se usan para cambiar el tamaño y rellenar las imágenes de entrada. __C.RESULTS_NMS_THRESHOLD es el umbral de NMS que se usa para descartar los cuadros de límite previstos superpuestos en la evaluación. Un umbral inferior produce menos eliminaciones y, por tanto, más cuadros de límite previstos en la salida final.

# 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 aumentará los datos de entrenamiento al voltear todas las imágenes cada otra época, es decir, la primera época tiene todas las imágenes normales, la segunda tiene todas las imágenes volteadas, etc. __C.TRAIN_CONV_LAYERS determina si las capas convolucionales, de entrada a la asignación de características convolucionales, se entrenarán o corregirán. Corregir los pesos de la capa de conv significa que los pesos del modelo base se toman y no se modifican durante el entrenamiento. (También puede especificar cuántas capas de conv quiere entrenar, consulte la sección Uso de un modelo base diferente). Para los parámetros rpn, consulte los comentarios junto a su definición o consulte el documento de investigación original para obtener más detalles. También para los siguientes parámetros del detector:

# 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)

Ejecutar R-CNN más rápido en Pascal VOC

Para descargar los datos de Pascal y crear los archivos de anotación para Pascal en formato CNTK, ejecute los siguientes scripts:

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

Cambie en dataset_cfg el get_configuration() método de run_faster_rcnn.py a .

from utils.configs.Pascal_config import cfg as dataset_cfg

Ahora está configurado para entrenar en los datos de Pascal VOC 2007 mediante python run_faster_rcnn.py. Tenga en cuenta que el entrenamiento puede tardar un tiempo.

Ejecutar R-CNN más rápido en sus propios datos

La preparación de sus propios datos y la anotación con cuadros de límite de verdad de tierra se describe en Detección de objetos mediante Fast R-CNN. Después de almacenar las imágenes en la estructura de carpetas descrita y anotarlas, ejecute

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

después de cambiar la carpeta de ese script a la carpeta de datos. Por último, cree un MyDataSet_config.py en la utils\configs carpeta siguiendo los ejemplos existentes, como en este fragmento de código:

...

# 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 se usa en generate_anchors() (vea utils/rpn/generate_anchors.py). A partir de un tamaño base de 16 tres anclajes con relaciones 0.5, 1.0 de aspecto y 2.0 se crean dando como resultado (8 x 24, 16 x 16, 24 x 8). Se multiplican por cada escala de capa de propuesta, lo que da como resultado nueve anclajes (64 x 192, ... , 768 x 256). Son coordenadas de píxel absolutas w.r.t. la imagen de entrada. Todos los anclajes se aplican en cada posición espacial del mapa de características convolucionales para generar regiones candidatas de interés. Adapte estas capas de propuesta según los tamaños de objeto del conjunto de datos y el tamaño de la imagen de entrada que use. Por ejemplo, para el conjunto de datos de comestibles que usamos __C.DATA.PROPOSAL_LAYER_SCALES = [4, 8, 12] y un tamaño de imagen de entrada de 850 x 850 (consulte utils/configs/Grocery_config.py).

Para entrenar y evaluar R-CNN más rápido en los datos, cambie en dataset_cfg el get_configuration() método de run_faster_rcnn.py a .

from utils.configs.MyDataSet_config import cfg as dataset_cfg

y ejecute python run_faster_rcnn.py.

Detalles técnicos

Como la mayoría de los detectores de objetos basados en DNN Más rápido R-CNN usa el aprendizaje de transferencia. Se inicia a partir de un modelo base que es un modelo entrenado para la clasificación de imágenes. El modelo base se corta en dos partes, la primera que es todas las capas convolucionales hasta (y excluye) la última capa de agrupación y la segunda parte es el resto de la red de (y excluye) la última capa de agrupación hasta (excluyendo) la capa de predicción final. La salida de la primera parte se denomina a veces mapa de características convolucionales. Esto se usa como entrada para la capa de agrupación de roi, que realiza una operación de agrupación en una parte del mapa de entrada que corresponde a las propuestas de región de la imagen original. Las propuestas de región son una segunda entrada para la capa de agrupación de roi. En R-CNN más rápido, estas propuestas las genera una pequeña subred denominada red de propuestas de región (RPN, consulte la sección siguiente).

La salida de la capa de agrupación roi siempre tendrá el mismo tamaño fijo, ya que agrupa cualquier entrada (mapa de características convolucionales + propuesta de región) al mismo tamaño de salida. Tenga en cuenta que el tamaño de entrada, es decir, el tamaño del mapa de provolución convolucional y, por tanto, también el tamaño de la imagen de entrada, puede ser arbitrario. Para entrenar el algoritmo, usa cuatro funciones de pérdida, dos para el RPN y dos para el detector (consulte también la sección siguiente). El siguiente método está incluido en FasterRCNN_train.py y muestra la construcción de alto nivel del modelo de R-CNN más rápido. FasterRCNN_train.py Consulte y utils/rpn/rpn_helpers.py para obtener el código completo.

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

Después de entrenar la red se convierte en un modelo de evaluación quitando todas las partes que no son necesarias para la evaluación, por ejemplo, las funciones de pérdida. El modelo de evaluación final tiene tres salidas (consulte create_faster_rcnn_eval_model() para FasterRCNN_train.py obtener más información):

  • rpn_rois - las coordenadas de píxeles absolutas del rois del candidato
  • cls_pred : las probabilidades de clase para cada ROI
  • bbox_regr : los coeficientes de regresión por clase para cada ROI

Para usar el modelo de evaluación de Python, puede usar desde FasterRCNN_EvaluatorFasterRCNN_eval.py. Puede cargar el modelo una vez y, a continuación, evaluar imágenes únicas a medida que vaya. El process_image() método del evaluador toma una ruta de acceso a una imagen como argumento, evalúa el modelo en esa imagen y aplica la regresión del cuadro de límite a las ROIs resultantes. Devuelve las ROIs con regresión y las probabilidades de clase correspondientes:

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

Red de propuesta de región

R-CNN más rápido usa una llamada propuesta de región netwrok (RPN) que genera regiones candidatas de interés (ROIs) basadas en la imagen de entrada. Esto se opone a Fast R-CNN, que requiere que una fuente externa proporcione propuestas de región. El RPN se basa esencialmente en tres capas de convolución y una nueva capa denominada capa de propuesta. Las nuevas capas se realizan como función definida por el usuario (UDF) en Python o C++ (consulte los detalles a continuación). El código de Python que crea el RPN en CNTK está en utils/rpn/rpn_helpers.py, las nuevas capas, como la capa de propuesta, están todas en la utils/rpn carpeta .

La entrada para el RPN es el mapa de características convolucionales, igual que la entrada a la capa de agrupación de ROI. Esta entrada se introduce en la primera capa de convolución del RPN y el resultado se propaga a las otras dos capas de convolución. Uno de los últimos predice puntuaciones de clase para cada región candidata, es decir, para cada delimitador en cada posición espacial (9 anclajes x 2 puntuaciones x ancho x alto). Las dos puntuaciones se convierten (mediante un nodo softmax) en puntuaciones de objeto por candidato que se interpretan como la probabilidad de que una región candidata contenga un objeto en primer plano o no. La otra capa convolucional predice coeficientes de regresión para la posición real del ROI, de nuevo para cada candidato (9 anclajes x 4 coeficientes x ancho x alto).

Los coeficientes de regresión y las puntuaciones de objeto (probabilidades en primer plano y en segundo plano) se introducen en el nivel de propuesta. Esta capa aplica primero los coeficientes de regresión a los anclajes generados, recorta el resultado a los límites de la imagen y filtra las regiones candidatas demasiado pequeñas. A continuación, ordena los candidatos por probabilidad de primer plano, aplica supresión no máxima (NMS) para reducir el número de candidatos y, por último, muestra el número deseado de ROIs para su salida.

Durante el entrenamiento, R-CNN requiere dos nuevas capas adicionales: la capa de destino de anclaje y la capa de destino de la propuesta. La capa de destino de anclaje genera los valores de destino para la puntuación de objeto y los coeficientes de regresión RPN que se usan en las funciones de pérdida del RPN. De forma similar, la capa de destino de propuesta genera las etiquetas de clase de destino para las ROIs y los coeficientes de regresión de destino por clase para el detector final que se usan en las funciones de pérdida del detector.

Durante la evaluación solo se requiere la capa de propuesta (ya que no se necesitan destinos para las funciones de pérdida). La capa de propuesta de CNTK está disponible en Python, así como en C++, las capas de destino solo están disponibles actualmente en Python. Por lo tanto, el entrenamiento de R-CNN más rápido tiene que realizarse actualmente desde la API de Python. Para almacenar un modelo de evaluación después del entrenamiento que usa el conjunto __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = Truede implementación de la capa de propuesta nativa.

Origen de lector y minibatch

Al escalar imágenes o voltear imágenes para el aumento de datos, también es necesario aplicar las mismas transformaciones a las anotaciones de verdad básicas. (Voltear también tiene que aplicarse a las propuestas almacenadas en caché en la formación en 4 fases, consulte la sección siguiente). Dado que estas transformaciones combinadas de imágenes y anotaciones no son compatibles actualmente con los lectores CNTK integrados, usamos un lector de Python personalizado y un UserMinibatchSource para Faster R-CNN. Se incluyen en utils/od_reader.py y utils/od_mb_source.py respectivamente.

Entrenamiento de E2E y 4 fases

En el documento de investigación de R-CNN más rápido se describen dos métodos para entrenar la red. El entrenamiento de un extremo a otro entrena toda la red en un solo entrenamiento mediante la función de pérdida de las cuatro (pérdida de regresión rpn, pérdida de objetos rpn, pérdida de regresión del detector, pérdida de clase detector). De forma predeterminada, el entrenamiento de un extremo a otro se puede elegir entre los dos estableciendo __C.CNTK.TRAIN_E2E en consecuencia en FasterRCNN_config.py.

El esquema de entrenamiento de 4 fases alterna entre el entrenamiento solo la red de propuesta de región (manteniendo fijo el detector) y el entrenamiento solo el detector (fijando los pesos de RPN). Este esquema de entrenamiento se implementa en train_faster_rcnn_alternating() en FasterRCNN_train.py. Es ligeramente más elaborado y hace uso frecuente de las partes de clonación del modelo para permitir la congelación y los pesos de entrenamiento selectivamente. Además, en la formación en 4 fases, las propuestas del RPN se almacenan en búfer después de las fases uno y tres y se usan en la fase posterior.

Uso de un modelo base diferente

Para usar un modelo base diferente, debe elegir una configuración de modelo diferente en el get_configuration() método de run_faster_rcnn.py. Se admiten dos modelos inmediatamente:

    # 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

Para descargar el modelo VGG16, use el script de descarga en <cntkroot>/PretrainedModels:

    python download_model.py VGG16_ImageNet_Caffe

Si desea usar otro modelo base diferente, debe copiar, por ejemplo, el archivo utils/configs/VGG16_config.py de configuración y modificarlo según el modelo 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

Para investigar los nombres de nodo del modelo base, puede usar el plot() método de cntk.logging.graph. Tenga en cuenta que los modelos de ResNet no se admiten actualmente, ya que la agrupación de roi en CNTK todavía no admite la agrupación media de roi.