def create_net(self, dropout=0.5): self.embed = layer.Dense('embed', self.embed_size, input_sample_shape=(self.vocab_size, )) self.embed.to_device(self.dev) self.lstm = layer.LSTM( name='lstm', hidden_size=self.hidden_size, num_stacks=self.num_stack_layers, dropout=dropout, input_sample_shape=( self.embed_size, )) self.lstm.to_device(self.dev) self.dense = layer.Dense( 'dense', 2, #output shape input_sample_shape=( self.hidden_size, )) self.dense.to_device(self.dev) self.sft = layer.Softmax('softmax', input_sample_shape=( 2, )) self.sft.to_device(self.dev) self.loss = loss.SoftmaxCrossEntropy()
def test_softmax_cross_entropy(self): sce = loss.SoftmaxCrossEntropy() l1 = sce.forward(True, self.x, self.y) sce.backward() l2 = sce.evaluate(True, self.x, self.y) self.assertAlmostEqual(l1.l1(), l2)
def create_net(self): ''' Create singa net based on caffe proto files. net_proto: caffe prototxt that describes net solver_proto: caffe prototxt that describe solver input_sample_shape: shape of input data tensor return: a FeedForwardNet object ''' caffe_net = self.read_net_proto() caffe_solver = None if self.caffe_solver_path is not None: caffe_solver = self.read_solver_proto() layer_confs = '' flatten_id = 0 # If the net proto has the input shape if len(caffe_net.input_dim) > 0: self.input_sample_shape = caffe_net.input_dim if len(caffe_net.layer): layer_confs = caffe_net.layer elif len(caffe_net.layers): layer_confs = caffe_net.layers else: raise Exception('Invalid proto file!') net = ffnet.FeedForwardNet() for i in range(len(layer_confs)): if layer_confs[i].type == 'Data' or layer_confs[i].type == 5: continue elif layer_confs[i].type == 'Input': self.input_sample_shape = layer_confs[i].input_param.shape[0].dim[1:] elif layer_confs[i].type == 'SoftmaxWithLoss' or layer_confs[i].type == 21: net.loss = loss.SoftmaxCrossEntropy() elif layer_confs[i].type == 'EuclideanLoss' or layer_confs[i].type == 7: net.loss = loss.SquareError() elif layer_confs[i].type == 'Accuracy' or layer_confs[i].type == 1: net.metric = metric.Accuracy() else: strConf = layer_confs[i].SerializeToString() conf = model_pb2.LayerConf() conf.ParseFromString(strConf) if caffe_solver: layer.engine = self.convert_engine( layer_confs[i], caffe_solver.solver_mode) else: # if caffe_solver is None, layer.engine = self.convert_engine(layer_confs[i], 0) lyr = layer.Layer(conf.name, conf) if len(net.layers) == 0: print('input sample shape: ', self.input_sample_shape) lyr.setup(self.input_sample_shape) print(lyr.name, lyr.get_output_sample_shape()) if layer_confs[i].type == 'InnerProduct' or layer_confs[i].type == 14: net.add(layer.Flatten('flat' + str(flatten_id))) flatten_id += 1 net.add(lyr) return net
def create_net(use_cpu=False): if use_cpu: layer.engine = 'singacpp' net = ffnet.FeedForwardNet(loss.SoftmaxCrossEntropy(), metric.Accuracy()) ConvBnReLU(net, 'conv1_1', 64, (3, 32, 32)) net.add(layer.Dropout('drop1', 0.3)) ConvBnReLU(net, 'conv1_2', 64) net.add(layer.MaxPooling2D('pool1', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv2_1', 128) net.add(layer.Dropout('drop2_1', 0.4)) ConvBnReLU(net, 'conv2_2', 128) net.add(layer.MaxPooling2D('pool2', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv3_1', 256) net.add(layer.Dropout('drop3_1', 0.4)) ConvBnReLU(net, 'conv3_2', 256) net.add(layer.Dropout('drop3_2', 0.4)) ConvBnReLU(net, 'conv3_3', 256) net.add(layer.MaxPooling2D('pool3', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv4_1', 512) net.add(layer.Dropout('drop4_1', 0.4)) ConvBnReLU(net, 'conv4_2', 512) net.add(layer.Dropout('drop4_2', 0.4)) ConvBnReLU(net, 'conv4_3', 512) net.add(layer.MaxPooling2D('pool4', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv5_1', 512) net.add(layer.Dropout('drop5_1', 0.4)) ConvBnReLU(net, 'conv5_2', 512) net.add(layer.Dropout('drop5_2', 0.4)) ConvBnReLU(net, 'conv5_3', 512) net.add(layer.MaxPooling2D('pool5', 2, 2, border_mode='valid')) net.add(layer.Flatten('flat')) net.add(layer.Dropout('drop_flat', 0.5)) net.add(layer.Dense('ip1', 512)) net.add(layer.BatchNormalization('batchnorm_ip1')) net.add(layer.Activation('relu_ip1')) net.add(layer.Dropout('drop_ip2', 0.5)) net.add(layer.Dense('ip2', 10)) print 'Start intialization............' for (p, name) in zip(net.param_values(), net.param_names()): print name, p.shape if 'mean' in name or 'beta' in name: p.set_value(0.0) elif 'var' in name: p.set_value(1.0) elif 'gamma' in name: initializer.uniform(p, 0, 1) elif len(p.shape) > 1: if 'conv' in name: initializer.gaussian(p, 0, 3 * 3 * p.shape[0]) else: p.gaussian(0, 0.02) else: p.set_value(0) print name, p.l1() return net
def test_single_input_output(self): ffn = net.FeedForwardNet(loss.SoftmaxCrossEntropy()) ffn.add(layer.Activation('relu1', input_sample_shape=(2,))) ffn.add(layer.Activation('relu2')) x = np.array([[-1, 1], [1, 1], [-1, -2]], dtype=np.float32) x = tensor.from_numpy(x) y = tensor.Tensor((3,)) y.set_value(0) out, _ = ffn.evaluate(x, y) self.assertAlmostEqual(out * 3, - math.log(1.0/(1+math.exp(1))) - math.log(0.5) -math.log(0.5), 5);
def create_net(input_shape, use_cpu=False): if use_cpu: layer.engine = 'singacpp' net = ffnet.FeedForwardNet(loss.SoftmaxCrossEntropy(), metric.Accuracy()) net.add( layer.Conv2D('conv1', nb_kernels=32, kernel=7, stride=3, pad=1, input_sample_shape=input_shape)) net.add(layer.Activation('relu1')) net.add(layer.MaxPooling2D('pool1', 2, 2, border_mode='valid')) net.add(layer.Conv2D('conv2', nb_kernels=64, kernel=5, stride=3)) net.add(layer.Activation('relu2')) net.add(layer.MaxPooling2D('pool2', 2, 2, border_mode='valid')) net.add(layer.Conv2D('conv3', nb_kernels=128, kernel=3, stride=1, pad=2)) net.add(layer.Activation('relu3')) net.add(layer.MaxPooling2D('pool3', 2, 2, border_mode='valid')) net.add(layer.Conv2D('conv4', nb_kernels=256, kernel=3, stride=1)) net.add(layer.Activation('relu4')) net.add(layer.MaxPooling2D('pool4', 2, 2, border_mode='valid')) net.add(layer.Flatten('flat')) net.add(layer.Dense('ip5', 256)) net.add(layer.Activation('relu5')) net.add(layer.Dense('ip6', 16)) net.add(layer.Activation('relu6')) net.add(layer.Dense('ip7', 2)) print 'Parameter intialization............' for (p, name) in zip(net.param_values(), net.param_names()): print name, p.shape if 'mean' in name or 'beta' in name: p.set_value(0.0) elif 'var' in name: p.set_value(1.0) elif 'gamma' in name: initializer.uniform(p, 0, 1) elif len(p.shape) > 1: if 'conv' in name: initializer.gaussian(p, 0, p.size()) else: p.gaussian(0, 0.02) else: p.set_value(0) print name, p.l1() return net
def test_mult_inputs(self): ffn = net.FeedForwardNet(loss.SoftmaxCrossEntropy()) s1 = ffn.add(layer.Activation('relu1', input_sample_shape=(2, )), []) s2 = ffn.add(layer.Activation('relu2', input_sample_shape=(2, )), []) ffn.add(layer.Merge('merge', input_sample_shape=(2, )), [s1, s2]) x1 = tensor.Tensor((2, 2)) x1.set_value(1.1) x2 = tensor.Tensor((2, 2)) x2.set_value(0.9) out = ffn.forward(False, {'relu1': x1, 'relu2': x2}) out = tensor.to_numpy(out) self.assertAlmostEqual(np.average(out), 2)
def test_save_load(self): ffn = net.FeedForwardNet(loss.SoftmaxCrossEntropy()) ffn.add(layer.Conv2D('conv', 4, 3, input_sample_shape=(3, 12, 12))) ffn.add(layer.Flatten('flat')) # ffn.add(layer.BatchNorm('bn')) ffn.add(layer.Dense('dense', num_output=4)) for pname, pval in zip(ffn.param_names(), ffn.param_values()): pval.set_value(0.1) ffn.save('test_snaphost') ffn.save('test_pickle', use_pickle=True) ffn.load('test_snaphost') ffn.load('test_pickle', use_pickle=True)
def create_net(input_shape, use_cpu=False): if use_cpu: layer.engine = 'singacpp' net = ffnet.FeedForwardNet(loss.SoftmaxCrossEntropy(), metric.Accuracy()) ConvBnReLUPool(net, 'conv1', 32, input_shape) ConvBnReLUPool(net, 'conv2', 64) ConvBnReLUPool(net, 'conv3', 128) ConvBnReLUPool(net, 'conv4', 128) ConvBnReLUPool(net, 'conv5', 256) ConvBnReLUPool(net, 'conv6', 256) ConvBnReLUPool(net, 'conv7', 512) ConvBnReLUPool(net, 'conv8', 512) net.add(layer.Flatten('flat')) net.add(layer.Dense('ip1', 256)) net.add(layer.BatchNormalization('bn1')) net.add(layer.Activation('relu1')) net.add(layer.Dropout('dropout1', 0.2)) net.add(layer.Dense('ip2', 16)) net.add(layer.BatchNormalization('bn2')) net.add(layer.Activation('relu2')) net.add(layer.Dropout('dropout2', 0.2)) net.add(layer.Dense('ip3', 2)) print 'Parameter intialization............' for (p, name) in zip(net.param_values(), net.param_names()): print name, p.shape if 'mean' in name or 'beta' in name: p.set_value(0.0) elif 'var' in name: p.set_value(1.0) elif 'gamma' in name: initializer.uniform(p, 0, 1) elif len(p.shape) > 1: if 'conv' in name: initializer.gaussian(p, 0, p.size()) else: p.gaussian(0, 0.02) else: p.set_value(0) print name, p.l1() return net
def create_net(use_cpu=False): if use_cpu: layer.engine = 'singacpp' net = ffnet.FeedForwardNet(loss.SoftmaxCrossEntropy(), metric.Accuracy()) net.add( layer.Conv2D("conv1", 16, 3, 1, pad=1, input_sample_shape=(3, 32, 32))) net.add(layer.BatchNormalization("bn1")) net.add(layer.Activation("relu1")) Block(net, "2a", 16, 1) Block(net, "2b", 16, 1) Block(net, "2c", 16, 1) Block(net, "3a", 32, 2) Block(net, "3b", 32, 1) Block(net, "3c", 32, 1) Block(net, "4a", 64, 2) Block(net, "4b", 64, 1) Block(net, "4c", 64, 1) net.add(layer.AvgPooling2D("pool4", 8, 8, border_mode='valid')) net.add(layer.Flatten('flat')) net.add(layer.Dense('ip5', 10)) print 'Start intialization............' for (p, name) in zip(net.param_values(), net.param_names()): # print name, p.shape if 'mean' in name or 'beta' in name: p.set_value(0.0) elif 'var' in name: p.set_value(1.0) elif 'gamma' in name: initializer.uniform(p, 0, 1) elif len(p.shape) > 1: if 'conv' in name: # initializer.gaussian(p, 0, math.sqrt(2.0/p.shape[1])) initializer.gaussian(p, 0, 9.0 * p.shape[0]) else: initializer.uniform(p, p.shape[0], p.shape[1]) else: p.set_value(0) # print name, p.l1() return net
def test_train_one_batch(self): ffn = net.FeedForwardNet(loss.SoftmaxCrossEntropy()) ffn.add(layer.Conv2D('conv', 4, 3, input_sample_shape=(3, 12, 12))) ffn.add(layer.Flatten('flat')) ffn.add(layer.Dense('dense', num_output=4)) for pname, pval in zip(ffn.param_names(), ffn.param_values()): pval.set_value(0.1) x = tensor.Tensor((4, 3, 12, 12)) x.gaussian(0, 0.01) y = np.asarray([[1, 0, 0], [0, 0, 1], [0, 0, 1], [0, 1, 0]], dtype=np.int32) y = tensor.from_numpy(y) o = ffn.forward(True, x) ffn.loss.forward(True, o, y) g = ffn.loss.backward() for pname, pvalue, pgrad in ffn.backward(g): self.assertEqual(len(pvalue), len(pgrad)) for p, g in zip(pvalue, pgrad): self.assertEqual(p.size(), g.size())
def create_net(in_shape, hyperpara, use_cpu=False): if use_cpu: layer.engine = 'singacpp' height, width, kernel_y, kernel_x, stride_y, stride_x = hyperpara[0], hyperpara[1], hyperpara[2], hyperpara[3], hyperpara[4], hyperpara[5] print ("kernel_x: ", kernel_x) print ("stride_x: ", stride_x) net = myffnet.ProbFeedForwardNet(loss.SoftmaxCrossEntropy(), metric.Accuracy()) net.add(layer.Conv2D('conv1', 100, kernel=(kernel_y, kernel_x), stride=(stride_y, stride_x), pad=(0, 0), input_sample_shape=(int(in_shape[0]), int(in_shape[1]), int(in_shape[2])))) net.add(layer.Activation('relu1')) net.add(layer.MaxPooling2D('pool1', 2, 1, pad=0)) net.add(layer.Flatten('flat')) net.add(layer.Dense('dense', 2)) for (pname, pvalue) in zip(net.param_names(), net.param_values()): if len(pvalue.shape) > 1: initializer.gaussian(pvalue, pvalue.shape[0], pvalue.shape[1]) else: pvalue.set_value(0) print (pname, pvalue.l1()) return net
def build_net(self): if self.use_cpu: layer.engine = 'singacpp' else: layer.engine = 'cudnn' self.net = ffnet.FeedForwardNet(loss.SoftmaxCrossEntropy(), metric.Accuracy()) self.net.add( Reshape('reshape1', (self.vocab_size, ), input_sample_shape=(self.maxlen, self.vocab_size))) self.net.add(layer.Dense('embed', self.embed_size)) # output: (embed_size, ) self.net.add(layer.Dropout('dropout')) self.net.add(Reshape('reshape2', (1, self.maxlen, self.embed_size))) self.net.add( layer.Conv2D('conv', self.filters, (self.kernel_size, self.embed_size), border_mode='valid')) # output: (filter, embed_size) if self.use_cpu == False: self.net.add(layer.BatchNormalization('batchNorm')) self.net.add(layer.Activation('activ')) # output: (filter, embed_size) self.net.add(layer.MaxPooling2D('max', stride=self.pool_size)) self.net.add(layer.Flatten('flatten')) self.net.add(layer.Dense('dense', 2))
def create_net(use_cpu=False): if use_cpu: layer.engine = 'singacpp' net = ffnet.FeedForwardNet(loss.SoftmaxCrossEntropy(), metric.Accuracy()) W0_specs = {'init': 'gaussian', 'mean': 0, 'std': 0.0001} W1_specs = {'init': 'gaussian', 'mean': 0, 'std': 0.01} W2_specs = {'init': 'gaussian', 'mean': 0, 'std': 0.01, 'decay_mult': 250} b_specs = {'init': 'constant', 'value': 0, 'lr_mult': 2, 'decay_mult': 0} net.add( layer.Conv2D('conv1', 32, 5, 1, W_specs=W0_specs.copy(), b_specs=b_specs.copy(), pad=2, input_sample_shape=( 3, 32, 32, ))) net.add(layer.MaxPooling2D('pool1', 3, 2, pad=1)) net.add(layer.Activation('relu1')) net.add(layer.LRN(name='lrn1', size=3, alpha=5e-5)) net.add( layer.Conv2D('conv2', 32, 5, 1, W_specs=W1_specs.copy(), b_specs=b_specs.copy(), pad=2)) net.add(layer.Activation('relu2')) net.add(layer.AvgPooling2D('pool2', 3, 2, pad=1)) net.add(layer.LRN('lrn2', size=3, alpha=5e-5)) net.add( layer.Conv2D('conv3', 64, 5, 1, W_specs=W1_specs.copy(), b_specs=b_specs.copy(), pad=2)) net.add(layer.Activation('relu3')) net.add(layer.AvgPooling2D('pool3', 3, 2, pad=1)) net.add(layer.Flatten('flat')) net.add( layer.Dense('dense', 10, W_specs=W2_specs.copy(), b_specs=b_specs.copy())) for (p, specs) in zip(net.param_values(), net.param_specs()): filler = specs.filler if filler.type == 'gaussian': p.gaussian(filler.mean, filler.std) else: p.set_value(0) print specs.name, filler.type, p.l1() return net
def train(data, max_epoch, hidden_size=100, seq_length=100, batch_size=16, num_stacks=1, dropout=0.5, model_path='model'): # SGD with L2 gradient normalization opt = optimizer.RMSProp(constraint=optimizer.L2Constraint(5)) cuda = device.create_cuda_gpu() rnn = layer.LSTM(name='lstm', hidden_size=hidden_size, num_stacks=num_stacks, dropout=dropout, input_sample_shape=(data.vocab_size, )) rnn.to_device(cuda) print 'created rnn' rnn_w = rnn.param_values()[0] rnn_w.uniform(-0.08, 0.08) # init all rnn parameters print 'rnn weight l1 = %f' % (rnn_w.l1()) dense = layer.Dense('dense', data.vocab_size, input_sample_shape=(hidden_size, )) dense.to_device(cuda) dense_w = dense.param_values()[0] dense_b = dense.param_values()[1] print 'dense w ', dense_w.shape print 'dense b ', dense_b.shape initializer.uniform(dense_w, dense_w.shape[0], 0) print 'dense weight l1 = %f' % (dense_w.l1()) dense_b.set_value(0) print 'dense b l1 = %f' % (dense_b.l1()) g_dense_w = tensor.Tensor(dense_w.shape, cuda) g_dense_b = tensor.Tensor(dense_b.shape, cuda) lossfun = loss.SoftmaxCrossEntropy() for epoch in range(max_epoch): train_loss = 0 for b in range(data.num_train_batch): batch = data.train_dat[b * batch_size:(b + 1) * batch_size] inputs, labels = convert(batch, batch_size, seq_length, data.vocab_size, cuda) inputs.append(tensor.Tensor()) inputs.append(tensor.Tensor()) outputs = rnn.forward(model_pb2.kTrain, inputs)[0:-2] grads = [] batch_loss = 0 g_dense_w.set_value(0.0) g_dense_b.set_value(0.0) for output, label in zip(outputs, labels): act = dense.forward(model_pb2.kTrain, output) lvalue = lossfun.forward(model_pb2.kTrain, act, label) batch_loss += lvalue.l1() grad = lossfun.backward() grad /= batch_size grad, gwb = dense.backward(model_pb2.kTrain, grad) grads.append(grad) g_dense_w += gwb[0] g_dense_b += gwb[1] # print output.l1(), act.l1() utils.update_progress( b * 1.0 / data.num_train_batch, 'training loss = %f' % (batch_loss / seq_length)) train_loss += batch_loss grads.append(tensor.Tensor()) grads.append(tensor.Tensor()) g_rnn_w = rnn.backward(model_pb2.kTrain, grads)[1][0] dense_w, dense_b = dense.param_values() opt.apply_with_lr(epoch, get_lr(epoch), g_rnn_w, rnn_w, 'rnnw') opt.apply_with_lr(epoch, get_lr(epoch), g_dense_w, dense_w, 'dense_w') opt.apply_with_lr(epoch, get_lr(epoch), g_dense_b, dense_b, 'dense_b') print '\nEpoch %d, train loss is %f' % \ (epoch, train_loss / data.num_train_batch / seq_length) eval_loss = 0 for b in range(data.num_test_batch): batch = data.val_dat[b * batch_size:(b + 1) * batch_size] inputs, labels = convert(batch, batch_size, seq_length, data.vocab_size, cuda) inputs.append(tensor.Tensor()) inputs.append(tensor.Tensor()) outputs = rnn.forward(model_pb2.kEval, inputs)[0:-2] for output, label in zip(outputs, labels): output = dense.forward(model_pb2.kEval, output) eval_loss += lossfun.forward(model_pb2.kEval, output, label).l1() print 'Epoch %d, evaluation loss is %f' % \ (epoch, eval_loss / data.num_test_batch / seq_length) if (epoch + 1) % 30 == 0: # checkpoint the file model with open('%s_%d.bin' % (model_path, epoch), 'wb') as fd: print 'saving model to %s' % model_path d = {} for name, w in zip(['rnn_w', 'dense_w', 'dense_b'], [rnn_w, dense_w, dense_b]): w.to_host() d[name] = tensor.to_numpy(w) w.to_device(cuda) d['idx_to_char'] = data.idx_to_char d['char_to_idx'] = data.char_to_idx d['hidden_size'] = hidden_size d['num_stacks'] = num_stacks d['dropout'] = dropout pickle.dump(d, fd)
decoder_w = decoder.param_values()[0] decoder_w.uniform(-0.08, 0.08) dense = layer.Dense('dense', vocab_size, input_sample_shape=(64, )) dense.to_device(cuda) dense_w = dense.param_values()[0] dense_b = dense.param_values()[1] initializer.uniform(dense_w, dense_w.shape[0], 0) dense_b.set_value(0) #g_encoder_w = tensor.Tensor(encoder_w.shape, cuda) #g_encoder_w.set_value(0.0) g_dense_w = tensor.Tensor(dense_w.shape, cuda) g_dense_b = tensor.Tensor(dense_b.shape, cuda) lossfun = loss.SoftmaxCrossEntropy() batch_size = 50 maxlength = 22 num_train_batch = 5000 num_epoch = 5 metadata, idx_q, idx_a = load_data() trainlosslist = np.zeros(num_epoch) for epoch in range(num_epoch): train_loss = 0 bar = range(num_train_batch) for b in range(num_train_batch): batcha = idx_a[b * batch_size:(b + 1) * batch_size] batchq = idx_q[b * batch_size:(b + 1) * batch_size] inputs = convert(batchq, batch_size, 20, vocab_size, cuda) #print 'origin input:', len(inputs), inputs[0].shape inputs.append(tensor.Tensor())
def create_net(input_shape, use_cpu=False): if use_cpu: layer.engine = 'singacpp' net = ffnet.FeedForwardNet(loss.SoftmaxCrossEntropy(), metric.Accuracy()) ConvBnReLU(net, 'conv1_1', 64, input_shape) #net.add(layer.Dropout('drop1', 0.3)) net.add(layer.MaxPooling2D('pool0', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv1_2', 128) net.add(layer.MaxPooling2D('pool1', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv2_1', 128) net.add(layer.Dropout('drop2_1', 0.4)) ConvBnReLU(net, 'conv2_2', 128) net.add(layer.MaxPooling2D('pool2', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv3_1', 256) net.add(layer.Dropout('drop3_1', 0.4)) ConvBnReLU(net, 'conv3_2', 256) net.add(layer.Dropout('drop3_2', 0.4)) ConvBnReLU(net, 'conv3_3', 256) net.add(layer.MaxPooling2D('pool3', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv4_1', 256) net.add(layer.Dropout('drop4_1', 0.4)) ConvBnReLU(net, 'conv4_2', 256) net.add(layer.Dropout('drop4_2', 0.4)) ConvBnReLU(net, 'conv4_3', 256) net.add(layer.MaxPooling2D('pool4', 2, 2, border_mode='valid')) ConvBnReLU(net, 'conv5_1', 512) net.add(layer.Dropout('drop5_1', 0.4)) ConvBnReLU(net, 'conv5_2', 512) net.add(layer.Dropout('drop5_2', 0.4)) ConvBnReLU(net, 'conv5_3', 512) net.add(layer.MaxPooling2D('pool5', 2, 2, border_mode='valid')) #ConvBnReLU(net, 'conv6_1', 512) #net.add(layer.Dropout('drop6_1', 0.4)) #ConvBnReLU(net, 'conv6_2', 512) #net.add(layer.Dropout('drop6_2', 0.4)) #ConvBnReLU(net, 'conv6_3', 512) #net.add(layer.MaxPooling2D('pool6', 2, 2, border_mode='valid')) #ConvBnReLU(net, 'conv7_1', 512) #net.add(layer.Dropout('drop7_1', 0.4)) #ConvBnReLU(net, 'conv7_2', 512) #net.add(layer.Dropout('drop7_2', 0.4)) #ConvBnReLU(net, 'conv7_3', 512) #net.add(layer.MaxPooling2D('pool7', 2, 2, border_mode='valid')) net.add(layer.Flatten('flat')) net.add(layer.Dense('ip1', 256)) net.add(layer.BatchNormalization('bn1')) net.add(layer.Activation('relu1')) net.add(layer.Dropout('dropout1', 0.2)) net.add(layer.Dense('ip2', 16)) net.add(layer.BatchNormalization('bn2')) net.add(layer.Activation('relu2')) net.add(layer.Dropout('dropout2', 0.2)) net.add(layer.Dense('ip3', 2)) print 'Parameter intialization............' for (p, name) in zip(net.param_values(), net.param_names()): print name, p.shape if 'mean' in name or 'beta' in name: p.set_value(0.0) elif 'var' in name: p.set_value(1.0) elif 'gamma' in name: initializer.uniform(p, 0, 1) elif len(p.shape) > 1: if 'conv' in name: initializer.gaussian(p, 0, p.size()) else: p.gaussian(0, 0.02) else: p.set_value(0) print name, p.l1() return net