Python caffe 模块，TRAIN 实例源码

def __init__(self, use_gpu=True, model=[]):
        '''
        Init net.
        :param model: Network definition.
        '''
        if model == []:
            raise("model should not be empty!")
        print("Init NetTester: Use gpu: {}").format(use_gpu)
        print("Network: {}").format(model)
        if use_gpu:
            caffe.set_device(0)
            caffe.set_mode_gpu()
        else:
            caffe.set_mode_cpu()

        self.__net = caffe.Net(model, caffe.TRAIN)

def gen_net():
    caffe.set_device(1)
    caffe.set_mode_gpu()

    filename = '2007_000032.jpg'
    im = Image.open(filename)
    m = np.asarray(im, dtype=np.float32)
    m = m[:,:,::-1]
    m -= np.array((104.00698793,116.66876762,122.67891434))
    m = m.transpose((2, 0, 1))

    net = caffe.Net(
        "deploy.prototxt",
        #"train_iter_" + str(num) + ".caffemodel",
        #"/data/VGG16/caffemodel",
        "good.caffemodel",
        caffe.TRAIN)

    net.blobs["data"].reshape(1, *m.shape)
    net.blobs["data"].data[...] = m
    net.forward()
    return net

def gen_net(num):
    caffe.set_device(0)
    caffe.set_mode_gpu()

    filename = '2007_000032.jpg'
    im = Image.open(filename)
    m = np.asarray(im, dtype=np.float32)
    m = m[:,:,::-1]
    m -= np.array((104.00698793,116.66876762,122.67891434))
    m = m.transpose((2, 0, 1))

    net = caffe.Net(
        "train_val.prototxt",
        "train_iter_" + str(num) + ".caffemodel",
        # "/data/VGG16/caffemodel",
        # "../fcn-32s/good.caffemodel",
        caffe.TRAIN)

    net.blobs["data"].reshape(1, *m.shape)
    net.blobs["data"].data[...] = m
    net.forward()
    return net

def create_top_layer(self, phase=caffe.TRAIN, input_file="", train=True):
        if self.hp.GCN_APPROX:
            transform_param = {'scale': 0.0078125,'mean_value': 128}
        else:
            transform_param = {}
        if train:
            transform_param['mirror'] = self.hp.MIRROR
            if self.hp.CROP:
                # Adds random crops.
                transform_param['crop_size'] = self.hp.IMAGE_HEIGHT

        data, label = cl.Data(
            batch_size=self.hp.TRAIN_BATCH_SIZE if train else self.hp.EVAL_BATCH_SIZE, backend=P.Data.LMDB, name="data",
            source=input_file, ntop=2, include={'phase': phase}, transform_param=transform_param)
        return data, label

    # MAIN FUNCTION: Converts a net string to a caffe netspec.
    # Adds the data layer and accuracy layer for test/train.

def add_batchnormscale(self, input, name):

        if True : # necessary?
            batch_norm_param={'moving_average_fraction': 0.95, 'use_global_stats': True }
            param = [dict(lr_mult=0),dict(lr_mult=0),dict(lr_mult=0)]
            l = L.BatchNorm(input, name=name+'_bn', batch_norm_param=batch_norm_param, param=param, include={'phase': caffe.TEST}, ntop=1)
            setattr(self.net_spec, name+'_bn', l)

            batch_norm_param={'moving_average_fraction': 0.95, 'use_global_stats': False }
            l = L.BatchNorm(input, name=name+'_bn', top=name+'_bn', batch_norm_param=batch_norm_param, param=param, include={'phase': caffe.TRAIN}, ntop=0)
            setattr(self.net_spec, name+'_bn' + '_train', l)

            l = L.Scale(getattr(self.net_spec, name+'_bn'), scale_param = { 'bias_term': True } )
            setattr(self.net_spec, name, l)
        else : # here without split in use_global_stats True/False
            l = L.Scale(L.BatchNorm(input), scale_param={'bias_term': True})
            setattr(self.net_spec, name, l)

        return l

