def net_deploy(deploy_prototxt, model): from ofnet import ofnet n = caffe.NetSpec() n.data = L.Input(shape=[dict(dim=[1, 3, 224, 224])]) ofnet(n, is_train=False) n.sigmoid_edge = L.Sigmoid(n.unet1b_edge) with open('ofnet_eval.prototxt', 'w') as f: f.write(str(n.to_proto())) ## write network net = caffe.Net(deploy_prototxt, model, caffe.TEST) return net
def net(): n = caffe.NetSpec() n.data = L.Input(input_param=dict(shape=dict(dim=data_shape))) n.dataout = L.Convolution(n.data, param=[ dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0) ], kernel_size=7, stride=2, num_output=64, weight_filler=dict(type="xavier", std=0.03)) n.prelu = L.PReLU(n.dataout, in_place=True) return n.to_proto()
def test_convolution4(self): CAFFE_ENGINE = 1 n = caffe.NetSpec() n.input1 = L.Input(shape=make_shape([10, 4, 6, 6, 6])) n.conv1 = L.Convolution(n.input1, num_output=10, kernel_size=5, pad=10, stride=2, group=2, weight_filler=make_weight_filler(), bias_filler=make_bias_filler(), engine=CAFFE_ENGINE) self._test_model(*self._netspec_to_model(n, 'convolution4'))
def test_deconvolution_multilinear_upsample(self): factor = 2 n = caffe.NetSpec() n.input1 = L.Input(shape=make_shape([10, 3, 64, 64])) n.deconv1 = L.Deconvolution(n.input1, convolution_param=dict( kernel_size=2 * factor - factor % 2, stride=factor, num_output=3, pad=int(math.ceil((factor - 1) / 2.0)), weight_filler=dict(type="bilinear"), bias_term=False, group=3)) self._test_model(*self._netspec_to_model( n, 'deconvolution_multilinear_upsample', random_weights=False))
def overall_net(batch_size, channels, height, width, action_size, net_type): # param = learned_param n = caffe.NetSpec() # action n.frames = L.Input(shape=dict(dim=[batch_size, channels, height, width])) # Image feature if net_type == 'action': param = learned_param else: param = frozen_param n.conv1, n.relu1 = conv_relu(n.frames, 8, 32, stride=4, param=param) n.conv2, n.relu2 = conv_relu(n.relu1, 4, 64, stride=2, param=param) n.conv3, n.relu3 = conv_relu(n.relu2, 3, 64, stride=1, param=param) n.fc4, n.relu4 = fc_relu(n.relu3, 512, param=param) n.value_q = L.InnerProduct(n.relu4, num_output=action_size, param=param, weight_filler=dict(type='gaussian', std=0.005), bias_filler=dict(type='constant', value=1)) if net_type == 'test': return n.to_proto() n.filter = L.Input(shape=dict(dim=[batch_size, action_size])) # operation 0: PROD n.filtered_value_q = L.Eltwise(n.value_q, n.filter, operation=0) n.target = L.Input(shape=dict(dim=[batch_size, action_size])) n.loss = L.EuclideanLoss(n.filtered_value_q, n.target) return n.to_proto()
def _miso_op(data_list, func, *args, **kwargs): """Create multi input and single output Caffe op""" n = caffe.NetSpec() if not isinstance(data_list, (tuple, list)): raise TypeError("Need tuple or list but get {}".format( type(data_list))) input_list = list() for idx, data in enumerate(data_list): n["data" + str(idx)] = L.Input(input_param={"shape": { "dim": list(data.shape) }}) input_list.append(n["data" + str(idx)]) n.output = func(*input_list, *args, **kwargs) return n
def residual_factory_padding1(bottom, num_filter, stride, batch_size, feature_size): conv1 = conv_factory_relu(bottom, ks=3, nout=num_filter, stride=stride, pad=1) conv2 = conv_factory(conv1, ks=3, nout=num_filter, stride=1, pad=1) pool1 = L.Pooling(bottom, pool=P.Pooling.AVE, kernel_size=2, stride=2) padding = L.Input(input_param=dict(shape=dict( dim=[batch_size, num_filter / 2, feature_size, feature_size]))) concate = L.Concat(pool1, padding, axis=1) addition = L.Eltwise(concate, conv2, operation=P.Eltwise.SUM) relu = L.ReLU(addition, in_place=True) return relu
def test_deconvolution3(self): CAFFE_ENGINE = 1 n = caffe.NetSpec() n.input1 = L.Input(shape=make_shape([10, 4, 6, 6, 6])) n.deconv1 = L.Deconvolution(n.input1, convolution_param=dict( num_output=10, kernel_size=5, pad=1, stride=2, group=2, weight_filler=make_weight_filler(), bias_filler=make_bias_filler(), engine=CAFFE_ENGINE)) self._test_model(*self._netspec_to_model(n, 'deconvolution3'))
def _make_module(model_path, in_shape, axis): ns = caffe.NetSpec() ns.data = L.Input(name="data", input_param={"shape": {"dim": in_shape}}) ns.softmax = L.Softmax(ns.data, name="softmax", axis=axis) with open(os.path.join(model_path, 'test.prototxt'), 'w') as f: f.write(str(ns.to_proto())) net = caffe.Net(f.name, caffe.TEST) for l in net.layers: for b in l.blobs: if np.count_nonzero(b.data) == 0: b.data[...] = np.random.randn(*b.data.shape) net.save(os.path.join(model_path, 'test.caffemodel'))
def test_deconvolution(): # type: ()->caffe.NetSpec n = caffe.NetSpec() n.input1 = L.Input(shape=make_shape([10, 4, 64, 64])) n.deconv1 = L.Deconvolution(n.input1, convolution_param=dict( num_output=10, kernel_size=5, pad=10, stride=2, group=2, weight_filler=make_weight_filler(), bias_filler=make_bias_filler())) return n
def test_deconvolution2(): # type: ()->caffe.NetSpec n = caffe.NetSpec() n.input1 = L.Input(shape=make_shape([10, 4, 64, 64])) n.deconv1 = L.Deconvolution(n.input1, convolution_param=dict( num_output=10, kernel_size=5, bias_term=False, pad_h=10, pad_w=5, weight_filler=make_weight_filler(), bias_filler=make_bias_filler())) return n
def net(): n = caffe.NetSpec() n.data = L.Input(input_param=dict(shape=dict(dim=data_shape))) n.dataout = L.InnerProduct(n.data, param=[ dict(lr_mult=1, decay_mult=1), dict(lr_mult=1, decay_mult=1) ], inner_product_param=dict( num_output=_num_output, weight_filler=dict(type='xavier', std=_std), bias_filler=dict(type='constant', value=_vaule))) return n.to_proto()
def createNet(shape1, shape2): blobShape1 = caffe_pb2.BlobShape() blobShape1.dim.extend(shape1) blobShape2 = caffe_pb2.BlobShape() blobShape2.dim.extend(shape2) n = caffe.NetSpec() # 创建net n.data1, n.data2 = L.Input(shape=[blobShape1, blobShape2], ntop=2) prototxt = 'temp.prototxt' with open(prototxt, 'w') as f: f.write(str(n.to_proto())) net = caffe.Net(prototxt, caffe.TEST) #os.remove(prototxt) return net
def _make_module(model_path, n, i_channels, i_size): ns = caffe.NetSpec() ns.data = L.Input( name="data", input_param={"shape": { "dim": [n, i_channels, i_size[0], i_size[1]] }}) ns.relu = L.ReLU(ns.data, name="relu") with open(os.path.join(model_path, 'test.prototxt'), 'w') as f: f.write(str(ns.to_proto())) net = caffe.Net(f.name, caffe.TEST) net.save(os.path.join(model_path, 'test.caffemodel'))
def head(in_place_bn=False, index_width=1, scale_ext=False): ns = caffe.NetSpec() input_params = dict(shape=dict(dim=[1, 3, 224, 224])) ns.data = L.Input(**input_params) conv1_params = dict(kernel_size=3, num_output=32, stride=2, pad=1, weight_filler=default_weight_filler, bias_term=False) ns[f'conv{1:0{index_width}d}'] = L.Convolution(ns.data, **conv1_params) BatchNorm(ns, in_place_bn, scale_ext) ns[f'relu{1:0{index_width}d}/relu'] = L.ReLU(ns[ns.keys()[-1]], in_place=True) return ns
def net(): n = caffe.NetSpec() n.data = L.Input(input_param=dict(shape=dict(dim=data_shape))) n.dataout = L.Convolution(n.data, param=[ dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0) ], kernel_size=7, stride=2, num_output=64, pad=3, weight_filler=dict(type="xavier", std=0.03), bias_filler=dict(type='constant', value=0.2)) n.drop = L.Dropout(n.dataout, dropout_ratio=ratio, in_place=True) return n.to_proto()
def net(): n = caffe.NetSpec() n.data = L.Input(input_param=dict(shape=dict(dim=data_shape))) n.dataout = L.Convolution(n.data, param=[ dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0) ], kernel_size=_kernel_size, stride=_stride, num_output=_num_output, pad=_pad, group=_group, weight_filler=dict(type="xavier", std=0.03), bias_filler=dict(type='constant', value=0.2)) 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 netinputv3(): n = caffe.NetSpec() n.data = L.Input(input_param=dict(shape=[dict(dim=[1, 1, 32, 32])])) n.conv1 = conv(n.data, 3, 60) n.conv2 = conv(n.conv1, 3, 90) n.pool2 = pooling(n.conv2, 2, 2) n.conv3 = conv(n.pool2, 3, 120) n.pool3 = pooling(n.conv3, 2, 2) n.conv4 = conv(n.pool3, 3, 150) n.ip1 = ip(n.conv4, 1000) n.relu1 = relu(n.ip1) n.ip2 = ip(n.relu1, 500) n.relu2 = relu(n.ip2) n.ip3 = ip(n.relu2, 34) n.prob = L.Softmax(n.ip3) return str(n.to_proto())
def test_deconvolution_multilinear_upsample(): # type: ()->caffe.NetSpec factor = 2 n = caffe.NetSpec() n.input1 = L.Input(shape=make_shape([10, 3, 64, 64])) n.deconv1 = L.Deconvolution(n.input1, convolution_param=dict( kernel_size=2 * factor - factor % 2, stride=factor, num_output=3, pad=int(math.ceil((factor - 1) / 2.0)), weight_filler=dict(type="bilinear"), bias_term=False, group=3)) return n
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 _make_module(model_path, n, i_channels, i_size, k_size, o_channels, strides, padding, dilations): ns = caffe.NetSpec() ns.data = L.Input(name="data", input_param={ "shape": {"dim": [n, i_channels, i_size[0], i_size[1]]}}) ns.conv = L.Convolution(ns.data, name="conv2d", kernel_size=k_size, num_output=o_channels, stride=strides, pad=padding, dilation=dilations, weight_filler=dict(type='xavier')) with open(os.path.join(model_path, 'test.prototxt'), 'w') as f: f.write(str(ns.to_proto())) net = caffe.Net(f.name, caffe.TEST) for l in net.layers: for b in l.blobs: if np.count_nonzero(b.data) == 0: b.data[...] = np.random.randn(*b.data.shape) net.save(os.path.join(model_path, 'test.caffemodel'))
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 KitModel(weight_file=None): n = caffe.NetSpec() n.input = L.Input(shape=[dict(dim=[1, 1, 32, 32])], ntop=1) n.HardNetnSequentialnfeaturesnnConv2dn0n7 = L.Convolution(n.input, kernel_h=7, kernel_w=7, stride=1, num_output=32, pad_h=0, pad_w=0, group=1, bias_term=True, ntop=1) n.HardNetnSequentialnfeaturesnnTanhn1n8 = L.TanH( n.HardNetnSequentialnfeaturesnnConv2dn0n7, ntop=1) n.HardNetnSequentialnfeaturesnnMaxPool2dn2n9 = L.Pooling( n.HardNetnSequentialnfeaturesnnTanhn1n8, pool=0, kernel_size=2, pad_h=0, pad_w=0, stride=2, ntop=1) n.HardNetnSequentialnfeaturesnnConv2dn3n10 = L.Convolution( n.HardNetnSequentialnfeaturesnnMaxPool2dn2n9, kernel_h=6, kernel_w=6, stride=1, num_output=64, pad_h=0, pad_w=0, group=1, bias_term=True, ntop=1) n.HardNetnSequentialnfeaturesnnTanhn4n11 = L.TanH( n.HardNetnSequentialnfeaturesnnConv2dn3n10, ntop=1) n.HardNetnSequentialnclassifiernnLinearn0n13 = L.InnerProduct( n.HardNetnSequentialnfeaturesnnTanhn4n11, num_output=128, bias_term=True, ntop=1) n.HardNetnSequentialnclassifiernnTanhn1n14 = L.TanH( n.HardNetnSequentialnclassifiernnLinearn0n13, ntop=1) return n
def create_proto(split): n = caffe.NetSpec() # data layer if split == 'train' or split == 'test': if split == 'train': source = "mnist_train_lmdb" phase = caffe.TRAIN bs = 64 else: source = "mnist_test_lmdb" phase = caffe.TEST bs = 100 data_param = { "source" : source, "backend" : P.Data.LMDB, "batch_size" : bs, } transform_param = { "scale": 1/256.0 } n.data, n.label = L.Data( ntop=2, data_param=data_param, transform_param = transform_param) elif split == 'deploy': n.data = L.Input( input_param={"shape": {"dim": [64, 1, 28, 28]}}) else: raise NotImplementedError n.conv1 = convolution(n.data, nout=20, ks=5, stride=1, pad=0) n.pool1 = max_pool(n.conv1, ks=2, stride=2) n.conv2 = convolution(n.pool1, nout=50, ks=5, stride=1, pad=0) n.pool2 = max_pool(n.conv2, ks=2, stride=2) n.ip1 = inner_product(n.pool2, nout=500) n.relu1 = relu(n.ip1) n.ip2 = inner_product(n.ip1, nout=10) if split == 'train' or split == 'test': n.accuracy = accuracy(n.ip2, n.label) n.softmax = softmax_loss(n.ip2, n.label) elif split == 'deploy': n.softmax = softmax(n.ip2) return n.to_proto()
def fcn(split, num_classes=None): n = caffe.NetSpec() n.data = L.Input(shape=[dict(dim=[1, 3, 500, 500])]) # conv1 n.conv1_1, n.relu1_1 = conv_relu(n.data, 64, pad=100) n.conv1_2, n.relu1_2 = conv_relu(n.relu1_1, 64) n.pool1 = max_pool(n.relu1_2) # conv2 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) # conv3 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) # conv4 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) # score n.score_fr = L.Convolution( n.pool4, num_output=num_classes, kernel_size=1, pad=0, param=[dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0)]) # deconv : 16x n.upscore = L.Deconvolution(n.score_fr, convolution_param=dict(num_output=num_classes, kernel_size=32, stride=16, bias_term=False), param=[dict(lr_mult=0)]) n.score = crop(n.upscore, n.data) return n.to_proto()
def test_net(): import caffe import skimage.data as dt import skimage.transform as skt import numpy as np from matplotlib import pyplot as plt def pre_processing(img): if img.ndim == 2: # Gray image img = np.concatenate([np.expand_dims(img, 2)] * 3, 2) elif img.shape[2] > 3: # RGB+depth or RGB+alpha. Ignore 4th channel img = img[:, :, :3] img = skt.resize(img, (256, 256)) * 255 img = img[:, :, (2, 1, 0)] img = np.transpose(img, (2, 0, 1)) img = img[:, 16:243, 16:243] img -= np.array([104, 117, 123]).reshape((3, 1, 1)) return img # Load and process image img = dt.chelsea() img_prep = pre_processing(img) # Specify model ns = caffe.NetSpec() alexnet = AlexNet(ns) ns.data = L.Input(shape=dict(dim=[1, 3, 227, 227])) alexnet.inference_proto(ns.data, mult=1.) deploy_fn = '/tmp/deploy.prototxt' with open(deploy_fn, 'w') as f: f.write(str(ns.to_proto())) # Load pretrained model net = caffe.Net(deploy_fn, caffe.TEST) alexnet.load_pretrained(net) # Forward image and infer class net.blobs['data'].data[0] = img_prep net.forward() label = np.argmax(net.blobs['fc8'].data, axis=1) classes = [l.strip() for l in open('imagenet_synsets.txt')] print classes[label[0]] plt.imshow(img) plt.show()
def construc_net(): net = caffe.NetSpec() net.data = L.Input(shape=dict(dim=[10, 3, 224, 224])) block_1 = _block_crp('1', 2, net, net.data, 64) block_2 = _block_crp('2', 2, net, block_1, 128) block_3 = _block_crp('3', 4, net, block_2, 256) block_4 = _block_crp('4', 4, net, block_3, 512) block_5 = _block_crp('5', 4, net, block_4, 512) block_6 = _block_frd('6', net, block_5, 4096) block_7 = _block_frd('7', net, block_6, 4096) net.fc8 = L.InnerProduct(block_7, num_output=1000) net.prob = L.Softmax(net.fc8) return net.to_proto()
def residual_factory_padding2(bottom, num_filter, stride, batch_size, feature_size): conv1 = conv_factory_relu(bottom, ks=3, nout=num_filter, stride=stride, pad=1) conv2 = conv_factory(conv1, ks=3, nout=num_filter, stride=1, pad=1) pool1 = L.Pooling(bottom, pool=P.Pooling.AVE, kernel_size=2, stride=2) padding = L.Input(input_param=dict(shape=dict( dim=[batch_size, num_filter / 2, feature_size, feature_size]))) concate = L.Concat(pool1, padding, axis=1) addition = L.Python(concate, conv2, module='resnet_oc', ntop=1, layer='RandAdd') relu = L.ReLU(addition, in_place=True) return relu
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, 128, has_branch1=True, is_branch_2a=True) branch_2b = _branch('2b', net, branch_2a, 128) branch_2c = _branch('2c', net, branch_2b, 128) branch_3a = _branch('3a', net, branch_2c, 256, has_branch1=True) branch_3b = _branch('3b', net, branch_3a, 256) branch_3c = _branch('3c', net, branch_3b, 256) branch_3d = _branch('3d', net, branch_3c, 256) branch_4a = _branch('4a', net, branch_3d, 512, has_branch1=True) branch_4b = _branch('4b', net, branch_4a, 512) branch_4c = _branch('4c', net, branch_4b, 512) branch_4d = _branch('4d', net, branch_4c, 512) branch_4e = _branch('4e', net, branch_4d, 512) branch_4f = _branch('4f', net, branch_4e, 512) branch_5a = _branch('5a', net, branch_4f, 1024, has_branch1=True) branch_5b = _branch('5b', net, branch_5a, 1024) branch_5c = _branch('5c', net, branch_5b, 1024) 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()