def Add_Original_CIFAR10_Model(model, data, num_classes, image_height, image_width, image_channels, save_png=True): conv1 = brew.conv(model, data, 'conv1', dim_in=image_channels, dim_out=32, kernel=5, stride=1, pad=2) h, w = update_dims(height=image_height, width=image_width, kernel=5, stride=1, pad=2) pool1 = brew.max_pool(model, conv1, 'pool1', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) relu1 = brew.relu(model, pool1, 'relu1') conv2 = brew.conv(model, relu1, 'conv2', dim_in=32, dim_out=32, kernel=5, stride=1, pad=2) h, w = update_dims(height=h, width=w, kernel=5, stride=1, pad=2) relu2 = brew.relu(model, conv2, 'relu2') pool2 = brew.average_pool(model, relu2, 'pool2', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) conv3 = brew.conv(model, pool2, 'conv3', dim_in=32, dim_out=64, kernel=5, stride=1, pad=2) h, w = update_dims(height=h, width=w, kernel=5, stride=1, pad=2) relu3 = brew.relu(model, conv3, 'relu3') pool3 = brew.average_pool(model, relu3, 'pool3', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) fc1 = brew.fc(model, pool3, 'fc1', dim_in=64 * h * w, dim_out=64) fc2 = brew.fc(model, fc1, 'fc2', dim_in=64, dim_out=num_classes) softmax = brew.softmax(model, fc2, 'softmax') if save_png: graph = net_drawer.GetPydotGraph(model.net, rankdir="LR") graph.write_png("CIFAR10_Model.png") return softmax
def create_resnet( model, data, num_input_channels, num_groups, num_labels, device_opts, is_test=False, ): with core.DeviceScope(device_opts): filters = [16, 32, 64] brew.conv(model, data, 'conv1', num_input_channels, filters[0], no_bias=1, kernel=3, stride=1, pad=1) builder = ResNetBuilder(model, 'conv1', no_bias=1, is_test=is_test) # input: 32x32x16 output: 32x32x16 for _ in range(num_groups): builder.add_simple_block(filters[0], filters[0], down_sampling=False) # input: 32x32x16 output: 16x16x32 builder.add_simple_block(filters[0], filters[1], down_sampling=True) for _ in range(1, num_groups): builder.add_simple_block(filters[1], filters[1], down_sampling=False) # input: 16x16x32 output: 8x8x64 builder.add_simple_block(filters[1], filters[2], down_sampling=True) for _ in range(1, num_groups): builder.add_simple_block(filters[2], filters[2], down_sampling=False) brew.spatial_bn(model, builder.prev_blob, 'last_spatbn', filters[2], epsilon=1e-3, is_test=is_test) brew.relu(model, 'last_spatbn', 'last_relu') # Final layers brew.average_pool(model, 'last_relu', 'final_avg', kernel=8, stride=1) last_out = brew.fc(model, 'final_avg', 'last_out', 64, num_labels) return last_out
def create_resnet20(model, data, num_input_channels=3, num_labels=10, is_test=False): ''' Create residual net for cifar-10/100 num_groups = 3 ''' # conv1 + maxpool, input=32x32x3, output=32x32x16 brew.conv(model, data, 'conv1', num_input_channels, 16, kernel=3, stride=1) brew.spatial_bn(model, 'conv1', 'conv1_spatbn', 16, epsilon=1e-3, is_test=is_test) brew.relu(model, 'conv1_spatbn', 'relu1') builder = ResNet20Builder(model, 'relu1', is_test=is_test) # conv2, output=32x32x16 builder.add_simple_block(16, 16) builder.add_simple_block(16, 16) builder.add_simple_block(16, 16) #conv3, output=16x16x32 builder.add_simple_block(16, 32, down_sampling=True) builder.add_simple_block(32, 32) builder.add_simple_block(32, 32) #conv4, output=8x8x64 builder.add_simple_block(32, 64, down_sampling=True) builder.add_simple_block(64, 64) builder.add_simple_block(64, 64) # avg_pool output=1x1, 64 brew.average_pool(model, builder.prev_blob, 'final_avg', kernel=8, stride=1) # fc layer output=1x1x(num_labels) brew.fc(model, 'final_avg', 'last_out', 64, num_labels) softmax = brew.softmax(model, 'last_out', 'softmax') return softmax
def add_cnn_model_1(model, data, num_classes, image_height, image_width, image_channels): conv1 = brew.conv(model, data, 'conv1', dim_in=image_channels, dim_out=32, kernel=5, stride=1, pad=2) h, w = update_dims(height=image_height, width=image_width, kernel=5, stride=1, pad=2) pool1 = brew.max_pool(model, conv1, 'pool1', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) relu1 = brew.relu(model, pool1, 'relu1') conv2 = brew.conv(model, relu1, 'conv2', dim_in=32, dim_out=32, kernel=5, stride=1, pad=2) h, w = update_dims(height=h, width=w, kernel=5, stride=1, pad=2) relu2 = brew.relu(model, conv2, 'relu2') pool2 = brew.average_pool(model, relu2, 'pool2', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) conv3 = brew.conv(model, pool2, 'conv3', dim_in=32, dim_out=64, kernel=5, stride=1, pad=2) h, w = update_dims(height=h, width=w, kernel=5, stride=1, pad=2) relu3 = brew.relu(model, conv3, 'relu3') pool3 = brew.average_pool(model, relu3, 'pool3', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) fc1 = brew.fc(model, pool3, 'fc1', dim_in=64 * h * w, dim_out=64) fc2 = brew.fc(model, fc1, 'fc2', dim_in=64, dim_out=num_classes) softmax = brew.softmax(model, fc2, 'softmax') return softmax
def _add_compact_bilinear_pooling(model, config, bottom1, bottom2, sum_pool=True): # one more GAP bottom1_gap = brew.average_pool( model, bottom1, 'bottom1_gap', kernel=config['model_arch']['last_conv_size'], stride=1, ) bottom2_gap = brew.average_pool( model, bottom2, 'bottom2_gap', kernel=config['model_arch']['last_conv_size'], stride=1, ) # fc3 att1 = brew.fc( model, bottom1_gap, 'att1', dim_in=config['model_arch']['feature_dim'], dim_out=config['model_arch']['compact_dim'], ) att2 = brew.fc( model, bottom2_gap, 'att2', dim_in=config['model_arch']['feature_dim'], dim_out=config['model_arch']['compact_dim'], ) cbp_feature = model.net.Add( [att1, att2], ['cbp_feature'], broadcast=1, axis=0, ) return cbp_feature
def create_resnet_32x32(model, data, num_input_channels, num_groups, num_labels, is_test=False): ''' Create residual net for smaller images (sec 4.2 of He et. al (2015)) num_groups = 'n' in the paper ''' # conv1 + maxpool brew.conv(model, data, 'conv1', num_input_channels, 16, kernel=3, stride=1) brew.spatial_bn(model, 'conv1', 'conv1_spatbn', 16, epsilon=1e-3, is_test=is_test) brew.relu(model, 'conv1_spatbn', 'relu1') # Number of blocks as described in sec 4.2 filters = [16, 32, 64] builder = ResNetBuilder(model, 'relu1', is_test=is_test) prev_filters = 16 for groupidx in range(0, 3): for blockidx in range(0, 2 * num_groups): builder.add_simple_block( prev_filters if blockidx == 0 else filters[groupidx], filters[groupidx], down_sampling=(True if blockidx == 0 and groupidx > 0 else False)) prev_filters = filters[groupidx] # Final layers brew.average_pool(model, builder.prev_blob, 'final_avg', kernel=8, stride=1) brew.fc(model, 'final_avg', 'last_out', 64, num_labels) softmax = brew.softmax(model, 'last_out', 'softmax') return softmax
def create_resnet_32x32( model, data, num_input_channels, num_groups, num_labels, is_test=False ): ''' Create residual net for smaller images (sec 4.2 of He et. al (2015)) num_groups = 'n' in the paper ''' # conv1 + maxpool brew.conv( model, data, 'conv1', num_input_channels, 16, kernel=3, stride=1 ) brew.spatial_bn( model, 'conv1', 'conv1_spatbn', 16, epsilon=1e-3, is_test=is_test ) brew.relu(model, 'conv1_spatbn', 'relu1') # Number of blocks as described in sec 4.2 filters = [16, 32, 64] builder = ResNetBuilder(model, 'relu1', is_test=is_test) prev_filters = 16 for groupidx in range(0, 3): for blockidx in range(0, 2 * num_groups): builder.add_simple_block( prev_filters if blockidx == 0 else filters[groupidx], filters[groupidx], down_sampling=(True if blockidx == 0 and groupidx > 0 else False)) prev_filters = filters[groupidx] # Final layers brew.average_pool( model, builder.prev_blob, 'final_avg', kernel=8, stride=1 ) brew.fc(model, 'final_avg', 'last_out', 64, num_labels) softmax = brew.softmax(model, 'last_out', 'softmax') return softmax
def add_resnet20_conv_topk_list(model, data, **kwargs): ''' Based on original ResNet20 network structure, according to meProp, we add topk gradient selecting layer for conv layers ''' # resolving arguments config = kwargs.get('config', {}) ks = kwargs.get('k', [10, 10, 10, 10]) # hard-coded topk for resnet20 groups assert(type(ks) is list) is_test = kwargs.get('is_test', False) # construct models # Image size: 32 x 32 -> 32 x 32 first_conv_relu = input_block_conv_topk(model, data, 3, 16, 3, 1, 1, topk=ks[0], is_test=is_test) # Image size: 32 x 32 -> 32 x 32 group_0 = res_module_conv_topk(model, first_conv_relu, 16, 16, topk=ks[1], module_seq="0", block_list=[2, 2, 2]) # Image size: 32 x 32 -> 16 x 16 group_1 = res_module_conv_topk(model, group_0, 16, 32, topk=ks[2], module_seq="1", block_list=[1, 2, 2]) # Image size: 16 x 16 -> 8 x 8 group_2 = res_module_conv_topk(model, group_1, 32, 64, topk=ks[3], module_seq="2", block_list=[1, 2, 2]) # predicting pool = brew.average_pool( model, group_2, 'pool', kernel=config['model_arch']['last_conv_size'], stride=1, ) pred = brew.fc( model, pool, 'pred', dim_in=64, dim_out=config['model_arch']['num_classes'], ) softmax = brew.softmax(model, pred, 'softmax') return softmax
def add_avg_pool(self, prev_blob, kernel=3, stride=1, pad=1, global_pool=False): self.prev_blob = brew.average_pool( self.model, prev_blob, '%s_avg_pool_%d' % (self.block_name, self.layer_num), kernel=kernel, stride=stride, pad=pad, global_pooling=global_pool, ) self.layer_num += 1 return self.prev_blob
def add_resnet50(model, data, is_test=False): ''' construct resnet50 net ''' pool_1 = input_block(model, data, 3, 64, 7, 3, 2, no_bias=False, is_test=is_test) module_2 = res_module(model, pool_1, 64, 64, 256, 1, 0, 1, no_bias=True, is_test=is_test, module_seq='res2', sub_num=3) module_3 = res_module(model, module_2, 256, 128, 512, 1, 0, 2, no_bias=True, is_test=is_test, module_seq='res3', sub_num=4) module_4 = res_module(model, module_3, 512, 256, 1024, 1, 0, 2, no_bias=True, is_test=is_test, module_seq='res4', sub_num=6) module_5 = res_module(model, module_4, 1024, 512, 2048, 1, 0, 2, no_bias=True, is_test=is_test, module_seq='res5', sub_num=3) pool_5 = brew.average_pool(model, module_5, 'pool5', kernel=7, stride=1) pred = brew.fc(model, pool5, 'pred', dim_in=2048, dim_out=1000) softmax = brew.softmax(model, pred, 'softmax') return softmax
def AddLeNetModel(model, data): h = conv_bn(model, data, 3, 32, stride=2, name='conv_bn') h = conv_dw(model, h, 32, 64, stride=1, name='conv_ds_2') h = conv_dw(model, h, 64, 128, stride=2, name='conv_ds_3') h = conv_dw(model, h, 128, 128, stride=1, name='conv_ds_4') h = conv_dw(model, h, 128, 256, stride=2, name='conv_ds_5') h = conv_dw(model, h, 256, 256, stride=1, name='conv_ds_6') h = conv_dw(model, h, 256, 512, stride=2, name='conv_ds_7') h = conv_dw(model, h, 512, 512, stride=1, name='conv_ds_8') h = conv_dw(model, h, 512, 512, stride=1, name='conv_ds_9') h = conv_dw(model, h, 512, 512, stride=1, name='conv_ds_10') h = conv_dw(model, h, 512, 512, stride=1, name='conv_ds_11') h = conv_dw(model, h, 512, 512, stride=1, name='conv_ds_12') h = conv_dw(model, h, 512, 1024, stride=2, name='conv_ds_13') h = conv_dw(model, h, 1024, 1024, stride=1, name='conv_ds_14') h = brew.average_pool(model, h, 'pool5', kernel=7) softmax = brew.softmax(model, h, 'softmax') return softmax
def add_resnet50_finetune(model, data, num_class=2, is_test=False): ''' construct resnet50 net for finetune default remove last fc ''' pool_1 = input_block(model, data, 3, 64, 7, 3, 2, no_bias=False, is_test=is_test) module_2 = res_module(model, pool_1, 64, 64, 256, 1, 0, 1, no_bias=True, is_test=is_test, module_seq='res2', sub_num=3) module_3 = res_module(model, module_2, 256, 128, 512, 1, 0, 2, no_bias=True, is_test=is_test, module_seq='res3', sub_num=4) module_4 = res_module(model, module_3, 512, 256, 1024, 1, 0, 2, no_bias=True, is_test=is_test, module_seq='res4', sub_num=6) module_5 = res_module(model, module_4, 1024, 512, 2048, 1, 0, 2, no_bias=True, is_test=is_test, module_seq='res5', sub_num=3) pool_5 = brew.average_pool(model, module_5, 'pool5', kernel=7, stride=1) # finetune part finetune_fc = brew.fc(model, pool_5, 'finetune_fc', dim_in=2048, dim_out=num_class) softmax = brew.softmax(model, finetune_fc, 'softmax') return softmax
def _add_model(model, config, data, is_test=False): # add back-bone network (resnet-50 with last conv) bottom_feature = add_resnet50_core(model, data, is_test=is_test) gap_feature = brew.average_pool( model, bottom_feature, 'gap_feature', kernel=config['model_arch']['last_conv_size'], stride=1) # add prediction for classification pred = brew.fc( model, gap_feature, 'bi_attention_pred', dim_in=config['model_arch']['feature_dim'], dim_out=config['model_arch']['num_classes'], ) return pred
def add_resnet20(model, data, **kwargs): ''' This part is the standard ResNet20 model: from data to the softmax prediction. ''' # resolving arguments config = kwargs.get('config', {}) is_test = kwargs.get('is_test', False) # construct models # Image size: 32 x 32 -> 32 x 32 first_conv_relu = input_block(model, data, 3, 16, 3, 1, 1, is_test=is_test) # Image size: 32 x 32 -> 32 x 32 group_0 = res_module(model, first_conv_relu, 16, 16, module_seq="0", block_list=[2, 2, 2]) # Image size: 32 x 32 -> 16 x 16 group_1 = res_module(model, group_0, 16, 32, module_seq="1", block_list=[1, 2, 2]) # Image size: 16 x 16 -> 8 x 8 group_2 = res_module(model, group_1, 32, 64, module_seq="2", block_list=[1, 2, 2]) # predicting pool = brew.average_pool( model, group_2, 'pool', kernel=config['model_arch']['last_conv_size'], stride=1, ) pred = brew.fc( model, pool, 'pred', dim_in=64, dim_out=config['model_arch']['num_classes'], ) softmax = brew.softmax(model, pred, 'softmax') return softmax
def forward_pass_builder(self, model, loss_scale=1.0): """ This function adds the operators, layers to the network. It should return a list of loss-blobs that are used for computing the loss gradient. This function is also passed an internally calculated loss_scale parameter that is used to scale your loss to normalize for the number of GPUs. Signature: function(model, loss_scale) """ self.counts = defaultdict(lambda: 0) is_inference = self.phase == 'inference' v = 'data' # Input conv modules v = self.conv(model, 'conv', v, input_depth=3, num_filters=32, kernel=3, stride=2, pad=0, is_inference=is_inference) v = self.conv(model, 'conv', v, input_depth=32, num_filters=32, kernel=3, stride=1, pad=0, is_inference=is_inference) v = self.conv(model, 'conv', v, input_depth=32, num_filters=64, kernel=3, stride=1, pad=1, is_inference=is_inference) v = brew.max_pool(model, v, blob_out='pool1', kernel=3, stride=2, pad=0) v = self.conv(model, 'conv', v, input_depth=64, num_filters=80, kernel=1, stride=1, pad=0, is_inference=is_inference) v = self.conv(model, 'conv', v, input_depth=80, num_filters=192, kernel=3, stride=1, pad=0, is_inference=is_inference) v = brew.max_pool(model, v, blob_out='pool2', kernel=3, stride=2, pad=0) # Three Type A inception modules v = self.module_a(model, inputs=v, input_depth=192, n=32, is_inference=is_inference) v = self.module_a(model, inputs=v, input_depth=256, n=64, is_inference=is_inference) v = self.module_a(model, inputs=v, input_depth=288, n=64, is_inference=is_inference) # One Type B inception module v = self.module_b(model, inputs=v, input_depth=288, is_inference=is_inference) # Four Type C inception modules for n in (128, 160, 160, 192): v = self.module_c(model, inputs=v, input_depth=768, n=n, is_inference=is_inference) # One Type D inception module v = self.module_d(model, inputs=v, input_depth=768, is_inference=is_inference) # Two Type E inception modules v = self.module_e(model, inputs=v, input_depth=1280, pooltype='avg', is_inference=is_inference) v = self.module_e(model, inputs=v, input_depth=2048, pooltype='max', is_inference=is_inference) # Final global pooling v = brew.average_pool(model, v, blob_out='pool', kernel=8, stride=1, pad=0) # And classifier return self.add_head_nodes(model, v, 2048, 'classifier', loss_scale=loss_scale)
def AddForwardPassOps(model, loss_scale, dtype): """Add forward pass ops and return a list of losses.""" initializer = (pFP16Initializer if dtype == DataType.FLOAT16 else Initializer) with brew.arg_scope([brew.conv, brew.fc], WeightInitializer=initializer, BiasInitializer=initializer): conv1 = brew.conv(model, 'data', 'conv1', 3, 32, 5, pad=2, weight_init=('GaussianFill', { 'std': 0.0001, 'mean': 0.0 })) pool1 = brew.max_pool(model, conv1, 'pool1', kernel=3, stride=2) relu1 = brew.relu(model, pool1, 'relu1') conv2 = brew.conv(model, relu1, 'conv2', 32, 32, 5, pad=2, weight_init=('GaussianFill', { 'std': 0.01 })) conv2 = brew.relu(model, conv2, conv2) pool2 = brew.average_pool(model, conv2, 'pool2', kernel=3, stride=2) conv3 = brew.conv(model, pool2, 'conv3', 32, 64, 5, pad=2, weight_init=('GaussianFill', { 'std': 0.01 })) conv3 = brew.relu(model, conv3, conv3) pool3 = brew.average_pool(model, conv3, 'pool3', kernel=3, stride=2) fc1 = brew.fc(model, pool3, 'fc1', 64 * 3 * 3, 64, weight_init=('GaussianFill', { 'std': 0.1 })) fc2 = brew.fc(model, fc1, 'fc2', 64, 10, weight_init=('GaussianFill', { 'std': 0.1 })) if dtype == DataType.FLOAT16: fc2 = model.net.HalfToFloat(fc2, fc2 + '_fp32') softmax, loss = model.SoftmaxWithLoss([fc2, 'label'], ['softmax', 'loss']) loss = model.Scale(loss, loss, scale=loss_scale) brew.accuracy(model, [softmax, 'label'], 'accuracy') return [loss]
def add_osme_branch(model, config, feature, seq): ''' add OSME module model net architecture: feature -> avgpool -> fc[1] -> relu -> fc[2] -> sigmoid -> mul ->(avgpool -> fc[3] ->) attention ''' # set weight initialization method init_policy = "XavierFill" if seq == 1 else "MSRAFill" # GAP avg_pool = brew.average_pool( model, feature, 'osme_GAP1_{}'.format(seq), kernel = config['model_arch']['last_conv_size'], stride = 1, ) # fc1 (need different initializer) fc1 = brew.fc( model, avg_pool, 'osme_fc1_{}'.format(seq), dim_in=config['model_arch']['feature_dim'], dim_out=config['model_arch']['feature_dim'] // config['model_arch']['r'], weight_init=(init_policy, {}), ) # relu fc1_relu = brew.relu(model, fc1, fc1) # fc2 fc2 = brew.fc( model, fc1_relu, 'osme_fc2_{}'.format(seq), dim_in=config['model_arch']['feature_dim'] // config['model_arch']['r'], dim_out=config['model_arch']['feature_dim'], weight_init=(init_policy, {}), ) # sigmoid mask = model.net.Sigmoid(fc2, 'osme_mask_{}'.format(seq)) # channel-wise mul attention = model.net.Mul( [feature, mask], ['osme_excitation_{}'.format(seq)], broadcast=1, axis=0, ) # one more GAP attention_gap = brew.average_pool( model, attention, 'osme_GAP2_{}'.format(seq), kernel = config['model_arch']['last_conv_size'], stride = 1, ) # fc3 att_feature = brew.fc( model, attention_gap, 'attention_{}'.format(seq), dim_in=config['model_arch']['feature_dim'], dim_out=config['model_arch']['attention_dim'], weight_init=(init_policy, {}), ) return att_feature
def Add_Original_CIFAR10_Model(model, data, num_classes, image_height, image_width, image_channels): # Convolutional layer 1 conv1 = brew.conv(model, data, 'conv1', dim_in=image_channels, dim_out=32, kernel=5, stride=1, pad=2) h, w = update_dims(height=image_height, width=image_width, kernel=5, stride=1, pad=2) # Pooling layer 1 pool1 = brew.max_pool(model, conv1, 'pool1', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) # ReLU layer 1 relu1 = brew.relu(model, pool1, 'relu1') # Convolutional layer 2 conv2 = brew.conv(model, relu1, 'conv2', dim_in=32, dim_out=32, kernel=5, stride=1, pad=2) h, w = update_dims(height=h, width=w, kernel=5, stride=1, pad=2) # ReLU layer 2 relu2 = brew.relu(model, conv2, 'relu2') # Pooling layer 1 pool2 = brew.average_pool(model, relu2, 'pool2', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) # Convolutional layer 3 conv3 = brew.conv(model, pool2, 'conv3', dim_in=32, dim_out=64, kernel=5, stride=1, pad=2) h, w = update_dims(height=h, width=w, kernel=5, stride=1, pad=2) # ReLU layer 3 relu3 = brew.relu(model, conv3, 'relu3') # Pooling layer 3 pool3 = brew.average_pool(model, relu3, 'pool3', kernel=3, stride=2) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) # Fully connected layers fc1 = brew.fc(model, pool3, 'fc1', dim_in=64 * h * w, dim_out=64) fc2 = brew.fc(model, fc1, 'fc2', dim_in=64, dim_out=num_classes) # Softmax layer softmax = brew.softmax(model, fc2, 'softmax') return softmax
def add_classifier_ops(model, blob_in, dim_in, num_classes): pool_blob = brew.average_pool(model, blob_in, 'layer5_pool', kernel=7) fc_blob = brew.fc(model, pool_blob, 'fc', dim_in, num_classes) return brew.softmax(model, fc_blob, 'softmax')
def forward_pass_builder(self, model, loss_scale=1.0): v = 'data' # 3x299x299 # conv1 = self.conv_factory(model, v, 3, num_filters=32, kernel=3, stride=2, name='conv1') #32x149x149 conv2 = self.conv_factory(model, conv1, 32, 32, kernel=3, name='conv2') #32x147x147 conv3 = self.conv_factory(model, conv2, 32, 64, kernel=3, pad=1, name='conv3') #64x147x147 pool1 = brew.max_pool(model, conv3, 'pool1', kernel=3, stride=2) #64x73x73 # conv4r = self.conv_factory(model, pool1, 64, 80, kernel=1, name='conv4_reduce') #80x73x73 conv4 = self.conv_factory(model, conv4r, 80, 192, kernel=3, name='conv4') #192x71x71 pool2 = brew.max_pool(model, conv4, 'pool2', kernel=3, stride=2) #192x35x35 # conv5 = [None, None, None, None] conv5[0] = self.conv_factory(model, pool2, 192, 96, kernel=1, name='conv5_1_1') #96x35x35 conv5[1] = self.conv_factory(model, pool2, 192, 48, kernel=1, name='conv5_2_1') #48x35x35 conv5[1] = self.conv_factory(model, conv5[1], 48, 64, kernel=5, pad=2, name='conv5_2_2') #64x35x35 conv5[2] = self.conv_factory(model, pool2, 192, 64, kernel=1, name='conv5_3_1') #64x35x35 conv5[2] = self.conv_factory(model, conv5[2], 64, 96, kernel=3, pad=1, name='conv5_3_2') #96x35x35 conv5[2] = self.conv_factory(model, conv5[2], 96, 96, kernel=3, pad=1, name='conv5_3_3') #96x35x35 conv5[3] = brew.average_pool(model, pool2, 'conv5_4_1_pool', kernel=3, stride=1, pad=1) #192x35x35 conv5[3] = self.conv_factory(model, conv5[3], 192, 64, kernel=1, name='conv5_4_2') #64x35x35 conv5 = brew.concat(model, conv5, blob_out='conv5') #320x35x35 # block35 = conv5 for i in range(10): block35 = self.block35(model, block35, num_in_channels=320, scale=0.17, name='inception_resnet_v2_a%d'%(i+1)) #320x35x35 # ra - reduction_a ra = [None, None, None] ra[0] = self.conv_factory(model, block35, 320, 384, kernel=3, stride=2, name='ra_1_1') #384x17x17 ra[1] = self.conv_factory(model, block35, 320, 256, kernel=1, name='ra_2_1') #256x35x35 ra[1] = self.conv_factory(model, ra[1], 256, 256, kernel=3, pad=1, name='ra_2_2') #256x35x35 ra[1] = self.conv_factory(model, ra[1], 256, 384, kernel=3, stride=2, name='ra_2_3') #384x17x17 ra[2] = brew.max_pool(model, block35, 'ra_3_1_pool', kernel=3, stride=2) #320x17x17 ra = brew.concat(model, ra, blob_out='ra') #1088x35x35 # block17 = ra for i in range(20): block17 = self.block17(model, block17, num_in_channels=1088, scale=0.1, name='inception_resnet_v2_b%d'%(i+1)) #1088x35x35 # rb -reduction_b rb = [None, None, None, None] rb[0] = self.conv_factory(model, block17, 1088, 256, kernel=1, name='rb_1_1') #256x17x17 rb[0] = self.conv_factory(model, rb[0], 256, 384, kernel=3, stride=2, name='rb_1_2') #384x8x8 rb[1] = self.conv_factory(model, block17, 1088, 256, kernel=1, name='rb_2_1') #256x17x17 rb[1] = self.conv_factory(model, rb[1], 256, 288, kernel=3, stride=2, name='rb_2_2') #288x8x8 rb[2] = self.conv_factory(model, block17, 1088, 256, kernel=1, name='rb_3_1') #256x17x17 rb[2] = self.conv_factory(model, rb[2], 256, 288, kernel=3, pad=1, name='rb_3_2') #288x17x17 rb[2] = self.conv_factory(model, rb[2], 288, 320, kernel=3, stride=2, name='rb_3_3') #320x8x8 rb[3] = brew.max_pool(model, block17, 'rb_4_1_pool', kernel=3, stride=2) #1088x8x8 rb = brew.concat(model, rb, blob_out='rb') #2080x8x8 # block8 = rb for i in range(9): block8 = self.block8(model, block8, num_in_channels=2080, scale=0.2, name='inception_resnet_v2_c%d'%(i+1)) #2080x8x8 block8 = self.block8(model, block8, num_in_channels=2080, relu=False, name='inception_resnet_v2_c10') #2080x8x8 # conv6 = self.conv_factory(model, block8, 2080, 1536, kernel=1, name='conv6') #1536x8x8 pool8 = brew.average_pool(model, conv6, 'pool8', kernel=8, global_pool=True) #1536x1x1 drop8 = brew.dropout(model, pool8, 'dtop8', ratio=0.2, #1536x1x1 is_test=(self.phase == 'inference')) if not self.__run_with_resnet50_trainer: return self.add_head_nodes(model, drop8, 1536, 'classifier', loss_scale=loss_scale) else: return brew.fc(model, drop8, 'classifier', dim_in=1536, dim_out=self.num_classes)
def create_resnext( model, data, num_input_channels, num_labels, num_layers, num_groups, num_width_per_group, label=None, is_test=False, no_loss=False, no_bias=1, conv1_kernel=7, conv1_stride=2, final_avg_kernel=7, log=None, bn_epsilon=1e-5, bn_momentum=0.9, ): if num_layers not in RESNEXT_BLOCK_CONFIG: log.error("{}-layer is invalid for resnext config".format(num_layers)) num_blocks = RESNEXT_BLOCK_CONFIG[num_layers] strides = RESNEXT_STRIDES num_filters = [64, 256, 512, 1024, 2048] if num_layers in [18, 34]: num_filters = [64, 64, 128, 256, 512] # the number of features before the last FC layer num_features = num_filters[-1] # conv1 + maxpool conv_blob = brew.conv(model, data, 'conv1', num_input_channels, num_filters[0], weight_init=("MSRAFill", {}), kernel=conv1_kernel, stride=conv1_stride, pad=3, no_bias=no_bias) bn_blob = brew.spatial_bn(model, conv_blob, 'conv1_spatbn_relu', num_filters[0], epsilon=bn_epsilon, momentum=bn_momentum, is_test=is_test) relu_blob = brew.relu(model, bn_blob, bn_blob) max_pool = brew.max_pool(model, relu_blob, 'pool1', kernel=3, stride=2, pad=1) # Residual blocks... builder = ResNetBuilder(model, max_pool, no_bias=no_bias, is_test=is_test, bn_epsilon=1e-5, bn_momentum=0.9) inner_dim = num_groups * num_width_per_group # 4 different kinds of residual blocks for residual_idx in range(4): residual_num = num_blocks[residual_idx] residual_stride = strides[residual_idx] dim_in = num_filters[residual_idx] for blk_idx in range(residual_num): dim_in = builder.add_bottleneck( dim_in, inner_dim, num_filters[residual_idx + 1], # dim out stride=residual_stride if blk_idx == 0 else 1, group=num_groups, ) inner_dim *= 2 # Final layers final_avg = brew.average_pool( model, builder.prev_blob, 'final_avg', kernel=final_avg_kernel, stride=1, global_pooling=True, ) # Final dimension of the "image" is reduced to 7x7 last_out = brew.fc(model, final_avg, 'last_out_L{}'.format(num_labels), num_features, num_labels) if no_loss: return last_out # If we create model for training, use softmax-with-loss if (label is not None): (softmax, loss) = model.SoftmaxWithLoss( [last_out, label], ["softmax", "loss"], ) return (softmax, loss) else: # For inference, we just return softmax return brew.softmax(model, last_out, "softmax")
def AveragePool(self, *args, **kwargs): return brew.average_pool(self, *args, use_cudnn=self.use_cudnn, order=self.order, **kwargs)
def create_caffe2_model(model, input_shape, use_cudnn=True, init_params=False, keras_channel_last=True): arg_scope = {'order': 'NCHW', 'use_cudnn': use_cudnn} caffe2_model = model_helper.ModelHelper(name='model', init_params=init_params, arg_scope=arg_scope) num_conv_layers = 0 layer_num = 0 layer_sizes = {} prev_layer_name = '' for layer in model.layers: inb_node = layer._inbound_nodes[0] num_input_layers = len(inb_node.inbound_layers) input_name_list = [] for ii in range(0, num_input_layers): inp_layer = inb_node.inbound_layers[ii] input_name_list.append(inp_layer.name) prev_layer_name = inp_layer.name if isinstance(inp_layer, keras.layers.Flatten): pass #pinb_node = inp_layer._inbound_nodes[0] #prev_layer_name = pinb_node.inbound_layers[0].name name = layer.name config = layer.get_config() inputShape = layer.input_shape outputShape = layer.output_shape if isinstance(layer, keras.engine.input_layer.InputLayer): input_sizes = (input_shape[2], input_shape[3]) layer_sizes[name] = input_sizes else: if (input_name_list[0] not in layer_sizes): raise ValueError("Can't find layer size for ", input_name_list[0]) else: input_sizes = layer_sizes[input_name_list[0]] layer_dim = len(outputShape) if (layer_dim == 4): if (keras_channel_last): out_sizes = (outputShape[1], outputShape[2]) else: out_sizes = (outputShape[2], outputShape[3]) elif (layer_dim == 2): out_sizes = (0, 0) #flattened else: raise ValueError( 'Unsupported layer dimension : {0}'.format(layer_dim)) if isinstance(layer, keras.layers.Flatten): tmp_prev = prev_layer_name if (keras_channel_last): tmp_prev = prev_layer_name + '_transpose' #nb, img_h, img_w, chan <-- nb, chan, img_h, img_w c2_layer = brew.transpose(caffe2_model, prev_layer_name, tmp_prev, axes=(0, 2, 3, 1)) c2_layer = caffe2_model.net.Flatten(tmp_prev, name) #print('FLatten previous layer ', prev_layer_name, ' current layer ', name , 'inputshape ', inputShape) layer_sizes[name] = out_sizes elif isinstance(layer, keras.layers.Dropout): #print('name is ', name, ' prev_layer_name ', prev_layer_name) c2_layer = caffe2_model.net.Dropout(prev_layer_name, name, is_test=True #ratio=config['rate'] ) #same size layer_sizes[name] = input_sizes elif (isinstance(layer, keras.layers.convolutional.Conv2D)): dim_in = inputShape[-1] dim_out = outputShape[-1] kernel = config['kernel_size'][0] stride = config['strides'][0] if (config['padding'] == 'same'): pad_sizes = get_padding_sizes(input_sizes, config['kernel_size'], config['strides']) elif (config['padding'] == 'valid'): pad_sizes = ((0, 0), (0, 0)) else: raise ValueError('unsupported padding') #print('pad sizes ', pad_sizes) layer_sizes[name] = out_sizes c2_layer = brew.conv(caffe2_model, prev_layer_name, name, dim_in=dim_in, dim_out=dim_out, kernel=kernel, stride=stride, pad_l=pad_sizes[0][0], pad_r=pad_sizes[0][1], pad_t=pad_sizes[1][0], pad_b=pad_sizes[1][1]) if config['activation'] == 'linear': pass elif config['activation'] == 'relu': c2_layer = brew.relu(caffe2_model, name, name) elif config['activation'] == 'softmax': #c2_layer = brew.softmax(caffe2_model, name, name) c2_layer = brew.softmax(caffe2_model, name, 'softmax') else: raise ValueError( 'The only supported activation for conv layer is relu') elif isinstance(layer, keras.layers.MaxPooling2D): kernel = config['pool_size'][0] stride = config['strides'][0] pad_size = ((0, 0), (0, 0)) layer_sizes[name] = out_sizes c2_layer = brew.max_pool(caffe2_model, prev_layer_name, name, kernel=kernel, stride=stride) elif isinstance(layer, keras.layers.AveragePooling2D): kernel = config['pool_size'][0] stride = config['strides'][0] pad_size = ((0, 0), (0, 0)) layer_sizes[name] = out_sizes c2_layer = brew.average_pool(caffe2_model, prev_layer_name, name, kernel=kernel, stride=stride) elif isinstance(layer, keras.layers.BatchNormalization): dim_in = inputShape[-1] epsilon = config['epsilon'] momentum = config['momentum'] c2_layer = brew.spatial_bn(caffe2_model, prev_layer_name, name, dim_in=dim_in, epsilon=epsilon, momentum=momentum, is_test=True) #same size layer_sizes[name] = input_sizes elif (isinstance(layer, keras.layers.core.Dense)): dim_in = inputShape[-1] dim_out = outputShape[-1] #print('input shape for dense is ', inputShape) if (len(inputShape) == 2): #flattened input c2_layer = brew.fc(caffe2_model, prev_layer_name, name, dim_in=dim_in, dim_out=dim_out) else: #fully convolutional input c2_layer = brew.conv(caffe2_model, prev_layer_name, name, dim_in=dim_in, dim_out=dim_out, kernel=1, stride=1) activation = config['activation'] if activation == 'relu': c2_layer = brew.relu(caffe2_model, name, name) elif activation == 'softmax': c2_layer = brew.softmax(caffe2_model, name, 'softmax') elif activation == 'linear': pass # else: raise ValueError( 'The only supported activations for fc layer are relu and softmax' ) #same size layer_sizes[name] = input_sizes elif (isinstance(layer, keras.layers.advanced_activations.LeakyReLU)): dim_in = inputShape[-1] c2_layer = caffe2_model.net.LeakyRelu(prev_layer_name, name, alpha=config['alpha']) #same size layer_sizes[name] = input_sizes elif (isinstance(layer, keras.layers.merge.Add)): c2_layer = brew.sum(caffe2_model, [input_name_list[0], input_name_list[1]], name) #same size layer_sizes[name] = input_sizes layer_num = layer_num + 1 if (layer_num == len(model.layers)): caffe2_model.net.AddExternalOutput(c2_layer) return caffe2_model
def forward_pass_builder(self, model, loss_scale=1.0): """ This function adds the operators, layers to the network. It should return a list of loss-blobs that are used for computing the loss gradient. This function is also passed an internally calculated loss_scale parameter that is used to scale your loss to normalize for the number of GPUs. Signature: function(model, loss_scale) """ self.counts = defaultdict(lambda: 0) is_inference = self.phase == 'inference' v = 'data' # Input conv modules v = self.conv(model, 'conv', v, input_depth=3, num_filters=32, kernel=3, stride=2, pad=0, is_inference=is_inference) v = self.conv(model, 'conv', v, input_depth=32, num_filters=32, kernel=3, stride=1, pad=0, is_inference=is_inference) v = self.conv(model, 'conv', v, input_depth=32, num_filters=64, kernel=3, stride=1, pad=1, is_inference=is_inference) # Stem modules v = self.inception_v4_sa(model, inputs=v, input_depth=64, is_inference=is_inference) v = self.inception_v4_sb(model, inputs=v, input_depth=160, is_inference=is_inference) v = self.inception_v4_sc(model, inputs=v, input_depth=192, is_inference=is_inference) # Four Type A modules for _ in xrange(4): v = self.inception_v4_a(model, inputs=v, input_depth=384, is_inference=is_inference) # One Type A Reduction module v = self.inception_v4_ra(model, inputs=v, input_depth=384, k=192, l=224, m=256, n=384, is_inference=is_inference) # Seven Type B modules for _ in xrange(7): v = self.inception_v4_b(model, inputs=v, input_depth=1024, is_inference=is_inference) # One Type B Reduction module v = self.inception_v4_rb(model, inputs=v, input_depth=1024, is_inference=is_inference) # Three Type C modules for _ in xrange(3): v = self.inception_v4_c(model, inputs=v, input_depth=1536, is_inference=is_inference) # Final global pooling v = brew.average_pool(model, v, blob_out='pool', kernel=8, stride=1, pad=0) v = brew.dropout(model, v, 'drop', ratio=0.2, is_test=is_inference) # And classifier return self.add_head_nodes(model, v, 1536, 'classifier', loss_scale=loss_scale)
def create_resnet50( model, data, num_input_channels, num_labels, label=None, is_test=False, no_loss=False, no_bias=0, conv1_kernel=7, conv1_stride=2, final_avg_kernel=7, ): # conv1 + maxpool brew.conv( model, data, 'conv1', num_input_channels, 64, weight_init=("MSRAFill", {}), kernel=conv1_kernel, stride=conv1_stride, pad=3, no_bias=no_bias ) brew.spatial_bn( model, 'conv1', 'conv1_spatbn_relu', 64, epsilon=1e-3, momentum=0.1, is_test=is_test ) brew.relu(model, 'conv1_spatbn_relu', 'conv1_spatbn_relu') brew.max_pool(model, 'conv1_spatbn_relu', 'pool1', kernel=3, stride=2) # Residual blocks... builder = ResNetBuilder(model, 'pool1', no_bias=no_bias, is_test=is_test, spatial_bn_mom=0.1) # conv2_x (ref Table 1 in He et al. (2015)) builder.add_bottleneck(64, 64, 256) builder.add_bottleneck(256, 64, 256) builder.add_bottleneck(256, 64, 256) # conv3_x builder.add_bottleneck(256, 128, 512, down_sampling=True) for _ in range(1, 4): builder.add_bottleneck(512, 128, 512) # conv4_x builder.add_bottleneck(512, 256, 1024, down_sampling=True) for _ in range(1, 6): builder.add_bottleneck(1024, 256, 1024) # conv5_x builder.add_bottleneck(1024, 512, 2048, down_sampling=True) builder.add_bottleneck(2048, 512, 2048) builder.add_bottleneck(2048, 512, 2048) # Final layers final_avg = brew.average_pool( model, builder.prev_blob, 'final_avg', kernel=final_avg_kernel, stride=1, ) # Final dimension of the "image" is reduced to 7x7 last_out = brew.fc( model, final_avg, 'last_out_L{}'.format(num_labels), 2048, num_labels ) if no_loss: return last_out # If we create model for training, use softmax-with-loss if (label is not None): (softmax, loss) = model.SoftmaxWithLoss( [last_out, label], ["softmax", "loss"], ) return (softmax, loss) else: # For inference, we just return softmax return brew.softmax(model, last_out, "softmax")
def Inception(order, cudnn_ws, device): my_arg_scope = {'order': order, 'use_cudnn': True, 'cudnn_exhaustive_search': True, 'ws_nbytes_limit': str(cudnn_ws)} model = ModelHelper(name="inception", arg_scope=my_arg_scope) conv1 = brew.conv( model, "data", "conv1", 3, 64, 7, ('XavierFill', {}), ('ConstantFill', {}), stride=2, pad=3 ) relu1 = brew.relu(model, conv1, "conv1") pool1 = brew.max_pool(model, relu1, "pool1", kernel=3, stride=2, pad=1) conv2a = brew.conv( model, pool1, "conv2a", 64, 64, 1, ('XavierFill', {}), ('ConstantFill', {}) ) conv2a = brew.relu(model, conv2a, conv2a) conv2 = brew.conv( model, conv2a, "conv2", 64, 192, 3, ('XavierFill', {}), ('ConstantFill', {}), pad=1 ) relu2 = brew.relu(model, conv2, "conv2") pool2 = brew.max_pool(model, relu2, "pool2", kernel=3, stride=2, pad=1) # Inception modules inc3 = _InceptionModule( model, pool2, 192, "inc3", 64, [96, 128], [16, 32], 32 ) inc4 = _InceptionModule( model, inc3, 256, "inc4", 128, [128, 192], [32, 96], 64 ) pool5 = brew.max_pool(model, inc4, "pool5", kernel=3, stride=2, pad=1) inc5 = _InceptionModule( model, pool5, 480, "inc5", 192, [96, 208], [16, 48], 64 ) inc6 = _InceptionModule( model, inc5, 512, "inc6", 160, [112, 224], [24, 64], 64 ) inc7 = _InceptionModule( model, inc6, 512, "inc7", 128, [128, 256], [24, 64], 64 ) inc8 = _InceptionModule( model, inc7, 512, "inc8", 112, [144, 288], [32, 64], 64 ) inc9 = _InceptionModule( model, inc8, 528, "inc9", 256, [160, 320], [32, 128], 128 ) pool9 = brew.max_pool(model, inc9, "pool9", kernel=3, stride=2, pad=1) inc10 = _InceptionModule( model, pool9, 832, "inc10", 256, [160, 320], [32, 128], 128 ) inc11 = _InceptionModule( model, inc10, 832, "inc11", 384, [192, 384], [48, 128], 128 ) pool11 = brew.average_pool(model, inc11, "pool11", kernel=7, stride=1) fc = brew.fc( model, pool11, "fc", 1024, 1000, ('XavierFill', {}), ('ConstantFill', {}) ) # It seems that Soumith's benchmark does not have softmax on top # for Inception. We will add it anyway so we can have a proper # backward pass. pred = brew.softmax(model, fc, "pred") xent = model.LabelCrossEntropy([pred, "label"], "xent") if device != 'MKL': loss = model.AveragedLoss(xent, "loss") return model, 224
def Inception(order, gpu_engine_ws): my_arg_scope = { 'order': order, 'use_gpu_engine': True, 'gpu_engine_exhaustive_search': True, } if gpu_engine_ws: my_arg_scope['ws_nbytes_limit'] = gpu_engine_ws model = model_helper.ModelHelper( name="inception", arg_scope=my_arg_scope, ) conv1 = brew.conv( model, "data", "conv1", 3, 64, 7, ('XavierFill', {}), ('ConstantFill', {}), stride=2, pad=3, ) relu1 = brew.relu(model, conv1, "conv1") pool1 = brew.max_pool(model, relu1, "pool1", kernel=3, stride=2, pad=1) conv2a = brew.conv(model, pool1, "conv2a", 64, 64, 1, ('XavierFill', {}), ('ConstantFill', {})) conv2a = brew.relu(model, conv2a, conv2a) conv2 = brew.conv( model, conv2a, "conv2", 64, 192, 3, ('XavierFill', {}), ('ConstantFill', {}), pad=1, ) relu2 = brew.relu(model, conv2, "conv2") pool2 = brew.max_pool(model, relu2, "pool2", kernel=3, stride=2, pad=1) # Inception modules inc3 = _InceptionModule(model, pool2, 192, "inc3", 64, [96, 128], [16, 32], 32) inc4 = _InceptionModule(model, inc3, 256, "inc4", 128, [128, 192], [32, 96], 64) pool5 = brew.max_pool(model, inc4, "pool5", kernel=3, stride=2, pad=1) inc5 = _InceptionModule(model, pool5, 480, "inc5", 192, [96, 208], [16, 48], 64) inc6 = _InceptionModule(model, inc5, 512, "inc6", 160, [112, 224], [24, 64], 64) inc7 = _InceptionModule(model, inc6, 512, "inc7", 128, [128, 256], [24, 64], 64) inc8 = _InceptionModule(model, inc7, 512, "inc8", 112, [144, 288], [32, 64], 64) inc9 = _InceptionModule(model, inc8, 528, "inc9", 256, [160, 320], [32, 128], 128) pool9 = brew.max_pool(model, inc9, "pool9", kernel=3, stride=2, pad=1) inc10 = _InceptionModule(model, pool9, 832, "inc10", 256, [160, 320], [32, 128], 128) inc11 = _InceptionModule(model, inc10, 832, "inc11", 384, [192, 384], [48, 128], 128) pool11 = brew.average_pool(model, inc11, "pool11", kernel=7, stride=1) fc = brew.fc(model, pool11, "fc", 1024, 1000, ('XavierFill', {}), ('ConstantFill', {})) # It seems that Soumith's benchmark does not have softmax on top # for Inception. We will add it anyway so we can have a proper # backward pass. pred = brew.softmax(model, fc, "pred") xent = model.net.LabelCrossEntropy([pred, "label"], "xent") model.net.AveragedLoss(xent, "loss") return model, 224
def TestModel_ops(model, data, label): # Image size: 227 x 227 -> 224 x 224 conv1_s2 = brew.conv(model, data, 'conv1_s2', dim_in=3, dim_out=32, kernel=4, stride=2) conv1_s2_s = brew.spatial_bn(model, conv1_s2, 'conv1_s2_s', 32, epsilon=1e-3, momentum=0.9) conv1_dw = brew.conv(model, conv1_s2_s, 'conv1_dw', dim_in=32, dim_out=32, kernel=3, pad=2) # conv1_dw_s = brew.spatial_bn(model, conv1_dw, 'conv1_dw_s', 32, epsilon=1e-3, momentum=0.9) conv1_s1 = brew.conv(model, conv1_dw, 'conv1_s1', dim_in=32, dim_out=64, kernel=1) conv1_s1_s = brew.spatial_bn(model, conv1_s1, 'conv1_s1_s', 64, epsilon=1e-3, momentum=0.9) conv2_s2 = brew.conv(model, conv1_s1_s, 'conv2_s2', dim_in=64, dim_out=64, kernel=3, pad=2, stride=2) conv2_dw = brew.conv(model, conv2_s2, 'conv2_dw', dim_in=64, dim_out=128, kernel=1) conv2_k3 = brew.conv(model, conv2_dw, 'conv2_k3', dim_in=128, dim_out=128, kernel=3, pad=2) conv2_s1 = brew.conv(model, conv2_k3, 'conv2_s1', dim_in=128, dim_out=128, kernel=1) conv3_s2 = brew.conv(model, conv2_s1, 'conv3_s2', dim_in=128, dim_out=128, kernel=3, pad=2, stride=2) conv3_dw = brew.conv(model, conv3_s2, 'conv3_dw', dim_in=128, dim_out=256, kernel=1) conv3_k3 = brew.conv(model, conv3_dw, 'conv3_k3', dim_in=256, dim_out=256, kernel=3, pad=2) conv3_s1 = brew.conv(model, conv3_k3, 'conv3_s1', dim_in=256, dim_out=256, kernel=1) conv4_s2 = brew.conv(model, conv3_s1, 'conv4_s2', dim_in=256, dim_out=256, kernel=3, pad=2, stride=2) conv4_dw = brew.conv(model, conv4_s2, 'conv4_dw', dim_in=256, dim_out=512, kernel=1) #5 conv5_s2 = brew.conv(model, conv4_dw, 'conv5_s2', dim_in=512, dim_out=512, kernel=3, pad=2) conv5_dw = brew.conv(model, conv5_s2, 'conv5_dw', dim_in=512, dim_out=512, kernel=1) #4 conv6_s2 = brew.conv(model, conv5_dw, 'conv6_s2', dim_in=512, dim_out=512, kernel=3, pad=2) conv6_dw = brew.conv(model, conv6_s2, 'conv6_dw', dim_in=512, dim_out=512, kernel=1) #3 conv7_s2 = brew.conv(model, conv6_dw, 'conv7_s2', dim_in=512, dim_out=512, kernel=3, pad=2) conv7_dw = brew.conv(model, conv7_s2, 'conv7_dw', dim_in=512, dim_out=512, kernel=1) #2 conv8_s2 = brew.conv(model, conv7_dw, 'conv8_s2', dim_in=512, dim_out=512, kernel=3, pad=2) conv8_dw = brew.conv(model, conv8_s2, 'conv8_dw', dim_in=512, dim_out=512, kernel=1) #1 conv9_s2 = brew.conv(model, conv8_dw, 'conv9_s2', dim_in=512, dim_out=512, kernel=3, pad=2) conv9_dw = brew.conv(model, conv9_s2, 'conv9_dw', dim_in=512, dim_out=512, kernel=1) conv10_s2 = brew.conv(model, conv9_dw, 'conv10_s2', dim_in=512, dim_out=512, kernel=3, pad=2, stride=2) conv10_dw = brew.conv(model, conv10_s2, 'conv10_dw', dim_in=512, dim_out=1024, kernel=1) # out 1024 conv10_k3 = brew.conv(model, conv10_dw, 'conv10_k3', dim_in=1024, dim_out=1024, kernel=3) conv10_s1 = brew.conv(model, conv10_k3, 'conv10_s1', dim_in=1024, dim_out=1024, kernel=1) pool1 = brew.average_pool(model, conv10_s1, 'pool1', kernel=7, stride=7) # pool1 = brew.max_pool(model, conv10_s1, 'pool1', kernel=7, stride=7) fc1 = brew.fc(model, pool1, 'fc1', dim_in=1 * 1 * 1024, dim_out=num_labels) # softmax = brew.softmax(model, fc1, 'softmax') [softmax, loss] = model.SoftmaxWithLoss( [fc1, label], ["softmax", "loss"], ) return [softmax, loss]
def Inception(model, loss_scale, dtype='float'): initializer = (PseudoFP16Initializer if dtype == 'float16' else Initializer) with brew.arg_scope( [brew.conv, brew.fc], WeightInitializer=initializer, BiasInitializer=initializer, ): conv1 = brew.conv( model, "data", "conv1", 3, 64, 7, ('XavierFill', {}), ('ConstantFill', {}), stride=2, pad=3, ) relu1 = brew.relu(model, conv1, "conv1") pool1 = brew.max_pool(model, relu1, "pool1", kernel=3, stride=2, pad=1) conv2a = brew.conv(model, pool1, "conv2a", 64, 64, 1, ('XavierFill', {}), ('ConstantFill', {})) conv2a = brew.relu(model, conv2a, conv2a) conv2 = brew.conv( model, conv2a, "conv2", 64, 192, 3, ('XavierFill', {}), ('ConstantFill', {}), pad=1, ) relu2 = brew.relu(model, conv2, "conv2") pool2 = brew.max_pool(model, relu2, "pool2", kernel=3, stride=2, pad=1) # Inception modules inc3 = _InceptionModule(model, pool2, 192, "inc3", 64, [96, 128], [16, 32], 32) inc4 = _InceptionModule(model, inc3, 256, "inc4", 128, [128, 192], [32, 96], 64) pool5 = brew.max_pool(model, inc4, "pool5", kernel=3, stride=2, pad=1) inc5 = _InceptionModule(model, pool5, 480, "inc5", 192, [96, 208], [16, 48], 64) inc6 = _InceptionModule(model, inc5, 512, "inc6", 160, [112, 224], [24, 64], 64) inc7 = _InceptionModule(model, inc6, 512, "inc7", 128, [128, 256], [24, 64], 64) inc8 = _InceptionModule(model, inc7, 512, "inc8", 112, [144, 288], [32, 64], 64) inc9 = _InceptionModule(model, inc8, 528, "inc9", 256, [160, 320], [32, 128], 128) pool9 = brew.max_pool(model, inc9, "pool9", kernel=3, stride=2, pad=1) inc10 = _InceptionModule(model, pool9, 832, "inc10", 256, [160, 320], [32, 128], 128) inc11 = _InceptionModule(model, inc10, 832, "inc11", 384, [192, 384], [48, 128], 128) pool11 = brew.average_pool(model, inc11, "pool11", kernel=7, stride=1) fc = brew.fc(model, pool11, "fc", 1024, 1000, ('XavierFill', {}), ('ConstantFill', {})) if dtype == 'float16': fc = model.net.HalfToFloat(fc, fc + '_fp32') # It seems that Soumith's benchmark does not have softmax on top # for Inception. We will add it anyway so we can have a proper # backward pass. pred = brew.softmax(model, fc, "pred") xent = model.net.LabelCrossEntropy([pred, "label"], "xent") loss = model.net.AveragedLoss(xent, "loss") return [loss]
def forward_pass_builder(self, model, loss_scale=1.0): """ This function adds the operators, layers to the network. It should return a list of loss-blobs that are used for computing the loss gradient. This function is also passed an internally calculated loss_scale parameter that is used to scale your loss to normalize for the number of GPUs. Signature: function(model, loss_scale) """ v = 'data' v = conv_factory(model, v, self.input_shape[0], 64, kernel=7, stride=2, pad=3, name="conv1/7x7_s2") v = brew.max_pool(model, v, 'pool1/3x3_s2', kernel=3, stride=2) v = brew.lrn(model, v, 'pool1/norm1', size=5, alpha=0.0001, beta=0.75) v = conv_factory(model, v, 64, 64, kernel=1, stride=1, name="conv2/3x3_reduce") v = conv_factory(model, v, 64, 192, kernel=3, stride=1, pad=1, name="conv2/3x3") v = brew.lrn(model, v, 'conv2/norm2', size=5, alpha=0.0001, beta=0.75) v = brew.max_pool(model, v, 'pool2/3x3_s2', kernel=3, stride=2) v = inception_factory(model, v, 192, 64, 96, 128, 16, 32, 32, name="inception_3a") v = inception_factory(model, v, 256, 128, 128, 192, 32, 96, 64, name="inception_3b") v = brew.max_pool(model, v, 'pool3/3x3_s2', kernel=3, stride=2) v = inception_factory(model, v, 480, 192, 96, 208, 16, 48, 64, name="inception_4a") v = inception_factory(model, v, 512, 160, 112, 224, 24, 64, 64, name="inception_4b") v = inception_factory(model, v, 512, 128, 128, 256, 24, 64, 64, name="inception_4c") v = inception_factory(model, v, 512, 112, 144, 288, 32, 64, 64, name="inception_4d") v = inception_factory(model, v, 528, 256, 160, 320, 32, 128, 128, name="inception_4e") v = brew.max_pool(model, v, 'pool4/3x3_s2', kernel=3, stride=2, pad=1) v = inception_factory(model, v, 832, 256, 160, 320, 32, 128, 128, name="inception_5a") v = inception_factory(model, v, 832, 384, 192, 384, 48, 128, 128, name="inception_5b") v = brew.average_pool(model, v, 'pool5/7x7_s1', kernel=7, stride=1) v = brew.dropout(model, v, 'pool5/drop_7x7_s1', ratio=0.5, is_test=(self.phase == 'inference')) return self.add_head_nodes(model, v, 1024, 'classifier', loss_scale=loss_scale)
def create_mobilenet( model, data, num_input_channels, num_labels, label=None, is_test=False ): ''' Create residual net for smaller images (sec 4.2 of He et. al (2015)) num_groups = 'n' in the paper ''' # conv1 brew.conv( model, data, 'conv1', 3, 32, weight_init=("MSRAFill", {}), kernel=3, stride=2, pad=2, no_bias=False, ) brew.spatial_bn( model, 'conv1', 'conv1_spatbn', 32, epsilon=1e-3, is_test=is_test ) # brew.relu(model, 'conv1_spatbn', 'relu1') # builder = MobileNetBuilder(model, 'conv1_spatbn', is_test=is_test) builder = MobileNetBuilder(model, 'conv1_spatbn', no_bias=False, is_test=is_test) # block1 builder.add_simple_block(input_filters=32, output_filters=64, down_sampling=False, spatial_batch_norm=True) # block2 builder.add_simple_block(input_filters=64, output_filters=128, down_sampling=True, spatial_batch_norm=True) # block3 builder.add_simple_block(input_filters=128, output_filters=128, down_sampling=False, spatial_batch_norm=True) # block4 builder.add_simple_block(input_filters=128, output_filters=256, down_sampling=True, spatial_batch_norm=True) # block5 builder.add_simple_block(input_filters=256, output_filters=256, down_sampling=False, spatial_batch_norm=True) # block6 builder.add_simple_block(input_filters=256, output_filters=512, down_sampling=True, spatial_batch_norm=True) # block7-11 for i in xrange(7, 12): builder.add_simple_block(input_filters=512, output_filters=512, down_sampling=False, spatial_batch_norm=True) # block12 builder.add_simple_block(input_filters=512, output_filters=1024, down_sampling=True, spatial_batch_norm=True) # block13 builder.add_simple_block(input_filters=1024, output_filters=1024, down_sampling=False, spatial_batch_norm=True) # Final layers brew.average_pool( model, builder.prev_blob, 'final_avg', kernel=7, stride=7) last_out = brew.fc(model, 'final_avg', 'last_out', 1024, num_labels) if (label is not None): (softmax, loss) = model.SoftmaxWithLoss( [last_out, label], ['softmax', 'loss'], ) return (softmax, loss) else: return brew.softmax(model, 'last_out', 'softmax')
def Add_Action_Tufts_Model(model, num_classes, image_height, image_width, image_channels, is_test=0): ################################## Block 1 ############################ # Convolutional layer 1 # conv1_1 = brew.conv(model, 'data', 'conv1_1', dim_in=image_channels, dim_out=64, kernel=3, stride=2, pad=0) # h,w = update_dims(height=image_height, width=image_width, kernel=3, stride=2, pad=0) # ReLU layer 1 # relu1_1 = brew.relu(model, conv1_1, 'relu1_1') # Batch normalization layer 1 # bn1_1 = brew.spatial_bn(model, relu1_1, 'bn1_1', dim_in=64, epsilon=1e-3, momentum=0.1, is_test=is_test) # Drop out with p=0.25 # dropout1_1 = brew.dropout(model, bn1_1, 'dropout1_1', ratio=0.25, is_test=is_test) # Convolutional layer 2 # conv1_2 = brew.conv(model, dropout1_1, 'conv1_2', dim_in=64, dim_out=64, kernel=3, stride=1, pad=0) # h,w = update_dims(height=h, width=w, kernel=3, stride=1, pad=0) # ReLU layer 1 # relu1_2 = brew.relu(model, conv1_2, 'relu1_2') # Batch normalization layer 1 # bn1_2 = brew.spatial_bn(model, relu1_2, 'bn1_2', dim_in=64, epsilon=1e-3, momentum=0.1, is_test=is_test) # Drop out with p=0.25 # dropout1_2 = brew.dropout(model, bn1_2, 'dropout1_2', ratio=0.25, is_test=is_test) ##################################### Block 2 ########################## # Convolutional layer 3 conv2_1 = brew.conv(model, 'data', 'conv2_1', dim_in=image_channels, dim_out=128, kernel=3, stride=2, pad=0) h, w = update_dims(height=image_height, width=image_width, kernel=3, stride=2, pad=0) # ReLU layer 1 relu2_1 = brew.relu(model, conv2_1, 'relu2_1') # Batch normalization layer 1 bn2_1 = brew.spatial_bn(model, relu2_1, 'bn2_1', dim_in=128, epsilon=1e-3, momentum=0.1, is_test=is_test) # Drop out with p=0.25 dropout2_1 = brew.dropout(model, bn2_1, 'dropout2_1', ratio=0.25, is_test=is_test) # Convolutional layer 4 conv2_2 = brew.conv(model, dropout2_1, 'conv2_2', dim_in=128, dim_out=128, kernel=3, stride=1, pad=0) h, w = update_dims(height=h, width=w, kernel=3, stride=1, pad=0) # ReLU layer 1 relu2_2 = brew.relu(model, conv2_2, 'relu2_2') # Batch normalization layer 1 bn2_2 = brew.spatial_bn(model, relu2_2, 'bn2_2', dim_in=128, epsilon=1e-3, momentum=0.1, is_test=is_test) # Drop out with p=0.25 dropout2_2 = brew.dropout(model, bn2_2, 'dropout2_2', ratio=0.25, is_test=is_test) ##################################### Block 3 ############################ # Convolutional layer 5 conv3_1 = brew.conv(model, dropout2_2, 'conv3_1', dim_in=128, dim_out=256, kernel=3, stride=2, pad=0) h, w = update_dims(height=h, width=w, kernel=3, stride=2, pad=0) # ReLU layer 1 relu3_1 = brew.relu(model, conv3_1, 'relu3_1') # Batch normalization layer 1 bn3_1 = brew.spatial_bn(model, relu3_1, 'bn3_1', dim_in=256, epsilon=1e-3, momentum=0.1, is_test=is_test) # Drop out with p=0.25 dropout3_1 = brew.dropout(model, bn3_1, 'dropout3_1', ratio=0.25, is_test=is_test) # Convolutional layer 4 conv3_2 = brew.conv(model, dropout3_1, 'conv3_2', dim_in=256, dim_out=256, kernel=3, stride=1, pad=0) h, w = update_dims(height=h, width=w, kernel=3, stride=1, pad=0) # ReLU layer 1 relu3_2 = brew.relu(model, conv3_2, 'relu3_2') # Batch normalization layer 1 bn3_2 = brew.spatial_bn(model, relu3_2, 'bn3_2', dim_in=256, epsilon=1e-3, momentum=0.1, is_test=is_test) # Drop out with p=0.25 dropout3_2 = brew.dropout(model, bn3_2, 'dropout3_2', ratio=0.25, is_test=is_test) # Global average pooling pool1 = brew.average_pool(model, dropout3_2, 'pool1', global_pooling=True) # Fully connected layers pred = brew.fc(model, pool1, 'fc1', dim_in=256, dim_out=num_classes) # Softmax layer softmax, loss = model.SoftmaxWithLoss([pred, 'label'], ['softmax', 'loss']) brew.accuracy(model, [softmax, 'label'], 'accuracy') model.net.MultiClassAccuracy([softmax, 'label'], ['accuracy_per_class', 'amount_per_class']) return [loss]
def create_resnet152( model, data, num_input_channels, num_labels, label=None, is_test=False, no_loss=False, no_bias=0, conv1_kernel=7, conv1_stride=2, final_avg_kernel=7, ): # conv1 + maxpool brew.conv(model, data, 'conv1', num_input_channels, 64, weight_init=("MSRAFill", {}), kernel=conv1_kernel, stride=conv1_stride, pad=3, no_bias=no_bias) brew.spatial_bn(model, 'conv1', 'conv1_spatbn_relu', 64, epsilon=1e-3, momentum=0.1, is_test=is_test) brew.relu(model, 'conv1_spatbn_relu', 'conv1_spatbn_relu') brew.max_pool(model, 'conv1_spatbn_relu', 'pool1', kernel=3, stride=2) # Residual blocks... builder = ResNetBuilder(model, 'pool1', no_bias=no_bias, is_test=is_test, spatial_bn_mom=0.1) # conv2_x (ref Table 1 in He et al. (2015)) builder.add_bottleneck(64, 64, 256) builder.add_bottleneck(256, 64, 256) builder.add_bottleneck(256, 64, 256) # conv3_x builder.add_bottleneck(256, 128, 512, down_sampling=True) for _ in range(1, 8): builder.add_bottleneck(512, 128, 512) # conv4_x builder.add_bottleneck(512, 256, 1024, down_sampling=True) for _ in range(1, 36): builder.add_bottleneck(1024, 256, 1024) # conv5_x builder.add_bottleneck(1024, 512, 2048, down_sampling=True) builder.add_bottleneck(2048, 512, 2048) builder.add_bottleneck(2048, 512, 2048) # Final layers final_avg = brew.average_pool( model, builder.prev_blob, 'final_avg', kernel=final_avg_kernel, stride=1, ) # Final dimension of the "image" is reduced to 7x7 last_out = brew.fc(model, final_avg, 'last_out_L{}'.format(num_labels), 2048, num_labels) if no_loss: return last_out # If we create model for training, use softmax-with-loss if (label is not None): (softmax, loss) = model.SoftmaxWithLoss( [last_out, label], ["softmax", "loss"], ) return (softmax, loss) else: # For inference, we just return softmax return brew.softmax(model, last_out, "softmax")
def AveragePool(self, *args, **kwargs): return brew.average_pool( self, *args, use_cudnn=self.use_cudnn, order=self.order, **kwargs )