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)
"""
is_inference = self.phase == 'inference'
v = 'data'
v = brew.conv(model, v, 'conv1', 3, 96, kernel=11, stride=4)
v = brew.relu(model, v, 'relu1')
v = brew.lrn(model, v, 'norm1', size=5, alpha=0.0001, beta=0.75)
v = brew.max_pool(model, v, 'pool1', kernel=3, stride=2)
v = brew.conv(model, v, 'conv2', 96, 256, kernel=5, pad=2, group=1)
v = brew.relu(model, v, 'relu2')
v = brew.lrn(model, v, 'norm2', size=5, alpha=0.0001, beta=0.75)
v = brew.max_pool(model, v, 'pool2', kernel=3, stride=2)
v = brew.conv(model, v, 'conv3', 256, 384, kernel=3, pad=1)
v = brew.relu(model, v, 'relu3')
v = brew.conv(model, v, 'conv4', 384, 384, kernel=3, pad=1, group=1)
v = brew.relu(model, v, 'relu4')
v = brew.conv(model, v, 'conv5', 384, 256, kernel=3, pad=1, group=1)
v = brew.relu(model, v, 'relu5')
v = brew.max_pool(model, v, 'pool5', kernel=3, stride=2)
v = brew.fc(model, v, 'fc6', dim_in=9216, dim_out=4096)
v = brew.relu(model, v, 'relu6')
v = brew.dropout(model, v, 'drop6', ratio=0.5, is_test=is_inference)
v = brew.fc(model, v, 'fc7', dim_in=4096, dim_out=4096)
v = brew.relu(model, v, 'relu7')
v = brew.dropout(model, v, 'drop7', ratio=0.5, is_test=is_inference)
return self.add_head_nodes(model,
v,
4096,
'fc8',
loss_scale=loss_scale)
def _MiniAlexNetNoDropout(self, order):
# First, AlexNet using the cnn wrapper.
model = model_helper.ModelHelper(name="alexnet")
conv1 = brew.conv(
model,
"data",
"conv1",
3,
16,
11,
("XavierFill", {}),
("ConstantFill", {}),
stride=4,
pad=0
)
relu1 = brew.relu(model, conv1, "relu1")
norm1 = brew.lrn(model, relu1, "norm1", size=5, alpha=0.0001, beta=0.75)
pool1 = brew.max_pool(model, norm1, "pool1", kernel=3, stride=2)
conv2 = brew.group_conv(
model,
pool1,
"conv2",
16,
32,
5,
("XavierFill", {}),
("ConstantFill", {"value": 0.1}),
group=2,
stride=1,
pad=2
)
relu2 = brew.relu(model, conv2, "relu2")
norm2 = brew.lrn(model, relu2, "norm2", size=5, alpha=0.0001, beta=0.75)
pool2 = brew.max_pool(model, norm2, "pool2", kernel=3, stride=2)
conv3 = brew.conv(
model,
pool2,
"conv3",
32,
64,
3,
("XavierFill", {'std': 0.01}),
("ConstantFill", {}),
pad=1
)
relu3 = brew.relu(model, conv3, "relu3")
conv4 = brew.group_conv(
model,
relu3,
"conv4",
64,
64,
3,
("XavierFill", {}),
("ConstantFill", {"value": 0.1}),
group=2,
pad=1
)
relu4 = brew.relu(model, conv4, "relu4")
conv5 = brew.group_conv(
model,
relu4,
"conv5",
64,
32,
3,
("XavierFill", {}),
("ConstantFill", {"value": 0.1}),
group=2,
pad=1
)
relu5 = brew.relu(model, conv5, "relu5")
pool5 = brew.max_pool(model, relu5, "pool5", kernel=3, stride=2)
fc6 = brew.fc(
model, pool5, "fc6", 1152, 1024, ("XavierFill", {}),
("ConstantFill", {"value": 0.1})
)
relu6 = brew.relu(model, fc6, "relu6")
fc7 = brew.fc(
model, relu6, "fc7", 1024, 1024, ("XavierFill", {}),
("ConstantFill", {"value": 0.1})
)
relu7 = brew.relu(model, fc7, "relu7")
fc8 = brew.fc(
model, relu7, "fc8", 1024, 5, ("XavierFill", {}),
("ConstantFill", {"value": 0.0})
)
pred = brew.softmax(model, fc8, "pred")
xent = model.LabelCrossEntropy([pred, "label"], "xent")
loss = model.AveragedLoss([xent], ["loss"])
model.AddGradientOperators([loss])
return model
def LRN(self, *args, **kwargs):
return brew.lrn(self, order=self.order, *args, **kwargs)
def alexnet():
model = ModelHelper(name="r", arg_scope={"order": "NCHW", "is_test": True})
conv1 = brew.conv(model,
"data",
"conv1",
3,
64,
11, ('XavierFill', {}), ('ConstantFill', {}),
stride=4,
pad=2)
relu1 = brew.relu(model, conv1, "conv1")
pool1 = brew.max_pool(model,
relu1,
"pool1",
kernel=3,
stride=2,
pad=0,
legacy_pad=3)
lrn1 = brew.lrn(model,
pool1,
"pool1_lrn",
size=5,
alpha=1.0e-4,
beta=0.75,
bias=1.0)
conv2 = brew.conv(model,
lrn1,
"conv2",
64,
192,
5, ('XavierFill', {}), ('ConstantFill', {}),
pad=2)
relu2 = brew.relu(model, conv2, "conv2")
pool2 = brew.max_pool(model, relu2, "pool2", kernel=3, stride=2)
lrn2 = brew.lrn(model,
pool2,
"pool2_lrn",
size=5,
alpha=1.0e-4,
beta=0.75,
bias=1.0)
conv3 = brew.conv(model,
lrn2,
"conv3",
192,
384,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu3 = brew.relu(model, conv3, "conv3")
conv4 = brew.conv(model,
relu3,
"conv4",
384,
256,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu4 = brew.relu(model, conv4, "conv4")
conv5 = brew.conv(model,
relu4,
"conv5",
256,
256,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu5 = brew.relu(model, conv5, "conv5")
pool5 = brew.max_pool(model, relu5, "pool5", kernel=3, stride=2)
fc6 = brew.fc(model, pool5, "fc6", 256 * 6 * 6, 4096, ('XavierFill', {}),
('ConstantFill', {}))
relu6 = brew.relu(model, fc6, "fc6")
fc7 = brew.fc(model, relu6, "fc7", 4096, 4096, ('XavierFill', {}),
('ConstantFill', {}))
relu7 = brew.relu(model, fc7, "fc7")
drop7 = brew.dropout(model, relu7, "fc7_dropout", is_test=1, ratio=0.5)
fc8 = brew.fc(model, drop7, "fc8", 4096, 1000, ('XavierFill', {}),
('ConstantFill', {}))
relu8 = brew.relu(model, fc8, "fc8")
_ = brew.dropout(model, relu8, "fc8_dropout", is_test=1, ratio=0.5)
return model, [(1, 3, 224, 224)]
def LRN(self, *args, **kwargs):
return brew.lrn(self,
*args,
order=self.order,
use_cudnn=self.use_cudnn,
**kwargs)
def _MiniAlexNetNoDropout(self, order):
# First, AlexNet using the cnn wrapper.
model = model_helper.ModelHelper(name="alexnet")
conv1 = brew.conv(
model,
"data",
"conv1",
3,
16,
11,
("XavierFill", {}),
("ConstantFill", {}),
stride=4,
pad=0
)
relu1 = brew.relu(model, conv1, "relu1")
norm1 = brew.lrn(model, relu1, "norm1", size=5, alpha=0.0001, beta=0.75)
pool1 = brew.max_pool(model, norm1, "pool1", kernel=3, stride=2)
conv2 = brew.group_conv(
model,
pool1,
"conv2",
16,
32,
5,
("XavierFill", {}),
("ConstantFill", {"value": 0.1}),
group=2,
stride=1,
pad=2
)
relu2 = brew.relu(model, conv2, "relu2")
norm2 = brew.lrn(model, relu2, "norm2", size=5, alpha=0.0001, beta=0.75)
pool2 = brew.max_pool(model, norm2, "pool2", kernel=3, stride=2)
conv3 = brew.conv(
model,
pool2,
"conv3",
32,
64,
3,
("XavierFill", {'std': 0.01}),
("ConstantFill", {}),
pad=1
)
relu3 = brew.relu(model, conv3, "relu3")
conv4 = brew.group_conv(
model,
relu3,
"conv4",
64,
64,
3,
("XavierFill", {}),
("ConstantFill", {"value": 0.1}),
group=2,
pad=1
)
relu4 = brew.relu(model, conv4, "relu4")
conv5 = brew.group_conv(
model,
relu4,
"conv5",
64,
32,
3,
("XavierFill", {}),
("ConstantFill", {"value": 0.1}),
group=2,
pad=1
)
relu5 = brew.relu(model, conv5, "relu5")
pool5 = brew.max_pool(model, relu5, "pool5", kernel=3, stride=2)
fc6 = brew.fc(
model, pool5, "fc6", 1152, 1024, ("XavierFill", {}),
("ConstantFill", {"value": 0.1})
)
relu6 = brew.relu(model, fc6, "relu6")
fc7 = brew.fc(
model, relu6, "fc7", 1024, 1024, ("XavierFill", {}),
("ConstantFill", {"value": 0.1})
)
relu7 = brew.relu(model, fc7, "relu7")
fc8 = brew.fc(
model, relu7, "fc8", 1024, 5, ("XavierFill", {}),
("ConstantFill", {"value": 0.0})
)
pred = brew.softmax(model, fc8, "pred")
xent = model.LabelCrossEntropy([pred, "label"], "xent")
loss = model.AveragedLoss([xent], ["loss"])
model.AddGradientOperators([loss])
return model
def LRN(self, *args, **kwargs):
return brew.lrn(self, *args, **kwargs)
def alexnet():
model = ModelHelper(name="r", arg_scope={"order": "NCHW", "is_test": True})
conv1 = brew.conv(
model,
"data",
"conv1",
3,
64,
11, ('XavierFill', {}), ('ConstantFill', {}),
stride=4,
pad=2
)
relu1 = brew.relu(model, conv1, "conv1")
pool1 = brew.max_pool(model, relu1, "pool1", kernel=3, stride=2, pad=0,
legacy_pad=3)
lrn1 = brew.lrn(
model, pool1, "pool1_lrn", size=5, alpha=1.0e-4, beta=0.75, bias=1.0)
conv2 = brew.conv(
model,
lrn1,
"conv2",
64,
192,
5,
('XavierFill', {}),
('ConstantFill', {}),
pad=2
)
relu2 = brew.relu(model, conv2, "conv2")
pool2 = brew.max_pool(model, relu2, "pool2", kernel=3, stride=2)
lrn2 = brew.lrn(
model, pool2, "pool2_lrn", size=5, alpha=1.0e-4, beta=0.75, bias=1.0)
conv3 = brew.conv(
model,
lrn2,
"conv3",
192,
384,
3,
('XavierFill', {}),
('ConstantFill', {}),
pad=1
)
relu3 = brew.relu(model, conv3, "conv3")
conv4 = brew.conv(
model,
relu3,
"conv4",
384,
256,
3,
('XavierFill', {}),
('ConstantFill', {}),
pad=1
)
relu4 = brew.relu(model, conv4, "conv4")
conv5 = brew.conv(
model,
relu4,
"conv5",
256,
256,
3,
('XavierFill', {}),
('ConstantFill', {}),
pad=1
)
relu5 = brew.relu(model, conv5, "conv5")
pool5 = brew.max_pool(model, relu5, "pool5", kernel=3, stride=2)
fc6 = brew.fc(
model,
pool5, "fc6", 256 * 6 * 6, 4096, ('XavierFill', {}),
('ConstantFill', {})
)
relu6 = brew.relu(model, fc6, "fc6")
fc7 = brew.fc(
model, relu6, "fc7", 4096, 4096, ('XavierFill', {}), ('ConstantFill', {})
)
relu7 = brew.relu(model, fc7, "fc7")
drop7 = brew.dropout(model, relu7, "fc7_dropout", is_test=1, ratio=0.5)
fc8 = brew.fc(
model, drop7, "fc8", 4096, 1000, ('XavierFill', {}), ('ConstantFill', {})
)
relu8 = brew.relu(model, fc8, "fc8")
_ = brew.dropout(model, relu8, "fc8_dropout", is_test=1, ratio=0.5)
return model, [(1, 3, 224, 224)]
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 LRN(self, *args, **kwargs):
return brew.lrn(
self, *args, order=self.order, use_cudnn=self.use_cudnn, **kwargs
)
def create_alexnetv0(
model,
data,
num_input_channels,
num_labels,
is_test=False,
):
conv1 = brew.conv(
model,
data,
"conv1",
num_input_channels, # dim_in
96, # dim_out
11, # kernel
('XavierFill', {}),
('ConstantFill', {}),
stride=4,
pad=2)
relu1 = brew.relu(model, conv1, "conv1")
norm1 = brew.lrn(model, relu1, "norm1", size=5, alpha=0.0001, beta=0.75)
pool1 = brew.max_pool(model, norm1, "pool1", kernel=3, stride=2)
conv2 = brew.conv(model,
pool1,
"conv2",
96,
256,
5, ('XavierFill', {}), ('ConstantFill', {}),
pad=2)
relu2 = brew.relu(model, conv2, "conv2")
norm2 = brew.lrn(model, relu2, "norm2", size=5, alpha=0.0001, beta=0.75)
pool2 = brew.max_pool(model, norm2, "pool2", kernel=3, stride=2)
conv3 = brew.conv(model,
pool2,
"conv3",
256,
384,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu3 = brew.relu(model, conv3, "conv3")
conv4 = brew.conv(model,
relu3,
"conv4",
384,
384,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu4 = brew.relu(model, conv4, "conv4")
conv5 = brew.conv(model,
relu4,
"conv5",
384,
256,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu5 = brew.relu(model, conv5, "conv5")
pool5 = brew.max_pool(model, relu5, "pool5", kernel=3, stride=2)
fc6 = brew.fc(model, pool5, "fc6", 256 * 6 * 6, 4096, ('XavierFill', {}),
('ConstantFill', {}))
relu6 = brew.relu(model, fc6, "fc6")
dropout1 = brew.dropout(model,
relu6,
'dropout1',
ratio=0.5,
is_test=is_test)
fc7 = brew.fc(model, dropout1, "fc7", 4096, 4096, ('XavierFill', {}),
('ConstantFill', {}))
relu7 = brew.relu(model, fc7, "fc7")
dropout2 = brew.dropout(model,
relu7,
'dropout2',
ratio=0.5,
is_test=is_test)
fc8 = brew.fc(model, dropout2, "fc8", 4096, num_labels, ('XavierFill', {}),
('ConstantFill', {}))
return fc8
def create_alexnet(
model,
data,
num_input_channels,
num_labels,
is_test=False,
):
conv1 = brew.conv(
model,
data,
"conv1",
num_input_channels, # dim_in
64, # dim_out
11, # kernel
('XavierFill', {}),
('ConstantFill', {}),
stride=4,
pad=2)
relu1 = brew.relu(model, conv1, "conv1")
norm1 = brew.lrn(model, relu1, "norm1", size=5, alpha=0.0001, beta=0.75)
pool1 = brew.max_pool(model, norm1, "pool1", kernel=3, stride=2)
conv2 = brew.conv(model,
pool1,
"conv2",
64,
192,
5, ('XavierFill', {}), ('ConstantFill', {}),
pad=2)
relu2 = brew.relu(model, conv2, "conv2")
norm2 = brew.lrn(model, relu2, "norm2", size=5, alpha=0.0001, beta=0.75)
pool2 = brew.max_pool(model, norm2, "pool2", kernel=3, stride=2)
conv3 = brew.conv(model,
pool2,
"conv3",
192,
384,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu3 = brew.relu(model, conv3, "conv3")
conv4 = brew.conv(model,
relu3,
"conv4",
384,
256,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu4 = brew.relu(model, conv4, "conv4")
conv5 = brew.conv(model,
relu4,
"conv5",
256,
256,
3, ('XavierFill', {}), ('ConstantFill', {}),
pad=1)
relu5 = brew.relu(model, conv5, "conv5")
pool5 = brew.max_pool(model, relu5, "pool5", kernel=3, stride=2)
fc6 = brew.fc(model, pool5, "fc6", 256 * 6 * 6, 4096, ('XavierFill', {}),
('ConstantFill', {}))
relu6 = brew.relu(model, fc6, "fc6")
dropout1 = brew.dropout(model,
relu6,
'dropout1',
ratio=0.5,
is_test=is_test)
fc7 = brew.fc(model, dropout1, "fc7", 4096, 4096, ('XavierFill', {}),
('ConstantFill', {}))
relu7 = brew.relu(model, fc7, "fc7")
dropout2 = brew.dropout(model,
relu7,
'dropout2',
ratio=0.5,
is_test=is_test)
fc8 = brew.fc(model, dropout2, "fc8", 4096, num_labels, ('XavierFill', {}),
('ConstantFill', {}))
# pred = brew.softmax(model, fc8, "pred")
# xent = model.net.LabelCrossEntropy([pred, "label"], "xent")
# model.net.AveragedLoss(xent, "loss")
return fc8
