Objektidentifiering med snabbare R-CNN
Innehållsförteckning
Sammanfattning
Ovanstående är exempel på bilder och objektanteckningar för datauppsättningen Grocery (vänster) och Pascal VOC-datauppsättningen (höger) som används i den här självstudien.
Faster R-CNN är en objektidentifieringsalgoritm som föreslogs av Shaoqing Ren, Kaiming He, Ross Girshick och Jian Sun 2015. Forskningsartikeln heter "Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks" och arkiveras på https://arxiv.org/abs/1506.01497. Snabbare R-CNN bygger på tidigare arbete för att effektivt klassificera objektförslag med hjälp av djupa konvolutionala nätverk. Jämfört med tidigare arbete använder Faster R-CNN ett regionförslagsnätverk och kräver ingen extern metod för förslag i kandidatregionen.
Den här självstudien är strukturerad i tre huvudavsnitt. Det första avsnittet innehåller en kortfattad beskrivning av hur du kör Faster R-CNN i CNTK på den angivna exempeldatauppsättningen. Det andra avsnittet innehåller information om alla steg, inklusive installation och parameterisering av Faster R-CNN. I det sista avsnittet beskrivs teknisk information om algoritmen och regionförslagets nätverk, läsning och förhöjda indata samt olika utbildningsalternativ för Snabbare R-CNN.
Snabbstart
Det här avsnittet förutsätter att du har konfigurerat systemet för att använda CNTK Python-API:et. Vi förutsätter vidare att du använder Python 3.5 i Windows eller 3.5/3.6 i Linux. En detaljerad genomgång finns i stegvisa instruktioner. Om du vill köra Snabbare R-CNN installerar du följande ytterligare paket i din cntk Python-miljö
pip install opencv-python easydict pyyaml
Kör leksaksexemplet
Vi använder en leksaksdatamängd med bilder som tagits från ett kylskåp för att demonstrera Faster R-CNN (samma som för Fast R-CNN-exemplet). Både datauppsättningen och den förtränade AlexNet-modellen kan laddas ned genom att köra följande Python-kommando från mappen Examples/Image/Detection/FastRCNN:
python install_data_and_model.py
När du har kört skriptet installeras leksaksdatauppsättningen Examples/Image/DataSets/Grocery under mappen . AlexNet-modellen laddas ned till PretrainedModels mappen.
Vi rekommenderar att du behåller nedladdade data i respektive mapp eftersom konfigurationsfilerna förutsätter den platsen som standard.
Träna och utvärdera snabbare R-CNN-körning
python run_faster_rcnn.py
Resultaten för träning från slutpunkt till slutpunkt för dagligvaror med AlexNet som basmodell bör se ut ungefär så här:
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
Om du vill visualisera de förutsagda avgränsningsrutorna och etiketterna på bilderna öppnar FasterRCNN_config.py du FasterRCNN från mappen och ställer in
__C.VISUALIZE_RESULTS = True
Bilderna sparas i FasterRCNN/Output/Grocery/ mappen om du kör python run_faster_rcnn.py.
Stegvisa instruktioner
Installation
Om du vill köra koden i det här exemplet behöver du en CNTK Python-miljö (se här för installationshjälp). Installera följande ytterligare paket i din cntk Python-miljö
pip install opencv-python easydict pyyaml
Förkompilerade binärfiler för regression av avgränsningsrutor och icke-maximal undertryckning
Mappen Examples\Image\Detection\utils\cython_modules innehåller förkompilerade binärfiler som krävs för att köra Snabbare R-CNN. De versioner som för närvarande finns på lagringsplatsen är Python 3.5 för Windows och Python 3.5, 3.6 för Linux, alla 64-bitars. Om du behöver en annan version kan du kompilera den enligt stegen som beskrivs i
- Linux: https://github.com/rbgirshick/py-faster-rcnn
- Windows: https://github.com/MrGF/py-faster-rcnn-windows
Kopiera binärfilerna genererade cython_bbox och (och/eller gpu_nms) från $FRCN_ROOT/lib/utils till $CNTK_ROOT/Examples/Image/Detection/utils/cython_modulescpu_nms .
Exempeldata och baslinjemodell
Vi använder en förtränad AlexNet-modell som grund för Faster-R-CNN-träning (för VGG eller andra basmodeller finns i Använda en annan basmodell. Både exempeldatauppsättningen och den förtränade AlexNet-modellen kan laddas ned genom att köra följande Python-kommando från FastRCNN-mappen :
python install_data_and_model.py
- Lär dig hur du använder en annan basmodell
- Lär dig hur du kör Snabbare R-CNN på Pascal VOC-data
- Lär dig hur du kör Snabbare R-CNN på dina egna data
Konfiguration och parametrar
Parametrarna är grupperade i tre delar:
- Detektorparametrar (se
FasterRCNN/FasterRCNN_config.py) - Datauppsättningsparametrar (se till exempel
utils/configs/Grocery_config.py) - Basmodellparametrar (se till exempel
utils/configs/AlexNet_config.py)
De tre delarna läses in och sammanfogas i get_configuration() -metoden i run_faster_rcnn.py. I det här avsnittet går vi igenom detektorparametrarna. Datauppsättningsparametrar beskrivs här, basmodellparametrar här. I följande går vi igenom innehållet FasterRCNN_config.py i uppifrån och ned. Konfigurationen använder paketet EasyDict som ger enkel åtkomst till kapslade ordlistor.
# 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
Det första blocket med parametrar innehåller instruktioner på högre nivå om träningsprocessen. __C.CNTK.TRAIN_E2E gör att du kan välja antingen träningsschemat från slutpunkt till slutpunkt eller 4 steg. Information om de två utbildningssystemen beskrivs här. __C.CNTK.FAST_MODE = True kör bara en enda epok. det är användbart att testa om konfigurationen fungerar och alla parametrar är korrekta. __C.CNTK.DEBUG_OUTPUT = True genererar ytterligare felsökningsmeddelande i konsolens utdata. Den ritar också CNTK-beräkningsdiagram för både tränings- och evalmodellerna (observera kraven för att rita CNTK-grafer). De resulterande graferna lagras i FasterRCNN/Output mappen. __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = True lagrar en andra utvärderingsmodell som endast använder intern kod (inga Python-lager). Den här modellen kan läsas in och utvärderas från C++ eller C# till exempel.
# 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]
Det andra blocket innehåller inlärningsparametrarna. Det här är mestadels vanliga CNTK-inlärningsparametrar. Det enda undantaget är __C.CNTK.BIAS_LR_MULT, som är den inlärningstaktsmultiplikator som används för alla fördomar i nätverket. Det tränar i huvudsak fördomarna med dubbelt så hög nuvarande inlärningshastighet, vilket också görs i den ursprungliga Faster R-CNN-koden. Antalet epoker och inlärningsfrekvens per prov anges separat för de två olika inlärningsschemana (parametrar med fyra steg som utelämnas ovan).
# 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 anger det maximala antalet markanteckningar för sanning per bild. CNTK kräver för närvarande att ange ett maximalt tal. Om det finns färre anteckningar kommer de att fyllas internt. __C.IMAGE_WIDTH och __C.IMAGE_HEIGHT är de dimensioner som används för att ändra storlek på och fylla på indatabilderna. __C.RESULTS_NMS_THRESHOLD är det NMS-tröskelvärde som används för att ignorera överlappande förutsagda avgränsningsrutor i utvärderingen. Ett lägre tröskelvärde ger färre borttagningar och därmed mer förutsagda avgränsningsrutor i de slutliga utdata.
# 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 utökar träningsdata genom att vända alla bilder varannan epok, dvs. den första epoken har alla vanliga bilder, den andra har alla bilder vänt och så vidare. __C.TRAIN_CONV_LAYERS avgör om de convolutional lagren, från indata till den convolutional funktionskartan, ska tränas eller fixas. Fixering av konvexskiktets vikter innebär att vikterna från basmodellen tas och inte ändras under träningen. (Du kan också ange hur många konvade lager du vill träna i avsnittet Använda en annan basmodell). För rpn-parametrarna kan du läsa kommentarerna bredvid deras definition eller läsa det ursprungliga forskningsdokumentet för mer information. Även för följande detektorparametrar:
# 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)
Kör Snabbare R-CNN på Pascal VOC
Kör följande skript för att ladda ned Pascal-data och skapa anteckningsfilerna för Pascal i CNTK-format:
python Examples/Image/DataSets/Pascal/install_pascalvoc.py
python Examples/Image/DataSets/Pascal/mappings/create_mappings.py
dataset_cfg Ändra i get_configuration() -metoden run_faster_rcnn.py för till
from utils.configs.Pascal_config import cfg as dataset_cfg
Nu är du inställd på att träna på Pascal VOC 2007-data med hjälp av python run_faster_rcnn.py. Se upp för att träningen kan ta en stund.
Kör Snabbare R-CNN på dina egna data
Att förbereda dina egna data och kommentera dem med markbaserade sanningsavgränsningsrutor beskrivs i Objektidentifiering med snabb R-CNN. När du har lagrat avbildningarna i den beskrivna mappstrukturen och kommenterat dem kör du
python Examples/Image/Detection/utils/annotations/annotations_helper.py
när du har ändrat mappen i skriptet till din datamapp. Skapa slutligen en MyDataSet_config.py i utils\configs mappen enligt de befintliga exemplen, som i det här kodfragmentet:
...
# 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 används i generate_anchors() (se utils/rpn/generate_anchors.py). Från en basstorlek på 16 tre fästpunkter med proportioner 0.5, 1.0 och 2.0 skapas resulterar i (8 x 24, 16 x 16, 24 x 8). Dessa multipliceras med varje förslagslagerskala som resulterar i nio fästpunkter (64 x 192, ... , 768 x 256). Det här är absoluta pixelkoordinater w.r.t. indatabilden. Alla fästpunkter tillämpas på varje rumslig position på den convolutional funktionskartan för att generera kandidatregioner av intresse. Anpassa de här förslagslagrets skalningar enligt objektstorlekarna i datauppsättningen och den indatabildstorlek som du använder. Till exempel för den datauppsättning för livsmedelsvaror som vi använder __C.DATA.PROPOSAL_LAYER_SCALES = [4, 8, 12] och en indatabildstorlek på 850 x 850 (se utils/configs/Grocery_config.py).
Om du vill träna och utvärdera Snabbare R-CNN på dina data ändrar du dataset_cfg metoden get_configuration()run_faster_rcnn.py för till
from utils.configs.MyDataSet_config import cfg as dataset_cfg
och kör python run_faster_rcnn.py.
Teknisk information
Eftersom de flesta DNN-baserade objektdetektorer använder Snabbare R-CNN överföringsinlärning. Den utgår från en basmodell som är en modell som tränats för bildklassificering. Basmodellen delas in i två delar, den första är alla volutional lager upp till (och exkluderar) det sista poolskiktet och den andra delen är resten av nätverket från (och exklusive) det sista poollagret upp till (återigen exklusive) det slutliga förutsägelseskiktet. Utdata från den första delen kallas ibland för den convolutional funktionskartan. Detta används som indata till roi-poollagret, som utför en poolåtgärd på en del av indatakartan som motsvarar regionförslag i den ursprungliga bilden. Regionförslagen är ett andra bidrag till roi-poollagret. I Snabbare R-CNN genereras dessa förslag av ett litet undernätverk som kallas regionförslagsnätverk (RPN, se nästa avsnitt).
Utdata från roi-poollagret har alltid samma fasta storlek, eftersom alla indata (convolutional feature map + regionförslag) har samma utdatastorlek. Observera att indatastorleken, dvs. storleken på den convolutional featute-kartan och därmed även indatabildens storlek, kan vara godtycklig. För träning använder algoritmen fyra förlustfunktioner, två för RPN och två för detektorn (se även nästa avsnitt). Följande metod finns i FasterRCNN_train.py och visar högnivåkonstruktionen av Modellen Faster R-CNN. FasterRCNN_train.py Se och utils/rpn/rpn_helpers.py för den fullständiga koden.
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
När nätverket har tränats konverteras det till en utvärderingsmodell genom att alla delar som inte krävs för utvärdering tas bort, till exempel förlustfunktionerna. Den slutliga utvärderingsmodellen har tre utdata (se create_faster_rcnn_eval_model() i FasterRCNN_train.py för mer information):
rpn_rois– de absoluta pixelkoordinaterna för kandidat-roiscls_pred- klassannolikheterna för varje ROIbbox_regr- regressionskoefficienterna per klass för varje ROI
Om du vill använda utvärderingsmodellen från Python kan du använda FasterRCNN_Evaluator från FasterRCNN_eval.py. Du kan läsa in modellen en gång och sedan utvärdera enskilda avbildningar när du går. Utvärderarens process_image() metod tar en sökväg till en bild som argument, utvärderar modellen på bilden och tillämpar regressionen för avgränsningsrutan på de resulterande ROI:erna. Den returnerar regresserade ROI:er och motsvarande klassannolikheter:
evaluator = FasterRCNN_Evaluator(model, cfg)
regressed_rois, cls_probs = evaluator.process_image(img_path)
Nätverk för regionförslag
Snabbare R-CNN använder en så kallad netwrok (RPN) för regionförslag som genererar kandidatregioner av intresse (ROIs) baserat på indatabilden. Detta motsätter sig Fast R-CNN som kräver att regionförslag tillhandahålls av en extern källa. RPN bygger i princip upp med tre skikt för decentralisering och ett nytt lager som kallas förslagslager. De nya lagren realiseras som användardefinierad funktion (UDF) i antingen Python eller C++ (se information nedan). Python-koden som skapar RPN i CNTK finns i utils/rpn/rpn_helpers.py, de nya lagren, till exempel förslagsskiktet, finns i utils/rpn mappen.
Indata till RPN är den convolutional funktionskartan, samma som är indata till ROI-poollagret. Dessa indata matas in i det första rpn-skiktet för volution och resultatet sprids till de andra två skikten för decentralisering. En av de senare förutsäger klasspoäng för varje kandidatregion, dvs. för varje fästpunkt vid varje rumslig position (9 fästpunkter x 2 poäng x bredd x höjd). De två poängen konverteras (med en softmax-nod) till objektitetspoäng per kandidat som tolkas som sannolikheten för att en kandidatregion ska innehålla ett förgrundsobjekt eller inte. Det andra convolutional lagret förutsäger regressionskoefficienter för den faktiska positionen för ROI, återigen för varje kandidat (9 fästpunkter x 4 koefficienter x bredd x höjd).
Regressionskoefficienterna och objektitetspoängen (förgrunds- och bakgrundsannolikheter) matas in i förslagsskiktet. Det här lagret tillämpar först regressionskoefficienterna på de genererade fästpunkterna, klipper ut resultatet till bildgränserna och filtrerar ut kandidatregioner som är för små. Den sorterar sedan kandidaterna efter förgrundssannolikhet, tillämpar icke-maximal undertryckning (NMS) för att minska antalet kandidater och tar slutligen exempel på önskat antal ROI:er för dess utdata.
Under träningen kräver Snabbare R-CNN ytterligare två nya lager: ankarmålskiktet och målskiktet för förslaget. Ankarmålskiktet genererar målvärdena för objektitetspoängen och de RPN-regressionskoefficienter som används i förlustfunktionerna i RPN. På samma sätt genererar förslagets målskikt målklassetiketterna för ROIs och målregressionskoefficienterna per klass för den slutliga detektorn som används i detektorns förlustfunktioner.
Under utvärderingen krävs endast förslagsskiktet (eftersom inga mål för förlustfunktioner behövs). Förslagsskiktet i CNTK är tillgängligt i Python och C++. Målskikten är för närvarande endast tillgängliga i Python. Därför måste du träna Snabbare R-CNN för närvarande från Python-API:et. Lagra en utvärderingsmodell efter träning som använder den interna implementeringsuppsättningen __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = Trueför förslagslager .
Läsare och minibatchkälla
När vi skalar bilder eller vänder bilder för dataförstoring måste vi även tillämpa samma transformeringar på de grundläggande sanningsanteckningarna. (Flipping måste också tillämpas på cachelagrade förslag i 4-stegsträning, se nästa avsnitt.) Eftersom dessa kopplade omvandlingar av bilder och anteckningar för närvarande inte stöds av de inbyggda CNTK-läsarna använder vi en anpassad Python-läsare och en UserMinibatchSource för Snabbare R-CNN. Dessa finns i utils/od_reader.py respektive utils/od_mb_source.py .
E2E- och 4-stegsträning
Forskningsartikeln Faster R-CNN beskriver två metoder för att träna nätverket. Träning från slutpunkt till slutpunkt tränar hela nätverket i en enda träning med hjälp av alla fyra förlustfunktionen (rpn regressionsförlust, rpn objectness loss, detector regression loss, detector class loss). Vi använder träning från slutpunkt till slutpunkt som standard. Du kan välja mellan de två genom att ange __C.CNTK.TRAIN_E2E i FasterRCNN_config.py.
Utbildningsschemat i fyra steg växlar mellan att endast träna nätverket för regionförslag (hålla detektorn fast) och träna endast detektorn (fastställa RPN-vikterna). Det här utbildningsprogrammet implementeras i i train_faster_rcnn_alternating()FasterRCNN_train.py. Den är något mer detaljerad och använder ofta kloningsdelar av modellen för att möjliggöra frysning och träningsvikter selektivt. I 4-stegsutbildning buffras också förslagen från RPN efter steg ett och tre och används i det efterföljande skedet.
Använda en annan basmodell
Om du vill använda en annan basmodell måste du välja en annan modellkonfiguration i get_configuration() metoden run_faster_rcnn.py. Två modeller stöds direkt:
# 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
Om du vill ladda ned VGG16-modellen använder du nedladdningsskriptet i <cntkroot>/PretrainedModels:
python download_model.py VGG16_ImageNet_Caffe
Om du vill använda en annan basmodell måste du till exempel kopiera konfigurationsfilen utils/configs/VGG16_config.py och ändra den enligt basmodellen:
# 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
Om du vill undersöka nodnamnen för basmodellen kan du använda plot() metoden från cntk.logging.graph. Observera att ResNet-modeller för närvarande inte stöds eftersom roi-poolning i CNTK ännu inte stöder roi-genomsnittlig poolning.