def train_FNNSR(train_data=train_data_path, test_data=test_data_path,
batch_size_train=batch_size_train, batch_size_test=batch_size_test,
depth=depth, channel=channel, kernel=kernel):
net = caffe.NetSpec()
net.data, net.label = L.HDF5Data(hdf5_data_param={'source': train_data,
'batch_size': batch_size_train}, include={'phase': caffe.TRAIN}, ntop=2)
train_data_layer = str(net.to_proto())
net.data, net.label = L.HDF5Data(hdf5_data_param={'source': test_data,
'batch_size': batch_size_test}, include={'phase': caffe.TEST}, ntop=2)
## pointwise product
net.layer_out = weight_smooth(net.data, kernel)
for i in range(channel-1):
net.model = weight_smooth(net.data, kernel)
net.layer_out = L.Eltwise(net.layer_out, net.model)
net.S = net.layer_out
for j in range(depth-1):
net.layer_in = net.layer_out
## pointwise product
net.layer_out = weight_smooth(net.layer_in, kernel)
for i in range(channel - 1):
net.model = weight_smooth(net.layer_in, kernel)
net.layer_out = L.Eltwise(net.layer_out, net.model)
net.S = L.Eltwise(net.S, net.layer_out)
net.P = weighting(net.S)
net.loss = L.EuclideanLoss(net.P, net.label)
return train_data_layer + str(net.to_proto())
def create_architecture(self, mode, hdf5_data):
"""Returns the architecture (i.e., caffe prototxt) of the model.
Jer: One day this should probably be written to be more general.
"""
arch = self.arch
pars = self.pars
n = caffe.NetSpec()
if mode == 'deploy':
n.data = L.DummyData(shape=[dict(dim=pars['deploy_dims'])])
elif mode == 'train':
n.data, n.label = L.HDF5Data(batch_size=pars['train_batch_size'], source=hdf5_data, ntop=pars['ntop'])
else: # Test.
n.data, n.label = L.HDF5Data(batch_size=pars['test_batch_size'], source=hdf5_data, ntop=pars['ntop'])
# print(n.to_proto())
in_layer = n.data
for layer in arch:
layer_type, vals = layer
if layer_type == 'e2e':
in_layer = n.e2e = e2e_conv(in_layer, vals['n_filters'], vals['kernel_h'], vals['kernel_w'])
elif layer_type == 'e2n':
in_layer = n.e2n = e2n_conv(in_layer, vals['n_filters'], vals['kernel_h'], vals['kernel_w'])
elif layer_type == 'fc':
in_layer = n.fc = full_connect(in_layer, vals['n_filters'])
elif layer_type == 'out':
n.out = full_connect(in_layer, vals['n_filters'])
# Rename to user specified unique layer name.
# n.__setattr__('out', n.new_layer)
elif layer_type == 'dropout':
in_layer = n.dropout = L.Dropout(in_layer, in_place=True,
dropout_param=dict(dropout_ratio=vals['dropout_ratio']))
elif layer_type == 'relu':
in_layer = n.relu = L.ReLU(in_layer, in_place=True,
relu_param=dict(negative_slope=vals['negative_slope']))
else:
raise ValueError('Unknown layer type: ' + str(layer_type))
# ~ end for.
if mode != 'deploy':
if self.pars['loss'] == 'EuclideanLoss':
n.loss = L.EuclideanLoss(n.out, n.label)
else:
ValueError("Only 'EuclideanLoss' currently implemented for pars['loss']!")
return n
def lenethdf5(hdf5, batch_size):
# Net: a series of linear and simple nonlinear transformations
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
# the base net
n.conv1, n.relu1 = conv_relu(n.data, 32)
n.pool1 = max_pool(n.relu1)
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.accuracy = L.Accuracy(n.conv8, n.label)
n.loss = L.SoftmaxWithLoss(n.conv8, n.label)
return n.to_proto()
def modeltest(hdf5s, hdf5t, batch_size):
#logistic regression: data, matrix multiplication, and 2-class softmax loss
n = caffe.NetSpec()
#n.data, n.lp_label, n.bag_label = L.HDF5Data(batch_size=batch_size, source=hdf5t, ntop=3)
#n.data, n.lp_label, n.instance_label = L.HDF5Data(batch_size=batch_size, source=hdf5t, ntop=3)
#n.data, n.lp_label = L.HDF5Data(batch_size=batch_size, source=hdf5t, ntop=2)
n.data, n.lp_label, n.bag_label, n.instance_label = L.HDF5Data(batch_size=batch_size, source=hdf5t, ntop=4)
n.dc_label=L.DummyData(data_filler=dict(type='constant', value=1), num=batch_size, channels=1, height=1, width=1)
n.ip1 = L.InnerProduct(n.data, num_output=neuronL1, weight_filler=dict(type='xavier'))
n.relu1 = L.Sigmoid(n.ip1, in_place=True)
#n.dropout1 = L.Dropout(n.relu1, dropout_ratio=0.5)
n.ip2 = L.InnerProduct(n.relu1, num_output=neuronL1-400, weight_filler=dict(type='xavier'))
n.target_feature=L.Split(n.ip2)
n.ip4 = L.InnerProduct(n.target_feature, num_output=1, weight_filler=dict(type='xavier'))
#n.ip5=L.Sigmoid(n.ip4, in_place=True)
#n.real, n.ip3 = L.Python(n.source_feature, n.lp_label, n.bag_label, module= 'missSVM', layer='missSVMLayer', ntop=2)
#n.ip3 = L.InnerProduct(n.source_feature, num_output=1, weight_filler=dict(type='xavier'))
#n.accuracy = L.Accuracy(n.ip4, n.lp_label)
#L.Silence(n.bag_label);
#n.losslp = L.Python(n.ip4, n.lp_label, n.bag_label, module = 'GMloss', layer='MultipleInstanceLossLayer')
#n.P , n.Y = L.Python(n.ip4, n.lp_label, n.bag_label, module = 'MIloss', layer='MultipleInstanceLossLayer', ntop=2)
#n.losslp = L.SigmoidCrossEntropyLoss(n.P, n.Y)
n.losslp = L.SigmoidCrossEntropyLoss(n.ip4, n.lp_label)
#n.losstlp = L.SigmoidCrossEntropyLoss(n.ip4, n.lp_label)
n.grl= L.GradientScaler(n.ip2, lower_bound=0.0)
n.ip11 = L.InnerProduct(n.grl, num_output=300, weight_filler=dict(type='xavier'))
n.relu11 = L.Sigmoid(n.ip11, in_place=True)
n.dropout11 = L.Dropout(n.relu11, dropout_ratio=0.5)
n.ip12 = L.InnerProduct(n.dropout11, num_output=1, weight_filler=dict(type='xavier'))
n.lossdc = L.SigmoidCrossEntropyLoss(n.ip12, n.dc_label, loss_weight=0.1)
return n.to_proto()
def VS_net(train=True,
learn_all=False,
subset=None,
deploy=False,
numClassesVS=numClassesVS):
if subset is None:
subset = 'train' if train else 'test'
#source = caffe_root + 'data/flickr_style/%s.txt' % subset
#transform_param = dict(mirror=train, crop_size=227, mean_file=caffe_root + 'data/ilsvrc12/imagenet_mean.binaryproto')
#style_data, style_label = L.ImageData(transform_param=transform_param, source=source,batch_size=50, new_height=256, new_width=256, ntop=2)
if train:
batch_size = 50
else:
batch_size = 1
# HDF5 data source
VS_data, VS_label = L.HDF5Data(source=hdf5DataFolderPath +
'train_h5_list.txt',
batch_size=batch_size,
ntop=2)
# test
print type(VS_label)
return caffenet(data=VS_data,
label=VS_label,
train=train,
num_classes=numClassesVS,
classifier_name='fc8_VS',
learn_all=learn_all,
deploy=deploy)
def style_net(train=True, learn_all=False, subset=None):
if subset is None:
subset = 'train' if train else 'test'
source = caffe_root + 'data/flickr_style/%s.txt' % subset
transform_param = dict(mirror=train,
crop_size=227,
mean_file=caffe_root +
'data/ilsvrc12/imagenet_mean.binaryproto')
style_data, style_label = L.ImageData(transform_param=transform_param,
source=source,
batch_size=50,
new_height=256,
new_width=256,
ntop=2)
# HDF5 data source
style_data, style_label = L.HDF5Data(source=hdf5DataFolderPath +
'train_h5_list.txt',
batch_size=50,
ntop=2)
# test
print type(style_label)
return caffenet(data=style_data,
label=style_label,
train=train,
num_classes=NUM_STYLE_LABELS,
classifier_name='fc8_flickr',
learn_all=learn_all)
def SRCNN3D(hdf5name, batch_size, kernel ):
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size,
source=hdf5name,
ntop=2,
include=dict(phase = caffe.TRAIN))
n.conv1 = L.Convolution(n.data, kernel_size=kernel[0], num_output=64, stride = 1, pad = 0,
param=[{'lr_mult':1},{'lr_mult':0.1}],
weight_filler=dict(type='gaussian',std=0.001),
bias_filler = dict(type= "constant", value=0),
engine = 1 )
n.relu1 = L.ReLU(n.conv1,
in_place=True,
engine = 1)
n.conv2 = L.Convolution(n.conv1, kernel_size=kernel[1], num_output=32, stride = 1, pad = 0,
param=[{'lr_mult':1},{'lr_mult':0.1}],
weight_filler=dict(type='gaussian',std=0.001),
bias_filler = dict(type= "constant", value=0),
engine = 1 )
n.relu2 = L.ReLU(n.conv2,
in_place=True,
engine = 1)
n.conv3 = L.Convolution(n.conv2, kernel_size=kernel[2], num_output=1, stride = 1, pad = 0,
param=[{'lr_mult':1},{'lr_mult':0.1}],
weight_filler=dict(type='gaussian',std=0.001),
bias_filler = dict(type= "constant", value=0),
engine = 1 )
n.conv3_flat = L.Flatten(n.conv3)
n.label_flat = L.Flatten(n.label)
n.loss = L.EuclideanLoss(n.conv3_flat,n.label_flat)
return n.to_proto()
def ipcai(database, batch_size):
# our version of LeNet: a series of linear and simple nonlinear transformations
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size,
source=database,
ntop=2)
n.fc1 = L.InnerProduct(n.data,
num_output=25,
weight_filler=dict(type='xavier'),
bias_filler=dict(type='constant', value=0.1))
n.relu1 = L.ReLU(n.fc1, in_place=True)
n.fc2 = L.InnerProduct(n.relu1,
num_output=25,
weight_filler=dict(type='xavier'),
bias_filler=dict(type='constant', value=0.1))
n.relu2 = L.ReLU(n.fc2, in_place=True)
n.score = L.InnerProduct(n.relu2,
num_output=1,
weight_filler=dict(type='xavier'),
bias_filler=dict(type='constant', value=0.1))
n.loss = L.EuclideanLoss(n.score, n.label)
return n.to_proto()
def logreg(hdf5, batch_size):
# logistic regression: data, matrix multiplication, and 2-class softmax loss
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
n.ip1 = L.InnerProduct(n.data, num_output=2, weight_filler=dict(type='xavier'))
n.accuracy = L.Accuracy(n.ip1, n.label)
n.loss = L.SoftmaxWithLoss(n.ip1, n.label)
return n.to_proto()
def net(hdf5, batch_size):
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
n.ip1 = L.InnerProduct(n.data, num_output=50, weight_filler=dict(type='xavier'))
n.relu1 = L.ReLU(n.ip1, in_place=True)
n.ip2 = L.InnerProduct(n.relu1, num_output=4, weight_filler=dict(type='xavier'))
n.loss = L.SigmoidCrossEntropyLoss(n.ip2, n.label)
return n.to_proto()
def model(h5path, batchsize):
n = caffe.NetSpec()
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(source=h5path, batch_size=batchsize, ntop=2)
n.ip1 = L.InnerProduct(n.data,
num_output=10,
weight_filler=dict(type='xavier'))
n.accuracy = L.Accuracy(n.ip1, n.label)
n.loss = L.SoftmaxWithLoss(n.ip1, n.label)
return n.to_proto()
def train_SRDenseNet(train_data=train_data_path, test_data=test_data_path,
batch_size_train=batch_size_train, batch_size_test=batch_size_test,
first_channel=first_channel, block=block, depth=depth, grow_rate=grow_rate,
bottleneck=bottleneck, dropout=dropout):
net = caffe.NetSpec()
net.data, net.label = L.HDF5Data(hdf5_data_param={
'source': train_data, 'batch_size': batch_size_train}, include={'phase': caffe.TRAIN}, ntop=2)
train_data_layer = str(net.to_proto())
net.data, net.label = L.HDF5Data(hdf5_data_param={
'source': test_data, 'batch_size': batch_size_test}, include={'phase': caffe.TEST}, ntop=2)
net.model = conv_relu(net.data, channel=first_channel, kernel=3, stride=1, pad=1, dropout=dropout)
num_channels = first_channel
for i in range(block):
net.dense = conv_relu(net.model, channel=grow_rate, kernel=3, stride=1, pad=1, dropout=dropout)
for j in range(depth-1):
net.dense = add_layer(net.dense, grow_rate, dropout)
num_channels += grow_rate * depth
net.model = L.Concat(net.model, net.dense, axis=1)
net.bottleneck = conv_relu(net.model, channel=bottleneck, kernel=1, stride=1, pad=0, dropout=dropout)
net.deconv1 = L.Deconvolution(net.bottleneck, convolution_param=dict(num_output=bottleneck,
kernel_size=4, stride=2, pad=1,
bias_term=False,
weight_filler=dict(type='msra'),
bias_filler=dict(type='constant')))
net.deconv1 = L.ReLU(net.deconv1, in_place=True)
net.deconv2 = L.Deconvolution(net.deconv1, convolution_param=dict(num_output=bottleneck,
kernel_size=4, stride=2, pad=1,
bias_term=False,
weight_filler=dict(type='msra'),
bias_filler=dict(type='constant')))
net.deconv2 = L.ReLU(net.deconv2, in_place=True)
net.reconstruct = L.Convolution(net.deconv2, num_output=1, kernel_size=3, stride=1,
pad=1, bias_term=False, weight_filler=dict(type='msra'),
bias_filler=dict(type='constant'))
net.loss = L.EuclideanLoss(net.reconstruct, net.label)
return train_data_layer + str(net.to_proto())
def logreg(hdf5, batch_size):
n = caffe.NetSpec() # 创建神经网络
n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5,
ntop=2) # 读入数据集
n.ip1 = L.InnerProduct(n.data,
num_output=2,
weight_filler=dict(type='xavier')) # 输入层定义
n.accuracy = L.Accuracy(n.ip1, n.label) # 准确度评估值
n.loss = L.SoftmaxWithLoss(n.ip1, n.label) # 输出层
return n.to_proto()
def train_IFNNSR():
net = caffe.NetSpec()
net.data, net.label = L.HDF5Data(hdf5_data_param={
'source': train_data_path,
'batch_size': batch_size_train
},
include={'phase': caffe.TRAIN},
ntop=2)
train_data_layer = str(net.to_proto())
net.data, net.label = L.HDF5Data(hdf5_data_param={
'source': test_data_path,
'batch_size': batch_size_test
},
include={'phase': caffe.TEST},
ntop=2)
net.model = net.data
net.model = weight(net.model, share) # element-wise product
net.model = smooth(net.model, channel, group, kernel,
dilate) # convolution
net.model = L.TanH(net.model) # tanh actiavtion function
net.model = smooth(net.model, channel, group, kernel,
dilate) # convolution
net.model = L.TanH(net.model) # tanh actiavtion function
net.model = smooth(net.model, share, group, kernel, dilate) # convolution
net.model = L.TanH(net.model) # tanh actiavtion function
net.sum = net.model
for j in range(depth - 1):
net.model = weight(net.model, share)
net.model = smooth(net.model, channel, group, kernel, dilate)
net.model = L.TanH(net.model)
net.model = smooth(net.model, channel, group, kernel, dilate)
net.model = L.TanH(net.model)
net.model = smooth(net.model, share, group, kernel, dilate)
net.model = L.TanH(net.model)
net.sum = L.Eltwise(net.sum, net.model)
net.predict = weight(net.sum, share)
net.loss = L.WeightL2Loss(net.predict, net.label)
# net.loss = L.EuclideanLoss(net.predict, net.label)
return train_data_layer + str(net.to_proto())
def gen_net(train_hdf5_in,
train_batch_size,
test_hdf5_in,
test_batch_size,
deploy=False):
# Input Layers
n = caffe.NetSpec()
if deploy:
n.data = L.DummyData(ntop=1, shape=[dict(dim=[1, 1, 20, 20, 20])])
else:
n.data, n.label = L.HDF5Data(
ntop=2,
include=dict(phase=caffe.TRAIN),
hdf5_data_param=dict(batch_size=train_batch_size),
source=train_hdf5_in)
n.data2 = L.HDF5Data(ntop=0,
top=['data', 'label'],
include=dict(phase=caffe.TEST),
hdf5_data_param=dict(batch_size=test_batch_size),
source=test_hdf5_in)
# Core Architecture
n.deconv1 = Deconvolution(n.data)
n.conv1, n.bn1, n.relu1 = Convolution_BN_ReLU(n.deconv1, num_output=64)
n.conv2, n.bn2, n.relu2 = Convolution_BN_ReLU(n.relu1, num_output=64)
n.conv3, n.bn3, n.relu3 = Convolution_BN_ReLU(n.relu2, num_output=32)
n.conv4, n.bn4, n.relu4 = Convolution_BN_ReLU(n.relu3, num_output=16)
n.conv5, n.bn5, n.relu5 = Convolution_BN_ReLU(n.relu4, num_output=16)
n.conv6 = Convolution(n.relu5,
num_output=1,
param=[dict(lr_mult=0.1),
dict(lr_mult=0.1)])
n.recon = L.Eltwise(n.deconv1, n.conv6, operation=P.Eltwise.SUM)
# Output Layers
if not deploy:
n.loss = L.EuclideanLoss(n.recon, n.label)
#n.loss = L.Python (n.recon, n.label, python_param=dict(module='pyloss',layer='SmoothL1LossLayer_2'),loss_weight=1)
# Return the network
return n.to_proto()
def finetuningNet(h5, batch_size, layerNum):
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(source=h5,
batch_size=batch_size,
shuffle=True,
ntop=2)
flatdata = L.Flatten(n.data)
flatdata_name = 'flatdata'
n.__setattr__(flatdata_name, flatdata)
param = learned_param
for l in range(layerNum):
if l == 0:
encoder_name_last = flatdata_name
else:
encoder_name_last = relu_en_name
encoder = L.InnerProduct(n[encoder_name_last],
num_output=layerNeuronNum[l + 1],
param=param,
weight_filler=dict(type='gaussian',
std=0.005),
bias_filler=dict(type='constant', value=0.1))
encoder_name = 'encoder' + str(l + 1)
n.__setattr__(encoder_name, encoder)
relu_en = L.ReLU(n[encoder_name], in_place=True)
relu_en_name = 'relu_en' + str(l + 1)
n.__setattr__(relu_en_name, relu_en)
for l in range(layerNum):
if l == 0:
decoder_name_last = relu_en_name
else:
decoder_name_last = relu_de_name
decoder = L.InnerProduct(n[decoder_name_last],
num_output=layerNeuronNum[layerNum - l - 1],
param=param,
weight_filler=dict(type='gaussian',
std=0.005),
bias_filler=dict(type='constant', value=0.1))
decoder_name = 'decoder' + str(layerNum - l)
n.__setattr__(decoder_name, decoder)
if l < (layerNum - 1):
relu_de = L.ReLU(n[decoder_name], in_place=True)
relu_de_name = 'relu_de' + str(layerNum - l)
n.__setattr__(relu_de_name, relu_de)
n.loss = L.EuclideanLoss(n[decoder_name], n.flatdata)
return n.to_proto()
def nonlinear_net(hdf5, batch_size):
#one small nonlinearnet , on liap for model kind
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
n.ip1 = L.InnerProduct(n.data,
num_output=40,
weight_filler=dict(type='xavier'))
n.relu1 = L.ReLU(n.ip1, in_place=True)
n.ip2 = L.InnerProduct(n.ip1,
num_output=2,
weight_filler=dict(type='xavier'))
n.accuracy = L.Accuracy(n.ip2, n.label)
n.loss = L.SoftmaxWithLoss(n.ip2, n.label)
return n.to_proto()
def nonlinear_net(hdf5, batch_size):
# one small nonlinearity, one leap for model kind
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
# define a hidden layer of dimension 40
n.ip1 = L.InnerProduct(n.data, num_output=40, weight_filler=dict(type='xavier'))
# transform the output through the ReLU (rectified linear) non-linearity
n.relu1 = L.ReLU(n.ip1, in_place=True)
# score the (now non-linear) features
n.ip2 = L.InnerProduct(n.ip1, num_output=2, weight_filler=dict(type='xavier'))
# same accuracy and loss as before
n.accuracy = L.Accuracy(n.ip2, n.label)
n.loss = L.SoftmaxWithLoss(n.ip2, n.label)
return n.to_proto()
def net(hdf5_list, batch_size):
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size,
source=hdf5_list,
ntop=2) # ntop: two param returns
n.ip1 = L.InnerProduct(n.data,
num_output=50,
weight_filler=dict(type='xavier'))
n.relu1 = L.ReLU(n.ip1, in_place=True)
n.ip2 = L.InnerProduct(n.relu1,
num_output=2,
weight_filler=dict(type='xavier'))
n.loss = L.SoftmaxWithLoss(n.ip2, n.label)
n.accu = L.Accuracy(n.ip2, n.label)
return n.to_proto()
def createAutoencoder(hdf5, input_size, batch_size, phase):
n = caffe.NetSpec()
if phase == "inference":
n.data = L.Input(input_param={'shape': {'dim': [1, input_size]}})
else:
n.data = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=1)
n.ip1 = L.InnerProduct(n.data,
num_output=256,
weight_filler=dict(type='xavier'))
n.bottleneck = L.Sigmoid(n.ip1, in_place=True)
n.decode = L.InnerProduct(n.bottleneck,
num_output=input_size,
weight_filler=dict(type='xavier'))
n.loss = L.EuclideanLoss(n.decode, n.data)
return n.to_proto()
def lenet(self, hdf5, batch_size):
'''
Initialise the Basic LeNet layers
Input Parameters:
hdf5 : train hdf5 file
batch_size : batch size for training the system
Output Parameters:
n.to_proto() : dictionary of network layers
'''
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(name="data",
data_param={
'source': hdf5,
'batch_size': batch_size
},
ntop=2,
include={'phase': caffe.TRAIN})
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.accuracy = L.Accuracy(n.ip2, n.label, include={'phase': caffe.TEST})
print(str(n.to_proto()))
return n.to_proto()
def lenet_test(self, hdf5, batch_size):
'''
Declaring the validation phase for the network layer
Input Parameters:
hdf5 : val hdf5 file
batch_size : batch size for validating the system
'''
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(name="data",
data_param={
'source': hdf5,
'batch_size': batch_size
},
ntop=2,
include={'phase': caffe.TEST})
return n.to_proto()
def classificationNet(h5, batch_size, layerNeuronNum, layerNum, classNum,
learned_param):
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(source=h5,
batch_size=batch_size,
shuffle=True,
ntop=2)
flatdata = L.Flatten(n.data)
flatdata_name = 'flatdata'
n.__setattr__(flatdata_name, flatdata)
param = learned_param
for l in range(layerNum):
if l == 0:
encoder_name_last = flatdata_name
else:
encoder_name_last = relu_en_name
encoder = L.InnerProduct(n[encoder_name_last],
num_output=layerNeuronNum[l + 1],
param=param,
weight_filler=dict(type='gaussian',
std=0.005),
bias_filler=dict(type='constant', value=0.1))
encoder_name = 'encoder' + str(l + 1)
n.__setattr__(encoder_name, encoder)
relu_en = L.ReLU(n[encoder_name], in_place=True)
relu_en_name = 'relu_en' + str(l + 1)
n.__setattr__(relu_en_name, relu_en)
output = L.InnerProduct(n[relu_en_name],
num_output=classNum,
param=param,
weight_filler=dict(type='gaussian', std=0.005),
bias_filler=dict(type='constant', value=0.1))
output_name = 'output'
n.__setattr__(output_name, output)
n.loss = L.SoftmaxWithLoss(n[output_name], n.label)
return n.to_proto()
def logreg(hdf5, batch_size):
# read in the data
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
# a bit of preprocessing - helpful!
n.log = L.Log(n.data, base=-1, scale=1, shift=1)
n.norm = L.BatchNorm(n.log, use_global_stats=False)
n.scaled = L.Scale(n.norm, bias_term=True)
# the actual regression - the core of what we want to do!
n.dropout = L.Dropout(n.scaled, dropout_ratio=0.5)
n.ip = L.InnerProduct(n.dropout,
num_output=nCategories,
weight_filler=dict(type='xavier'))
# don't mess with these. They don't affect learning.
n.prob = L.Softmax(n.ip)
n.accuracy1 = L.Accuracy(n.prob, n.label)
if nCategories > 5:
n.accuracy5 = L.Accuracy(n.prob, n.label, top_k=5)
n.loss = L.SoftmaxWithLoss(n.ip, n.label)
return n.to_proto()
def Bounding_Box_Reg(hdf5, batch_size):
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
n.conv1 = L.Convolution(n.data,
kernel_size=5,
num_output=64,
pad=2,
weight_filler=dict(type='xavier'))
n.relu1 = L.ReLU(n.conv1, in_place=True)
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=128,
pad=2,
weight_filler=dict(type='xavier'))
n.relu2 = L.ReLU(n.conv2, in_place=True)
n.pool2 = L.Pooling(n.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX)
n.conv3 = L.Convolution(n.pool2,
kernel_size=3,
num_output=256,
pad=1,
weight_filler=dict(type='xavier'))
n.relu3 = L.ReLU(n.conv3, in_place=True)
n.pool3 = L.Pooling(n.conv3, kernel_size=2, stride=2, pool=P.Pooling.MAX)
n.conv4 = L.Convolution(n.pool3,
kernel_size=3,
num_output=512,
pad=1,
weight_filler=dict(type='xavier'))
n.relu4 = L.ReLU(n.conv4, in_place=True)
n.pool4 = L.Pooling(n.conv4, kernel_size=2, stride=2, pool=P.Pooling.MAX)
n.ip1 = L.InnerProduct(n.pool4,
num_output=4000,
weight_filler=dict(type='xavier'))
n.dp1 = L.Dropout(n.ip1, dropout_ratio=0.5)
n.ip2 = L.InnerProduct(n.ip1,
num_output=4,
weight_filler=dict(type='xavier'))
n.loss = L.EuclideanLoss(n.ip2, n.label)
return n.to_proto()
def InterSRReCNN3D_net(hdf5name, batch_size, layers, kernel , numkernels, padding, residual=True):
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(batch_size=batch_size,
source=hdf5name,
ntop=2,
include=dict(phase = caffe.TRAIN))
n.conv1 = L.Convolution(n.data, kernel_size=kernel, num_output=numkernels, stride = 1, pad = padding,
param=[{'lr_mult':1},{'lr_mult':0.1}],
weight_filler=dict(type='gaussian',std=np.sqrt(2/float(2*kernel**3))),
bias_filler = dict( type= "constant", value=0),
engine = 1 )
n.relu1 = L.ReLU(n.conv1,
in_place=True,
engine = 1)
for idx in range(2,layers):
n['conv'+str(idx)] = L.Convolution(n['conv'+str(idx-1)], kernel_size=kernel, num_output=numkernels, stride = 1, pad = padding,
param=[{'lr_mult':1},{'lr_mult':0.1}],
weight_filler=dict(type='gaussian',std=np.sqrt(2/float(numkernels*kernel**3))),
bias_filler = dict( type= "constant", value=0),
engine = 1 )
n['relu'+str(idx)] = L.ReLU(n['conv'+str(idx)],
in_place=True,
engine = 1)
n['conv'+str(layers)] = L.Convolution(n['conv'+str(layers-1)], kernel_size=kernel, num_output=1, stride = 1, pad = padding,
param=[{'lr_mult':1},{'lr_mult':0.1}],
weight_filler=dict(type='gaussian',std=np.sqrt(2/float(numkernels*kernel**3))),
bias_filler = dict( type= "constant", value=0),
engine = 1 )
if residual == True:
n.out = L.Eltwise(n['conv'+str(layers)],n.data,
operation= 1 )
n.out_flat = L.Flatten(n.out)
else:
n.out_flat = L.Flatten(n['conv'+str(layers)])
n.label_flat = L.Flatten(n.label)
n.loss = L.EuclideanLoss(n.out_flat,n.label_flat)
return n.to_proto()
def MLP(hdf5, batch_size, sample_length, phase):
n = caffe.NetSpec()
if phase != 'inference':
n.data, n.label = L.HDF5Data(batch_size=batch_size,
source=hdf5,
ntop=2)
else:
n.data = L.Input(input_param={'shape': {'dim': [1, sample_length]}})
#n.data, n.label = L.HDF5Data(batch_size=batch_size, source=hdf5, ntop=2)
n.ip1 = L.InnerProduct(n.data,
num_output=512,
weight_filler=dict(type='xavier'))
n.drop1 = L.Dropout(n.ip1, dropout_ratio=0.5, in_place=True)
n.sig1 = L.ReLU(n.drop1, in_place=True)
n.ip2 = L.InnerProduct(n.sig1,
num_output=256,
weight_filler=dict(type='xavier'))
n.drop2 = L.Dropout(n.ip2, dropout_ratio=0.5, in_place=True)
n.sig2 = L.ReLU(n.drop2, in_place=True)
n.ip3 = L.InnerProduct(n.sig2,
num_output=128,
weight_filler=dict(type='xavier'))
n.drop3 = L.Dropout(n.ip3, dropout_ratio=0.5, in_place=True)
n.sig3 = L.ReLU(n.drop3, in_place=True)
n.ip4 = L.InnerProduct(n.sig3,
num_output=2,
weight_filler=dict(type='xavier'))
if phase == 'train':
n.loss = L.SoftmaxWithLoss(n.ip4, n.label)
n.prob = L.Softmax(n.ip4)
n.accuracy = L.Accuracy(n.prob, n.label)
elif phase == 'test':
n.prob = L.Softmax(n.ip4)
#n.accuracy = L.Accuracy(n.prob, n.label)
elif phase == 'inference':
n.prob = L.Softmax(n.ip4)
return n.to_proto()
def model(h5path, batchsize):
n = caffe.NetSpec()
n.data, n.label = L.HDF5Data(source=h5path, batch_size=batchsize, ntop=2)
n.dataim = L.Reshape(n.data, shape={'dim': [batchsize, 1, 28, 28]})
n.conv1 = L.Convolution(n.dataim,
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.accuracy = L.Accuracy(n.score, n.label)
n.loss = L.SoftmaxWithLoss(n.score, n.label)
return n.to_proto()
def gen_net(split, batch_size, blk_size, subrate, source_path=''):
''' Define network '''
n = caffe.NetSpec()
#n.name = net_type;
# ====================== Step 1. Define the input layer ==========================================
if net_type == 'ReconNet' or net_type == 'DR2_Stage1' or net_type == 'DR2_Stage2':
noMeas = int(round(subrate * blk_size * blk_size))
if split == 'train':
n.data, n.label = L.HDF5Data(name="data",
batch_size=batch_size,
source=source_path,
ntop=2,
include={'phase': caffe.TRAIN},
type="HDF5Data")
elif split == 'test':
n.data, n.label = L.HDF5Data(name="data",
batch_size=2,
source=source_path,
ntop=2,
include={'phase': caffe.TEST},
type="HDF5Data")
else:
n.data = L.Input(name="data",
ntop=1,
input_param={'shape': {
'dim': [1, noMeas, 1, 1]
}})
elif net_type == 'CSNet':
if split == 'train_val':
n.data, n.label = L.HDF5Data(name="data",
batch_size=batch_size,
source=source_path,
ntop=2,
include={'phase': caffe.TRAIN},
type="HDF5Data")
n.data, n.label = L.HDF5Data(name="data",
batch_size=2,
source=source_path,
ntop=2,
include={'phase': caffe.TEST},
type="HDF5Data")
else:
n.data = L.Input(
name="data",
ntop=1,
input_param={'shape': {
'dim': [1, 1, blk_size, blk_size]
}})
# ======================= Stage 2: Define the main network =======================================
if net_type == 'ReconNet' or net_type == 'DR2_Stage1' or net_type == 'DR2_Stage2':
if subrate == 0.01:
adap_std = 0.01
elif subrate == 0.04:
adap_std = 0.03
elif subrate == 0.25:
adap_std = 0.05
else:
adap_std = 0.05
n.fc1 = L.Convolution(n.data,
kernel_size=1,
stride=1,
num_output=blk_size * blk_size,
pad=0,
weight_filler=dict(type='gaussian',
std=adap_std),
bias_filler=dict(type='constant', value=0),
param=[
dict(lr_mult=1, decay_mult=1),
dict(lr_mult=2, decay_mult=0)
])
n.reshape = L.Reshape(
n.fc1,
reshape_param={'shape': {
'dim': [0, 1, blk_size, blk_size]
}})
if net_type == 'ReconNet':
n.conv1, n.relu1 = conv_relu(n.reshape, 64, 11, 1, 5)
n.conv2, n.relu2 = conv_relu(n.relu1, 32, 1, 1, 0)
n.conv3, n.relu3 = conv_relu(n.relu2, 1, 7, 1, 3, 'gaussian', 0.1)
n.conv4, n.relu4 = conv_relu(n.relu3, 64, 11, 1, 5)
n.conv5, n.relu5 = conv_relu(n.relu4, 32, 1, 1, 0)
n.conv6 = convLayer(n.relu5, 1, 7, 1, 3, 'gaussian', 0.1)
if (split == 'train' or split == 'test'):
n.loss = L.EuclideanLoss(n.conv6, n.label)
elif net_type == 'DR2_Stage1':
if (split == 'train' or split == 'test'):
n.loss = L.EuclideanLoss(n.reshape, n.label, loss_weight=1)
elif net_type == 'DR2_Stage2':
# 1st residual subnet
n.conv1r, n.bnorm1, n.scale1, n.relu1 = conv_bn_relu(
n.reshape, 64, 11, 1, 5)
n.conv2r, n.bnorm2, n.scale2, n.relu2 = conv_bn_relu(
n.relu1, 32, 1, 1, 0)
n.conv3r = L.Convolution(n.relu2,
kernel_size=7,
stride=1,
num_output=1,
pad=3,
weight_filler=dict(type='gaussian',
std=0.001),
bias_term=False,
param=[dict(lr_mult=0.1)])
n.res1 = L.Eltwise(n.reshape, n.conv3r)
# 2nd Residual subnet
n.conv4r, n.bnorm4, n.scale4, n.relu4 = conv_bn_relu(
n.res1, 64, 11, 1, 5)
n.conv5r, n.bnorm5, n.scale5, n.relu5 = conv_bn_relu(
n.relu4, 32, 1, 1, 0)
n.conv6r = L.Convolution(n.relu5,
kernel_size=7,
stride=1,
num_output=1,
pad=3,
weight_filler=dict(type='gaussian',
std=0.001),
bias_term=False,
param=[dict(lr_mult=0.1)])
n.res2 = L.Eltwise(n.res1, n.conv6r)
# 3rd Residual subnet
n.conv7r, n.bnorm7, n.scale7, n.relu7 = conv_bn_relu(
n.res2, 64, 11, 1, 5)
n.conv8r, n.bnorm8, n.scale8, n.relu8 = conv_bn_relu(
n.relu7, 32, 1, 1, 0)
n.conv9r = L.Convolution(n.relu8,
kernel_size=7,
stride=1,
num_output=1,
pad=3,
weight_filler=dict(type='gaussian',
std=0.001),
bias_term=False,
param=[dict(lr_mult=0.1)])
n.res3 = L.Eltwise(n.res2, n.conv9r)
# 4th Residual subnet
n.conv10r, n.bnorm10, n.scale10, n.relu10 = conv_bn_relu(
n.res3, 64, 11, 1, 5)
n.conv11r, n.bnorm11, n.scale11, n.relu11 = conv_bn_relu(
n.relu10, 32, 1, 1, 0)
n.conv12r = L.Convolution(n.relu11,
kernel_size=7,
stride=1,
num_output=1,
pad=3,
weight_filler=dict(type='gaussian',
std=0.001),
bias_term=False,
param=[dict(lr_mult=0.1)])
n.res4 = L.Eltwise(n.res3, n.conv12r)
# Loss layer
if (split == 'train' or split == 'test'):
n.loss = L.EuclideanLoss(n.res4, n.label, loss_weight=1)
n.loss2 = L.EuclideanLoss(n.reshape, n.label, loss_weight=0)
return n.to_proto()
def setLayers_twoBranches(data_source,
batch_size,
layername,
kernel,
stride,
outCH,
label_name,
transform_param_in,
deploy=False,
batchnorm=0,
lr_mult_distro=[1, 1, 1]):
# it is tricky to produce the deploy prototxt file, as the data input is not from a layer, so we have to creat a workaround
# producing training and testing prototxt files is pretty straight forward
n = caffe.NetSpec()
assert len(layername) == len(kernel)
assert len(layername) == len(stride)
assert len(layername) == len(outCH)
num_parts = transform_param['num_parts']
if deploy == False and "lmdb" not in data_source:
if (len(label_name) == 1):
n.data, n.tops[label_name[0]] = L.HDF5Data(hdf5_data_param=dict(
batch_size=batch_size, source=data_source),
ntop=2)
elif (len(label_name) == 2):
n.data, n.tops[label_name[0]], n.tops[label_name[1]] = L.HDF5Data(
hdf5_data_param=dict(batch_size=batch_size,
source=data_source),
ntop=3)
# produce data definition for deploy net
elif deploy == False:
n.data, n.tops['label'] = L.CPMData(
data_param=dict(backend=1,
source=data_source,
batch_size=batch_size),
cpm_transform_param=transform_param_in,
ntop=2)
n.tops[label_name[2]], n.tops[label_name[3]], n.tops[
label_name[4]], n.tops[label_name[5]] = L.Slice(
n.label,
slice_param=dict(
axis=1, slice_point=[38, num_parts + 1, num_parts + 39]),
ntop=4)
n.tops[label_name[0]] = L.Eltwise(n.tops[label_name[2]],
n.tops[label_name[4]],
operation=P.Eltwise.PROD)
n.tops[label_name[1]] = L.Eltwise(n.tops[label_name[3]],
n.tops[label_name[5]],
operation=P.Eltwise.PROD)
else:
input = "data"
dim1 = 1
dim2 = 4
dim3 = 368
dim4 = 368
# make an empty "data" layer so the next layer accepting input will be able to take the correct blob name "data",
# we will later have to remove this layer from the serialization string, since this is just a placeholder
n.data = L.Layer()
# something special before everything
n.image, n.center_map = L.Slice(n.data,
slice_param=dict(axis=1, slice_point=3),
ntop=2)
n.silence2 = L.Silence(n.center_map, ntop=0)
#n.pool_center_lower = L.Pooling(n.center_map, kernel_size=9, stride=8, pool=P.Pooling.AVE)
# just follow arrays..CPCPCPCPCCCC....
last_layer = ['image', 'image']
stage = 1
conv_counter = 1
pool_counter = 1
drop_counter = 1
local_counter = 1
state = 'image' # can be image or fuse
share_point = 0
for l in range(0, len(layername)):
if layername[l] == 'V': #pretrained VGG layers
conv_name = 'conv%d_%d' % (pool_counter, local_counter)
lr_m = lr_mult_distro[0]
n.tops[conv_name] = L.Convolution(
n.tops[last_layer[0]],
kernel_size=kernel[l],
num_output=outCH[l],
pad=int(math.floor(kernel[l] / 2)),
param=[
dict(lr_mult=lr_m, decay_mult=1),
dict(lr_mult=lr_m * 2, decay_mult=0)
],
weight_filler=dict(type='gaussian', std=0.01),
bias_filler=dict(type='constant'))
last_layer[0] = conv_name
last_layer[1] = conv_name
print '%s\tch=%d\t%.1f' % (last_layer[0], outCH[l], lr_m)
ReLUname = 'relu%d_%d' % (pool_counter, local_counter)
n.tops[ReLUname] = L.ReLU(n.tops[last_layer[0]], in_place=True)
local_counter += 1
print ReLUname
if layername[l] == 'B':
pool_counter += 1
local_counter = 1
if layername[l] == 'C':
if state == 'image':
#conv_name = 'conv%d_stage%d' % (conv_counter, stage)
conv_name = 'conv%d_%d_CPM' % (
pool_counter, local_counter
) # no image state in subsequent stages
if stage == 1:
lr_m = lr_mult_distro[1]
else:
lr_m = lr_mult_distro[1]
else: # fuse
conv_name = 'Mconv%d_stage%d' % (conv_counter, stage)
lr_m = lr_mult_distro[2]
conv_counter += 1
#if stage == 1:
# lr_m = 1
#else:
# lr_m = lr_sub
n.tops[conv_name] = L.Convolution(
n.tops[last_layer[0]],
kernel_size=kernel[l],
num_output=outCH[l],
pad=int(math.floor(kernel[l] / 2)),
param=[
dict(lr_mult=lr_m, decay_mult=1),
dict(lr_mult=lr_m * 2, decay_mult=0)
],
weight_filler=dict(type='gaussian', std=0.01),
bias_filler=dict(type='constant'))
last_layer[0] = conv_name
last_layer[1] = conv_name
print '%s\tch=%d\t%.1f' % (last_layer[0], outCH[l], lr_m)
if layername[l + 1] != 'L':
if (state == 'image'):
if (batchnorm == 1):
batchnorm_name = 'bn%d_stage%d' % (conv_counter, stage)
n.tops[batchnorm_name] = L.BatchNorm(
n.tops[last_layer[0]],
param=[
dict(lr_mult=0),
dict(lr_mult=0),
dict(lr_mult=0)
])
#scale_filler=dict(type='constant', value=1), shift_filler=dict(type='constant', value=0.001))
last_layer[0] = batchnorm_name
#ReLUname = 'relu%d_stage%d' % (conv_counter, stage)
ReLUname = 'relu%d_%d_CPM' % (pool_counter, local_counter)
n.tops[ReLUname] = L.ReLU(n.tops[last_layer[0]],
in_place=True)
else:
if (batchnorm == 1):
batchnorm_name = 'Mbn%d_stage%d' % (conv_counter,
stage)
n.tops[batchnorm_name] = L.BatchNorm(
n.tops[last_layer[0]],
param=[
dict(lr_mult=0),
dict(lr_mult=0),
dict(lr_mult=0)
])
#scale_filler=dict(type='constant', value=1), shift_filler=dict(type='constant', value=0.001))
last_layer[0] = batchnorm_name
ReLUname = 'Mrelu%d_stage%d' % (conv_counter, stage)
n.tops[ReLUname] = L.ReLU(n.tops[last_layer[0]],
in_place=True)
#last_layer = ReLUname
print ReLUname
#conv_counter += 1
local_counter += 1
elif layername[l] == 'C2':
for level in range(0, 2):
if state == 'image':
#conv_name = 'conv%d_stage%d' % (conv_counter, stage)
conv_name = 'conv%d_%d_CPM_L%d' % (
pool_counter, local_counter, level + 1
) # no image state in subsequent stages
if stage == 1:
lr_m = lr_mult_distro[1]
else:
lr_m = lr_mult_distro[1]
else: # fuse
conv_name = 'Mconv%d_stage%d_L%d' % (conv_counter, stage,
level + 1)
lr_m = lr_mult_distro[2]
#conv_counter += 1
#if stage == 1:
# lr_m = 1
#else:
# lr_m = lr_sub
if layername[l + 1] == 'L2' or layername[l + 1] == 'L3':
if level == 0:
outCH[l] = 38
else:
outCH[l] = 19
n.tops[conv_name] = L.Convolution(
n.tops[last_layer[level]],
kernel_size=kernel[l],
num_output=outCH[l],
pad=int(math.floor(kernel[l] / 2)),
param=[
dict(lr_mult=lr_m, decay_mult=1),
dict(lr_mult=lr_m * 2, decay_mult=0)
],
weight_filler=dict(type='gaussian', std=0.01),
bias_filler=dict(type='constant'))
last_layer[level] = conv_name
print '%s\tch=%d\t%.1f' % (last_layer[level], outCH[l], lr_m)
if layername[l + 1] != 'L2' and layername[l + 1] != 'L3':
if (state == 'image'):
if (batchnorm == 1):
batchnorm_name = 'bn%d_stage%d_L%d' % (
conv_counter, stage, level + 1)
n.tops[batchnorm_name] = L.BatchNorm(
n.tops[last_layer[level]],
param=[
dict(lr_mult=0),
dict(lr_mult=0),
dict(lr_mult=0)
])
#scale_filler=dict(type='constant', value=1), shift_filler=dict(type='constant', value=0.001))
last_layer[level] = batchnorm_name
#ReLUname = 'relu%d_stage%d' % (conv_counter, stage)
ReLUname = 'relu%d_%d_CPM_L%d' % (
pool_counter, local_counter, level + 1)
n.tops[ReLUname] = L.ReLU(n.tops[last_layer[level]],
in_place=True)
else:
if (batchnorm == 1):
batchnorm_name = 'Mbn%d_stage%d_L%d' % (
conv_counter, stage, level + 1)
n.tops[batchnorm_name] = L.BatchNorm(
n.tops[last_layer[level]],
param=[
dict(lr_mult=0),
dict(lr_mult=0),
dict(lr_mult=0)
])
#scale_filler=dict(type='constant', value=1), shift_filler=dict(type='constant', value=0.001))
last_layer[level] = batchnorm_name
ReLUname = 'Mrelu%d_stage%d_L%d' % (conv_counter,
stage, level + 1)
n.tops[ReLUname] = L.ReLU(n.tops[last_layer[level]],
in_place=True)
print ReLUname
conv_counter += 1
local_counter += 1
elif layername[l] == 'P': # Pooling
n.tops['pool%d_stage%d' % (pool_counter, stage)] = L.Pooling(
n.tops[last_layer[0]],
kernel_size=kernel[l],
stride=stride[l],
pool=P.Pooling.MAX)
last_layer[0] = 'pool%d_stage%d' % (pool_counter, stage)
pool_counter += 1
local_counter = 1
conv_counter += 1
print last_layer[0]
elif layername[l] == 'L':
# Loss: n.loss layer is only in training and testing nets, but not in deploy net.
if deploy == False and "lmdb" not in data_source:
n.tops['map_vec_stage%d' % stage] = L.Flatten(
n.tops[last_layer[0]])
n.tops['loss_stage%d' % stage] = L.EuclideanLoss(
n.tops['map_vec_stage%d' % stage], n.tops[label_name[1]])
elif deploy == False:
level = 1
name = 'weight_stage%d' % stage
n.tops[name] = L.Eltwise(n.tops[last_layer[level]],
n.tops[label_name[(level + 2)]],
operation=P.Eltwise.PROD)
n.tops['loss_stage%d' % stage] = L.EuclideanLoss(
n.tops[name], n.tops[label_name[level]])
print 'loss %d' % stage
stage += 1
conv_counter = 1
pool_counter = 1
drop_counter = 1
local_counter = 1
state = 'image'
elif layername[l] == 'L2':
# Loss: n.loss layer is only in training and testing nets, but not in deploy net.
weight = [lr_mult_distro[3], 1]
# print lr_mult_distro[3]
for level in range(0, 2):
if deploy == False and "lmdb" not in data_source:
n.tops['map_vec_stage%d_L%d' %
(stage, level + 1)] = L.Flatten(
n.tops[last_layer[level]])
n.tops['loss_stage%d_L%d' %
(stage, level + 1)] = L.EuclideanLoss(
n.tops['map_vec_stage%d' % stage],
n.tops[label_name[level]],
loss_weight=weight[level])
elif deploy == False:
name = 'weight_stage%d_L%d' % (stage, level + 1)
n.tops[name] = L.Eltwise(n.tops[last_layer[level]],
n.tops[label_name[(level + 2)]],
operation=P.Eltwise.PROD)
n.tops['loss_stage%d_L%d' %
(stage, level + 1)] = L.EuclideanLoss(
n.tops[name],
n.tops[label_name[level]],
loss_weight=weight[level])
print 'loss %d level %d' % (stage, level + 1)
stage += 1
#last_connect = last_layer
#last_layer = 'image'
conv_counter = 1
pool_counter = 1
drop_counter = 1
local_counter = 1
state = 'image'
elif layername[l] == 'L3':
# Loss: n.loss layer is only in training and testing nets, but not in deploy net.
weight = [lr_mult_distro[3], 1]
# print lr_mult_distro[3]
if deploy == False:
level = 0
n.tops['loss_stage%d_L%d' %
(stage, level + 1)] = L.Euclidean2Loss(
n.tops[last_layer[level]],
n.tops[label_name[level]],
n.tops[label_name[2]],
loss_weight=weight[level])
print 'loss %d level %d' % (stage, level + 1)
level = 1
n.tops['loss_stage%d_L%d' %
(stage, level + 1)] = L.EuclideanLoss(
n.tops[last_layer[level]],
n.tops[label_name[level]],
loss_weight=weight[level])
print 'loss %d level %d' % (stage, level + 1)
stage += 1
#last_connect = last_layer
#last_layer = 'image'
conv_counter = 1
pool_counter = 1
drop_counter = 1
local_counter = 1
state = 'image'
elif layername[l] == 'D':
if deploy == False:
n.tops['drop%d_stage%d' % (drop_counter, stage)] = L.Dropout(
n.tops[last_layer[0]],
in_place=True,
dropout_param=dict(dropout_ratio=0.5))
drop_counter += 1
elif layername[l] == '@':
#if not share_point:
# share_point = last_layer
n.tops['concat_stage%d' % stage] = L.Concat(
n.tops[last_layer[0]],
n.tops[last_layer[1]],
n.tops[share_point],
concat_param=dict(axis=1))
local_counter = 1
state = 'fuse'
last_layer[0] = 'concat_stage%d' % stage
last_layer[1] = 'concat_stage%d' % stage
print last_layer
elif layername[l] == '$':
share_point = last_layer[0]
pool_counter += 1
local_counter = 1
print 'share'
# final process
stage -= 1
#if stage == 1:
# n.silence = L.Silence(n.pool_center_lower, ntop=0)
if deploy == False:
return str(n.to_proto())
# for generating the deploy net
else:
# generate the input information header string
deploy_str = 'input: {}\ninput_dim: {}\ninput_dim: {}\ninput_dim: {}\ninput_dim: {}'.format(
'"' + input + '"', dim1, dim2, dim3, dim4)
# assemble the input header with the net layers string. remove the first placeholder layer from the net string.
return deploy_str + '\n' + 'layer {' + 'layer {'.join(
str(n.to_proto()).split('layer {')[2:])