Detekce objektů pomocí rychlejšího R-CNN
Obsah
Souhrn
Výše uvedené příklady jsou obrázky a poznámky k objektům pro sadu dat potravin (vlevo) a sadu dat Pascal VOC (vpravo) použitou v tomto kurzu.
Rychlejší R-CNN je algoritmus detekce objektů navržený Shaoqing Ren, Kaiming He, Ross Girshick a Jian Sun v roce 2015. Výzkumná práce se jmenuje "Rychlejší R-CNN: Směrem k Real-Time detekci objektů pomocí sítí návrhu oblasti" a archivuje se na https://arxiv.org/abs/1506.01497adrese . Rychlejší R-CNN vychází z předchozí práce, která efektivně klasifikuje návrhy objektů pomocí hlubokých konvolučních sítí. V porovnání s předchozí prací využívá rychlejší síť návrhu oblasti sítě R-CNN a nevyžaduje externí metodu pro návrhy kandidátských oblastí.
Tento kurz je strukturovaný do tří hlavních částí. První část obsahuje stručný popis toho, jak spustit rychlejší R-CNN v CNTK na zadané ukázkové datové sadě. Druhá část obsahuje podrobnosti o všech krocích, včetně nastavení a parametrizace služby Faster R-CNN. Poslední část popisuje technické podrobnosti algoritmu a sítě návrhu oblasti, čtení a rozšiřování vstupních dat a také různé možnosti trénování pro rychlejší R-CNN.
Rychlý start
Tato část předpokládá, že máte systém nastavený tak, aby používal rozhraní API Pythonu CNTK. Dále předpokládáme, že používáte Python 3.5 ve Windows nebo 3.5/3.6 v Linuxu. Podrobný postup najdete v podrobných pokynech. Pokud chcete spustit rychlejší R-CNN, nainstalujte následující další balíčky do prostředí Pythonu cntk.
pip install opencv-python easydict pyyaml
Spuštění ukázky toy
Používáme datovou sadu obrázků zachycených z ledničky k předvedení rychlejšího R-CNN (totéž jako u příkladu Fast R-CNN). Datovou sadu i předem vytrénovaný model AlexNet si můžete stáhnout spuštěním následujícího příkazu Pythonu ze složky Příklady/ Obrázek/Detekce/FastRCNN:
python install_data_and_model.py
Po spuštění skriptu se datová sada toy nainstaluje do Examples/Image/DataSets/Grocery složky. Model AlexNet se stáhne do PretrainedModels složky.
Doporučujeme zachovat stažená data v příslušné složce, protože konfigurační soubory ve výchozím nastavení předpokládají, že umístění.
Trénování a vyhodnocení rychlejšího spuštění R-CNN
python run_faster_rcnn.py
Výsledky kompletního trénování pro potraviny s využitím AlexNetu by měly vypadat podobně jako základní model:
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
Vizualizace předpovězených ohraničujících polí a popisků na obrázcích otevřených FasterRCNN_config.py ze FasterRCNN složky a nastavení
__C.VISUALIZE_RESULTS = True
Obrázky se uloží do FasterRCNN/Output/Grocery/ složky, pokud spustíte python run_faster_rcnn.py.
Podrobné pokyny
Nastavení
Ke spuštění kódu v tomto příkladu potřebujete prostředí Pythonu CNTK ( nápovědu k nastavení najdete tady ). Nainstalujte do prostředí Pythonu cntk následující další balíčky.
pip install opencv-python easydict pyyaml
Předkompilované binární soubory pro regresi ohraničujícího rámečku a ne maximální potlačení
Složka Examples\Image\Detection\utils\cython_modules obsahuje předem zkompilované binární soubory, které jsou potřeba pro spuštění služby Faster R-CNN. Verze, které jsou aktuálně obsaženy v úložišti, jsou Python 3.5 pro Windows a Python 3.5, 3.6 pro Linux, všechny 64bitové verze. Pokud potřebujete jinou verzi, můžete ji zkompilovat podle kroků popsaných v části
- Linux: https://github.com/rbgirshick/py-faster-rcnn
- Windows: https://github.com/MrGF/py-faster-rcnn-windows
Zkopírujte vygenerované cython_bbox a (nebo gpu_nmscpu_nms ) binární soubory od $FRCN_ROOT/lib/utils do $CNTK_ROOT/Examples/Image/Detection/utils/cython_modules.
Příklad modelu dat a směrného plánu
Jako základ pro trénování rychlejšího R-CNN používáme předem natrénovaný model AlexNet (pro VGG nebo jiné základní modely viz Použití jiného základního modelu. Ukázkovou datovou sadu i předem natrénovaný model AlexNet je možné stáhnout spuštěním následujícího příkazu Pythonu ze složky FastRCNN :
python install_data_and_model.py
- Naučte se používat jiný základní model.
- Zjistěte, jak spouštět rychlejší R-CNN v datech Pascal VOC
- Naučte se spouštět rychlejší R-CNN na vlastních datech.
Konfigurace a parametry
Parametry jsou seskupené do tří částí:
- Parametry detektoru (viz
FasterRCNN/FasterRCNN_config.py) - Parametry sady dat (viz příklad
utils/configs/Grocery_config.py) - Parametry základního modelu (viz příklad
utils/configs/AlexNet_config.py)
Tři části jsou načteny a sloučeny v get_configuration() metodě v run_faster_rcnn.py. V této části probereme parametry detektoru. Parametry sady dat jsou zde popsané, tady jsou parametry základního modelu. V následujícím příkladu procházíme obsahem FasterRCNN_config.py shora dolů. Konfigurace používá EasyDict balíček, který umožňuje snadný přístup k vnořeným slovníkům.
# 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
První blok parametrů obsahuje pokyny vyšší úrovně týkající se trénovacího procesu. __C.CNTK.TRAIN_E2E umožňuje vybrat komplexní nebo 4fázové schéma trénování. Podrobnosti o těchto dvou schématech školení jsou popsány tady. __C.CNTK.FAST_MODE = True spouští pouze jednu epochu; Je užitečné otestovat, jestli nastavení funguje a všechny parametry jsou správné. __C.CNTK.DEBUG_OUTPUT = True vygeneruje další zprávu ladění ve výstupu konzoly. Také vykresluje grafy výpočtů CNTK pro trénovací i evalové modely (všimněte si požadavků na vykreslení grafů CNTK). Výsledné grafy jsou uložené ve FasterRCNN/Output složce. __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = True uloží druhý model vyhodnocení, který používá pouze nativní kód (žádné vrstvy Pythonu). Tento model je možné načíst a vyhodnotit například z jazyka C++ nebo C#.
# 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]
Druhý blok obsahuje parametry výuky. Jedná se většinou o běžné parametry učení CNTK. Jedinou výjimkou je , což je __C.CNTK.BIAS_LR_MULTnásobitel rychlosti učení, který se používá pro všechny biase v síti. V podstatě trénuje biase s dvakrát aktuální četností učení, která se provádí také v původním kódu Faster R-CNN. Počet epoch a četnost učení na výběr se specifikuje samostatně pro dvě různá schémata učení (4fázové parametry vynechány výše).
# 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 určuje maximální počet poznámek základní pravdy na obrázek. CNTK v současné době vyžaduje nastavení maximálního počtu. Pokud existuje méně poznámek, budou se interně vkládat. __C.IMAGE_WIDTH a __C.IMAGE_HEIGHT jsou rozměry, které slouží ke změně velikosti a vkládání vstupních obrázků. __C.RESULTS_NMS_THRESHOLD je prahová hodnota NMS, která se používá k zahození překrývajících se předpovězených ohraničovaných polí při vyhodnocování. Nižší prahová hodnota přináší méně odebrání a tím více předpověděných ohraničovacích polí v konečném výstupu.
# 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 rozšíří trénovací data tak, že překlopí všechny obrázky každé druhé epochy, tj. první epocha obsahuje všechny běžné obrázky, druhý má všechny obrázky překlopené atd. __C.TRAIN_CONV_LAYERS určuje, zda budou konvoluční vrstvy od vstupu do konvoluční mapy funkcí natrénovány nebo opraveny. Oprava hmotností konvové vrstvy znamená, že váhy ze základního modelu se při trénování neupravují a neupravují. (Můžete také určit, kolik vrstev konv chcete trénovat, viz část Použití jiného základního modelu). Parametry rpn najdete v komentářích vedle jejich definování nebo si projděte původní výzkumné materiály, kde najdete další podrobnosti. Také pro následující parametry detektoru:
# 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)
Rychlejší spuštění R-CNN na Pascal VOC
Pokud chcete stáhnout data Pascalu a vytvořit soubory poznámek pro Pascal ve formátu CNTK, spusťte následující skripty:
python Examples/Image/DataSets/Pascal/install_pascalvoc.py
python Examples/Image/DataSets/Pascal/mappings/create_mappings.py
dataset_cfg Změna metody get_configuration()run_faster_rcnn.py na
from utils.configs.Pascal_config import cfg as dataset_cfg
Teď jste nastaveni na trénování dat Pascal VOC 2007 pomocí python run_faster_rcnn.py. Mějte na pozor, že trénování může nějakou dobu trvat.
Spouštění rychlejšího R-CNN na vlastních datech
Příprava vlastních dat a jejich přidávání poznámek k uzemně ohraničujícími rámečky pravdy je popsána v rozpoznávání objektů pomocí rychlého připojení R-CNN. Po uložení obrázků do popsané struktury složek a jejich přidávání poznámek spusťte
python Examples/Image/Detection/utils/annotations/annotations_helper.py
po změně složky v daném skriptu na složku s daty. Nakonec vytvořte MyDataSet_config.py ve utils\configs složce následující existující příklady jako v tomto fragmentu kódu:
...
# 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 používá v generate_anchors() (viz utils/rpn/generate_anchors.py). Počínaje základní velikostí 16 tří ukotvení s poměry 0.5, 1.0 stran a 2.0 vytvoří se (8 x 24, 16 x 16, 24 x 8). Tyto hodnoty se vynásobí každým měřítkem vrstvy návrhu, což vede k devíti ukotvení (64 x 192... , 768 x 256). Jedná se o absolutní souřadnice pixelů w.r.t. vstupního obrázku. Všechny kotvy se použijí na každé prostorové pozici konvoluční mapy funkcí, aby se vygenerovaly kandidátské oblasti zájmu. Přizpůsobte tato měřítka vrstvy návrhu podle velikostí objektů v datové sadě a velikosti vstupního obrázku, kterou používáte. Například pro datovou sadu potravin používáme __C.DATA.PROPOSAL_LAYER_SCALES = [4, 8, 12] a vstupní velikost obrázku 850 x 850 (viz).utils/configs/Grocery_config.py
Trénování a vyhodnocení rychlejšího R-CNN u dat změní metodu dataset_cfgget_configuration()run_faster_rcnn.py na
from utils.configs.MyDataSet_config import cfg as dataset_cfg
a spusťte python run_faster_rcnn.py.
Technické podrobnosti
Protože většina detektorů objektů založených na DNN rychlejší R-CNN používá předávací učení. Začíná ze základního modelu, který je model natrénovaný pro klasifikaci obrázků. Základní model je rozdělený na dvě části, první z nich je všechny konvoluční vrstvy až do poslední vrstvy sdružování (a s výjimkou) poslední vrstvy sdružování a druhá část je zbytek sítě ze (a s výjimkou) poslední vrstvy sdružování až (opět s výjimkou) poslední predikční vrstvy. Výstup první části se někdy označuje jako konvoluční mapa funkcí. Používá se jako vstup do vrstvy sdružování roi, která provádí operaci sdružování na části vstupní mapy, která odpovídá návrhům oblastí na původním obrázku. Návrhy oblastí představují druhý vstup do vrstvy sdružování roi. V případě rychlejšího R-CNN tyto návrhy generuje malá podsítě s názvem síť pro návrh oblasti (RPN, viz další část).
Výstup vrstvy sdružování roi bude mít vždy stejnou pevnou velikost, protože do fondu všech vstupů (konvoluční mapování funkcí + návrh oblasti) se stejnou velikostí výstupu. Všimněte si, že vstupní velikost, tj. velikost konvolučního featute mapy, a proto i vstupní velikost obrázku, může být libovolná. Pro trénování algoritmu používá čtyři ztrátové funkce, dvě pro RPN a dvě pro detektor (viz také další část). Následující metoda je obsažena FasterRCNN_train.py a ukazuje vysokou úroveň konstrukce modelu Faster R-CNN. Projděte si FasterRCNN_train.py úplný kód a utils/rpn/rpn_helpers.py projděte si ho.
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
Po trénování sítě se převede na model vyhodnocení odebráním všech částí, které nejsou nutné pro vyhodnocení, například funkce ztráty. Konečný model vyhodnocení má tři výstupy (další podrobnosti najdete create_faster_rcnn_eval_model() tady FasterRCNN_train.py ):
rpn_rois- absolutní pixelové souřadnice kandidáta roiscls_pred- pravděpodobnosti tříd pro každou roibbox_regr- regresní koeficienty na třídu pro každou ROI
Pokud chcete použít zkušební model z Pythonu, můžete použít FasterRCNN_EvaluatorFasterRCNN_eval.py Model můžete načíst jednou a pak při přechodu vyhodnotit jednotlivé image. Metoda process_image() vyhodnocovače vezme cestu k obrázku jako argument, vyhodnotí model na tomto obrázku a použije regresi ohraničujícího rámečku na výsledné roI. Vrátí regresní roI a odpovídající pravděpodobnosti třídy:
evaluator = FasterRCNN_Evaluator(model, cfg)
regressed_rois, cls_probs = evaluator.process_image(img_path)
Síť návrhu oblasti
Rychlejší R-CNN používá tzv. netwrok ( RPN) návrh oblasti, který generuje kandidátské oblasti zájmu (ROI) na základě vstupního obrázku. Toto je rozdíl oproti rychlému R-CNN, který vyžaduje, aby byly návrhy oblastí poskytovány externím zdrojem. RPN je v podstatě sestavena třemi konvolučními vrstvami a novou vrstvou označovanou jako vrstva návrhu. Nové vrstvy jsou realizovány jako uživatelem definovaná funkce (UDF) v Pythonu nebo C++ (viz podrobnosti níže). Kód Pythonu, který vytvoří RPN v CNTK, je v utils/rpn/rpn_helpers.py, nové vrstvy, jako je například vrstva návrhu utils/rpn , jsou všechny ve složce.
Vstupem do rpN je konvoluční mapa funkcí, která je stejná jako vstup do vrstvy sdružování ROI. Tento vstup se předává do první konvoluční vrstvy RPN a výsledek se rozšíří do dalších dvou konvolučních vrstev. Jeden z nich předpovídá skóre tříd pro každou kandidátské oblasti, tj. pro každou kotvu na každé prostorové pozici (9 ukotvení x 2 skóre x šířka x výška). Dvě skóre jsou převedena (pomocí uzlu softmax) na skóre objektu na kandidáta , které jsou interpretovány jako pravděpodobnost kandidátské oblasti, aby obsahovala objekt popředí nebo ne. Druhá konvoluční vrstva předpovídá regresní koeficienty pro skutečnou pozici ROI znovu pro každého kandidáta (9 ukotvení x 4 koeficientů x šířka x výška).
Regresní koeficienty a skóre objektnosti (popředí a pravděpodobnosti na pozadí) se předávají do vrstvy návrhu. Tato vrstva nejprve použije regresní koeficienty na vygenerované ukotvení, vystřižuje výsledek na hranice obrázků a vyfiltruje kandidátské oblasti, které jsou příliš malé. Potom seřadí kandidáty podle pravděpodobnosti popředí, použije non-maximum potlačení (NMS) ke snížení počtu kandidátů a nakonec vzorkuje požadovaný počet ROI pro jeho výstup.
Během trénování Rychlejší R-CNN vyžaduje dvě další nové vrstvy: cílovou vrstvu ukotvení a cílovou vrstvu návrhu. Cílová vrstva ukotvení vygeneruje cílové hodnoty pro skóre objektnosti a regresní koeficienty RPN, které se používají ve ztrátových funkcích RPN. Podobně cílová vrstva návrhu generuje popisky cílové třídy pro ROI a cílové regresní koeficienty na třídu pro konečný detektor, které se používají ve ztrátových funkcích detektoru.
Během vyhodnocení se vyžaduje pouze vrstva návrhu (protože nejsou potřeba žádné cíle pro ztrátové funkce). Vrstva návrhu v CNTK je dostupná v Pythonu i C++, cílové vrstvy jsou aktuálně dostupné jenom v Pythonu. Proto se trénování rychlejšího R-CNN musí v současné době provádět z rozhraní PYTHON API. Uložení zkušebního modelu po trénování, který používá nativní sadu __C.STORE_EVAL_MODEL_WITH_NATIVE_UDF = Trueimplementace vrstvy návrhu .
Čtenář a zdroj minibatch
Při škálování obrázků nebo překlopení obrázků pro rozšíření dat musíme použít stejné transformace i na základní poznámky pravdy. (Překlopení se také musí použít u návrhů uložených v mezipaměti v 4fázovém trénování, viz další část.) Vzhledem k tomu, že tyto spojené transformace obrázků a poznámek nejsou v současné době podporovány integrovanými čtečkami CNTK, používáme vlastní čtečku Pythonu a pro UserMinibatchSource rychlejší R-CNN. Jsou obsaženy v utils/od_reader.py uvedeném utils/od_mb_source.py pořadí.
E2E a 4fázové trénování
Výzkumná práce s R-CNN popisuje dvě metody trénováním sítě. Kompletní trénování trénuje celou síť v jednom trénování pomocí všech čtyř ztrátových funkcí (ztráta regrese rpn, ztráta objektů rpn, ztráta regrese detektoru, ztráta třídy detektoru). Ve výchozím nastavení používáme kompletní trénování, můžete mezi nimi zvolit nastavením __C.CNTK.TRAIN_E2E odpovídajícím způsobem .FasterRCNN_config.py
4fázové trénovací schéma se střídá mezi trénováním pouze sítě návrhu oblasti (udržování detektoru pevně) a trénováním pouze detektoru (oprava hmotností RPN). Toto schéma školení je implementováno v train_faster_rcnn_alternating() systému FasterRCNN_train.py. Je trochu složitější a často využívá klonování částí modelu k selektivnímu zamrznutí a trénování hmotností. V 4fázovém trénování se návrhy z RPN ukládají do vyrovnávací paměti po fázích jedna a tři a používají se v následující fázi.
Použití jiného základního modelu
Chcete-li použít jiný základní model, musíte zvolit jinou konfiguraci modelu v get_configuration() metodě run_faster_rcnn.py. Hned se podporují dva modely:
# 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
Ke stažení modelu VGG16 použijte skript pro stažení v :<cntkroot>/PretrainedModels
python download_model.py VGG16_ImageNet_Caffe
Pokud chcete použít jiný základní model, musíte zkopírovat například konfigurační soubor utils/configs/VGG16_config.py a upravit ho podle základního modelu:
# 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
Pokud chcete prozkoumat názvy uzlů základního modelu, můžete použít metodu plot() z cntk.logging.graph. Upozorňujeme, že modely ResNet se v současné době nepodporují, protože sdružování roi v CNTK zatím nepodporuje průměrné sdružování roi.