def add_batchnormscale(self, input, name):

        if True: # necessary?
            batch_norm_param = {'moving_average_fraction': 0.95, 'use_global_stats': True}
            param = [dict(lr_mult=0), dict(lr_mult=0), dict(lr_mult=0)]
            l = L.BatchNorm(input, name=name + '_bn', batch_norm_param=batch_norm_param, param=param, include={'phase': caffe.TEST}, ntop=1)
            setattr(self.net_spec, name + '_bn', l)

            batch_norm_param = {'moving_average_fraction': 0.95, 'use_global_stats': False}
            l = L.BatchNorm(input, name=name + '_bn', top=name + '_bn', batch_norm_param=batch_norm_param, param=param, include={'phase': caffe.TRAIN}, ntop=0)
            setattr(self.net_spec, name + '_bn' + '_train', l)

            l = L.Scale(getattr(self.net_spec, name + '_bn'), scale_param={'bias_term': True})
            setattr(self.net_spec, name, l)
        else: # here without split in use_global_stats True/False
            l = L.Scale(L.BatchNorm(input), scale_param={'bias_term': True})
            setattr(self.net_spec, name, l)

        return l

def add_multilabel_data_layer(net, name, phase, num_classes, class_list=None):
    """ Add a MultiLabelData layer """
    include_dict = {'phase': phase}
    param = {'num_classes': num_classes}
    if phase == caffe.TRAIN:
        param['stage'] = 'TRAIN'
    elif phase == caffe.TEST:
        param['stage'] = 'VAL'
    if class_list is not None:
        assert len(class_list) == num_classes, \
            'Length of class list does not match number of classes {} vs {}'.\
            format(len(class_list), num_classes)
        param['class_list'] = class_list

    param_str = yaml.dump(param)
    net[name[0]], net[name[1]] = L.Python(name=name[0], python_param=dict(module='layers.multilabel_data', 
        layer='MultiLabelData', param_str=param_str), include=include_dict, ntop=2)

def add_singlelabel_data_layer(net, name, phase, num_classes, class_list=None):
    """ Add a MultiLabelData layer """
    include_dict = {'phase': phase}
    param = {'num_classes': num_classes}
    if phase == caffe.TRAIN:
        param['stage'] = 'TRAIN'
    elif phase == caffe.TEST:
        param['stage'] = 'VAL'
    if class_list is not None:
        assert len(class_list) == num_classes, \
            'Length of class list does not match number of classes {} vs {}'.\
            format(len(class_list), num_classes)
        param['class_list'] = class_list

    param_str = yaml.dump(param)
    net[name[0]], net[name[1]] = L.Python(name=name[0], python_param=dict(module='layers.singlelabel_data', 
        layer='SingleLabelData', param_str=param_str), include=include_dict, ntop=2)

def add_loss(self, net, task_layer_list, deploy):
        """ Add the loss layers """        
        # concatenate layers in the order specified by task_layer_list, compute the sigmoid
        lh.add_concat(net, bottom=task_layer_list, name='score'+self.postfix, axis=1)
        lh.add_sigmoid(net, bottom=net['score'+self.postfix], name='prob'+self.postfix, in_place=False)
        if not deploy:
            if self.loss_layer == 'Sigmoid':
                lh.add_sigmoid_entropy_loss(net, bottom=[net['score'+self.postfix], net[self.label_names]], 
                    name='loss'+self.postfix, loss_weight=1.0, phase=caffe.TRAIN)
            elif self.loss_layer == 'Square':
                lh.add_euclidean_loss(net, bottom=[net['prob'+self.postfix], net[self.label_names]], 
                    name='loss'+self.postfix, loss_weight=1.0, phase=caffe.TRAIN)
            else:
                print 'The layer type {} is not recognized!'.format(self.loss_layer)
                raise

            lh.add_multilabel_err_layer(net, bottom=[net['prob'+self.postfix], net[self.label_names]], 
                name='error'+self.postfix)

def create_models(buckets = [25, 50, 100], phase = caffe.TRAIN):

  transformers = create_spatial_transformers(buckets, phase)
  proposal_net = create_yolo(phase)
  recog = create_recognizer(phase)

  return proposal_net, transformers, recog

def convert(self, net_string):
        net_list = cnn.parse('net', net_string)
        net_list = StateStringUtils(self.ssp).convert_model_string_to_states(net_list)[1:]
        data, label = self.create_top_layer(caffe.TRAIN, self.hp.TRAIN_FILE, train=True)
        data1, label1 = self.create_top_layer(caffe.TEST, self.hp.VAL_FILE, train=False)
        loss, acc = self.unpack_list(net_list, data, label)
        lls = [data, data1, acc, loss]

        cc = to_proto(*lls)
        cc = self.replace_top_names(cc)
        return cc

    # Iterate over token list from parser.

