Deteção de objetos usando R-CNN mais rápido
Tabela de Conteúdos
Resumo
Acima são exemplos de imagens e anotações de objeto para o conjunto de dados de mercearia (à esquerda) e o conjunto de dados pascal VOC (à direita) usado neste tutorial.
R-CNN mais rápido é um algoritmo de deteção de objetos proposto por Shaoqing Ren, Kaiming He, Ross Girshick e Jian Sun em 2015. O trabalho de investigação intitula-se "Mais rápido 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 eficientemente as propostas de objetos utilizando redes profundas convolucionais. Em comparação com os trabalhos anteriores, a R-CNN emprega uma rede de propostas de região e não requer um método externo para as propostas da região candidata.
Este tutorial está estruturado em três secções principais. A primeira secção fornece uma descrição concisa de como executar R-CNN mais rápido em CNTK no conjunto de dados de exemplo fornecido. A segunda secção fornece detalhes sobre todas as etapas, incluindo configuração e parametrização de R-CNN mais rápido. A secçã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 treino para A R-CNN mais rápida.
Início rápido
Esta secção pressupõe que tem o seu sistema configurado para utilizar a API python CNTK. Assumimos ainda que está a usar o Python 3.5 no Windows ou 3.5/3.6 no Linux. Para uma caminhada detalhada, consulte as instruções passo a passo. Para executar a R-CNN mais rápida, por favor instale os seguintes pacotes adicionais no seu ambiente cntk Python
pip install opencv-python easydict pyyaml
Executar o exemplo de brinquedo
Usamos um conjunto de dados de brinquedos de imagens capturadas a partir de um frigorífico para demonstrar r-CNN mais rápido (o mesmo que para o exemplo Fast R-CNN). Tanto o conjunto de dados como o modelo AlexNet pré-treinado podem ser descarregados executando o seguinte comando Python a partir da pasta Exemplos/Imagem/Deteção/FastRCNN:
python install_data_and_model.py
Depois de executar o script, o conjunto de dados de brinquedos será instalado sob a Examples/Image/DataSets/Grocery pasta. O modelo AlexNet será descarregado para a PretrainedModels pasta.
Recomendamos manter os dados descarregados na respetiva pasta, uma vez que os ficheiros de configuração assumem essa localização por predefinição.
Para treinar e avaliar a corrida R-CNN mais rápida
python run_faster_rcnn.py
Os resultados do treino de ponta a ponta na mercearia utilizando o 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 e etiquetas de delimitação previstas nas imagens abertas FasterRCNN_config.py a FasterRCNN partir da pasta e definidas
__C.VISUALIZE_RESULTS = True
As imagens serão guardadas na FasterRCNN/Output/Grocery/ pasta se correr python run_faster_rcnn.py.
Instruções passo a passo
Configuração
Para executar o código neste exemplo, você precisa de um ambiente CNTK Python (consulte aqui para obter ajuda de configuração). Por favor, instale os seguintes pacotes adicionais no seu ambiente cntk Python
pip install opencv-python easydict pyyaml
Binários pré-compilados para regressão da caixa de delimitação 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 64 bits. Se precisar de uma versão diferente, pode compilá-la seguindo os passos descritos em
- Linux: https://github.com/rbgirshick/py-faster-rcnn
- Windows: https://github.com/MrGF/py-faster-rcnn-windows
Copie os binários gerados cython_bboxcpu_nms e /ou /ou gpu_nmsde $FRCN_ROOT/lib/utils .$CNTK_ROOT/Examples/Image/Detection/utils/cython_modules
Dados de exemplo e modelo de base
Utilizamos um modelo AlexNet pré-treinado como base para o treino Mais Rápido-R-CNN (para modelos VGG ou outros modelos base ver usando um modelo base diferente. Tanto o conjunto de dados de exemplo como o modelo AlexNet pré-treinado podem ser descarregados executando o seguinte comando Python a partir da pasta FastRCNN :
python install_data_and_model.py
- Saiba como usar um modelo base diferente
- Saiba como executar R-CNN mais rápido em dados do VOC pascal
- Saiba como executar a R-CNN mais rápida nos seus próprios dados
Configuração e Parâmetros
Os parâmetros são agrupados em três partes:
- Parâmetros do detetor (ver
FasterRCNN/FasterRCNN_config.py) - Parâmetros de definição de dados (ver por exemplo
utils/configs/Grocery_config.py) - Parâmetros do modelo base (ver por exemplo
utils/configs/AlexNet_config.py)
As três partes são carregadas e fundidas no get_configuration() método em run_faster_rcnn.py. Nesta secção vamos cobrir os parâmetros do detetor. Os parâmetros de conjunto de dados são descritos aqui, parâmetros de base aqui. No seguinte passamos pelo conteúdo de FasterRCNN_config.py cima para baixo. A configuração utiliza o EasyDict pacote que permite fácil acesso 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 mais elevados no que diz respeito ao processo de treino. __C.CNTK.TRAIN_E2E permite selecionar o sistema de treino de ponta a ponta ou de 4 estágios. Os detalhes sobre os dois programas de treino 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 depurar adicional na saída da consola. Também traça gráficos de computação CNTK para os modelos de treino e eval (note os requisitos para a tramação de gráficos CNTK). Os gráficos resultantes são armazenados na FasterRCNN/Output pasta. __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = True irá armazenar um segundo modelo de avaliação que utiliza apenas código nativo (sem camadas Python). Este modelo pode ser carregado e avaliado a partir 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. Estes são principalmente parâmetros regulares de aprendizagem CNTK. A única exceção é __C.CNTK.BIAS_LR_MULT, que é o multiplicador de taxa de aprendizagem que é usado para todos os enviesamentos da rede. Treina essencialmente os enviesamentos com o dobro da taxa de aprendizagem atual, o que também é feito no código R-CNN original. O número de épocas e a taxa de aprendizagem por amostra são especificados separadamente para os dois diferentes regimes de aprendizagem (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 terrestre por imagem. A CNTK requer atualmente a definição de um número máximo. Se houver menos anotações, serão acolchoadas internamente. __C.IMAGE_WIDTH e __C.IMAGE_HEIGHT são as dimensões que são usadas para redimensionar e remar as imagens de entrada. __C.RESULTS_NMS_THRESHOLD é o limiar de SNM utilizado para descartar as caixas de delimitação previstas na avaliação. Um limiar mais baixo produz menos remoção e, portanto, caixas de delimitação mais previstas na produção 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 irá aumentar os dados de treino, invertendo todas as imagens em todas as outras épocas, ou seja, a primeira época tem todas as imagens regulares, a segunda tem todas as imagens viradas, e assim por diante. __C.TRAIN_CONV_LAYERS determina se as camadas convolucionais, desde a entrada até ao mapa de características convolucionais, serão treinadas ou fixas. A fixação dos pesos da camada conv significa que os pesos do modelo base são tomados e não modificados durante o treino. (Também pode especificar quantas camadas conv pretende treinar, ver secção Utilizando um modelo base diferente). Para os parâmetros rpn, consulte os comentários ao lado da sua definição ou consulte o trabalho de investigação original para obter mais detalhes. Também para os seguintes parâmetros do detetor:
# 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)
Corra R-CNN mais rápido em Pascal VOC
Para descarregar os dados pascal e criar os ficheiros de anotação para Pascal no formato CNTK, executar os seguintes scripts:
python Examples/Image/DataSets/Pascal/install_pascalvoc.py
python Examples/Image/DataSets/Pascal/mappings/create_mappings.py
Alterar o dataset_cfg método get_configuration() de run_faster_rcnn.py
from utils.configs.Pascal_config import cfg as dataset_cfg
Agora está pronto para treinar os dados do Pascal VOC 2007 usando python run_faster_rcnn.py. Cuidado que o treino pode demorar um pouco.
Executar R-CNN mais rápido nos seus próprios dados
Preparar os seus próprios dados e anotar com caixas de limite de verdade terrestre é descrito na deteção de objetos usando Fast R-CNN. Depois de armazenar as suas imagens na estrutura descrita da pasta e anotando-as, por favor, corra
python Examples/Image/Detection/utils/annotations/annotations_helper.py
depois de ter mudado a pasta do guião para a pasta de dados. Por fim, crie uma MyDataSet_config.py na utils\configs pasta seguindo os exemplos existentes, como neste corte 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 é utilizado em generate_anchors() (ver utils/rpn/generate_anchors.py). Partindo de um tamanho base de 16 três âncoras com rácios de aspeto e 2.0 são criadas 0.5, 1.0 resultando em (8 x 24, 16 x 16, 24 x 8). Estes são multiplicados com cada escala de camada de proposta, resultando em nove âncoras (64 x 192,... , 768 x 256). Estas são coordenadas absolutas de pixel w.r.t. a imagem de entrada. Todas as âncoras são aplicadas em cada posição espacial do mapa de características convolucionais para gerar regiões de interesse candidatos. Adapte estas escalas de camada de proposta de acordo com os tamanhos do objeto no seu conjunto de dados e o tamanho da imagem de entrada que está a usar. Por exemplo, para o conjunto de dados de mercearia que estamos a usar __C.DATA.PROPOSAL_LAYER_SCALES = [4, 8, 12] e um tamanho de imagem de entrada de 850 x 850 (ver utils/configs/Grocery_config.py).
Para treinar e avaliar mais rápido R-CNN nos 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 correr python run_faster_rcnn.py.
Detalhes Técnicos
Como a maioria dos detetores de objetos baseados em DNN, a R-CNN utiliza a aprendizagem de transferência. Começa a partir de um modelo base que é um modelo treinado para a classificação de imagem. O modelo base é cortado em duas partes, sendo a primeira todas as camadas convolucional até (e excluindo) a última camada de agrupamento e a segunda parte é o restante da rede de (e excluindo) a última camada de agrupamento até (mais uma vez excluindo) a camada de previsão final. A saída da primeira parte é por vezes chamada de mapa de características convolucionais. Isto é usado como a entrada para a camada de piscina roi, que realiza uma operação de agrupamento em uma parte do mapa de entrada que corresponde às propostas da região na imagem original. As propostas da região são uma segunda entrada para a camada de agrupamento roi. Na R-CNN mais rápida, estas propostas são geradas por uma pequena sub-rede chamada rede de propostas de região (RPN, ver secção seguinte).
A saída da camada de agrupamento roi terá sempre o mesmo tamanho fixo, uma vez que junta qualquer entrada (mapa de recurso convolucional + proposta de região) para o mesmo tamanho de saída. Note que o tamanho da entrada, ou seja, o tamanho do mapa de proezas convolucionais e, portanto, também o tamanho da imagem de entrada, pode ser arbitrário. Para treinar o algoritmo utiliza quatro funções de perda, duas para o RPN e duas para o detetor (ver também a secção seguinte). O seguinte método está contido FasterRCNN_train.py e mostra a construção de alto nível do modelo R-CNN mais rápido. Por favor, consulte FasterRCNN_train.py 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 a formação, a rede é convertida num modelo de avaliação, removendo todas as peças 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 (ver create_faster_rcnn_eval_model()FasterRCNN_train.py mais detalhes):
rpn_rois- as coordenadas absolutas do pixel dos rois candidatoscls_pred- as probabilidades de classe para cada ROIbbox_regr- os coeficientes de regressão por classe para cada ROI
Para utilizar o modelo de avaliação da Python pode utilizar o FasterRCNN_Evaluator de FasterRCNN_eval.py. Pode carregar o modelo uma vez e depois avaliar imagens únicas à medida que avança. O process_image() método do avaliador percorre um caminho para uma imagem como argumento, avalia o modelo nessa imagem e aplica a regressão da caixa de delimitação aos ROIs resultantes. Devolve as ROIs regressas 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
A R-CNN utiliza uma proposta de região chamada netwrok (RPN) que gera regiões de interesse candidatos (ROIs) com base na imagem de entrada. Isto opõe-se à Rápida R-CNN, que exige que as propostas da região sejam fornecidas por uma fonte externa. O RPN é essencialmente acumulado por três camadas de convolução e uma nova camada chamada camada de proposta. As novas camadas são realizadas como função definida pelo utilizador (UDF) em Python ou C++ (ver detalhes abaixo). O código Python que cria o RPN em CNTK está em 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 características convolucional, o mesmo que é a entrada para a camada de agrupamento ROI. Esta 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 ou não um objeto de primeiro plano. 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 de primeiro plano e de fundo) são introduzidos na camada de proposta. Esta camada aplica primeiro os coeficientes de regressão às âncoras geradas, prende o resultado aos limites de imagem e filtra regiões candidatas que são demasiado pequenas. Em seguida, classifica os candidatos por probabilidade de primeiro plano, aplica supressão não máxima (SNM) para reduzir o número de candidatos e, finalmente, amostra o número desejado de ROIs para a sua produção.
Durante o treino, a R-CNN mais rápida requer duas novas camadas adicionais: a camada alvo de âncora e a camada alvo da proposta. A camada alvo da âncora gera os valores-alvo para a pontuação de objetividade e os coeficientes de regressão RPN que são utilizados nas funções de perda do RPN. Da mesma forma, a camada-alvo da proposta gera as etiquetas de classe-alvo para os ROIs e os coeficientes de regressão de destino por classe para o detetor final que são utilizados nas funções de perda do detetor.
Durante a avaliação, apenas é necessária a camada de proposta (uma vez que não são necessários alvos para funções de perda). A camada de proposta em CNTK está disponível em Python, bem como C++, as camadas-alvo estão atualmente apenas disponíveis em Python. Portanto, a formação R-CNN mais rápida tem atualmente a ser feita a partir da API Python. Para armazenar um modelo de avaliação após o treino que utilize o conjunto __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = Truede implementação da camada de proposta nativa .
Leitor e fonte de minibatch
Quando escalamos imagens ou invertemos imagens para o aumento de dados, precisamos aplicar as mesmas transformações nas anotações da verdade terrestre, também. (A flipping também tem de ser aplicada a propostas em cache em formação em 4 fases, ver secção seguinte.) Uma vez que estas transformações de imagens e anotações não são atualmente suportadas pelos leitores da CNTK, usamos um leitor de Python personalizado e um UserMinibatchSource para R-CNN mais rápido. Estes estão contidos utils/od_reader.py e utils/od_mb_source.py respectivamente.
E2E e treino em 4 etapas
O trabalho de investigação da R-CNN mais rápido descreve dois métodos para treinar a rede. O treino de ponta a ponta treina toda a rede num único treino utilizando todas as quatro funções de perda (perda de regressão rpn, perda de objetividade RPN, perda de regressão do detetor, perda de classe de detetor). Utilizamos o treino de ponta a ponta por padrão, pode escolher entre os dois definindo __C.CNTK.TRAIN_E2E em conformidade em FasterRCNN_config.py.
O sistema de formação em 4 fases alterna entre a formação apenas da rede de propostas da região (mantendo o detetor fixo) e a formação apenas do detetor (fixação dos pesos RPN). Este regime de formação é implementado em train_faster_rcnn_alternating()FasterRCNN_train.py. É um pouco mais elaborado e faz uso frequente de partes de clonagem do modelo para permitir a congelação e os pesos de treino seletivamente. Além disso, na formação em 4 fases, as propostas do RPN são tamponadas após as fases um e três e utilizadas na fase seguinte.
Usando um modelo base diferente
Para utilizar um modelo base diferente, é necessário escolher uma configuração de modelo diferente no get_configuration() método de run_faster_rcnn.py. Dois modelos são suportados de imediato:
# 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 descarregar o modelo VGG16, utilize o script de descarregamento em <cntkroot>/PretrainedModels:
python download_model.py VGG16_ImageNet_Caffe
Se quiser utilizar outro modelo base diferente, tem de copiar, por exemplo, o ficheiro utils/configs/VGG16_config.py de configuração e modificá-lo de acordo com o 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 dos nós do seu modelo base, pode utilizar o plot() método a partir de cntk.logging.graph. Por favor, note que os modelos ResNet não são suportados atualmente, uma vez que roi pooling em CNTK ainda não suporta a média de piscina roi.