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
)