def main():
    net = caffe.Net(MODEL_DEF, MODEL_WEIGHT, caffe.TRAIN)

    mat = []
    for i in range(len(net.layers)):
        mat_type = net.layers[i].type
        mat_data = []
        for j in range(len(net.layers[i].blobs)):
            mat_data.append(net.layers[i].blobs[j].data)
        mat.append((mat_type, mat_data))

    dt = np.dtype([('type', np.str_, 16), ('data', np.ndarray)])
    results = np.array(mat, dtype=dt)
    results.dump(MAT_RESULT)

def print_network_sizes(self, model_file):

        net = caffe.Net(model_file, caffe.TRAIN)
        for k, v in net.blobs.items():
            print k, v.data.shape

def print_network_sizes(self, model_file):

        net = caffe.Net(model_file, caffe.TRAIN)
        for k, v in net.blobs.items():
            print k, v.data.shape

def print_network_sizes(model_file) :
    net = caffe.Net(model_file, caffe.TRAIN)
    for k, v in net.blobs.items():
        print k, v.data.shape

def test_caffe_import(self):
        # Test 1
        data, label = L.ImageData(source='/dummy/source/', batch_size=32, ntop=2, rand_skip=0,
                                  shuffle=False, new_height=256, new_width=256, is_color=False,
                                  root_folder='/dummy/folder/',
                                  transform_param=dict(crop_size=227, mean_value=[104, 117, 123],
                                                       mirror=True, force_color=False,
                                                       force_gray=False))
        with open(os.path.join(settings.BASE_DIR, 'media', 'test.prototxt'), 'w') as f:
            f.write(str(to_proto(data, label)))
        sample_file = open(os.path.join(settings.BASE_DIR, 'media', 'test.prototxt'), 'r')
        response = self.client.post(reverse('caffe-import'), {'file': sample_file})
        response = json.loads(response.content)
        os.remove(os.path.join(settings.BASE_DIR, 'media', 'test.prototxt'))
        self.assertGreaterEqual(len(response['net']['l0']['params']), 13)
        self.assertEqual(response['result'], 'success')
        # Test 2
        data, label = L.ImageData(source='/dummy/source/', batch_size=32, ntop=2, rand_skip=0,
                                  shuffle=False, new_height=256, new_width=256, is_color=False,
                                  root_folder='/dummy/folder/', include=dict(phase=caffe.TRAIN),
                                  transform_param=dict(crop_size=227, mean_file='/path/to/file',
                                                       mirror=True, force_color=False,
                                                       force_gray=False))
        with open(os.path.join(settings.BASE_DIR, 'media', 'test.prototxt'), 'w') as f:
            f.write(str(to_proto(data, label)))
        sample_file = open(os.path.join(settings.BASE_DIR, 'media', 'test.prototxt'), 'r')
        response = self.client.post(reverse('caffe-import'), {'file': sample_file})
        response = json.loads(response.content)
        os.remove(os.path.join(settings.BASE_DIR, 'media', 'test.prototxt'))
        self.assertGreaterEqual(len(response['net']['l0']['params']), 13)
        self.assertEqual(response['result'], 'success')

def _semantic_regularization(self, xSemPr, xSemLb, semReg):
        ns = self.netspec

        if self.semantics == ATTRIBUTES:
            name = 'SCoRe/semLoss'
            ns[name] = L.SigmoidCrossEntropyLoss(*[xSemPr, xSemLb], name=name,
                                                 loss_weight=semReg/(len(self.constrains)*np.sqrt(2.))*10.,
                                                 include=dict(phase=caffe.TRAIN))
        else:
            c_keys = [key for key in self.constrains.keys()]
            losses = ['SCoRe/semLoss/%s' % key for key in c_keys]
            scores = ['SCoRe/semLoss/%s/scores' % key for key in c_keys]
            labels = ['SCoRe/semLoss/%s/labels' % key for key in c_keys]

            # Slice semantic scores
            xSemPr_name = [k for k, v in ns.tops.iteritems() if v ==xSemPr][0]
            slice_scores = L.Slice(name='SCoRe/semLoss/slice_scores', bottom=[xSemPr_name], ntop=len(scores), top=scores, in_place=True,
                                   slice_point=np.cumsum(self.num_states)[:-1].tolist(),
                                   include=dict(phase=caffe.TRAIN))

            # Slice semantic labels
            xSemLb_name = [k for k, v in ns.tops.iteritems() if v ==xSemLb][0]
            slice_labels = L.Slice(name='SCoRe/semLoss/slice_labels', bottom=[xSemLb_name], ntop=len(labels), top=labels, in_place=True,
                                   slice_point=range(1, len(self.constrains)),
                                   include=dict(phase=caffe.TRAIN))

            # Add supervision to each slice
            for i, xLoss in enumerate(losses):
                ns[xLoss] = L.SoftmaxWithLoss(*[slice_scores[i], slice_labels[i]], name=xLoss, loss_weight=semReg/len(self.constrains),
                                              include=dict(phase=caffe.TRAIN))

            # Summarize supervisions for display
            ns['SCoRe/semLoss'] = L.Eltwise(*[ns[l] for l in losses], name='SCoRe/semLoss',
                                            operation=P.Eltwise.SUM, coeff=[semReg/len(self.constrains)]*len(losses),
                                            include=dict(phase=caffe.TRAIN))

