def style_net(train=True, learn_all=False, subset=None):
if subset is None:
subset = 'train' if train else 'test'
source = '%s/labels.txt' % subset
transform_param = dict(mirror=train,
crop_size=227,
mean_file=caffe_root +
'data/ilsvrc12/imagenet_mean.binaryproto')
if (subset == 'train'):
style_data, style_label = L.ImageData(
transform_param=transform_param,
source=source,
batch_size=NUM_STYLE_IMAGES,
new_height=256,
new_width=256,
ntop=2)
else:
style_data, style_label = L.ImageData(
transform_param=transform_param,
source=source,
batch_size=NUM_TEST_IMAGES,
new_height=256,
new_width=256,
ntop=2)
return caffenet(data=style_data,
label=style_label,
train=train,
num_classes=NUM_STYLE_LABELS,
classifier_name='fc8_muic17',
learn_all=learn_all)
def compile_time_operation(self, learning_option, cluster):
"""
define input placeholder for JPEG input.
"""
# get attr from learning option
option = learning_option.get('option') #TODO: only consider training
file_format = learning_option.get("file_format")
data_path = learning_option.get('data_path')
label_path = learning_option.get('label_path')
batch_size = learning_option.get('batch_size')
iteration = learning_option.get('iteration')
# get attr
# required field
image_size = self.get_attr('image_size', default=None)
if image_size is None:
raise Exception('[DLMDL ERROR]: {0} in {1} layer must be declared.'.format('image_size', self.name))
num_class= self.get_attr('num_class', default=None)
if num_class is None:
raise Exception('[DLMDL ERROR]: {0} in {1} layer must be declared.'.format('num_classes', self.name))
# optional field
shuffle = self.get_attr('shuffle', default=False)
# Image Data layer setting
image, label = L.ImageData(name=self.name,
source=label_path.split('.')[0] + '_caffelist.txt',
batch_size=batch_size, include=dict(phase=caffe.TRAIN), ntop=2, root_folder=data_path,
new_height=image_size[1], new_width=image_size[0], shuffle=shuffle)
test_data_path = learning_option.get('test_data_path')
test_label_path = learning_option.get('test_label_path')
test_batch_size = learning_option.get('test_batch_size')
test_iteration = learning_option.get("test_iteration")
test_interval = learning_option.get("test_interval")
# Image Data layer for test dataset
if test_data_path is not None:
# Test image data layer setting
temp_image, temp_label = L.ImageData(name=self.name,
source=test_label_path.split('.')[
0] + '_caffelist.txt',
batch_size=test_batch_size, include=dict(phase=caffe.TEST), ntop=2,
root_folder=test_data_path, new_height=image_size[0],
new_width=image_size[1])
setattr(tempNet, str(self.name) + '.image', temp_image)
setattr(tempNet, str(self.name) + '.label', temp_label)
image_size = [batch_size, 3, image_size[0], image_size[1]]
# Record the layer output information
self.set_output('image', image)
self.set_output('label', label)
self.set_dimension('image', image_size)
# required value set to learning_option
learning_option['max_iter'] = iteration
learning_option['test_iter'] = test_iteration
learning_option['test_interval'] = test_interval
def make_net_test(desired_level=2):
net = caffe.NetSpec()
net.img0_nomean_resize= L.ImageData(image_data_param=dict(source="tmp/img1.txt",batch_size=1))
net.img1_nomean_resize= L.ImageData(image_data_param=dict(source="tmp/img2.txt",batch_size=1))
predict_flow_name = 'predict_flow{}'.format(desired_level)
net = make_pwc_net_encoder_plus(net, net.img0_nomean_resize, net.img1_nomean_resize)
net.blob44 = L.Eltwise(getattr(net, predict_flow_name), eltwise_param=dict(operation=1, coeff=20.0))
return net.to_proto()
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 get_train_prototxt_deephi(caffe_path, src_prototxt, train_prototxt, image_list, directory_path):
sys.path.insert(0, caffe_path)
import caffe
from caffe import layers as L
from caffe import params as P
from caffe.proto import caffe_pb2
import google.protobuf.text_format as tfmt
net_shape = []
net_parameter = caffe.proto.caffe_pb2.NetParameter()
with open(src_prototxt, "r") as f:
tfmt.Merge(f.read(), net_parameter)
net_shape = net_parameter.layer[0].input_param.shape[0].dim
print(net_shape[2], net_shape[3] )
n = caffe.NetSpec()
print(type(n))
n.data = L.ImageData(top='label', include=dict(phase=caffe_pb2.Phase.Value('TRAIN')), transform_param=dict(mirror=False,mean_value=128.0),
image_data_param=dict(source=image_list,batch_size=50, new_height=net_shape[2],new_width=net_shape[3],shuffle=False,root_folder=directory_path))
with open(train_prototxt, 'w') as f:
f.write(str(n.to_proto()))
print(n.to_proto())
net_parameter = caffe.proto.caffe_pb2.NetParameter()
with open(src_prototxt, "r") as f, open(train_prototxt, "a") as g:
tfmt.Merge(f.read(), net_parameter)
print("before\n", (net_parameter))
#L = next(L for L in net_parameter.layer if L.name == 'data')
print(net_parameter.layer[0])
print(net_parameter.layer[0].input_param.shape[0].dim)
del net_parameter.layer[0]
print("after\n", (net_parameter))
g.write(tfmt.MessageToString(net_parameter))
def CreateDataLayer_IMG(source,
batch_size=28,
shuffle=True,
new_width=224,
new_height=224,
is_color=True,
train=True,
transform_param={}):
if train:
kwargs = {
'include': dict(phase=caffe_pb2.Phase.Value('TRAIN')),
'transform_param': transform_param,
}
else:
kwargs = {
'include': dict(phase=caffe_pb2.Phase.Value('TEST')),
'transform_param': transform_param,
}
return L.ImageData(name="data",
image_data_param=dict(source=source,
shuffle=shuffle,
new_width=new_width,
new_height=new_height,
is_color=is_color,
batch_size=batch_size),
ntop=2,
**kwargs)
def create_data_layer(split="train", from_lmdb=True):
if split == "train":
shuffle = True
batch_size = 32
mirror = True
else:
shuffle = False
batch_size = 8
mirror = False
transform_param = dict(crop_size=227,
mean_file="modeldef/mean.binaryproto",
mirror=mirror)
if from_lmdb:
source = "lmdb/" + split + "_lmdb"
data, label = L.Data(data_param=dict(source=source,
batch_size=batch_size,
backend=P.Data.LMDB),
ntop=2,
transform_param=transform_param)
else:
source = "util/" + split + ".txt"
data, label = L.ImageData(image_data_param=dict(
source=source,
root_folder=root_folder,
batch_size=batch_size,
shuffle=shuffle,
new_width=256,
new_height=256),
ntop=2,
transform_param=transform_param)
return data, label
def caffenet(batch_size=256, include_acc=False, train = True, learn_all=True):
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')
n=caffe.NetSpec()
n.style_data, n.style_label = L.ImageData(
transform_param=transform_param, source=source,
batch_size=50, new_height=256, new_width=256, ntop=2)
param = learned_param if learn_all else frozen_param
# the net itself
n.conv1, n.relu1 = conv_relu(n.style_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)
n.drop6 = L.Dropout(n.relu6, in_place=True)
n.fc7, n.relu7 = fc_relu(n.drop6, 4096, param=param)
n.drop7 = L.Dropout(n.relu7, in_place=True)
n.fc8_style = L.InnerProduct(n.drop7, num_output=CLASS_NUM, param=learned_param)
n.loss = L.SoftmaxWithLoss(n.fc8_style, n.style_label)
n.acc = L.Accuracy(n.fc8_style, n.style_label)
return n.to_proto()
def Lenet(img_list, batch_size, include_acc=False):
# 第一层，数据输入层，以ImageData格式输入
data, label = L.ImageData(source=img_list, batch_size=batch_size, ntop=2, root_folder=root,
transform_param=dict(scale=0.00390625))
# 第二层：卷积层
conv1 = L.Convolution(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'))
# softmax层
loss = L.SoftmaxWithLoss(fc4, label)
if include_acc: # test阶段需要有accuracy层
acc = L.Accuracy(fc4, label)
return to_proto(loss, acc)
else:
return to_proto(loss)
def lenet_imagedata(source, batch_size):
n = caffe.NetSpec()
n.data, n.label = L.ImageData(
batch_size=batch_size,
source=source,
transform_param=dict(scale=1. / 255),
shuffle=True, # Don't omit this pllllllllllllllllllllllllllz!!!!
ntop=2,
is_color=False)
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.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.SoftmaxWithLoss(n.score, n.label)
n.acc = L.Accuracy(n.score, n.label)
return n.to_proto()
def create_landmark_net(train_list, batch_size):
spec = caffe.NetSpec()
spec.data, spec.label = L.ImageData(source=train_list, batch_size=batch_size, shuffle=True, ntop=2,
transform_param=dict(crop_size=112, mirror=False, scale=0.0078125, mean_value=127.5), include=dict(phase=caffe.TRAIN))
spec.conv0 = data_block(spec.data, kernel_size = 3, num_output = 8, stride = 2, pad = 1)#采样
spec.conv1 = mobile2_block(spec.conv0, kernel_size = 3, num_middle = 48, num_output = 8, stride = 2, pad = 1)#采样
spec.conv2 = shuffle_block(spec.conv1, kernel_size = 3, num_middle = 48, num_output = 8, stride = 1, pad = 1)
spec.conv3 = mobile2_block(spec.conv2, kernel_size = 3, num_middle = 48, num_output = 8, stride = 2, pad = 1)#采样
spec.conv4 = shuffle_block(spec.conv3, kernel_size = 3, num_middle = 48, num_output = 8, stride = 1, pad = 1)
spec.conv5 = shuffle_block(spec.conv4, kernel_size = 3, num_middle = 48, num_output = 8, stride = 1, pad = 1)
spec.conv6 = mobile2_block(spec.conv5, kernel_size = 3, num_middle = 48, num_output = 16, stride = 2, pad = 1)#采样
spec.conv7 = shuffle_block(spec.conv6, kernel_size = 3, num_middle = 96, num_output = 16, stride = 1, pad = 1)
spec.conv8 = shuffle_block(spec.conv7, kernel_size = 3, num_middle = 96, num_output = 16, stride = 1, pad = 1)
spec.conv9 = shuffle_block(spec.conv8, kernel_size = 3, num_middle = 96, num_output = 16, stride = 1, pad = 1)
spec.conv10 = mobile2_block(spec.conv9, kernel_size = 3, num_middle = 96, num_output = 24, stride = 1, pad = 1)
spec.conv11 = shuffle_block(spec.conv10, kernel_size = 3, num_middle = 144, num_output = 24, stride = 1, pad = 1)
spec.conv12 = shuffle_block(spec.conv11, kernel_size = 3, num_middle = 144, num_output = 24, stride = 1, pad = 1)
spec.conv13 = mobile2_block(spec.conv12, kernel_size = 3, num_middle = 144, num_output = 40, stride = 2, pad = 1)#采样
spec.conv14 = shuffle_block(spec.conv13, kernel_size = 3, num_middle = 240, num_output = 40, stride = 1, pad = 1)
spec.conv15 = shuffle_block(spec.conv14, kernel_size = 3, num_middle = 240, num_output = 40, stride = 1, pad = 1)
spec.conv16 = mobile2_block(spec.conv15, kernel_size = 3, num_middle = 240, num_output = 80, stride = 1, pad = 1)
spec.conv17 = L.Convolution(spec.conv16, kernel_size = 1, stride = 1, num_output = 1280, bias_term = False, pad = 0, weight_filler = dict(type = 'xavier'))
spec.conv18 = L.Convolution(spec.conv17, kernel_size = 1, stride = 1, num_output = 64, bias_term = False, pad = 0, weight_filler = dict(type = 'xavier'))
spec.fc0 = L.InnerProduct(spec.conv18, num_output = 212, weight_filler=dict(type='xavier'))
spec.loss = L.EuclideanLoss(spec.fc0, spec.label, include=dict(phase=caffe.TRAIN))
return spec.to_proto()
def train_head(self, subset):
n = NetSpec()
# train
image_data_param = dict(source=subset.get_list_absolute_path(),
batch_size=self.batch_sizes[0],
new_width=self.infmt.new_width,
new_height=self.infmt.new_height,
rand_skip=self.batch_size,
shuffle=True)
if subset.root_folder is not None:
image_data_param['root_folder'] = subset.root_folder
transform_param = dict(
mirror=self.infmt.mirror,
crop_size=self.infmt.crop_size,
# mean_value = self.infmt.mean_pixel,
)
if self.infmt.scale is not None:
transform_param['scale'] = self.infmt.scale
if self.infmt.mean_file is not None:
transform_param['mean_file'] = self.infmt.mean_file
elif self.infmt.mean_pixel is not None:
transform_param['mean_value'] = self.infmt.mean_pixel
n.data, n.label = L.ImageData(ntop=2,
image_data_param=image_data_param,
transform_param=transform_param,
include=dict(phase=caffe.TRAIN))
net = n.to_proto()
net.name = self.name
return net
def zero1_net(source, batch_size):
n = caffe.NetSpec()
n.data, n.label = L.ImageData(source=source, batch_size=batch_size, ntop=2)
n.conv1 = L.Convolution(n.data,
kernel_size=3,
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=3,
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=50,
weight_filler=dict(type='xavier'))
n.prob = L.InnerProduct(n.fc1,
num_output=10,
weight_filler=dict(type='xavier'))
n.loss = L.SoftmaxWithLoss(n.prob, n.label)
return n.to_proto()
def style_net(train=True, learn_all=False, subset=None):
if subset is None:
subset = 'train' if train else 'test'
# 'data/flickr_style/train.txt'存储内容：/home/momo/ZZ/caffe/data/flickr_style/images/10344996196_1117743cfe.jpg 0
# /home/momo/ZZ/caffe/data/flickr_style/images/10344996196_1117743cfe.jpg是style_data, 0是style_label
# L.ImagData()中的source直接输入图，不是lmdb文件
source = caffe_root + 'data/flickr_style/%s.txt' % subset
# mirror:是否对输入数据采取随机水平镜像，增加训练数据
# crop_size:尺寸超过277就会进行裁剪
# mean_file: 数据均值文件存放
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)
return caffenet(data=style_data,
label=style_label,
train=train,
num_classes=NUM_STYLE_LABELS,
classifier_name='fc8_flickr',
learn_all=learn_all)
def main():
# Pretrained models on ImageNet
weights = './mobilenet.caffemodel'
assert os.path.exists(weights)
# deploy
deploy_data = L.Input(input_param=dict(shape=dict(dim=[1, 3, 224, 224])))
deploy_proto = './deploy.prototxt'
with open(deploy_proto, 'w') as f:
f.write(str(mobilenet(data=deploy_data, num_classes=9)))
# train
train_source = './data/train_shuffled.txt'
train_transform_param = dict(scale=0.017,
mirror=True,
crop_size=224,
mean_value=[103.94, 116.78, 123.68])
train_data, train_label = L.ImageData(
transform_param=train_transform_param,
source=train_source,
root_folder="./data/",
batch_size=16,
new_height=256,
new_width=256,
ntop=2)
train_proto = './train.prototxt'
with open(train_proto, 'w') as f:
f.write(
str(mobilenet(data=train_data, label=train_label, num_classes=9)))
# test
test_source = './data/test_shuffled.txt'
test_transform_param = dict(scale=0.017,
mirror=False,
crop_size=224,
mean_value=[103.94, 116.78, 123.68])
test_data, test_label = L.ImageData(transform_param=test_transform_param,
source=test_source,
root_folder="./data/",
batch_size=2,
new_height=256,
new_width=256,
ntop=2)
test_proto = './test.prototxt'
with open(test_proto, 'w') as f:
f.write(str(mobilenet(data=test_data, label=test_label,
num_classes=9)))
def conv1_autoencoder(split, batch_sz):
n = caffe.NetSpec()
n.data, n.label = L.ImageData(image_data_param=dict(source=split,
batch_size=batch_sz,
new_height=height,
new_width=width,
is_color=False),
ntop=2)
n.silence = L.Silence(n.label, ntop=0)
n.flatdata_i = L.Flatten(n.data)
n.conv1 = conv(n.data, 5, 5, 64, pad=2)
n.bn1 = L.BatchNorm(n.conv1,
use_global_stats=False,
in_place=True,
param=[{
"lr_mult": 0
}, {
"lr_mult": 0
}, {
"lr_mult": 0
}])
n.scale1 = L.Scale(n.bn1, bias_term=True, in_place=True)
n.relu1 = L.ReLU(n.scale1, relu_param=dict(negative_slope=0.1))
n.pool1 = max_pool(n.relu1, 2, stride=2)
n.code = conv(n.pool1, 5, 5, 64, pad=2)
n.upsample1 = L.Deconvolution(n.code,
param=dict(lr_mult=0, decay_mult=0),
convolution_param=dict(
group=64,
num_output=64,
kernel_size=4,
stride=2,
pad=1,
bias_term=False,
weight_filler=dict(type="bilinear")))
n.deconv1 = conv(n.upsample1, 5, 5, 1, pad=2)
n.debn1 = L.BatchNorm(n.deconv1,
use_global_stats=False,
in_place=True,
param=[{
"lr_mult": 0
}, {
"lr_mult": 0
}, {
"lr_mult": 0
}])
n.descale1 = L.Scale(n.debn1, bias_term=True, in_place=True)
n.derelu1 = L.ReLU(n.descale1, relu_param=dict(negative_slope=0.1))
n.flatdata_o = L.Flatten(n.derelu1)
n.loss_s = L.SigmoidCrossEntropyLoss(n.flatdata_o,
n.flatdata_i,
loss_weight=1)
n.loss_e = L.EuclideanLoss(n.flatdata_o, n.flatdata_i, loss_weight=0)
return str(n.to_proto())
def generate_data(method):
if method == "train_test":
net.data, net.label = Layers.ImageData(
name="cifar",
ntop=2,
transform_param=dict(
mirror=True,
crop_size=32,
mean_value=[104, 117, 123],
),
image_data_param=dict(
source="/home/cengsl14/dataset/cifar10_train_list.txt",
batch_size=128,
shuffle=True,
is_color=True,
root_folder="/home/cengsl14/dataset/cifar10_train/",
),
include=dict(phase=caffe.TRAIN, ),
)
# add repetive train part
train_part = str(net.to_proto())
## test part
net.data, net.label = Layers.ImageData(
name="cifar",
ntop=2,
transform_param=dict(
mirror=False,
mean_value=[104, 117, 123],
),
image_data_param=dict(
source="/home/cengsl14/dataset/cifar10_test_list.txt",
batch_size=32,
shuffle=False,
is_color=True,
mirror=False,
root_folder="/home/cengsl14/dataset/cifar10_test/",
),
include=dict(phase=caffe.TEST),
)
return train_part
elif method == "deploy":
net.tops["data"] = Layers.Input(
name="cifar", input_param=dict(shape=dict(dim=[1, 3, 32, 32])))
return ""
else:
raise NotImplementedError
def net(img_list, batch_size, mean_value=0):
n = caffe.NetSpec()
n.data, n.label=L.ImageData(source=img_list,batch_size=batch_size,new_width=28,new_height=28,ntop=2,transform_param=dict(scale = 1/255.0, mean_value=mean_value))
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=10, weight_filler=dict(type='xavier'))
n.loss = L.SoftmaxWithLoss(n.ip2, n.label)
return n.to_proto()
def resnet18_fer2013(source, batch_size):
n = caffe.NetSpec()
#n.data, n.label = L.ImageData(image_data_param=dict(source='tmp' , batch_size=100),
# ntop=2, transform_param=dict(mean_file='tmp'))
#n.data, n.label = Custom_Data_Layer(src_file=, batch_size=64, im_shape=(64, 64), ntop=2) # 64 x 64
n.data, n.label = L.ImageData(batch_size=batch_size,
source=source,
transform_param=dict(scale=1./255),
shuffle=True, # Don't omit this pllllllllllllllllllllllllllz!!!!
new_width=64,
new_height=64,
ntop=2,
is_color=True)
output_size = 64
n.conv_layer = conv_factory(n.data, ks=3, nout=output_size, stride=1, pad=1)
#n.pool = max_pool(n.conv_layer, ks=3, stride=2)
n.part1 = part_block(n.conv_layer, nout=output_size, stride=1)
n.layer1 = layer_block(n.conv_layer, nout=output_size, upper_stride=1) # 64
n.concat1 = concat_block(n.part1, n.layer1)
n.layer2 = layer_block(n.concat1, nout=output_size, upper_stride=1) # 64
n.concat2 = concat_block(n.concat1, n.layer2)
output_size *= 2
n.part2 = part_block(n.concat2, nout=output_size)
n.layer3 = layer_block(n.concat2, nout=output_size, upper_stride=2) # 128
n.concat3 = concat_block(n.part2, n.layer3)
n.layer4 = layer_block(n.concat3, nout=output_size, upper_stride=1) # 128
n.concat4 = concat_block(n.concat3, n.layer4)
output_size *= 2
n.part3 = part_block(n.concat4, nout=output_size)
n.layer5 = layer_block(n.concat4, nout=output_size, upper_stride=2) # 256
n.concat5 = concat_block(n.part3, n.layer5)
n.layer6 = layer_block(n.concat5, nout=output_size, upper_stride=1) # 256
n.concat6 = concat_block(n.concat5, n.layer6)
output_size *= 2
n.part4 = part_block(n.concat6, nout=output_size)
n.layer7 = layer_block(n.concat6, nout=output_size, upper_stride=2) # 512
n.concat7 = concat_block(n.part4, n.layer7)
n.layer8 = layer_block(n.concat7, nout=output_size, upper_stride=1) # 512
n.concat8 = concat_block(n.concat7, n.layer8)
n.pool2 = L.Pooling(n.concat8, pool=P.Pooling.AVE, global_pooling=True)
n.fc = L.InnerProduct(n.pool2, num_output=7, weight_filler=dict(type='xavier'))
n.loss = L.SoftmaxWithLoss(n.fc, n.label)
n.acc = L.Accuracy(n.fc, n.label, include=dict(phase=getattr(caffe_pb2, 'TEST'))) # same as caffe.TEST
return n.to_proto()
def test_eltwise_relu_lego():
from lego.hybrid import EltwiseReLULego
n = caffe.NetSpec()
n.data, n.label = L.ImageData(image_data_param=dict(source='tmp',
batch_size=100),
ntop=2,
transform_param=dict(mean_file='tmp'))
EltwiseReLULego(dict(name='1')).attach(n, [n.data, n.label])
assert n['eltwise_1'] is not None
def miniplaces_net(source, train=False, with_labels=True):
mean = [104, 117, 123] # per-channel mean of the BGR image pixels
transform_param = dict(mirror=train, crop_size=args.crop, mean_value=mean)
batch_size = args.batch if train else 100
places_data, places_labels = L.ImageData(transform_param=transform_param,
source=source, root_folder=args.image_root, shuffle=train,
batch_size=batch_size, ntop=2)
return minialexnet(data=places_data, labels=places_labels, train=train,
with_labels=with_labels)
def test_relu():
from lego.base import BaseLegoFunction
n = caffe.NetSpec()
n.data, n.label = L.ImageData(image_data_param=dict(source='tmp',
batch_size=100),
ntop=2,
transform_param=dict(mean_file='tmp'))
BaseLegoFunction('ReLU', dict(name='relu1')).attach(n, [n.data])
assert n['relu1'] is not None
def get_data_layer(source, mirror):
transform_param = dict(mirror=mirror, crop_size=227)
species_data, species_label = L.ImageData(transform_param=transform_param,
source=source,
batch_size=50,
new_height=256,
new_width=256,
ntop=2)
return species_data, species_label
def test_fire_lego():
from lego.hybrid import FireLego
n = caffe.NetSpec()
n.data, n.label = L.ImageData(image_data_param=dict(source='tmp',
batch_size=100),
ntop=2,
transform_param=dict(mean_file='tmp'))
params = dict(name='fire1', squeeze_num_output=16, use_global_stats=True)
FireLego(params).attach(n, [n.data])
def ImageDataLayer(source_, batch_size_, root_folder_):
kwargs = {
'image_data_param':
dict(source=source_,
batch_size=batch_size_,
root_folder=root_folder_,
shuffle=True)
}
data, label = L.ImageData(ntop=2, **kwargs)
return [data, label]
def test_prediction_lego():
from lego.ssd import PredictionLego
n = caffe.NetSpec()
n.data, n.label = L.ImageData(image_data_param=dict(source='tmp',
batch_size=100),
ntop=2,
transform_param=dict(mean_file='tmp'))
params = dict(name='1', num_output=16, stride=1)
lego = PredictionLego(params)
lego.attach(n, [n.data])
def test_inception_v1_lego():
from lego.hybrid import InceptionV1Lego
n = caffe.NetSpec()
n.data, n.label = L.ImageData(image_data_param=dict(source='tmp',
batch_size=100),
ntop=2,
transform_param=dict(mean_file='tmp'))
params = dict(name='inception1',
num_outputs=[16, 96, 128, 16, 32, 32],
use_global_stats=True)
InceptionV1Lego(params).attach(n, [n.data])
def srcnn_net(source, target=None, train=False, with_labels=True):
transform_param = dict(scale=0.0039215684)
batch_size = args.batch if train else 100
source_images, source_labels = L.ImageData(transform_param=transform_param,
source=source,
root_folder=args.image_root,
batch_size=batch_size,
ntop=2)
target_images = None
if target:
target_images, target_labels = L.ImageData(
transform_param=transform_param,
source=target,
root_folder=args.image_root,
batch_size=batch_size,
ntop=2)
return srcnn(data=source_images,
labels=target_images,
train=train,
with_labels=(target != None))
def fcn():
n = caffe.NetSpec()
n.data = L.ImageData()
n.label = L.ImageData()
# the base net
n.conv1_1, n.relu1_1 = conv_relu(n.data, 64, pad=1)
n.conv1_2, n.relu1_2 = conv_relu(n.relu1_1, 64)
n.pool1 = max_pool(n.relu1_2)
n.conv2_1, n.relu2_1 = conv_relu(n.pool1, 128)
n.conv2_2, n.relu2_2 = conv_relu(n.relu2_1, 128)
n.pool2 = max_pool(n.relu2_2)
n.conv3_1, n.relu3_1 = conv_relu(n.pool2, 256)
n.conv3_2, n.relu3_2 = conv_relu(n.relu3_1, 256)
n.conv3_3, n.relu3_3 = conv_relu(n.relu3_2, 256)
n.pool3 = max_pool(n.relu3_3)
n.conv4_1, n.relu4_1 = conv_relu(n.pool3, 512)
n.conv4_2, n.relu4_2 = conv_relu(n.relu4_1, 512)
n.conv4_3, n.relu4_3 = conv_relu(n.relu4_2, 512)
n.pool4 = max_pool(n.relu4_3)
n.conv5_1, n.relu5_1 = conv_relu(n.pool4, 512)
n.conv5_2, n.relu5_2 = conv_relu(n.relu5_1, 512)
n.conv5_3, n.relu5_3 = conv_relu(n.relu5_2, 512)
n.pool5 = max_pool(n.relu5_3)
# fully conv
n.fc6, n.relu6 = fc_relu(n.pool5, 4096)
n.drop6 = L.Dropout(n.relu6, dropout_ratio=0.5, in_place=True)
n.fc7, n.relu7 = fc_relu(n.drop6, 4096)
n.drop7 = L.Dropout(n.relu7, dropout_ratio=0.5, in_place=True)
n.fc8_minc = L.InnerProduct(n.drop7, num_output=23, weight_filler=dict(type='gaussian',std=0.01))
n.loss = L.SoftmaxWithLoss(n.fc8_minc, n.label,
loss_param=dict(normalize=False))
return n.to_proto()
def val_head(self, subset, stage=None):
image_data_param = dict(
source=subset.get_list_absolute_path(),
batch_size=self.batch_sizes[1],
# root_folder=subset.root_folder,
rand_skip=self.batch_sizes[1],
shuffle=True,
# new_width,
# new_height
)
transform_param = dict(
mirror=False,
# crop_size = self.infmt.crop_size,
# mean_value = self.infmt.mean_pixel,
# mean_file,
# scale,
)
if subset.root_folder is not None:
image_data_param['root_folder'] = subset.root_folder
if self.crop_on_test:
image_data_param['new_width'] = self.infmt.new_width
image_data_param['new_height'] = self.infmt.new_height
transform_param['crop_size'] = self.infmt.crop_size
else:
image_data_param['new_width'] = self.infmt.crop_size
image_data_param['new_height'] = self.infmt.crop_size
if self.infmt.scale is not None:
transform_param['scale'] = self.infmt.scale
if self.infmt.mean_file is not None:
transform_param['mean_file'] = self.infmt.mean_file
elif self.infmt.mean_pixel is not None:
transform_param['mean_value'] = self.infmt.mean_pixel
include_param = dict(phase=caffe.TEST)
if stage is not None:
include_param['stage'] = stage
n = NetSpec()
n.data, n.label = L.ImageData(ntop=2,
image_data_param=image_data_param,
transform_param=transform_param,
include=include_param)
net = n.to_proto()
net.name = self.name
return net
