def create(self, dataLayerParams, phase="train"):
n = caffe.NetSpec()
n.data, n.label = L.Python(module="NpyDataLayer",
layer=self.dataLayer,
ntop=2,
param_str=str(dataLayerParams))
n.input_conv = L.Convolution(n.data,
num_output=16,
kernel_size=1,
stride=1,
pad=1,
bias_term=False,
param=[dict(lr_mult=1, decay_mult=1)],
weight_filler=dict(type="xavier"))
n.input_relu = L.ReLU(n.input_conv, in_place=False)
for i in range(len(self.stages)):
for j in range(self.stages[i]):
stageString = self.resnetString
bottomString = 'n.input_relu'
if (i != 0) or (j != 0):
bottomString = 'n.res{}_add'.format(
str(sum(self.stages[:i]) + j))
exec(
stageString.replace('(bottom)', bottomString).replace(
'(output)', str(2**i * 64)).replace(
'(n)', str(sum(self.stages[:i]) + j + 1)))
exec(
'n.pool_ave = L.Pooling(n.res{}_add, pool=P.Pooling.AVE, global_pooling=True)'
.format(str(sum(self.stages))))
n.classifier = L.InnerProduct(n.pool_ave,
num_output=self.classCount,
param=[
dict(lr_mult=1, decay_mult=1),
dict(lr_mult=2, decay_mult=0)
],
weight_filler=dict(type='xavier'),
bias_filler=dict(type='constant',
value=0))
if phase == "train":
n.loss = L.SoftmaxWithLoss(n.classifier, n.label)
elif phase == "test":
n.softmax_out = L.Softmax(n.classifier)
n.accuracy_top1 = L.Accuracy(n.softmax_out,
n.label,
accuracy_param=dict(top_k=1, axis=1))
n.accuracy_top5 = L.Accuracy(n.softmax_out,
n.label,
accuracy_param=dict(top_k=5, axis=1))
else: # deploy
n.softmax_out = L.Softmax(n.classifier)
n.result = L.ArgMax(n.softmax_out, argmax_param=dict(axis=1))
return n.to_proto()
def create(self, dataLayerParams, phase="train"):
n = caffe.NetSpec()
n.data, n.label = L.Python(module="VDataLayer",
layer=self.dataLayer,
ntop=2,
param_str=str(dataLayerParams))
n.input_conv = L.Convolution(n.data,
num_output=16,
kernel_size=1,
stride=1,
pad=1,
bias_term=False,
param=[dict(lr_mult=1, decay_mult=1)],
weight_filler=dict(type="xavier"))
n.input_relu = L.ReLU(n.input_conv, in_place=False)
for i in range(len(self.stages)):
for j in range(self.stages[i]):
stageString = self.resnetString
bottomString = 'n.input_relu'
if (i != 0) or (j != 0):
bottomString = 'n.res{}_add'.format(
str(sum(self.stages[:i]) + j))
exec(
stageString.replace('(bottom)', bottomString).replace(
'(output)', str(2**i * 64)).replace(
'(n)', str(sum(self.stages[:i]) + j + 1)))
exec(
'n.conv_output = L.Convolution(n.res{}_add, num_output=2, kernel_size=1, stride=1, pad=1, bias_term=False, param=[dict(lr_mult=1, decay_mult=1)], weight_filler=dict(type="xavier"))'
.format(str(sum(self.stages))))
# reshape result and label
n.flat_output = L.Reshape(n.conv_output,
reshape_param={"shape": {
"dim": [0, 2, -1]
}})
n.flat_label = L.Reshape(n.label,
reshape_param={"shape": {
"dim": [0, 1, -1]
}})
if phase == "train":
n.softmax_out = L.Softmax(n.flat_output)
n.loss = L.DiceLoss(n.softmax_out, n.flat_label)
elif phase == "test":
n.softmax_out = L.Softmax(n.flat_output)
n.accu = L.DiceLoss(n.softmax_out, n.flat_label)
else: # deploy
n.softmax_out = L.Softmax(n.flat_output)
n.result = L.ArgMax(n.softmax_out, argmax_param=dict(axis=1))
return n.to_proto()
def define_model(self):
n = caffe.NetSpec()
pylayer = 'ClsDataLayer'
pydata_params = dict(phase='train',
data_root=opt.cls_data_root,
batch_size=16,
ratio=5,
augument=True)
n.data, n.pre_prob, _, n.label = L.Python(module='data.ClsDataLayer',
layer=pylayer,
ntop=4,
param_str=str(pydata_params))
n.pre_conv = SingleConv(n.data,
64,
kernel_size=[3, 5, 5],
stride=[1, 1, 1],
padding=0)
n.pre_conv = SingleConv(n.pre_conv,
128,
kernel_size=[3, 3, 3],
stride=[2, 2, 2],
padding=0)
n.res2 = ResBlock(n.pre_conv, 128, z=True)
n.res2 = ResBlock(n.res2, 128)
n.conv = SingleConv(n.res2,
128,
kernel_size=[2, 3, 3],
stride=[1, 1, 1],
padding=[0, 0, 0])
n.conv = SingleConv(n.conv,
128,
kernel_size=[3, 5, 5],
stride=[1, 1, 1],
padding=0)
n.pool = L.Pooling(n.conv,
kernel_size=[6, 3, 3],
stride=1,
pad=0,
pool=P.Pooling.MAX)
# n.features = L.Flatten(n.conv)
# n.hidden = L.InnerProduct(n.features,num_output=256,weight_filler=dict(type='xavier'))
n.cls = L.InnerProduct(n.pool,
num_output=2,
weight_filler=dict(type='xavier'))
n.prob = L.Softmax(n.cls)
n.bprob = L.Eltwise(n.prob,
n.pre_prob,
operation=1,
engine=3,
coeff=0.5)
# n.bprob = L.Power(n.bprob,scale=0.5)
n.loss = L.MultinomialLogisticLoss(n.bprob, n.label)
with open(self.model_def, 'w') as f:
f.write(str(n.to_proto()))
def lenet(lmdb, batch_size):
# our version of LeNet: a series of linear and simple nonlinear transformations
n = caffe.NetSpec()
n.data, n.label = L.Data(batch_size=batch_size,
backend=P.Data.LMDB,
source=lmdb,
transform_param=dict(scale=1. / 255),
ntop=2)
n.conv1 = L.Convolution(n.data,
kernel_size=5,
num_output=20,
weight_filler=dict(type='xavier'))
n.pool1 = L.Pooling(n.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX)
n.conv2 = L.Convolution(n.pool1,
kernel_size=5,
num_output=50,
weight_filler=dict(type='xavier'))
n.pool2 = L.Pooling(n.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX)
n.ip1 = L.InnerProduct(n.pool2,
num_output=500,
weight_filler=dict(type='xavier'))
n.relu1 = L.ReLU(n.ip1, in_place=True)
n.ip2 = L.InnerProduct(n.relu1,
num_output=10,
weight_filler=dict(type='xavier'))
n.loss = L.SoftmaxWithLoss(n.ip2, n.label)
n.score = L.Softmax(n.ip2)
return n.to_proto()
def lenethdf5d():
# our version of LeNet: a series of linear and simple nonlinear transformations
n = caffe.NetSpec()
#cambiano il primo e gli ultimi 2 strati
n.data = L.Input(input_param=dict(shape=dict(dim=[1, 1, 128, 128])))
# the base net
n.conv1, n.relu1 = conv_relu(n.data, 32)
n.pool1 = max_pool(n.relu1)
#n.norm1 = L.LRN(n.pool1, local_size=5, alpha=1e-4, beta=0.75)
n.conv2, n.relu2 = conv_relu(n.pool1, 64)
n.pool2 = max_pool(n.relu2)
n.conv3, n.relu3 = conv_relu(n.pool2, 128)
n.pool3 = max_pool(n.relu3)
# fully convolutional
n.fc1, n.rlfc1 = conv_relu(n.pool3, 512, ks=3, pad=1)
n.decov5 = deconv(n.rlfc1, 128, pad=1)
n.relu5, n.conv5 = relu_conv(n.decov5, 128, pad=0)
n.decov6 = deconv(n.conv5, 64, pad=1)
n.relu6, n.conv6 = relu_conv(n.decov6, 64, pad=0)
n.decov7 = deconv(n.conv6, 32, pad=1)
n.relu7, n.conv7 = relu_conv(n.decov7, 32, pad=0)
n.relu8, n.conv8 = relu_conv(n.conv7, 2, pad=0)
n.prob = L.Softmax(n.conv8)
return n.to_proto()
def define_model(self):
n = caffe.NetSpec()
pylayer = 'ClsDataLayer'
pydata_params = dict(phase='train', data_root=opt.cls_data_root,
batch_size=16,ratio=5,augument=True)
n.data,n.pre_prob,_,n.label = L.Python(module='data.ClsDataLayer', layer=pylayer,
ntop=4, param_str=str(pydata_params))
n.pre_conv=SingleConv(n.data,32,kernel_size=3,stride=1,padding=1)
n.res = ResDown(n.pre_conv,128)
n.res = ResInception(n.res,128)
n.res = ResDown(n.res,512)
n.res = ResInception(n.res,512)
n.res = ResInception(n.res,512)
n.res = ResInception(n.res,512)
n.cls=L.Pooling(n.res, kernel_size=8,stride=1,pad=0, pool=P.Pooling.AVE)
n.cls=L.InnerProduct(n.cls, num_output=2,weight_filler=dict(type='xavier'))
n.prob = L.Softmax(n.cls)
n.bprob = L.Eltwise(n.prob,n.pre_prob,operation=1,engine=3,coeff=0.5)
# n.bprob = L.Power(n.bprob,scale=0.5)
n.loss= L.MultinomialLogisticLoss(n.bprob, n.label)
with open(self.model_def, 'w') as f:
f.write(str(n.to_proto()))
def create_deploy():
# No the first layer: data layer
conv1 = L.Convolution(bottom='data',
kernel_size=5,
stride=1,
num_output=20,
pad=0,
weight_filler=dict(type='xavier'))
pool1 = L.Pooling(conv1, pool=P.Pooling.MAX, kernel_size=2, stride=2)
conv2 = L.Convolution(pool1,
kernel_size=5,
stride=1,
num_output=50,
pad=0,
weight_filler=dict(type='xavier'))
pool2 = L.Pooling(conv2, pool=P.Pooling.MAX, kernel_size=2, stride=2)
fc3 = L.InnerProduct(pool2,
num_output=500,
weight_filler=dict(type='xavier'))
relu3 = L.ReLU(fc3, in_place=True)
fc4 = L.InnerProduct(relu3,
num_output=10,
weight_filler=dict(type='xavier'))
# No accuracy layer, but has softmax layer
prob = L.Softmax(fc4)
return to_proto(prob)
def __create_output_layer(self, n, bottom, deploy):
if deploy:
n['prob'] = L.Softmax(bottom)
else:
n['score/loss'] = L.SoftmaxWithLoss(bottom, n.label)
n['score/top-1'] = L.Accuracy(bottom, n.label, top_k=1)
n['score/top-5'] = L.Accuracy(bottom, n.label, top_k=5)
def create_deploy():
n = caffe.NetSpec()
# n.data, n.label = L.HDF5Data(batch_size = batch_size, source = hdf5, ntop = 2)
# n.data, n.label = L.MemoryData(batch_size = batch_size, channels = 1, height = 28, width = 28, ntop = 2,
# transform_param=dict(scale=1./255))
# 直接少了data层，
# n.data = L.Input(shape = 1)
n.conv1 = L.Convolution(bottom='data',
kernel_size=5,
num_output=20,
weight_filler=dict(type='xavier'))
n.pool1 = L.Pooling(n.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX)
n.conv2 = L.Convolution(n.pool1,
kernel_size=5,
num_output=50,
weight_filler=dict(type='xavier'))
n.pool2 = L.Pooling(n.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX)
n.fc1 = L.InnerProduct(n.pool2,
num_output=500,
weight_filler=dict(type='xavier'))
n.relu1 = L.ReLU(n.fc1, in_place=True)
n.score = L.InnerProduct(n.relu1,
num_output=10,
weight_filler=dict(type='xavier'))
n.loss = L.Softmax(n.score)
return n.to_proto()
def create_deploy():
#少了第一层，data层
conv1 = L.Convolution(bottom='data',
kernel_size=5,
stride=1,
num_output=20,
pad=0,
weight_filler=dict(type='xavier'))
pool1 = L.Pooling(conv1, pool=P.Pooling.MAX, kernel_size=2, stride=2)
conv2 = L.Convolution(pool1,
kernel_size=5,
stride=1,
num_output=50,
pad=0,
weight_filler=dict(type='xavier'))
pool2 = L.Pooling(conv2, pool=P.Pooling.MAX, kernel_size=2, stride=2)
fc3 = L.InnerProduct(pool2,
num_output=500,
weight_filler=dict(type='xavier'))
relu3 = L.ReLU(fc3, in_place=True)
fc4 = L.InnerProduct(relu3,
num_output=10,
weight_filler=dict(type='xavier'))
#最后没有accuracy层，但有一个Softmax层
prob = L.Softmax(fc4)
return to_proto(prob)
def construc_net():
net = caffe.NetSpec()
net.data = L.Input(input_param = dict(shape = dict(dim = [1,3,224,224])))
block1 = _block_first(net, net.data)
net.pool1 = L.Pooling(block1, pool = P.Pooling.MAX, kernel_size = 3, stride = 2)
branch_2a = _branch('2a', net, net.pool1, 64, has_branch1 = True, is_branch_2a = True)
branch_2b = _branch('2b', net, branch_2a, 64)
branch_2c = _branch('2c', net, branch_2b, 64)
branch_3a = _branch('3a', net, branch_2c, 128, has_branch1 = True)
branch_pre = branch_3a
for idx in xrange(1,8,1): # conv3_x total 1+7=8
flag = '3b{}'.format(idx)
branch_pre = _branch(flag, net, branch_pre, 128)
branch_4a = _branch('4a', net, branch_pre, 256, has_branch1 = True)
branch_pre = branch_4a
for idx in xrange(1,36,1): # conv4_x total 1+35=36
flag = '4b{}'.format(idx)
branch_pre = _branch(flag, net, branch_pre, 256)
branch_5a = _branch('5a', net, branch_pre, 512, has_branch1 = True)
branch_5b = _branch('5b', net, branch_5a, 512)
branch_5c = _branch('5c', net, branch_5b, 512)
net.pool5 = L.Pooling(branch_5c, pool = P.Pooling.AVE, kernel_size = 7, stride = 1)
net.fc6 = L.InnerProduct(net.pool5, num_output = 1000)
net.prob = L.Softmax(net.fc6)
return net.to_proto()
def gen_train_proto_single(target_interface, shape=(28, 28, 3)):
path = path_origin + '/train_' + target_interface + '.prototxt'
n = caffe.NetSpec()
n.data = L.DummyData(shape=dict(dim=[1, 3, shape[0], shape[1]]))
if target_interface == 'conv1':
n.conv1 = L.Convolution(n.data,
kernel_size=11,
stride=4,
num_output=1,
weight_filler={
"type": "constant",
"value": 1
})
elif target_interface == 'pool1':
n.pool1 = L.Pooling(n.data,
kernel_size=2,
stride=2,
pool=P.Pooling.MAX)
elif target_interface == 'pool2':
n.pool2 = L.Pooling(n.data,
kernel_size=2,
stride=2,
pool=P.Pooling.AVE)
elif target_interface == 'relu1':
n.relu1 = L.ReLU(n.data)
elif target_interface == 'sigmoid1':
n.sigmoid1 = L.Sigmoid(n.data)
elif target_interface == 'softmax1':
n.softmax1 = L.Softmax(n.data)
elif target_interface == 'tanh1':
n.tanh1 = L.TanH(n.data)
save_proto(n.to_proto(), path)
return path
def test_softmax2():
# type: ()->caffe.NetSpec
n = caffe.NetSpec()
n.input1 = L.Input(shape=make_shape([6, 4, 64, 64]))
n.softmax1 = L.Softmax(n.input1, axis=2)
return n
def assemble_net(self, lmdb, mean_file, proto_filename, batch_size, crop_size,img_channels, phase):
layer_dict = {}
n = caffe.NetSpec()
if phase in ['Train', 'TRAIN','train']:
dropout_flag = True
loss_layer_flag = True
prob_layer_flag = False
acc_layer_flag = True
if phase in ['test', 'TEST', 'Test']:
dropout_flag = False
loss_layer_flag = True
prob_layer_flag = False
acc_layer_flag = True
if phase in ['deploy', 'DEPLOY', 'Deploy']:
dropout_flag = False
loss_layer_flag = False
prob_layer_flag = True
acc_layer_flag = False
if phase in ['deploy', 'DEPLOY', 'Deploy']:
n.data = L.Input(input_param= {'shape':{'dim':[1,img_channels,crop_size,crop_size]}})
else:
n.data, n.label = L.Data(transform_param={'crop_size': crop_size, 'mean_file':mean_file}, data_param={'source':lmdb,'batch_size':batch_size, 'backend': P.Data.LMDB},
ntop=2)
for i, layer_name in enumerate(self.topology):
#print layer_name
if 'conv' in layer_name:
if i==0:
n.conv = self.conv2d(n.data, layer_name)
else:
n.conv = self.conv2d(layer_dict[str(i-1)], layer_name)
layer_dict[str(i)] = n.conv
elif 'pool' in layer_name:
pool_params = {'pool': 0, 'kernel_size': 3, 'stride': 2}
n.pool = L.Pooling(layer_dict[str(i - 1)], pooling_param=pool_params, name=layer_name)
layer_dict[str(i)] = n.pool
elif 'fc' in layer_name or 'output' in layer_name:
n.fc = self.fc(layer_dict[str(i - 1)], layer_name, dropout_flag)
layer_dict[str(i)] = n.fc
elif 'lrn' in layer_name:
n.norm = L.LRN(layer_dict[str(i - 1)], local_size=5, alpha=1e-4, beta=0.75, name=layer_name)
layer_dict[str(i)] = n.norm
if loss_layer_flag:
n.loss = L.SoftmaxWithLoss(layer_dict[str(i)], n.label, name='loss')
if prob_layer_flag:
n.prob = L.Softmax(layer_dict[str(i)], name='loss')
if acc_layer_flag:
n.accuracy = L.Accuracy(layer_dict[str(i)], n.label, name='accuracy')
print layer_dict
with open(proto_filename, 'w') as f:
f.write(str(n.to_proto()))
def create_deploy():
#少了第一层，data层
conv1 = L.Convolution(bottom = "data", kernel_size=5, stride=1, num_output=20, pad=4, weight_filler=dict(type='xavier'))
# 激活函数层
relu1 = L.ReLU(conv1, in_place=True)
# 卷积层
conv2 = L.Convolution(relu1, kernel_size=5, stride=1, num_output=50, pad=4, weight_filler=dict(type='xavier'))
# 激活函数层
relu2 = L.ReLU(conv2, in_place=True)
# 池化层
pool1 = L.Pooling(relu2, pool=P.Pooling.MAX, kernel_size=2, stride=2)
# 第二层：卷积层
conv3 = L.Convolution(pool1, kernel_size=5, stride=1, num_output=20, pad=4, weight_filler=dict(type='xavier'))
# 激活函数层
relu3 = L.ReLU(conv3, in_place=True)
# 卷积层
conv4 = L.Convolution(relu3, kernel_size=5, stride=1, num_output=50, pad=4, weight_filler=dict(type='xavier'))
# 激活函数层
relu4 = L.ReLU(conv4, in_place=True)
# 全连接层
fc3 = L.InnerProduct(relu4, num_output=500, weight_filler=dict(type='xavier'))
# 激活函数层
relu3 = L.ReLU(fc3, in_place=True)
# 全连接层
fc4 = L.InnerProduct(relu3, num_output=10, weight_filler=dict(type='xavier'))
#最后没有accuracy层，但有一个Softmax层
prob=L.Softmax(fc4)
return to_proto(prob)
def minivggnet(data,
labels=None,
train=False,
cudnn=False,
param=learned_param,
num_classes=100,
with_labels=True):
"""
Returns a protobuf text file specifying a variant of VGG
"""
n = caffe.NetSpec()
n.data = data
conv_kwargs = dict(param=param, train=train, cudnn=cudnn)
n.conv1, n.relu1 = conv_relu(n.data, 7, 96, stride=2, **conv_kwargs)
n.norm1 = L.LRN(n.relu1, local_size=5, alpha=0.0005, beta=0.75, k=2)
n.pool1 = max_pool(n.norm1, 3, stride=3, train=train, cudnn=cudnn)
n.conv2, n.relu2 = conv_relu(n.pool1,
5,
256,
pad=1,
stride=2,
group=2,
**conv_kwargs)
n.pool2 = max_pool(n.relu2, 2, stride=2, train=train, cudnn=cudnn)
n.conv3, n.relu3 = conv_relu(n.pool2, 3, 512, pad=1, **conv_kwargs)
n.conv4, n.relu4 = conv_relu(n.relu3,
3,
512,
pad=1,
group=2,
**conv_kwargs)
n.conv5, n.relu5 = conv_relu(n.relu4,
3,
512,
pad=1,
group=2,
**conv_kwargs)
n.pool5 = max_pool(n.relu5, 3, stride=3, train=train, cudnn=cudnn)
n.fc6, n.relu6 = fc_relu(n.pool5, 1024, param=param)
n.drop6 = L.Dropout(n.relu6, in_place=True)
n.fc7, n.relu7 = fc_relu(n.drop6, 1024, param=param)
n.drop7 = L.Dropout(n.relu7, in_place=True)
preds = n.fc8 = L.InnerProduct(n.drop7,
num_output=num_classes,
param=param)
if not train:
# Compute the per-label probabilities at test/inference time.
preds = n.probs = L.Softmax(n.fc8)
if with_labels:
n.label = labels
n.loss = L.SoftmaxWithLoss(n.fc8, n.label)
n.accuracy_at_1 = L.Accuracy(preds, n.label)
n.accuracy_at_5 = L.Accuracy(preds,
n.label,
accuracy_param=dict(top_k=5))
else:
n.ignored_label = labels
n.silence_label = L.Silence(n.ignored_label, ntop=0)
return to_tempfile(str(n.to_proto()))
def caffenet(data,
label=None,
train=True,
num_classes=1000,
classifier_name='fc8',
learn_all=False):
"""Returns a NetSpec specifying CaffeNet, following the original proto text
specification (./models/bvlc_reference_caffenet/train_val.prototxt)."""
n = caffe.NetSpec()
n.data = data
# frozen ?? #
# 解释：如果只训练最后一层即全连接层，那么其他层的参数都不变也就是frozen
param = learned_param if learn_all else frozen_param
n.conv1, n.relu1 = conv_relu(n.data, 11, 96, stride=4, param=param)
n.pool1 = max_pool(n.relu1, 3, stride=2)
n.norm1 = L.LRN(n.pool1, local_size=5, alpha=1e-4, beta=0.75)
n.conv2, n.relu2 = conv_relu(n.norm1, 5, 256, pad=2, group=2, param=param)
n.pool2 = max_pool(n.relu2, 3, stride=2)
n.norm2 = L.LRN(n.pool2, local_size=5, alpha=1e-4, beta=0.75)
n.conv3, n.relu3 = conv_relu(n.norm2, 3, 384, pad=1, param=param)
n.conv4, n.relu4 = conv_relu(n.relu3, 3, 384, pad=1, group=2, param=param)
n.conv5, n.relu5 = conv_relu(n.relu4, 3, 256, pad=1, group=2, param=param)
n.pool5 = max_pool(n.relu5, 3, stride=2)
n.fc6, n.relu6 = fc_relu(n.pool5, 4096, param=param)
## 这个if else 目的是什么？ ##
# 如果只预测不训练，params取多少都无所谓，因为不用反向传播，如果需要训练，那么就得分情况啦
# 如果训练，则还要增加一个层：L.Dropout
if train:
n.drop6 = fc7input = L.Dropout(n.relu6, in_place=True)
else:
fc7input = n.relu6
n.fc7, n.relu7 = fc_relu(fc7input, 4096, param=param)
if train:
n.drop7 = fc8input = L.Dropout(n.relu7, in_place=True)
else:
fc8input = n.relu7
# always learn fc8 (param=learned_param)
fc8 = L.InnerProduct(fc8input, num_output=num_classes, param=learned_param)
# give fc8 the name specified by argument `classifier_name`
n.__setattr__(classifier_name, fc8)
# 对于只预测不训练，当然只是输出每种类型对应的可能结果啦
if not train:
n.probs = L.Softmax(fc8)
# 对于要训练的，那么就是得输出训练集的损失函数和正确率啦
if label is not None:
n.label = label
n.loss = L.SoftmaxWithLoss(fc8, n.label)
n.acc = L.Accuracy(fc8, n.label)
# write the net to a temporary file and return its filename
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(str(n.to_proto()))
print(n.to_proto())
return f.name
def main():
parser = argparse.ArgumentParser(
description='Build a model for Edge Classification')
parser.add_argument('output_prototxt',
type=str,
help='Output prototxt file')
parser.add_argument('-n',
'--num-classes',
type=int,
default=5,
help='Number of output classes (default 5)')
args = parser.parse_args()
n = caffe.NetSpec()
n['conv1'] = L.Convolution(bottom='data',
kernel_size=3,
stride=1,
pad=1,
num_output=16,
weight_filler=dict(type='msra'),
bias_term=False)
n['bn1'] = L.BatchNorm(
n['conv1'], param=[dict(lr_mult=0),
dict(lr_mult=0),
dict(lr_mult=0)])
n['relu1'] = L.ReLU(n['bn1'], in_place=True)
top = residual_block(n, n['relu1'], num_output=64, first_stride=1)
top = residual_block(n, top, num_output=128)
top = residual_block(n, top, num_output=256)
n['conv_final'] = L.Convolution(top,
kernel_size=3,
stride=1,
pad=1,
num_output=args.num_classes,
weight_filler=dict(type='msra'),
bias_filler=dict(type='constant'))
n['relu_final'] = L.ReLU(n['conv_final'], in_place=True)
n['global_pool'] = L.Pooling(n['relu_final'],
pool=P.Pooling.AVE,
global_pooling=True)
n['loss'] = L.SoftmaxWithLoss(
bottom=['global_pool', 'label'],
include=[dict(phase=caffe.TRAIN),
dict(phase=caffe.TEST, stage='val')],
exclude=dict(phase=caffe.TEST, stage='deploy'))
n['accuracy'] = L.Accuracy(bottom=['global_pool', 'label'],
include=dict(phase=caffe.TEST, stage='val'))
n['prob'] = L.Softmax(bottom='global_pool',
include=dict(phase=caffe.TEST, stage='deploy'))
net = n.to_proto()
net.name = 'EdgeNet-Res'
with open(args.output_prototxt, 'wb') as f:
f.write(str(net))
def vgg16_score(input_param = dict(shape=dict(dim=[1, 3, 224, 224]))): # setup the python data layer net = caffe.NetSpec() net['data'] = L.Input(input_param = input_param) net, final = vgg16_body(net, 'data', '', is_train=False) net['score'] = fc_relu(net[final], nout=751, is_train=False, has_relu=False) net['prediction'] = L.Softmax(net['score']) return str(net.to_proto())
def convLayerSoftmax(prev, bn=False, **kwargs):
conv = L.Convolution(prev,
param=[dict(lr_mult=1),
dict(lr_mult=2)],
weight_filler=dict(type='msra'),
**kwargs)
probs = L.Softmax(conv)
return probs
def MaskNet_Val_MTD(net,
from_layer="data",
label="label",
lr=1,
decay=1,
visualize=False):
# net = YoloNetPart(net, from_layer=from_layer, use_bn=True, use_layers=6, use_sub_layers=7, lr=0, decay=0)
net, mbox_layers, parts_layers = MTD_BODY(net)
net.bbox, net.parts = L.SplitLabel(net[label],
name="SplitLabel",
ntop=2,
split_label_param=dict(add_parts=True))
# ConvBNUnitLayer(net,"conv2", "conv2_pool", use_bn=True, use_relu=True, num_output=64,
# kernel_size=1, pad=0, stride=2)
# net = UnifiedMultiScaleLayers(net,layers=["conv2_pool","conv3_3","conv4_3"],tags=["Down","Down","Ref"],unifiedlayer="featuremap1",dnsampleMethod=[["Conv"],["MaxPool"]],dnsampleChannels=64)
# net = UnifiedMultiScaleLayers(net,layers=["conv4_3","conv5_5"],tags=["Down","Ref"],unifiedlayer="featuremap2",dnsampleMethod=[["MaxPool"]])
# net = UnifiedMultiScaleLayers(net,layers=["conv5_5","conv6_7"],tags=["Down","Ref"],unifiedlayer="featuremap3",dnsampleMethod=[["MaxPool"]],pad=True)
# mbox_layers = SSDHeader(net,data_layer="data",from_layers=["featuremap1","featuremap2","featuremap3"],input_height=Input_Height,input_width=Input_Width,loc_postfix='det',**ssdparam)
reshape_name = "mbox_conf_reshape"
net[reshape_name] = L.Reshape(mbox_layers[1], \
shape=dict(dim=[0, -1, ssdparam.get("num_classes",2)]))
softmax_name = "mbox_conf_softmax"
net[softmax_name] = L.Softmax(net[reshape_name], axis=2)
flatten_name = "mbox_conf_flatten"
net[flatten_name] = L.Flatten(net[softmax_name], axis=1)
mbox_layers[1] = net[flatten_name]
net.detection_out = L.DenseDetOut(
*mbox_layers,
detection_output_param=det_out_param,
include=dict(phase=caffe_pb2.Phase.Value('TEST')))
net.detection_eval_accu = L.DetEval(
net.detection_out,
net.bbox,
detection_evaluate_param=det_eval_param,
include=dict(phase=caffe_pb2.Phase.Value('TEST')))
# net = UnifiedMultiScaleLayers(net,layers=["conv2","conv3_3"],tags=["Down","Ref"],unifiedlayer="conf23",dnsampleMethod=[["Conv"]],dnsampleChannels=64)
# net = UnifiedMultiScaleLayers(net,layers=["conf23","conv4_3"],tags=["Down","Ref"],unifiedlayer="conf34",dnsampleMethod=[["MaxPool"]])
# net = UnifiedMultiScaleLayers(net,layers=["conv3_3","conv4_3"],tags=["Down","Ref"],unifiedlayer="conf34",dnsampleMethod=[["MaxPool"]])
# net = UnifiedMultiScaleLayers(net,layers=["conf34","conv5_5"],tags=["Down","Ref"],unifiedlayer="conf45",dnsampleMethod=[["MaxPool"]])
# # net = UnifiedMultiScaleLayers(net,layers=["conf45","conv6_7"],tags=["Down","Ref"],unifiedlayer="conf56",dnsampleMethod=[["MaxPool"]],pad=True)
# parts_layers = SSDHeader(net,data_layer="data",from_layers=["conf34","conf45","conv6_7"],input_height=Input_Height,input_width=Input_Width,loc_postfix='parts',**partsparam)
# parts_layers = SSDHeader(net,data_layer="data",from_layers=["conf23","conf34","conf45","conf56"],input_height=Input_Height,input_width=Input_Width,loc_postfix='parts',**partsparam)
sigmoid_name = "parts_conf_sigmoid"
net[sigmoid_name] = L.Sigmoid(parts_layers[1])
parts_layers[1] = net[sigmoid_name]
net.parts_out = L.DenseDetOut(
*parts_layers,
detection_output_param=parts_out_param,
include=dict(phase=caffe_pb2.Phase.Value('TEST')))
net.parts_eval_accu = L.DetEval(
net.parts_out,
net.parts,
detection_evaluate_param=parts_eval_param,
include=dict(phase=caffe_pb2.Phase.Value('TEST')))
# net.out=L.Concat(net.detection_eval_accu,net.parts_eval_accu,axis=2)
return net
def convert_configuration(config, train=False, loc_layer=False):
""" given a list of YOLO layers as dictionaries, convert them to Caffe """
layers = []
conv_layers = []
count = 0
reorg_count = 0
concat_count = 0
region_count = 0
conv_count = 0
for section, params in config:
if section == "net":
input_params = params
layers.append(data_layer("data", input_params, train))
elif section == "crop":
if train: # update data layer with crop parameters
input_params.update(params)
layers[-1] = data_layer("data", input_params, train)
elif section == "convolutional":
conv_count += 1
count += 1
add_convolutional_layer(layers, count, params, train)
conv_layers.append(layers[-1])
elif section == "maxpool":
layers.append(max_pooling_layer(layers[-1], "pool{0}".format(count),
params))
elif section == "avgpool":
layers.append(global_pooling_layer(layers[-1], "pool{0}".format(count)))
elif section == "softmax":
layers.append(cl.Softmax(layers[-1], name="softmax{0}".format(count)))
elif section == "connected":
count += 1
add_dense_layer(layers, count, params, train)
elif section == "route":
concat_count += 1
layers.append(cl.Concat(conv_layers[-8], name="concat{0}".format(concat_count)))
elif section == "reorg":
reorg_count += 1
add_reorg_layer(layers, reorg_count, params, train)
elif section == "region":
region_count += 1
add_regionloss_layer(layers, reorg_count, params, train)
elif section == "dropout":
if train:
layers.append(cl.Dropout(layers[-1], name="drop{0}".format(count),
dropout_ratio=float(params["probability"])))
elif section == "local" and loc_layer:
count += 1
add_local_layer(layers, count, params, train)
else:
print("WARNING: {0} layer not recognized".format(section))
model = caffe.NetSpec()
for layer in layers:
setattr(model, layer.fn.params["name"], layer)
model.result = layers[-1]
return model
def construct_model(self,
net_cfg,
lmdb,
batch_size=256,
train_val=False,
deploy=False):
net = caffe.NetSpec()
if train_val:
net.data, net.label = L.Data(name='data',
source=lmdb,
backend=P.Data.LMDB,
batch_size=batch_size,
ntop=2,
include=dict(phase=caffe.TRAIN))
elif deploy:
net.data = L.Input(
name='data',
ntop=1,
shape=dict(dim=[
batch_size, self.img_channels, self.img_rows, self.img_rows
]),
include=dict(phase=caffe.TEST))
# 7x7 convolution followed by 3x3 max pooling
net.conv1 = conv_bn_scale_relu(net.data, 7, 64, stride=2, pad=3)
net.pool1 = L.Pooling(net.conv1,
pool=P.Pooling.MAX,
kernel_size=2,
stride=2)
# Build the denseblock
_out = net.pool1
dense_block_id = 0
for i, item in enumerate(net_cfg):
layer_type = item['Type']
if layer_type == 'DenseBlock':
_out = dense_block(net, _out, item['KernelNum'],
dense_block_id, item['LayerNum'])
dense_block_id += 1
elif layer_type == 'Transition':
_out = transition_layer(_out, item['KernelNum'])
elif layer_type == 'Classification':
_out = classfication_layer(_out, item['OutputNum'])
else:
raise ValueError, 'layer_type not supported' + item['Type']
#Connect full connected network to softmax
net.fc = _out
if train_val:
net.loss = L.SoftmaxWithLoss(net.fc, net.label)
net.acc = L.Accuracy(net.fc,
net.label,
include=dict(phase=caffe.TEST))
if deploy:
net.prob = L.Softmax(net.fc, name='prob')
return net.to_proto()
def densenet(net_cfg=None,
data_cfg=None,
batch_size=None,
mode='train',
datafile=None):
if mode == 'deploy':
data = L.Input(name='data',
ntop=1,
shape=dict(dim=data_cfg['imgsize']))
else:
data, label = L.Data(name='data',
source=datafile,
backend=P.Data.LMDB,
batch_size=batch_size,
ntop=2,
transform_param=dict(mirror=True,
crop_size=32,
mean_value=[0, 0, 0],
scale=1))
if data_cfg['Dataset'] == 'IMAGENET':
# 7x7 convolution followed by 3x3 max pooling
conv1 = conv_bn_scale_relu(data, 7, 64, stride=2, pad=3)
pool1 = L.Pooling(conv1, pool=P.Pooling.MAX, kernel_size=3, stride=2)
_out = pool1
if data_cfg['Dataset'] == 'CIFAR':
# 3x3 convolution
# conv1 = L.Convolution(data, kernel_size=3, stride=1, num_output=nchannels,
# pad=1, bias_term=False, weight_filler=dict(type='msra'), bias_filler=dict(type='constant'))
conv1 = conv_bn_scale_relu(data, 3, 24, stride=1, pad=1)
_out = conv1
# Build the denseblock
dense_block_id = 0
for i, item in enumerate(net_cfg):
layer_type = item['Type']
if layer_type == 'DenseBlock':
_out = dense_block(_out, item['conv1Num'], item['conv3Num'],
dense_block_id, item['layerNum'],
item['dropout'])
dense_block_id += 1
elif layer_type == 'Transition':
_out = transition_layer(_out, item['conv1Num'])
elif layer_type == 'Classification':
_out = classfication_layer(_out, item['OutputNum'])
else:
raise ValueError, 'layer_type not supported' + item['Type']
#Connect full connected network to softmax
fc = _out
if mode == 'deploy':
prob = L.Softmax(fc, name='prob')
return to_proto(prob)
else:
loss = L.SoftmaxWithLoss(fc, label)
acc = L.Accuracy(fc, label)
return to_proto(loss, acc)
def add_classify_header(net, classes=120): bottom = net.tops.keys()[-1] net.global_pool = L.Pooling(net[bottom], pool=P.Pooling.AVE, global_pooling=True) net.classifier = L.InnerProduct(net.global_pool, num_output=classes, bias_term=True, weight_filler=dict(type='xavier'), bias_filler=dict(type='constant')) net.prob = L.Softmax(net.classifier) return net
def make_deploy_net(config):
configuration = get_configuration(config)
variant = configuration.get('variant', 'v0')
num_hidden_layers = len(configuration['layer_dims']) - 2
layers_dims = configuration['layer_dims']
ns = caffe.NetSpec()
ns.input_hot_vecotr = L.Input(name='input_hot_vecotr', ntop=1, input_param={'shape': {'dim': [1, SEQ_GLOBALS.DIM]}})
# # hiddens
# rec_param = {'debug': False,
# 'output_shapes': [(1, h_) for h_ in layers_dims[1:-1]]}
# hiddens = L.Python(name='recurrence_handler', ntop=num_hidden_layers,
# python_param={'module': 'r2d2_text',
# 'layer': 'recurrence_handler',
# 'param_str': json.dumps(rec_param)})
# input hiddens
hidden_in = []
for li in xrange(num_hidden_layers):
hin = L.Parameter(name='h{}_t0'.format(li),
parameter_param={'shape':{'dim':[1, layers_dims[li+1]]}},
param={'lr_mult': 0, 'decay_mult': 0, 'name': 'h{}_share'.format(li)})
ns.__setattr__('h{}_t0'.format(li), hin)
hidden_in.append(('h{}_t0'.format(li), hin))
if variant == 'v0':
ns, outputs = one_time_step_v0(ns, ns.input_hot_vecotr, hidden_in, layers_dims,
prefix_='v0_t0', phase=caffe.TEST)
elif variant == 'v1':
ns, outputs = one_time_step_v1(ns, ns.input_hot_vecotr, hidden_in, layers_dims,
prefix_='v1_t0', phase=caffe.TEST)
elif variant == 'v2':
ns, outputs = one_time_step_v2(ns, ns.input_hot_vecotr, hidden_in, layers_dims,
prefix_='v2_t0', phase=caffe.TEST)
elif variant in ('vnl', 'vanilla', 'rnn'):
ns, outputs = one_time_step_vanilla(ns, ns.input_hot_vecotr, hidden_in, layers_dims,
prefix_='vnl_t0', phase=caffe.TEST)
else:
raise Exception('unknown variant {}'.format(variant))
# take care of hiddens of last time step...
param = []
inputs = []
for li in xrange(num_hidden_layers):
param.append({'lr_mult': 0, 'decay_mult': 0, 'name': 'h{}_share'.format(li)})
inputs.append(outputs[li][1])
ns.keeing_hidden_states = L.Python(*inputs, name='keeing_hidden_states', ntop=0,
python_param={'module': 'r2d2_text', 'layer': 'parameter_in'},
param=param)
# add SoftmaxLayer
ns.prob = L.Softmax(outputs[-1][1], name='prob', softmax_param={'axis': -1})
deploy_file_name = os.path.join(configuration['base_dir'], config + '_deploy.prototxt')
with open(deploy_file_name, 'w') as W:
W.write(str(ns.to_proto()))
net = caffe.Net(deploy_file_name, caffe.TEST)
return net
def create_deploy_net():
'''创建部署模型'''
# 建立缩写
from caffe import layers as L, params as P
n = caffe.NetSpec()
n.data = L.Input(input_param=dict(shape=dict(dim=[1, 1, 28, 28])))
n = create_net_body(n)
n.prob = L.Softmax(n.ip2)
return n
def tail(ns, index_width=1):
pool_params = dict(pool=pb2.PoolingParameter.AVE, global_pooling=True)
ns['avgpool'] = L.Pooling(ns[ns.keys()[-1]], **pool_params)
conv10_params = dict(kernel_size=1,
num_output=1000,
weight_filler=default_weight_filler,
bias_filler=dict(type='constant', value=0),
param=dict(lr_mult=2, decay_mult=0))
conv_index = get_conv_index(ns) + 1
ns[f'conv{conv_index:0{index_width}d}'] = L.Convolution(
ns[ns.keys()[-1]], **conv10_params)
ns['prob'] = L.Softmax(ns[ns.keys()[-1]])
def roi_proposals(net,
rpn_cls_score_reshape,
rpn_bbox_pred,
im_info,
anchors,
feat_stride,
scales,
classes,
out_w,
deploy=False):
net["rpn_cls_prob"] = L.Softmax(rpn_cls_score_reshape, name="rpn_cls_prob")
net["rpn_cls_prob_reshape"] = L.Reshape(net["rpn_cls_prob"], name="rpn_cls_prob_reshape", \
reshape_param={"shape": {"dim": [0, 2 * anchors, -1, 0]}})
if not deploy:
net["rpn_rois"] = L.Python(
net["rpn_cls_prob_reshape"],
rpn_bbox_pred,
im_info,
name='proposal',
python_param=dict(module='rpn.proposal_layer',
layer='ProposalLayer',
param_str='{"feat_stride": %s,"scales": %s}' %
(feat_stride, scales)),
# param_str='"feat_stride": %s \n "scales": !!python/tuple %s ' %(feat_stride, scales)),
ntop=1,
)
net["rois"], net["labels"], net["bbox_targets"], net["bbox_inside_weights"], net[
"bbox_outside_weights"] \
, net["mask_rois"], net["masks"] = \
L.Python(net["rpn_rois"], net["gt_boxes"], net["ins"],
name='roi-data',
python_param=dict(
module='rpn.proposal_target_layer',
layer='ProposalTargetLayer',
param_str='{"num_classes": %s,"out_size": %s}' % (classes, out_w)),
ntop=7, )
return net["rois"], net["labels"], net["bbox_targets"], net["bbox_inside_weights"], \
net["bbox_outside_weights"], net["mask_rois"], net["masks"]
else:
net["rois"], net["scores"] = L.Python(
net["rpn_cls_prob_reshape"],
rpn_bbox_pred,
im_info,
name='proposal',
python_param=dict(module='rpn.proposal_layer',
layer='ProposalLayer',
param_str='{"feat_stride": %s,"scales": %s}' %
(feat_stride, scales)),
# param_str='"feat_stride": %s \n "scales": !!python/tuple %s ' %(feat_stride, scales)),
ntop=2,
)
return net["rois"], net["scores"]
def net_def(self, phase):
print('sizes', self.cmd.sizes, file = sys.stderr)
print('types', self.cmd.types, file = sys.stderr)
if len(self.cmd.sizes) != len(self.cmd.types):
raise Exception
n = caffe.NetSpec()
name = ''
for i in range(len(self.cmd.types)):
if self.cmd.types[i] == 'data':
name = 'data'
if phase == caffe.TRAIN:
n[name], n.label = L.Python(
module = 'solver',
layer = 'DataLayer',
ntop = 2,
)
else:
n[name] = L.Python(
module = 'solver',
layer = 'DataLayer',
)
else:
fc = L.InnerProduct(
n[name],
inner_product_param = {'num_output': self.cmd.sizes[i],
'weight_filler': {'type': 'xavier',
'std': 0.1},
'bias_filler': {'type': 'constant',
'value': 0}})
name = 'fc%d' % i
n[name] = fc
if self.cmd.types[i] == 'relu':
relu = L.ReLU(n[name], in_place = True)
name = 'relu%d' % i
n[name] = relu
elif self.cmd.types[i] == 'loss':
if self.cmd.regression:
if phase == caffe.TRAIN:
n.loss = L.EuclideanLoss(n[name], n.label)
else:
if phase == caffe.TRAIN:
n.loss = L.SoftmaxWithLoss(n[name], n.label)
else:
n.output = L.Softmax(n[name])
else:
raise Exception('TODO unsupported: ' + self.cmd.types[i])
return n.to_proto()