def _code_regularization(self, lCW):
        ns = self.netspec

        # Semantic codes. Needs to be initialized.
        code_shape = [sum(self.code_dim), len(self.train_classes) if self.semantics == ATTRIBUTES else sum(self.num_states)]

        name = 'SCoRe/cwReg/codewords'
        sem_cw = ns[name] = L.DummyData(name=name, shape=dict(dim=code_shape), include=dict(phase=caffe.TRAIN))

        # Classification codes.
        name = 'SCoRe/cwReg/eye'
        x = ns[name] = L.DummyData(name=name, shape=dict(dim=[code_shape[0], code_shape[0]]), include=dict(phase=caffe.TRAIN))

        name = 'SCoRe/cwReg/cls_codewords'
        clf_cw = ns[name] = L.InnerProduct(x, name=name, num_output=code_shape[1], bias_term=False,
                                           param=[{'name': lCW}], include=dict(phase=caffe.TRAIN))

        # Compute \sum |S-C|^2
        name = 'SCoRe/cwReg/diff'
        x_diff = ns[name] = L.Eltwise(*[sem_cw, clf_cw], name=name,
                                      operation=P.Eltwise.SUM, coeff=[1., -1.], include=dict(phase=caffe.TRAIN))

        name = 'SCoRe/cwReg'
        ns[name] = L.Reduction(x_diff, name=name,
                               operation=P.Reduction.SUMSQ, axis=0,
                               loss_weight=self.code_coeff, include=dict(phase=caffe.TRAIN))

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 generate_train_proto(self, model_fn, fts_lmdb, sem_lmdb, batch_size):
        ns = self._new_model()

        # Inputs
        mean = [104., 116., 122.]
        stage = {'testRecg': 'TestRecognition',
                 'testZS': 'TestZeroShot'}
        for subset in ['train', 'testRecg', 'testZS']:
            if subset == 'train':
                include = {'phase': caffe.TRAIN}
            else:
                include = {'phase': caffe.TEST, 'stage': stage[subset]}
            ns[subset+'_data'], ns[subset+'_labels'] = L.Data(name='data', ntop=2, top=['data', 'labels'], in_place=True,
                                                              source=fts_lmdb[subset], batch_size=batch_size, backend=P.Data.LMDB,
                                                              transform_param=dict(mirror=True if subset == 'train' else False,
                                                                                   crop_size=self.base_cnn.input_size,
                                                                                   mean_value=mean),
                                                              include=include)

        # Semantic labels for training
        if self.sem_coeff > 0:
            ns.semantics = L.Data(name='semantics',
                                  source=sem_lmdb['train'], batch_size=batch_size, backend=P.Data.LMDB,
                                  include=dict(phase=caffe.TRAIN))

        # Run base CNN
        xFt = self.base_cnn.inference_proto(ns.train_data, mult=1., truncate_at=self.feat_layer)

        # Run score
        xObj, xSem, lCW = self._score_proto(xFt, source_net=True, target_net=self.test_classes is not None, mult=1.0)
        self.scores = {'obj': xObj, 'semantics': xSem}

        # Loss
        self._loss_proto(ns[xObj], ns.train_labels, ns[xSem], ns.semantics if self.sem_coeff > 0 else None, lCW)

        # Evaluation
        self._eval_proto(ns[xObj], ns.train_labels)

        with open(model_fn, 'w') as f:
            f.write(str(ns.to_proto()))

