def discriminator_3D(input_var=None, num_units=512, seq_length=4): discriminator = [] lrelu = lasagne.nonlinearities.LeakyRectify(0.2) discriminator.append( ll.InputLayer(shape=(None, seq_length, 3, 80, 160), input_var=input_var)) # lasagne documentations requires shape : # (batch_size, num_input_channels, input_depth, input_rows, input_columns) # so we need to change dimension ordering discriminator.append(ll.DimshuffleLayer(discriminator[-1], (0, 2, 1, 3, 4))) discriminator.append( ll.Conv3DLayer(discriminator[-1], num_filters=num_units / 8, filter_size=5, stride=2, pad=2, nonlinearity=lrelu)) discriminator.append( ll.batch_norm( ll.Conv3DLayer(discriminator[-1], num_filters=num_units / 4, filter_size=5, stride=2, pad=2, nonlinearity=lrelu))) discriminator.append( ll.batch_norm( ll.Conv3DLayer(discriminator[-1], num_filters=num_units / 2, filter_size=5, stride=2, pad=2, nonlinearity=lrelu))) discriminator.append( ll.batch_norm( ll.Conv3DLayer(discriminator[-1], num_filters=num_units, filter_size=5, stride=2, pad=2, nonlinearity=lrelu))) discriminator.append(ll.FlattenLayer(discriminator[-1])) discriminator.append( ll.DenseLayer(discriminator[-1], num_units=1, nonlinearity=None)) for layer in discriminator: print layer.output_shape print "" return discriminator
def conv4_net(data, ndim, pad='same'): res = conv_nonl(data, 6, '1', pad=pad) res = conv_nonl(res, 12, '2', pad=pad) res = conv_nonl(res, 24, '3', pad=pad) res = conv(res, ndim - 1, '4', pad=pad) res = L.DimshuffleLayer(res, (0, 2, 3, 1), name='transpose') res = L2NormLayer(res, 1e-8, name='l2norm') return res
def conv4_net_dense_color(data, ndim, pad='same'): res = conv_nonl(data, 6, '1', pad=pad) res = conv_nonl(res, 12, '2', pad=pad) res = conv_nonl(res, 24, '3', pad=pad) res = L.concat([data, res], axis=1, name='concat') res = L.DimshuffleLayer(res, (0, 2, 3, 1), name='transpose') res = L2NormLayer(res, 1e-8, name='l2norm') res = NormedDense(res, ndim, name='normed_dense') return res
def cls_net(_incoming): _drop1 = L.DropoutLayer(_incoming, p=0.2, rescale=True) _conv1 = batch_norm( conv(_drop1, num_filters=64, filter_size=7, stride=3, pad=0, W=I.Normal(0.02), b=None, nonlinearity=NL.rectify)) _drop2 = L.DropoutLayer(_conv1, p=0.2, rescale=True) _conv2 = batch_norm( conv(_drop2, num_filters=128, filter_size=3, stride=1, pad=0, W=I.Normal(0.02), b=None, nonlinearity=NL.rectify)) _pool2 = L.MaxPool2DLayer(_conv2, pool_size=2) _fc1 = batch_norm( L.DenseLayer(L.FlattenLayer(_pool2, outdim=2), 256, W=I.Normal(0.02), b=None, nonlinearity=NL.rectify)) _fc2 = L.DenseLayer(_fc1, ny, W=I.Normal(0.02), b=None, nonlinearity=NL.sigmoid) _aux = [ tanh(_conv1), tanh(_conv2), tanh(L.DimshuffleLayer(_fc1, (0, 1, 'x', 'x'))), L.DimshuffleLayer(_fc2, (0, 1, 'x', 'x')) ] return _aux, _fc2
def build_1Dregression_v1(input_var=None, input_width=None, nin_units=12, h_num_units=[64, 64], h_grad_clip=1.0, output_width=1): """ A stacked bidirectional RNN network for regression, alternating with dense layers and merging of the two directions, followed by a feature mean pooling in the time direction, with a linear dim-reduction layer at the start Args: input_var (theano 3-tensor): minibatch of input sequence vectors input_width (int): length of input sequences nin_units (list): number of NIN features h_num_units (int list): no. of units in hidden layer in each stack from bottom to top h_grad_clip (float): gradient clipping maximum value output_width (int): size of output layer (e.g. =1 for 1D regression) Returns: output layer (Lasagne layer object) """ # Non-linearity hyperparameter nonlin = lasagne.nonlinearities.LeakyRectify(leakiness=0.15) # Input layer l_in = LL.InputLayer(shape=(None, 22, input_width), input_var=input_var) batchsize = l_in.input_var.shape[0] # NIN-layer l_in = LL.NINLayer(l_in, num_units=nin_units, nonlinearity=lasagne.nonlinearities.linear) l_in_1 = LL.DimshuffleLayer(l_in, (0, 2, 1)) # RNN layers for h in h_num_units: # Forward layers l_forward_0 = LL.RecurrentLayer(l_in_1, nonlinearity=nonlin, num_units=h, backwards=False, learn_init=True, grad_clipping=h_grad_clip, unroll_scan=True, precompute_input=True) l_forward_0a = LL.ReshapeLayer(l_forward_0, (-1, h)) l_forward_0b = LL.DenseLayer(l_forward_0a, num_units=h, nonlinearity=nonlin) l_forward_0c = LL.ReshapeLayer(l_forward_0b, (batchsize, input_width, h)) # Backward layers l_backward_0 = LL.RecurrentLayer(l_in_1, nonlinearity=nonlin, num_units=h, backwards=True, learn_init=True, grad_clipping=h_grad_clip, unroll_scan=True, precompute_input=True) l_backward_0a = LL.ReshapeLayer(l_backward_0, (-1, h)) l_backward_0b = LL.DenseLayer(l_backward_0a, num_units=h, nonlinearity=nonlin) l_backward_0c = LL.ReshapeLayer(l_backward_0b, (batchsize, input_width, h)) l_in_1 = LL.ElemwiseSumLayer([l_forward_0c, l_backward_0c]) # Output layers network_0a = LL.ReshapeLayer(l_in_1, (-1, h_num_units[-1])) network_0b = LL.DenseLayer(network_0a, num_units=output_width, nonlinearity=nonlin) network_0c = LL.ReshapeLayer(network_0b, (batchsize, input_width, output_width)) output_net_1 = LL.FlattenLayer(network_0c, outdim=2) output_net_2 = LL.FeaturePoolLayer(output_net_1, pool_size=input_width, pool_function=T.mean) return output_net_2
def cls_net(_incoming, noise_sigma=0.05, drop_ratio_conv=0.3, drop_ratio_fc=0.5): _noise = L.GaussianNoiseLayer(_incoming, sigma=noise_sigma) _conv1 = conv(_noise, num_filters=128, filter_size=4, stride=2, pad=1, W=I.Normal(0.02), b=I.Constant(0.), nonlinearity=NL.rectify) _lrn1 = L.LocalResponseNormalization2DLayer(_conv1, alpha=0.0001, k=2, beta=0.75, n=5) _drop2 = L.DropoutLayer(_lrn1, p=drop_ratio_conv, rescale=True) _conv2 = batch_norm_n( conv(_drop2, num_filters=256, filter_size=4, stride=2, pad=1, W=I.Normal(0.02), b=None, nonlinearity=NL.rectify)) _drop3 = L.DropoutLayer(_conv2, p=drop_ratio_conv, rescale=True) _conv3 = batch_norm_n( conv(_drop3, num_filters=384, filter_size=3, stride=1, pad=0, W=I.Normal(0.02), b=None, nonlinearity=NL.rectify)) _drop4 = L.DropoutLayer(_conv3, p=drop_ratio_conv, rescale=True) _conv4 = batch_norm_n( conv(_drop4, num_filters=512, filter_size=3, stride=1, pad=0, W=I.Normal(0.02), b=None, nonlinearity=NL.rectify)) _drop5 = L.DropoutLayer(_conv4, p=drop_ratio_fc, rescale=True) _conv5 = batch_norm_n( conv(_drop5, num_filters=1024, filter_size=1, stride=1, pad=0, W=I.Normal(0.02), b=None, nonlinearity=NL.rectify)) _pool6 = L.GlobalPoolLayer(_conv5, pool_function=theano.tensor.max) #mean _drop6 = L.DropoutLayer(_pool6, p=drop_ratio_fc, rescale=True) _fc6 = L.DenseLayer(_drop6, ny, W=I.Normal(0.02), b=I.Constant(0), nonlinearity=NL.softmax) _aux = [ _conv1, _conv2, _conv3, _conv4, _conv5, L.DimshuffleLayer(_fc6, (0, 1, 'x', 'x')) ] ### used to have a tanh() around everything except last return _aux, _fc6
def __init__(self, incomings, vocab_size, emb_size, A=lasagne.init.Normal(std=0.1), C=lasagne.init.Normal(std=0.1), AT=lasagne.init.Normal(std=0.1), CT=lasagne.init.Normal(std=0.1), nonlin=lasagne.nonlinearities.softmax, RN=0., **kwargs): super(MemoryLayer, self).__init__(incomings, **kwargs) self.vocab_size, self.emb_size = vocab_size, emb_size self.nonlin = nonlin self.RN = RN # self.A, self.C, self.AT, self.CT = A, C, AT, CT batch_size, c_count, c_length = self.input_shapes[0] _, q_count, _ = self.input_shapes[2] self.l_c_in = LL.InputLayer(shape=(batch_size, c_count, c_length)) self.l_c_in_pe = LL.InputLayer(shape=(batch_size, c_count, c_length, self.emb_size)) self.l_u_in = LL.InputLayer(shape=(batch_size, q_count, self.emb_size)) self.l_c_A_enc = EncodingFullLayer((self.l_c_in, self.l_c_in_pe), self.vocab_size, self.emb_size, A, AT) self.l_c_C_enc = EncodingFullLayer((self.l_c_in, self.l_c_in_pe), self.vocab_size, self.emb_size, C, CT) self.A, self.C = self.l_c_A_enc.W, self.l_c_C_enc.W self.AT, self.CT = self.l_c_A_enc.WT, self.l_c_C_enc.WT if len(incomings ) == 4: # if there is also the probabilities over sentences self.l_in_ac_prob = LL.InputLayer(shape=(batch_size, c_count, emb_size)) self.l_c_A_enc_ = LL.ElemwiseMergeLayer( (self.l_c_A_enc, self.l_in_ac_prob), merge_function=T.mul) self.l_c_C_enc_ = LL.ElemwiseMergeLayer( (self.l_c_C_enc, self.l_in_ac_prob), merge_function=T.mul) self.l_u_in_tr = LL.DimshuffleLayer(self.l_u_in, pattern=(0, 2, 1)) if len(incomings) == 4: self.l_p = BatchedDotLayer((self.l_c_A_enc_, self.l_u_in_tr)) else: self.l_p = BatchedDotLayer((self.l_c_A_enc, self.l_u_in_tr)) if self.l_p.output_shape[2] == 1: self.l_p = LL.FlattenLayer(self.l_p, outdim=2) # self.l_p = LL.DimshuffleLayer(self.l_p, (0, 1)) if self.nonlin == 'MaxOut': raise NotImplementedError self.l_p = LL.NonlinearityLayer(self.l_p, nonlinearity=nonlin) self.l_p = LL.DimshuffleLayer(self.l_p, (0, 1, 'x')) # self.l_p = LL.ReshapeLayer(self.l_p, self.l_p.output_shape + (1,)) self.l_p = LL.ExpressionLayer(self.l_p, lambda X: X.repeat(emb_size, 2), output_shape='auto') ## self.l_p = RepeatDimLayer(self.l_p, emb_size, axis=2) if len(incomings) == 4: self.l_pc = LL.ElemwiseMergeLayer((self.l_p, self.l_c_C_enc_), merge_function=T.mul) else: self.l_pc = LL.ElemwiseMergeLayer((self.l_p, self.l_c_C_enc), merge_function=T.mul) self.l_o = LL.ExpressionLayer(self.l_pc, lambda X: X.sum(1), output_shape='auto') # self.l_o = SumLayer(self.l_pc, axis=1) self.l_o = LL.DimshuffleLayer(self.l_o, pattern=(0, 'x', 1)) self.l_o_u = LL.ElemwiseMergeLayer((self.l_o, self.l_u_in), merge_function=T.add) params = LL.helper.get_all_params(self.l_o_u, trainable=True) values = LL.helper.get_all_param_values(self.l_o_u, trainable=True) for p, v in zip(params, values): self.add_param(p, v.shape, name=p.name)
def UNet(data, ndim, pad='same'): res = uNet.build(data) res = L.Conv2DLayer(res, ndim - 1, 1, nonlinearity=None) res = L.DimshuffleLayer(res, (0, 2, 3, 1), name='transpose') res = L2NormLayer(res, 1e-8, name='l2norm') return res
def baseline(data, ndim, pad='same'): assert (ndim == 3) res = L.DimshuffleLayer(data, (0, 2, 3, 1), name='transpose') return res
def baseline_norm(data, ndim, pad='same'): assert (ndim == 4) res = L.DimshuffleLayer(data, (0, 2, 3, 1), name='transpose') res = L2NormLayer(res, 1e-8, name='l2norm') return res
def fcrnn( input_var_list, early_conv_dict_list, late_conv_dict, dense_filter_size, final_pool_function=T.max, input_size_list=[128], output_size=10, last_late_conv_size=128, p_dropout=0.5, num_feat_type = 1, num_lstm_unit = 512, gradient_steps = 10 ): assert(len(early_conv_dict_list) == len(input_var_list) == len(input_size_list)) # early conv layers conv_network_list = list() total_stride_list = list() for jj, [early_conv_dict, input_var, input_size] in enumerate(zip( early_conv_dict_list, input_var_list, input_size_list)): input_network = lasagne.layers.InputLayer( shape=(None, num_feat_type, None, input_size), input_var=input_var) total_stride = 1 network, total_stride = conv_layers(input_network, early_conv_dict, total_stride, init_input_size=input_size, p_dropout=0, base_name='early{}'.format(jj)) total_stride_list.append(total_stride) conv_network_list.append(network) ''' # upsampling conv_network_list = [cl.LocalExtend(net, axis=2, extend_size=ts) for net, ts in zip(conv_network_list, total_stride_list)] ''' network = layers.ConcatLayer(conv_network_list, axis=1, cropping=[None, None, 'lower', None], name='MultisourceConcatenate') # late conv layers (dense layers) network, total_stride = conv_layers(network, late_conv_dict, total_stride, init_input_size=1, p_dropout=p_dropout, base_name='late') # frame output layer. every frame has a value network = cl.Conv2DXLayer( lasagne.layers.dropout(network, p=p_dropout), num_filters=last_late_conv_size, filter_size=(dense_filter_size, 1), nonlinearity=lasagne.nonlinearities.sigmoid, W=lasagne.init.GlorotUniform() ) network = layers.ReshapeLayer(network, ([0], [1], -1)) network = layers.DimshuffleLayer(network, (0, 2, 1)) # lstm layers l_forward = layers.LSTMLayer(network, output_size, grad_clipping=100, gradient_steps=10, nonlinearity=lasagne.nonlinearities.sigmoid) # l_backward = layers.LSTMLayer(l_forward, output_size, # grad_clipping=100, # gradient_steps=gradient_steps, # nonlinearity=lasagne.nonlinearities.sigmoid, # backwards=True) network = layers.DimshuffleLayer(l_forward, (0, 2, 1)) # pool network = layers.GlobalPoolLayer(network, pool_function=final_pool_function) network = layers.ReshapeLayer(network, ([0], -1)) return network