Detecção de objetos usando r-CNN mais rápido
Sumário
Resumo
Os exemplos acima são imagens de exemplo e anotações de objeto para o conjunto de dados do Grocery (esquerda) e o conjunto de dados pascal VOC (à direita) usado neste tutorial.
Faster R-CNN é um algoritmo de detecção de objetos proposto por Shaoqing Ren, Kaiming He, Ross Girshick e Jian Sun em 2015. O artigo de pesquisa é intitulado 'Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks', e é arquivado em https://arxiv.org/abs/1506.01497. A R-CNN mais rápida baseia-se em trabalhos anteriores para classificar com eficiência propostas de objeto usando redes convolucionais profundas. Em comparação com o trabalho anterior, o Faster R-CNN emprega uma rede de propostas de região e não requer um método externo para propostas de região candidatas.
Este tutorial é estruturado em três seções principais. A primeira seção fornece uma descrição concisa de como executar o Faster R-CNN no CNTK no conjunto de dados de exemplo fornecido. A segunda seção fornece detalhes sobre todas as etapas, incluindo configuração e parametrização do R-CNN mais rápido. A seção final discute detalhes técnicos do algoritmo e da rede de propostas da região, lendo e aumentando os dados de entrada, bem como diferentes opções de treinamento para r-CNN mais rápido.
Início rápido
Esta seção pressupõe que você tenha seu sistema configurado para usar a API do Python do CNTK. Presumimos ainda que você esteja usando o Python 3.5 no Windows ou 3.5/3.6 no Linux. Para obter um passo a passo detalhado, consulte as instruções passo a passo. Para executar o R-CNN mais rápido, instale os seguintes pacotes adicionais em seu ambiente do Cntk Python
pip install opencv-python easydict pyyaml
Executar o exemplo de toy
Usamos um conjunto de dados de toy de imagens capturadas de uma geladeira para demonstrar Faster R-CNN (o mesmo que para o exemplo Fast R-CNN). O conjunto de dados e o modelo AlexNet pré-treinado podem ser baixados executando o seguinte comando Python na pasta Examples/Image/Detection/FastRCNN:
python install_data_and_model.py
Depois de executar o script, o conjunto de dados de toy será instalado na Examples/Image/DataSets/Grocery pasta. O modelo AlexNet será baixado para a PretrainedModels pasta.
É recomendável manter os dados baixados na respectiva pasta, pois os arquivos de configuração assumem esse local por padrão.
Para treinar e avaliar a execução mais rápida do R-CNN
python run_faster_rcnn.py
Os resultados do treinamento de ponta a ponta no Supermercado usando AlexNet como modelo base devem ser semelhantes a estes:
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 as caixas delimitadoras previstas e rótulos nas imagens abertas FasterRCNN_config.py da FasterRCNN pasta e definir
__C.VISUALIZE_RESULTS = True
As imagens serão salvas na FasterRCNN/Output/Grocery/ pasta se você executar python run_faster_rcnn.py.
Instruções passo a passo
Instalação
Para executar o código neste exemplo, você precisa de um ambiente do CNTK Python (consulte aqui para obter ajuda de instalação). Instale os seguintes pacotes adicionais em seu ambiente do cntk Python
pip install opencv-python easydict pyyaml
Binários pré-compilados para regressão de caixa delimitadora e supressão não máxima
A pasta Examples\Image\Detection\utils\cython_modules contém binários pré-compilados que são necessários para executar r-CNN mais rápido. As versões que estão atualmente contidas no repositório são Python 3.5 para Windows e Python 3.5, 3.6 para Linux, todas de 64 bits. Se você precisar de uma versão diferente, poderá compilá-la seguindo as etapas descritas em
- Linux: https://github.com/rbgirshick/py-faster-rcnn
- Windows: https://github.com/MrGF/py-faster-rcnn-windows
Copie os binários gerados cython_bbox e cpu_nms (e/ou gpu_nms) de $FRCN_ROOT/lib/utils para $CNTK_ROOT/Examples/Image/Detection/utils/cython_modules.
Exemplo de dados e modelo de linha de base
Usamos um modelo AlexNet pré-treinado como base para o treinamento Faster-R-CNN (para VGG ou outros modelos base, consulte Usando um modelo base diferente. O conjunto de dados de exemplo e o modelo AlexNet pré-treinado podem ser baixados executando o seguinte comando Python da pasta FastRCNN :
python install_data_and_model.py
- Saiba como usar um modelo base diferente
- Saiba como executar dados R-CNN mais rápidos no Pascal VOC
- Saiba como executar o R-CNN mais rápido em seus próprios dados
Configuração e parâmetros
Os parâmetros são agrupados em três partes:
- Parâmetros do detector (consulte
FasterRCNN/FasterRCNN_config.py) - Parâmetros do conjunto de dados (veja por exemplo
utils/configs/Grocery_config.py) - Parâmetros de modelo base (veja por exemplo
utils/configs/AlexNet_config.py)
As três partes são carregadas e mescladas no get_configuration() método em run_faster_rcnn.py. Nesta seção, abordaremos os parâmetros do detector. Os parâmetros do conjunto de dados são descritos aqui, parâmetros de modelo base aqui. No seguinte, passamos pelo conteúdo de FasterRCNN_config.py cima para baixo. A configuração usa o EasyDict pacote que permite acesso fácil a dicionários aninhados.
# 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
O primeiro bloco de parâmetros contém instruções de nível superior sobre o processo de treinamento. __C.CNTK.TRAIN_E2E permite selecionar o esquema de treinamento de ponta a ponta ou de 4 estágios. Detalhes sobre os dois esquemas de treinamento são descritos aqui. __C.CNTK.FAST_MODE = True executa apenas uma única época; é útil testar se a configuração está funcionando e todos os parâmetros estão corretos. __C.CNTK.DEBUG_OUTPUT = True gera mensagem de depuração adicional na saída do console. Ele também plota grafos de computação CNTK para os modelos de treinamento e de avaliação (observe os requisitos para plotar grafos CNTK). Os grafos resultantes são armazenados na FasterRCNN/Output pasta. __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = True armazenará um segundo modelo de avaliação que usa apenas código nativo (sem camadas do Python). Esse modelo pode ser carregado e avaliado de C++ ou C#, por exemplo.
# 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]
O segundo bloco contém os parâmetros de aprendizagem. Esses são principalmente parâmetros de aprendizagem CNTK regulares. A única exceção é __C.CNTK.BIAS_LR_MULT, que é o multiplicador de taxa de aprendizagem que é usado para todos os vieses na rede. Ele essencialmente treina os vieses com o dobro da taxa de aprendizagem atual, o que também é feito no código R-CNN R original. O número de épocas e a taxa de aprendizagem por exemplo são especificados separadamente para os dois esquemas de aprendizagem diferentes (parâmetros de 4 estágios omitidos acima).
# 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 o número máximo de anotações de verdade por imagem. Atualmente, o CNTK exige definir um número máximo. Se houver menos anotações, elas serão adicionadas internamente. __C.IMAGE_WIDTH e __C.IMAGE_HEIGHT são as dimensões usadas para redimensionar e adicionar as imagens de entrada. __C.RESULTS_NMS_THRESHOLD é o limite NMS usado para descartar caixas delimitadoras previstas sobrepostas na avaliação. Um limite inferior gera menos remoções e, portanto, mais caixas delimitadoras previstas na saída 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á os dados de treinamento invertendo todas as imagens a cada outra época, ou seja, a primeira época tem todas as imagens regulares, a segunda tem todas as imagens invertidas e assim por diante. __C.TRAIN_CONV_LAYERS determina se as camadas convolucionais, desde a entrada até o mapa de recursos convolucionais, serão treinadas ou corrigidas. Corrigir os pesos da camada de conv significa que os pesos do modelo base são tomados e não modificados durante o treinamento. (Você também pode especificar quantas camadas de conv deseja treinar, consulte a seção Usando um modelo base diferente). Para obter os parâmetros rpn, consulte os comentários ao lado de sua defintion ou consulte o artigo de pesquisa original para obter mais detalhes. Também para os seguintes parâmetros de 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)
Executar R-CNN mais rápido no Pascal VOC
Para baixar os dados pascal e criar os arquivos de anotação para Pascal no formato CNTK, execute os seguintes scripts:
python Examples/Image/DataSets/Pascal/install_pascalvoc.py
python Examples/Image/DataSets/Pascal/mappings/create_mappings.py
Alterar o dataset_cfgget_configuration() método de run_faster_rcnn.py para
from utils.configs.Pascal_config import cfg as dataset_cfg
Agora você está pronto para treinar os dados pascal VOC 2007 usando python run_faster_rcnn.py. Cuidado para que o treinamento possa levar algum tempo.
Executar r-CNN mais rápido em seus próprios dados
Preparar seus próprios dados e anotá-los com caixas delimitadoras de verdade em terra é descrito na detecção de objetos usando o Fast R-CNN. Depois de armazenar suas imagens na estrutura de pastas descrita e anotá-las, execute
python Examples/Image/Detection/utils/annotations/annotations_helper.py
depois de alterar a pasta nesse script para sua pasta de dados. Por fim, crie uma MyDataSet_config.py pasta seguindo utils\configs os exemplos existentes, como neste snippet 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 é usado em generate_anchors() (consulte utils/rpn/generate_anchors.py). A partir de um tamanho base de 16 três âncoras com proporções e 2.0 são criadas 0.5, 1.0 resultando em (8 x 24, 16 x 16, 24 x 8). Elas são multiplicadas com cada escala de camada de proposta resultando em nove âncoras (64 x 192, ... , 768 x 256). Essas são coordenadas de pixel absolutas w.r.t. a imagem de entrada. Todas as âncoras são aplicadas em cada posição espacial do mapa de recursos convolucionais para gerar regiões candidatas de interesse. Adapte essas escalas de camada de proposta de acordo com os tamanhos de objeto em seu conjunto de dados e o tamanho da imagem de entrada que você está usando. Por exemplo, para o conjunto de dados do Grocery que estamos usando __C.DATA.PROPOSAL_LAYER_SCALES = [4, 8, 12] e um tamanho de imagem de entrada de 850 x 850 (consulte utils/configs/Grocery_config.py).
Para treinar e avaliar o R-CNN mais rápido em seus dados, altere o dataset_cfgget_configuration() método de run_faster_rcnn.py
from utils.configs.MyDataSet_config import cfg as dataset_cfg
e execute python run_faster_rcnn.py.
Detalhes técnicos
Como a maioria dos detectores de objetos baseados em DNN, o Faster R-CNN usa o aprendizado de transferência. Ele começa a partir de um modelo base que é um modelo treinado para classificação de imagem. O modelo base é cortado em duas partes, sendo a primeira todas as camadas convolucionais até (e excluindo) a última camada de pooling e a segunda parte é o restante da rede de (e excluindo) a última camada de pooling até (novamente excluindo) a camada de previsão final. A saída da primeira parte às vezes é chamada de mapa de recursos convolucionais. Isso é usado como a entrada para a camada de pooling roi, que executa uma operação de pooling em uma parte do mapa de entrada que corresponde a propostas de região na imagem original. As propostas de região são uma segunda entrada para a camada de pooling roi. No Faster R-CNN, essas propostas são geradas por uma pequena sub-rede chamada RPN ( rede de proposta de região ), consulte a próxima seção.
A saída da camada de pooling roi sempre terá o mesmo tamanho fixo, pois ela agrupa qualquer entrada (mapa de recursos convolucionais + proposta de região) para o mesmo tamanho de saída. Observe que o tamanho da entrada, ou seja, o tamanho do mapa de featute convolucional e, portanto, também o tamanho da imagem de entrada, pode ser arbitrário. Para treinamento, o algoritmo usa quatro funções de perda, duas para o RPN e duas para o detector (consulte também a próxima seção). O método a seguir está contido FasterRCNN_train.py e mostra a construção de alto nível do modelo R-CNN mais rápido. FasterRCNN_train.py Consulte e utils/rpn/rpn_helpers.py para o 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
Após o treinamento, a rede é convertida em um modelo de avaliação removendo todas as partes que não são necessárias para avaliação, por exemplo, as funções de perda. O modelo de avaliação final tem três saídas (confira create_faster_rcnn_eval_model()FasterRCNN_train.py mais detalhes):
rpn_rois- as coordenadas de pixel absoluto do rois candidatocls_pred– as probabilidades de classe para cada ROIbbox_regr- os coeficientes de regressão por classe para cada ROI
Para usar o modelo de avaliação do Python, você pode usar o FasterRCNN_Evaluator de FasterRCNN_eval.py. Você pode carregar o modelo uma vez e avaliar imagens individuais conforme o uso. O process_image() método do avaliador usa um caminho para uma imagem como seu argumento, avalia o modelo nessa imagem e aplica a regressão da caixa delimitadora aos ROIs resultantes. Ele retorna os ROIs regressados e as probabilidades de classe correspondentes:
evaluator = FasterRCNN_Evaluator(model, cfg)
regressed_rois, cls_probs = evaluator.process_image(img_path)
Rede de propostas de região
O R-CNN mais rápido usa o chamado RPN ( netwrok ) de proposta de região que gera ROIs (regiões de interesse) candidatas com base na imagem de entrada. Isso se opõe ao Fast R-CNN, que exige que as propostas de região sejam fornecidas por uma fonte externa. O RPN é essencialmente compilado por três camadas de convolução e uma nova camada chamada camada de proposta. As novas camadas são realizadas como UDF (função definida pelo usuário) em Python ou C++ (confira detalhes abaixo). O código Python que cria o RPN no CNTK está dentro utils/rpn/rpn_helpers.py, as novas camadas, como a camada de proposta, estão todas na utils/rpn pasta.
A entrada para o RPN é o mapa de recursos convolucionais, o mesmo que é a entrada para a camada de pool de ROI. Essa entrada é alimentada na primeira camada de convolução do RPN e o resultado é propagado para as outras duas camadas de convolução. Um destes últimos prevê pontuações de classe para cada região candidata, ou seja, para cada âncora em cada posição espacial (9 âncoras x 2 pontuações x largura x altura). As duas pontuações são convertidas (usando um nó softmax) em pontuações de objetividade por candidato que são interpretadas como a probabilidade de uma região candidata conter um objeto em primeiro plano ou não. A outra camada convolucional prevê coeficientes de regressão para a posição real do ROI, novamente para cada candidato (9 âncoras x 4 coeficientes x largura x altura).
Os coeficientes de regressão e as pontuações de objetividade (probabilidades em primeiro plano e segundo plano) são alimentados na camada de proposta. Essa camada primeiro aplica os coeficientes de regressão às âncoras geradas, corta o resultado para os limites da imagem e filtra regiões candidatas muito pequenas. Em seguida, classifica os candidatos por probabilidade de primeiro plano, aplica NMS (supressão não máxima) para reduzir o número de candidatos e, finalmente, amostra o número desejado de ROIs para sua saída.
Durante o treinamento, o R-CNN mais rápido requer duas novas camadas adicionais: a camada de destino de âncora e a camada de destino da proposta. A camada de destino de âncora gera os valores de destino para a pontuação de objetividade e os coeficientes de regressão rpn que são usados nas funções de perda do RPN. Da mesma forma, a camada de destino da proposta gera os rótulos de classe de destino para os ROIs e os coeficientes de regressão de destino por classe para o detector final que são usados nas funções de perda do detector.
Durante a avaliação, somente a camada de proposta é necessária (já que não são necessárias metas para funções de perda). A camada de proposta no CNTK está disponível no Python, bem como no C++, as camadas de destino estão disponíveis atualmente apenas no Python. Portanto, o treinamento do Faster R-CNN deve ser feito atualmente por meio da API do Python. Para armazenar um modelo de avaliação após o treinamento que usa o conjunto __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = Truede implementação da camada de proposta nativa.
Origem do leitor e da minibatch
Quando dimensionamos imagens ou invertemos imagens para aumento de dados, também precisamos aplicar as mesmas transformações às anotações de verdade básicas. (A inversão também precisa ser aplicada a propostas armazenadas em cache no treinamento em 4 estágios, consulte a próxima seção.) Como essas transformações unidas de imagens e anotações não são suportadas atualmente pelos leitores CNTK internos, usamos um leitor de Python personalizado e um UserMinibatchSource para Faster R-CNN. Eles estão contidos dentro utils/od_reader.py e utils/od_mb_source.py respectivamente.
Treinamento em E2E e 4 estágios
O artigo de pesquisa Faster R-CNN descreve dois métodos para treinar a rede. O treinamento de ponta a ponta treina toda a rede em um único treinamento usando todas as quatro funções de perda (perda de regressão de rpn, perda de objetividade rpn, perda de regressão do detector, perda de classe do detector). Usamos o treinamento de ponta a ponta por padrão, você pode escolher entre os dois definindo __C.CNTK.TRAIN_E2E adequadamente em FasterRCNN_config.py.
O esquema de treinamento em 4 estágios alterna entre treinar apenas a rede de proposta de região (mantendo o detector fixo) e treinar apenas o detector (corrigindo os pesos RPN). Esse esquema de treinamento é implementado em train_faster_rcnn_alternating()FasterRCNN_train.py. Ele é um pouco mais elaborado e faz uso frequente da clonagem de partes do modelo para habilitar pesos de congelamento e treinamento seletivamente. Além disso, no treinamento em 4 estágios, as propostas do RPN são armazenadas em buffer após as fases um e três e usadas no estágio subsequente.
Usando um modelo base diferente
Para usar um modelo base diferente, você precisa escolher uma configuração de modelo diferente no get_configuration() método de run_faster_rcnn.py. Há suporte para dois modelos imediatamente:
# 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 baixar o modelo VGG16, use o script de download em <cntkroot>/PretrainedModels:
python download_model.py VGG16_ImageNet_Caffe
Se você quiser usar outro modelo base diferente, precisará copiar, por exemplo, o arquivo utils/configs/VGG16_config.py de configuração e modificá-lo de acordo com seu 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 os nomes de nós do modelo de base, você pode usar o plot() método de cntk.logging.graph. Observe que atualmente não há suporte para modelos ResNet, pois o pool de roi no CNTK ainda não dá suporte ao pool de roi.