def solver_graph(self):
        proto = caffe_pb2.SolverParameter()
        proto.type = self.cmd.solver_type
        if self.device is not None:
            proto.solver_mode = caffe_pb2.SolverParameter.SolverMode.Value(
                'GPU')
            proto.device_id = self.device
        else:
            proto.solver_mode = caffe_pb2.SolverParameter.SolverMode.Value(
                'CPU')
        proto.lr_policy = 'fixed'
        proto.base_lr = self.cmd.learning_rate
        proto.momentum = self.cmd.momentum
        proto.max_iter = int(2e9)
        proto.random_seed = self.cmd.random_seed + self.rank
        print('Setting seed ', proto.random_seed, file = sys.stderr)
        proto.display = 1

        batch = int(solver.cmd.input_shape[0] / solver.size)
        if self.cmd.graph:
            dir = os.path.dirname(os.path.realpath(__file__))
            proto.net = dir + '/' + self.cmd.graph + '.prototxt'
        else:
            proto.train_net_param.MergeFrom(self.net_def(caffe.TRAIN))
            proto.test_net_param.add().MergeFrom(self.net_def(caffe.TEST))

        proto.test_iter.append(1)
        proto.test_interval = 999999999  # cannot disable or set to 0
        proto.test_initialization = False
        return proto

def reshape(self, bottom, top):
        batch = int(solver.cmd.input_shape[0] / solver.size)
        input_shape = [batch,
                       solver.cmd.input_shape[1],
                       solver.cmd.input_shape[2],
                       solver.cmd.input_shape[3], ]
        top[0].reshape(*input_shape)
        print('top[0] shape ', list(top[0].shape), file = sys.stderr)
        if self.phase == caffe.TRAIN:
            top[1].reshape(batch, 1)
            print('top[1] shape ', list(top[1].shape), file = sys.stderr)

def add_input(self, net, deploy=False):
        """ add input layers """
        class_list = self.class_list
        num_classes = len(class_list)

        if not deploy:
            train_net = net['train']
            val_net = net['val']
            lh.add_multilabel_data_layer(train_net, name=[self.data_name, self.label_names], 
                phase=caffe.TRAIN, num_classes=num_classes, class_list=class_list)
            lh.add_multilabel_data_layer(val_net, name=[self.data_name, self.label_names], 
                phase=caffe.TEST, num_classes=num_classes, class_list=class_list)

def add_input(self, net, deploy=False):
        """ add input layers """
        class_list = self.class_list
        num_classes = len(class_list)

        if not deploy:
            train_net = net['train']
            val_net = net['val']
            lh.add_singlelabel_data_layer(train_net, name=[self.data_name, self.label_names], 
                phase=caffe.TRAIN, num_classes=num_classes, class_list=class_list)
            lh.add_singlelabel_data_layer(val_net, name=[self.data_name, self.label_names], 
                phase=caffe.TEST, num_classes=num_classes, class_list=class_list)

def pre_transplant(inp_proto, inp_model, fcn_proto, fcn_model):
    state = caffe.TRAIN
    net = caffe.Net(inp_proto, inp_model, state)

    new_net = caffe.Net(fcn_proto, inp_model, state)

    new_net = transplant(new_net, net, '-deconv')
    new_net.save(fcn_model)

def perform_surgery(inp_proto, inp_model, fcn_proto, fcn_model):
    state = caffe.TRAIN

    # Load the original network and extract the fully connected layers'
    # parameters.
    net = caffe.Net(inp_proto, inp_model, state)
    params = ['fc6', 'fc7_', 'fc8_output']

    #net.blobs['data'].reshape(1, 3, 67, 67)
    # net.reshape()

    # fc_params = {name: (weights, biases)}
    fc_params = {pr: (net.params[pr][0].data, net.params[
                      pr][1].data) for pr in params}
    for fc in params:
        print '{} weights are {} dimensional and biases are {} dimensional'.format(fc, fc_params[fc][0].shape, fc_params[fc][1].shape)

    # Load the fully convolutional network to transplant the parameters.
    net_full_conv = caffe.Net(fcn_proto, inp_model, state)
    params_full_conv = ['fc6-conv', 'fc7-conv', 'fc8-score']

    # conv_params = {name: (weights, biases)}
    conv_params = {pr: (net_full_conv.params[pr][0].data, net_full_conv.params[
                        pr][1].data) for pr in params_full_conv}
    for conv in params_full_conv:
        print '{} weights are {} dimensional and biases are {} dimensional'.format(conv, conv_params[conv][0].shape, conv_params[conv][1].shape)

    for pr, pr_conv in zip(params, params_full_conv):
        print '{} = {}'.format(pr_conv, pr)
        conv_params[pr_conv][0].flat = fc_params[
            pr][0].flat  # flat unrolls the arrays
        conv_params[pr_conv][1][...] = fc_params[pr][1]

    print 'Finished unrolling.....'

    if not os.path.exists('/'.join(fcn_model.split('/')[:-1])):
        os.makedirs('/'.join(fcn_model.split('/')[:-1]))

    net_full_conv.save(fcn_model)

