def create_Net (lmdb,batch_size,C1,C2,C3): 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=3, num_output=C1, weight_filler=dict(type='xavier')) n.tanh1 = L.TanH(n.conv1, in_place=True) n.pool1 = L.Pooling(n.tanh1, kernel_size=2, stride=2, pool=P.Pooling.MAX) n.conv2 = L.Convolution(n.pool1, kernel_size=3, num_output=C2, weight_filler=dict(type='xavier')) n.tanh2 = L.TanH(n.conv2, in_place=True) n.pool2 = L.Pooling(n.tanh2, kernel_size=2, stride=2, pool=P.Pooling.MAX) n.conv3 = L.Convolution(n.pool2, kernel_size=3, num_output=C3, weight_filler=dict(type='xavier')) n.tanh3 = L.TanH(n.conv3, in_place=True) n.fc = L.InnerProduct(n.tanh3, num_output=10, weight_filler=dict(type='xavier')) n.tanh4 = L.TanH(n.fc, in_place=True) n.cla = L.SoftmaxWithLoss(n.fc,n.label) n.acc = L.Accuracy(n.fc,n.label) return n.to_proto()
def anon_lenet(batch_size): data, label = L.DummyData(shape=[dict(dim=[batch_size, 1, 28, 28]), dict(dim=[batch_size, 1, 1, 1])], transform_param=dict(scale=1./255), ntop=2) conv1 = L.Convolution(data, kernel_size=5, num_output=20, weight_filler=dict(type='xavier')) pool1 = L.Pooling(conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX) conv2 = L.Convolution(pool1, kernel_size=5, num_output=50, weight_filler=dict(type='xavier')) pool2 = L.Pooling(conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX) ip1 = L.InnerProduct(pool2, num_output=500, weight_filler=dict(type='xavier')) relu1 = L.ReLU(ip1, in_place=True) ip2 = L.InnerProduct(relu1, num_output=10, weight_filler=dict(type='xavier')) loss = L.SoftmaxWithLoss(ip2, label) return loss.to_proto()
def lenet_bn_proto(self, batch_size, phase='TRAIN'): n = caffe.NetSpec() if phase == 'TRAIN': source_data = self.train_data mirror = False else: source_data = self.test_data mirror = False n.data, n.label = L.Data(source=source_data, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, transform_param=dict(scale=0.00390625, mirror=mirror)) n.conv1 = L.Convolution(n.data, kernel_size=5, num_output=20, stride=1, weight_filler=dict(type='xavier'), bias_filler=dict(type='constant')) n.bn1 = L.BatchNorm(n.conv1, use_global_stats=False) n.pool1 = L.Pooling(n.bn1, pool=P.Pooling.MAX, kernel_size=2, stride=2) n.conv2 = L.Convolution(n.pool1, kernel_size=5, num_output=50, stride=1, weight_filler=dict(type='xavier'), bias_filler=dict(type='constant')) n.bn2 = L.BatchNorm(n.conv2, use_global_stats=False) n.pool2 = L.Pooling(n.bn2, pool=P.Pooling.MAX, kernel_size=2, stride=2) n.ip1 = L.InnerProduct(n.pool2, num_output=500, weight_filler=dict(type='xavier'), bias_filler=dict(type='constant')) n.relu1 = L.ReLU(n.ip1, in_place=True) n.ip2 = L.InnerProduct(n.relu1, num_output=self.classifier_num, weight_filler=dict(type='xavier'), bias_filler=dict(type='constant')) if phase == 'TRAIN': pass else: n.accuracy = L.Accuracy(n.ip2, n.label, include=dict(phase=1)) n.loss = L.SoftmaxWithLoss(n.ip2, n.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)) data, label = L.Data( batch_size=batch_size, backend=P.Data.LMDB, source=img_list, transform_param=dict(scale=1. / 255), #缩放比例 ntop=2) #第二层:卷积层 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(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.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) return n.to_proto()
def densenet(data_file, architecture = 'densenet_121', mode='train', batch_size=64, no_of_classes = 3, dropout=0.2): architecture_map = dict({'densenet_121':[6, 12, 24, 16], 'densenet_169':[6, 12, 32, 32], 'densenet_201':[6, 12, 48, 32], 'densenet_264':[6, 12, 64, 48]}) no_dense_blocks_ar = architecture_map[architecture] data, label = L.Data(source=data_file, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, transform_param=dict(mean_file="/home/achyut/Desktop/classifier_sorted_rgb/lmdb/mean.binaryproto")) nchannels = 112 model = L.Convolution(data, kernel_size=7, stride=2, num_output=nchannels, pad=1, bias_term=False, weight_filler=dict(type='msra'), bias_filler=dict(type='constant')) model = L.Pooling(model, pool=P.Pooling.MAX, kernel_size=3, stride=2) nchannels = first_output/2 for i in range(no_of_dense_blocks_ar[0]): model = dense_block(model, nchannels, dropout) model = transition_block(model, nchannels, dropout) nchannels /= 2 for i in range(no_of_dense_blocks_ar[1]): model = dense_block(model, nchannels, dropout) model = transition_block(model, nchannels, dropout) nchannels /= 2 for i in range(no_of_dense_blocks_[2]): model = dense_block(model, nchannels, dropout) model = transition_block(model, nchannels, dropout) nchannels /= 2 for i in range(no_of_dense_blocks_ar[3]): model = dense_block(model, nchannels, dropout) model = transition_block(model, nchannels, dropout) nchannels /= 2 model = L.BatchNorm(model, in_place=False, param=[dict(lr_mult=0, decay_mult=0), dict(lr_mult=0, decay_mult=0), dict(lr_mult=0, decay_mult=0)]) model = L.Scale(model, bias_term=True, in_place=True, filler=dict(value=1), bias_filler=dict(value=0)) model = L.ReLU(model, in_place=True) model = L.Pooling(model, pool=P.Pooling.AVE, global_pooling=True) model = L.InnerProduct(model, num_output=no_of_classes, bias_term=True, weight_filler=dict(type='xavier'), bias_filler=dict(type='constant')) loss = L.SoftmaxWithLoss(model, label) accuracy = L.Accuracy(model, label) return to_proto(loss, accuracy)
def resnet(train_lmdb, test_lmdb, batch_size=256, stages=[2, 2, 2, 2], first_output=32, include_acc=False): # now, this code can't recognize include phase, so there will only be a TEST phase data layer data, label = L.Data(source=train_lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, transform_param=dict(crop_size=227, mean_value=[104, 117, 123], mirror=True), include=dict(phase=getattr(caffe_pb2, 'TRAIN'))) data, label = L.Data(source=test_lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, transform_param=dict(crop_size=227, mean_value=[104, 117, 123], mirror=True), include=dict(phase=getattr(caffe_pb2, 'TEST'))) # the net itself relu1 = conv_factory_relu(data, 3, first_output, stride=1, pad=1) relu2 = conv_factory_relu(relu1, 3, first_output, stride=1, pad=1) residual = max_pool(relu2, 3, stride=2) for i in stages[1:]: first_output *= 2 for j in range(i): if j == 0: if i == 0: residual = residual_factory_proj(residual, first_output, 1) else: residual = residual_factory_proj(residual, first_output, 2) else: residual = residual_factory1(residual, first_output) glb_pool = L.Pooling(residual, pool=P.Pooling.AVE, global_pooling=True) fc = L.InnerProduct(glb_pool, num_output=1000) loss = L.SoftmaxWithLoss(fc, label) acc = L.Accuracy(fc, label, include=dict(phase=getattr(caffe_pb2, 'TEST'))) return to_proto(loss, acc)
def caffenet(data, label=None, train=True, num_classes=1000, classifier_name='fc8', learn_all=False): n = caffe.NetSpec() n.data = data 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 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) mode = 'train' if train else 'test' filename = path_savemodel + num_fold + '_' + typeNet + '_' + mode + '.prototxt' with open(filename, 'w') as f: f.write(str(n.to_proto())) return filename
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 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 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())) return f.name
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 _loss_proto(self, xPr, xLb, xSemPr, xSemLb, lCW): ns = self.netspec # Classification loss if self.sem_coeff < 1: name = 'SCoRe/objLoss' ns[name] = L.SoftmaxWithLoss(*[xPr, xLb], name=name, loss_weight=1.0 - self.sem_coeff, include=dict(phase=caffe.TRAIN)) # Semantic regularization if self.sem_coeff > 0: self._semantic_regularization(xSemPr, xSemLb, self.sem_coeff) # Codeword regularization if 0 < self.code_coeff < np.inf: self._code_regularization(lCW)
def fcn(split, tops): n = caffe.NetSpec() n.color, n.hha, n.label = L.Python(module='nyud_layers', layer='NYUDSegDataLayer', ntop=3, param_str=str(dict(nyud_dir='../data/nyud', split=split, tops=tops, seed=1337))) n = modality_fcn(n, 'color', 'color') n = modality_fcn(n, 'hha', 'hha') n.score_fused = L.Eltwise(n.score_frcolor, n.score_frhha, operation=P.Eltwise.SUM, coeff=[0.5, 0.5]) n.upscore = L.Deconvolution(n.score_fused, convolution_param=dict(num_output=40, kernel_size=64, stride=32, bias_term=False), param=[dict(lr_mult=0)]) n.score = crop(n.upscore, n.color) n.loss = L.SoftmaxWithLoss(n.score, n.label, loss_param=dict(normalize=False, ignore_label=255)) return n.to_proto()
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 lenet(batch_size): n = caffe.NetSpec() n.data, n.label = L.DummyData(shape=[dict(dim=[batch_size, 1, 28, 28]), dict(dim=[batch_size, 1, 1, 1])], 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) return n.to_proto()
def gen_net(net_path, data_shape, label_shape): net = caffe.NetSpec() net.data = L.Input(shape=dict(dim=list(data_shape))) net.label = L.Input(shape=dict(dim=list(label_shape))) net.conv1 = L.Convolution(net.data, kernel_size=5, num_output=48, weight_filler=dict(type='xavier')) net.pool1 = L.Pooling(net.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX) net.conv2 = L.Convolution(net.pool1, kernel_size=3, num_output=128, weight_filler=dict(type='xavier')) net.pool2 = L.Pooling(net.conv2, kernel_size=2, stride=2, pool=P.Pooling.MAX) net.conv3 = L.Convolution(net.pool2, kernel_size=1, num_output=512, weight_filler=dict(type='xavier')) net.fc1 = L.InnerProduct(net.conv3, num_output=1000, weight_filler=dict(type='xavier')) net.relu1 = L.ReLU(net.fc1, in_place=True) net.dropout1 = L.Dropout(net.relu1, dropout_ratio=0.5) net.fc2 = L.InnerProduct(net.dropout1, num_output=1000, weight_filler=dict(type='xavier')) net.relu2 = L.ReLU(net.fc2, in_place=True) net.output = L.InnerProduct(net.relu2, num_output=10, weight_filler=dict(type='xavier')) net.loss = L.SoftmaxWithLoss(net.output, net.label) net.accuracy = L.Accuracy(net.output, net.label) with open(net_path, 'w') as f: f.write(str(net.to_proto()))
def alexnet_bn_proto(self, batch_size, phase='TRAIN'): n = caffe.NetSpec() if phase == 'TRAIN': source_data = self.train_data mirror = True else: source_data = self.test_data mirror = False n.data, n.label = L.Data(source=source_data, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, transform_param=dict(crop_size=227, mean_value=[104, 117, 123], mirror=mirror)) n.conv1, n.conv1_bn, n.conv1_scale, n.conv1_relu = \ factorization_conv_bn_scale_relu(n.data, num_output=96, kernel_size=11, stride=4,) # 96x55x55 n.pool1 = L.Pooling(n.conv1, kernel_size=3, stride=2, pool=P.Pooling.MAX) # 96x27x27 n.conv2, n.conv2_bn, n.conv2_scale, n.conv2_relu = \ factorization_conv_bn_scale_relu(n.pool1, num_output=256, kernel_size=5, pad=2) # 256x27x27 n.pool2 = L.Pooling(n.conv2, kernel_size=3, stride=2, pool=P.Pooling.MAX) # 256x13x13 n.conv3, n.conv3_bn, n.conv3_scale, n.conv3_relu = \ factorization_conv_bn_scale_relu(n.pool2, num_output=384, kernel_size=3, pad=1) # 384x13x13 n.conv4, n.conv4_bn, n.conv4_scale, n.conv4_relu = \ factorization_conv_bn_scale_relu(n.conv3, num_output=384, kernel_size=3, pad=1) # 384x13x13 n.conv5, n.conv5_bn, n.conv5_scale, n.conv5_relu = \ factorization_conv_bn_scale_relu(n.conv4, num_output=256, kernel_size=3, pad=1) # 256x13x13 n.pool5 = L.Pooling(n.conv5, kernel_size=3, stride=2, pool=P.Pooling.MAX) # 256x6x16 n.fc6, n.relu6, n.drop6 = fc_relu_drop(n.pool5, num_output=4096) # 4096x1x1 n.fc7, n.relu7, n.drop7 = fc_relu_drop(n.fc6, num_output=4096) # 4096x1x1 n.fc8 = L.InnerProduct(n.fc7, num_output=self.classifier_num, param=[dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0)], weight_filler=dict(type='gaussian', std=0.01), bias_filler=dict(type='constant', value=0)) if phase == 'TRAIN': pass else: n.accuracy_top1 = L.Accuracy(n.fc8, n.label, include=dict(phase=1)) n.accuracy_top5 = L.Accuracy(n.fc8, n.label, include=dict(phase=1), accuracy_param=dict(top_k=5)) n.loss = L.SoftmaxWithLoss(n.fc8, n.label) return n.to_proto()
def lenet(param): n = caffe.NetSpec() n.data, n.label = L.Python(module='wwt_data_layer', layer='wwtdatalayer', ntop=2, param_str=str(param)) n.bn1 = L.BatchNorm(n.data, batch_norm_param=dict(moving_average_fraction=0.90, use_global_stats=False, eps=1e-5), in_place=True) n.conv1 = L.Convolution(n.bn1, kernel_size=5, num_output=64, weight_filler=dict(type='xavier')) n.relu1 = L.ReLU(n.conv1, in_place=True) n.pool1 = L.Pooling(n.relu1, kernel_size=3, stride=2, pool=P.Pooling.MAX) n.relu2 = L.ReLU(n.pool1, in_place=True) n.conv2 = L.Convolution(n.relu2, kernel_size=5, num_output=64, weight_filler=dict(type='xavier')) n.relu3 = L.ReLU(n.conv2, in_place=True) n.pool3 = L.Pooling(n.relu3, kernel_size=3, stride=2, pool=P.Pooling.MAX) n.relu4 = L.ReLU(n.pool3, in_place=True) n.fc1 = L.InnerProduct(n.relu4, num_output=384, weight_filler=dict(type='xavier')) n.relu5 = L.ReLU(n.fc1, in_place=True) n.fc2 = L.InnerProduct(n.relu5, num_output=192, weight_filler=dict(type='xavier')) n.relu6 = L.ReLU(n.fc2, in_place=True) n.score = L.InnerProduct(n.relu6, num_output=10, weight_filler=dict(type='xavier')) n.loss = L.SoftmaxWithLoss(n.score, n.label) return n.to_proto()
def create_net(lmdb, batch_size, include_acc=False): #创建第一层:数据层。向上传递两类数据:图片数据和对应的标签 data, label = L.Data(source=lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, transform_param=dict(crop_size=40, mirror=True)) #创建第二屋:卷积层 conv1 = L.Convolution(data, kernel_size=5, stride=1, num_output=16, pad=2, weight_filler=dict(type='xavier')) #创建激活函数层 relu1 = L.ReLU(conv1, in_place=True) #创建池化层 pool1 = L.Pooling(relu1, pool=P.Pooling.MAX, kernel_size=3, stride=2) conv2 = L.Convolution(pool1, kernel_size=3, stride=1, num_output=32, pad=1, weight_filler=dict(type='xavier')) relu2 = L.ReLU(conv2, in_place=True) pool2 = L.Pooling(relu2, pool=P.Pooling.MAX, kernel_size=3, stride=2) #创建一个全连接层 fc3 = L.InnerProduct(pool2, num_output=1024, weight_filler=dict(type='xavier')) relu3 = L.ReLU(fc3, in_place=True) #创建一个dropout层 drop3 = L.Dropout(relu3, in_place=True) fc4 = L.InnerProduct(drop3, num_output=10, weight_filler=dict(type='xavier')) #创建一个softmax层 loss = L.SoftmaxWithLoss(fc4, label) if include_acc: #在训练阶段,不需要accuracy层,但是在验证阶段,是需要的 acc = L.Accuracy(fc4, label) return to_proto(loss, acc) else: return to_proto(loss)
def caffenet(data, label=None, train=True, num_classes=1000, classifier_name='fc8', learn_all=False): n = caffe.NetSpec() n.data = data 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=.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 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 fc8 = L.InnerProduct(fc8input, num_output=num_classes, param=learned_param) 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) with tempfile.NamedTemporaryFile(delete=False) as f: f.write(str(n.to_proto())) return f.name
def gen_net(net_path, data_shape, label_shape): net = caffe.NetSpec() net.data = L.Input(shape=dict(dim=list(data_shape))) net.label = L.Input(shape=dict(dim=list(label_shape))) net.fc0 = L.InnerProduct(net.data, num_output=30, weight_filler=dict(type='xavier')) net.relu0 = L.ReLU(net.fc0, in_place=True) net.output = L.InnerProduct(net.relu0, num_output=10, weight_filler=dict(type='xavier')) net.loss = L.SoftmaxWithLoss(net.output, net.label) net.accuracy = L.Accuracy(net.output, net.label) with open(net_path, 'w') as f: f.write(str(net.to_proto()))
def colorization_net(train_data, test_data, batch_size): net = caffe.NetSpec() net.data = L.Data(batch_size=batch_size, backend=P.Data.LMDB, source=train_data, phase=caffe.TRAIN) net.conv1 = L.Convolution(net.data, kernel_size=5, num_output=20, weight_filler=dict(type='xavier')) net.pool1 = L.Pooling(net.conv1, kernel_size=2, stride=2, pool=P.Pooling.MAX) net.ip1 = L.InnerProduct(net.pool1, num_output=10, weight_filler=dict(type='xavier')) net.loss = L.SoftmaxWithLoss(net.ip1, net.data) return net.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 mknet(lmdb, batch_size, gg_max): 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.fc1 = L.InnerProduct(n.data, num_output=128, weight_filler=dict(type='gaussian', std=gg_max), bias_filler=dict(type='constant')) n.relu1 = L.ReLU(n.fc1, in_place=True) n.fc2 = L.InnerProduct(n.relu1, num_output=10, weight_filler=dict(type='gaussian', std=gg_max), bias_filler=dict(type='constant')) n.loss = L.SoftmaxWithLoss(n.fc2, n.label) n.acc = L.Accuracy(n.fc2, n.label) return n.to_proto()
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(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=4, weight_filler=dict(type='xavier')) n.relu2 = L.ReLU(n.ip2, in_place=True) n.loss = L.SoftmaxWithLoss(n.relu2, n.label) n.accu = L.Accuracy(n.relu2, n.label, include={'phase': caffe.TEST}) return n.to_proto()
def create_net(lmdb, batch_size, net_typeflg = 0): n = caffe.NetSpec() #创建第一层:数据层。向上传递两类数据:图片数据和对应的标签 # data, label = L.Data(source=lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, # transform_param=dict(crop_size=40,mean_file=mean_file,mirror=True)) if net_typeflg != NET_TYPE_PREDICT: n.data, n.label = L.Data(source=lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2 ,transform_param=dict(scale=1./255)) #创建第二屋:卷积层 n.conv1=L.Convolution(n.data, kernel_size=5, stride=1, num_output=20, weight_filler=dict(type='xavier')) else: n.conv1=L.Convolution(bottom='data', kernel_size=5, stride=1, num_output=20,weight_filler=dict(type='xavier')) #创建激活函数层 n.relu1=L.ReLU(n.conv1, in_place=True) #创建池化层 n.pool1=L.Pooling(n.relu1, pool=P.Pooling.MAX, kernel_size=2, stride=2) n.conv2=L.Convolution(n.pool1, kernel_size=5, stride=1, num_output=50, weight_filler=dict(type='xavier')) n.relu2=L.ReLU(n.conv2, in_place=True) n.pool2=L.Pooling(n.relu2, pool=P.Pooling.MAX, kernel_size=2, stride=2) #创建一个全连接层 n.fc3=L.InnerProduct(n.pool2, num_output=500, weight_filler=dict(type='xavier')) n.relu3=L.ReLU(n.fc3, in_place=True) #创建一个dropout层 n.drop3 = L.Dropout(n.relu3, in_place=True) n.fc4 = L.InnerProduct(n.drop3, num_output=10, weight_filler=dict(type='xavier')) #创建一个softmax层 if net_typeflg != NET_TYPE_PREDICT: n.loss = L.SoftmaxWithLoss(n.fc4, n.label) #在训练阶段,不需要accuracy层,但是在验证阶段,是需要的 if net_typeflg == NET_TYPE_TRAIN: return n.to_proto() elif net_typeflg == NET_TYPE_TEST: n.score = n.fc4 # n.acc = L.Accuracy(n.fc4, n.label) return n.to_proto() elif net_typeflg == NET_TYPE_PREDICT: n.result = L.Softmax(n.fc4) return n.to_proto()
def caffe_net(lmdb, mean_file, batch_size=24, phase=False): data, label = L.Data( source=lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, transform_param=dict(crop_size=32, mean_file=mean_file, mirror=phase)) fractal_unit = fractal_block(data, 64, phase, 4) fractal_unit = fractal_block(fractal_unit, 128, phase, 4) fractal_unit = fractal_block(fractal_unit, 256, phase, 4) fractal_unit = fractal_block(fractal_unit, 512, phase, 4) fractal_unit = fractal_block(fractal_unit, 512, phase, 4) fc = caffe_net_fun.full_connect(fractal_unit, 10) loss = L.SoftmaxWithLoss(fc, label) if not phase: acc = L.Accuracy(fc, label) return to_proto(loss, acc) else: return to_proto(loss)
def caffenet(lmdb, batch_size=32, include_acc=False): print ("building net") data, label = L.Data(source=lmdb, backend=P.Data.LMDB, batch_size=batch_size, ntop=2, transform_param=dict(crop_size=84, mean_value=[104, 117, 123], mirror=True)) # the net itself conv1, relu1 = conv_relu(data, 8, 32, stride=4) conv2, relu2 = conv_relu(relu1, 4, 16, stride=2) ip1 = L.InnerProduct(relu2, num_output=256) relu3 = L.ReLU(ip1, in_place=True) ip2 = L.InnerProduct(relu3, num_output=64) loss = L.SoftmaxWithLoss(ip2, label) if include_acc: acc = L.Accuracy(ip2, label) return to_proto(loss, acc) else: return to_proto(loss)
def residual_net(total_depth, data_layer_params, num_classes = 1000, acclayer = True): """ Generates nets from "Deep Residual Learning for Image Recognition". Nets follow architectures outlined in Table 1. """ # figure out network structure net_defs = { 18:([2, 2, 2, 2], "standard"), 34:([3, 4, 6, 3], "standard"), 50:([3, 4, 6, 3], "bottleneck"), 101:([3, 4, 23, 3], "bottleneck"), 152:([3, 8, 36, 3], "bottleneck"), } assert total_depth in net_defs.keys(), "net of depth:{} not defined".format(total_depth) nunits_list, unit_type = net_defs[total_depth] # nunits_list a list of integers indicating the number of layers in each depth. nouts = [64, 128, 256, 512] # same for all nets # setup the first couple of layers n = caffe.NetSpec() n.data, n.label = L.Python(module = 'beijbom_caffe_data_layers', layer = 'ImageNetDataLayer', ntop = 2, param_str=str(data_layer_params)) n.conv1, n.bn1, n.lrn1 = conv_bn(n.data, ks = 7, stride = 2, nout = 64, pad = 3) n.relu1 = L.ReLU(n.lrn1, in_place=True) n.pool1 = L.Pooling(n.relu1, stride = 2, kernel_size = 3) # make the convolutional body for nout, nunits in zip(nouts, nunits_list): # for each depth and nunits for unit in range(1, nunits + 1): # for each unit. Enumerate from 1. s = str(nout) + '_' + str(unit) + '_' # layer name prefix if unit_type == "standard": residual_standard_unit(n, nout, s, newdepth = unit is 1 and nout > 64) else: residual_bottleneck_unit(n, nout, s, newdepth = unit is 1) # add the end layers n.global_pool = L.Pooling(n.__dict__['tops'][n.__dict__['tops'].keys()[-1]], pooling_param = dict(pool = 1, global_pooling = True)) n.score = L.InnerProduct(n.global_pool, num_output = num_classes, param=[dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0)]) n.loss = L.SoftmaxWithLoss(n.score, n.label) if acclayer: n.accuracy = L.Accuracy(n.score, n.label) return n
def fcn(split): n = caffe.NetSpec() pydata_params = dict(split=split, mean=(104.00699, 116.66877, 122.67892), seed=1337) if split == 'train': pydata_params['sbdd_dir'] = '../data/sbdd/dataset' pylayer = 'SBDDSegDataLayer' else: pydata_params['voc_dir'] = '../data/pascal/VOC2011' pylayer = 'VOCSegDataLayer' n.data, n.label = L.Python(module='voc_layers', layer=pylayer, ntop=2, param_str=str(pydata_params)) # the base net n.conv1, n.relu1 = conv_relu(n.data, 11, 96, stride=4, pad=100) 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) 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) n.conv4, n.relu4 = conv_relu(n.relu3, 3, 384, pad=1, group=2) n.conv5, n.relu5 = conv_relu(n.relu4, 3, 256, pad=1, group=2) n.pool5 = max_pool(n.relu5, 3, stride=2) # fully conv n.fc6, n.relu6 = conv_relu(n.pool5, 6, 4096) n.drop6 = L.Dropout(n.relu6, dropout_ratio=0.5, in_place=True) n.fc7, n.relu7 = conv_relu(n.drop6, 1, 4096) n.drop7 = L.Dropout(n.relu7, dropout_ratio=0.5, in_place=True) n.score_fr = L.Convolution(n.drop7, num_output=21, kernel_size=1, pad=0, param=[dict(lr_mult=1, decay_mult=1), dict(lr_mult=2, decay_mult=0)]) n.upscore = L.Deconvolution(n.score_fr, convolution_param=dict(num_output=21, kernel_size=63, stride=32, bias_term=False), param=[dict(lr_mult=0)]) n.score = crop(n.upscore, n.data) n.loss = L.SoftmaxWithLoss(n.score, n.label, loss_param=dict(normalize=True, ignore_label=255)) 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()