def __init__(self, net_path, model_path, mean_path):
        caffe.set_device(0)
        caffe.set_mode_gpu()
        self.net = caffe.Net(net_path, model_path, caffe.TRAIN)

        # input preprocessing: 'data' is the name of the input blob == net.inputs[0]
        self.transformer = caffe.io.Transformer({'data': self.net.blobs['data'].data.shape})
        self.transformer.set_transpose('data', (2,0,1))
        self.transformer.set_mean('data', np.load(mean_path).mean(1).mean(1)) # mean pixel
        self.transformer.set_raw_scale('data', 255)  # the reference model operates on images in [0,255] range instead of [0,1]
        self.transformer.set_channel_swap('data', (2,1,0))  # the reference model has channels in BGR order instead of RGB

        self.net.blobs['data'].reshape(1,3,227,227)

def __create_data_layer(self, n, deploy):
        if deploy:
            n.data = L.Input(input_param={
                'shape': [
                    {
                        'dim': [
                            self.__config['deploy-batch-size'],
                            self.__config['deploy-num-channels'],
                            self.__config['crop-size'],
                            self.__config['crop-size']
                        ]
                    }
                ]
            })
        else:
            transform_param = {
                'mirror': True,
                'crop_size': self.__config['crop-size'],
                'scale': 0.00390625
            }
            if self.__config['mean-file']:
                transform_param['mean_file'] = self.__config['mean-file']

            n.data, n.label = L.Data(batch_size=self.__config['train-batch-size'],
                                     include={'phase': caffe.TRAIN},
                                     backend=P.Data.LMDB,
                                     source=self.__config['train-database'],
                                     ntop=2,
                                     transform_param=transform_param)

            transform_param = dict.copy(transform_param)
            transform_param['mirror'] = False
            n.data__test, n.label__test = L.Data(batch_size=self.__config['test-batch-size'],
                                                 include={'phase': caffe.TEST},
                                                 backend=P.Data.LMDB,
                                                 source=self.__config['test-database'],
                                                 ntop=2,
                                                 transform_param=transform_param)
        return n.data

def net_def(self, phase):
        print('sizes', self.cmd.sizes, file = sys.stderr)
        print('types', self.cmd.types, file = sys.stderr)
        if len(self.cmd.sizes) != len(self.cmd.types):
            raise Exception

        n = caffe.NetSpec()
        name = ''

        for i in range(len(self.cmd.types)):
            if self.cmd.types[i] == 'data':
                name = 'data'
                if phase == caffe.TRAIN:
                    n[name], n.label = L.Python(
                        module = 'solver',
                        layer = 'DataLayer',
                        ntop = 2,
                    )
                else:
                    n[name] = L.Python(
                        module = 'solver',
                        layer = 'DataLayer',
                    )

            else:
                fc = L.InnerProduct(
                    n[name],
                    inner_product_param = {'num_output': self.cmd.sizes[i],
                                           'weight_filler': {'type': 'xavier',
                                                             'std': 0.1},
                                           'bias_filler': {'type': 'constant',
                                                           'value': 0}})
                name = 'fc%d' % i
                n[name] = fc

                if self.cmd.types[i] == 'relu':
                    relu = L.ReLU(n[name], in_place = True)
                    name = 'relu%d' % i
                    n[name] = relu
                elif self.cmd.types[i] == 'loss':
                    if self.cmd.regression:
                        if phase == caffe.TRAIN:
                            n.loss = L.EuclideanLoss(n[name], n.label)
                    else:
                        if phase == caffe.TRAIN:
                            n.loss = L.SoftmaxWithLoss(n[name], n.label)
                        else:
                            n.output = L.Softmax(n[name])
                else:
                    raise Exception('TODO unsupported: ' + self.cmd.types[i])

        return n.to_proto()