def get_network(self): network = lasagne.layers.InputLayer(shape=(None, self.num_features),input_var=self.input_var) for i in xrange(0, self.num_layers): network = DenseLayer(network,nonlinearity=rectify,num_units=self.num_nodes) if i != 0: network = FeaturePoolLayer(incoming=network, pool_size=2,axis=1, pool_function=theano.tensor.mean) for _ in xrange(0, 1): network = DenseLayer(network,nonlinearity=rectify,num_units=self.num_nodes) layers = [network] for _ in xrange(0, 4): network = batch_norm(self.add_dense_maxout_block(network, self.num_nodes, self.dropout)) layers.append(network) network = ConcatLayer(layers, axis=1) maxout = FeaturePoolLayer(incoming=network, pool_size=2,axis=1, pool_function=theano.tensor.mean) return lasagne.layers.DenseLayer(network, num_units=2,nonlinearity=lasagne.nonlinearities.softmax)
def broadcast_dot_layer(l_pred, l_targets, feature_dim, id_tag): l_broadcast = dimshuffle(l_pred, (0, 1, 'x'), name=id_tag + 'dot_broadcast') l_forget = ForgetSizeLayer(l_broadcast, axis=2, name=id_tag + 'dot_nosize') l_merge = ElemwiseMergeLayer((l_forget, l_targets), T.mul, name=id_tag + 'dot_elemwise_mul') l_pool = FeaturePoolLayer(l_merge, pool_size=feature_dim, axis=1, pool_function=T.sum, name=id_tag + 'dot_pool') return reshape(l_pool, ([0], [2]), name=id_tag + 'broadcast_dot')
def build_res_stafg(): net = collections.OrderedDict() # INPUTS---------------------------------------- net['sent_input'] = InputLayer((None, CFG['SEQUENCE LENGTH']), input_var=T.imatrix()) net['word_emb'] = EmbeddingLayer(net['sent_input'], input_size=CFG['VOCAB SIZE']+3,\ output_size=CFG['WORD VECTOR SIZE'],W=np.copy(CFG['wemb'])) net['vis_input'] = InputLayer((None,CFG['VISUAL LENGTH'], CFG['VIS SIZE'])) # key words model------------------------------------- net['vis_mean_pool'] = FeaturePoolLayer(net['vis_input'], CFG['VISUAL LENGTH'],pool_function=T.mean) net['ctx_vis_reshp'] = ReshapeLayer(net['vis_mean_pool'],(-1,CFG['VIS SIZE'])) net['global_vis'] = DenseLayer(net['ctx_vis_reshp'],num_units=CFG['EMBEDDING SIZE'],nonlinearity=linear) net['key_words_prob'] = DenseLayer(DropoutLayer(net['global_vis']), num_units=CFG['VOCAB SIZE']+3,nonlinearity=sigmoid) # gru model-------------------------------------- net['mask_input'] = InputLayer((None, CFG['SEQUENCE LENGTH'])) net['sgru'] = GRULayer(net['word_emb'],num_units=CFG['EMBEDDING SIZE'], \ mask_input=net['mask_input'],hid_init=net['global_vis']) net['sta_gru'] = CTXAttentionGRULayer([net['sgru'],net['vis_input'],net['global_vis']], num_units=CFG['EMBEDDING SIZE'], mask_input=net['mask_input']) net['fusion'] = DropoutLayer(ConcatLayer([net['sta_gru'],net['gru']],axis=2), p=0.5) net['fusion_reshp'] = ReshapeLayer(net['fusion'], (-1,CFG['EMBEDDING SIZE']*2)) net['word_prob'] = DenseLayer(net['fusion_reshp'], num_units=CFG['VOCAB SIZE']+3, nonlinearity=softmax) net['sent_prob'] = ReshapeLayer(net['word_prob'],(-1,CFG['SEQUENCE LENGTH'], CFG['VOCAB SIZE']+3)) return net
def add_residual_dense_maxout_block(self, network, num_nodes=240, dropout=0.5): network = lasagne.layers.DropoutLayer(network, p=self.dropout) identity = network network = DenseLayer(network, nonlinearity=rectify, num_units=self.num_nodes, W=HeNormal(gain=.01)) network = FeaturePoolLayer(incoming=network, pool_size=2, axis=1, pool_function=theano.tensor.max) return NonlinearityLayer(ElemwiseSumLayer( [identity, network.input_layer]), nonlinearity=rectify)
def choosy(network, cropsz, batchsz): # 1st. Data size 117 -> 111 -> 55 network = Conv2DLayer(network, 64, (7, 7), stride=1, W=HeUniform('relu')) network = prelu(network) network = BatchNormLayer(network) network = MaxPool2DLayer(network, (3, 3), stride=2) # 2nd. Data size 55 -> 27 network = Conv2DLayer(network, 112, (5, 5), stride=1, pad='same', W=HeUniform('relu')) network = prelu(network) network = BatchNormLayer(network) network = MaxPool2DLayer(network, (3, 3), stride=2) # 3rd. Data size 27 -> 13 network = Conv2DLayer(network, 192, (3, 3), stride=1, pad='same', W=HeUniform('relu')) network = prelu(network) network = BatchNormLayer(network) network = MaxPool2DLayer(network, (3, 3), stride=2) # 4th. Data size 11 -> 5 network = Conv2DLayer(network, 320, (3, 3), stride=1, W=HeUniform('relu')) network = prelu(network) network = BatchNormLayer(network) network = MaxPool2DLayer(network, (3, 3), stride=2) # 5th. Data size 5 -> 3 network = Conv2DLayer(network, 512, (3, 3), nonlinearity=None) network = prelu(network) network = BatchNormLayer(network) # 6th. Data size 3 -> 1 network = lasagne.layers.DenseLayer(network, 512, nonlinearity=None) network = DropoutLayer(network) network = FeaturePoolLayer(network, 2) return network
def cslim(network, cropsz, batchsz): # 1st network = Conv2DLayer(network, 64, (5, 5), stride=2, W=HeUniform('relu')) network = prelu(network) network = BatchNormLayer(network) network = MaxPool2DLayer(network, (5, 5), stride=2) # 2nd network = Conv2DLayer(network, 96, (5, 5), stride=1, pad='same', W=HeUniform('relu')) network = prelu(network) network = BatchNormLayer(network) network = MaxPool2DLayer(network, (5, 5), stride=2) # 3rd network = Conv2DLayer(network, 128, (3, 3), stride=1, pad='same', W=HeUniform('relu')) network = prelu(network) network = BatchNormLayer(network) network = MaxPool2DLayer(network, (3, 3), stride=2) # 4th network = Conv2DLayer(network, 128, (3, 3), stride=1, pad='same', W=HeUniform('relu')) network = prelu(network) network = DropoutLayer(network) network = BatchNormLayer(network) network = MaxPool2DLayer(network, (3, 3), stride=2) # 5th network = lasagne.layers.DenseLayer(network, 512, nonlinearity=None) network = DropoutLayer(network) network = FeaturePoolLayer(network, 2) return network
def slice_mean_layer(incoming, pool_size, axis=-1): l_slice = SliceLayer(incoming, -1) return FeaturePoolLayer(l_slice, pool_size=pool_size, axis=axis, pool_function=T.mean)
def mean_layer(incoming, pool_size, axis=-1): l_out = FeaturePoolLayer(incoming, pool_size=pool_size, axis=axis, pool_function=T.mean) return SliceLayer(l_out, indices=0, axis=axis)
def _get_l_out(self, input_vars): check_options(self.options) id_tag = (self.id + '/') if self.id else '' input_var = input_vars[0] context_vars = input_vars[1:] l_in = InputLayer(shape=(None, self.seq_vec.max_len), input_var=input_var, name=id_tag + 'desc_input') l_in_embed = EmbeddingLayer( l_in, input_size=len(self.seq_vec.tokens), output_size=self.options.listener_cell_size, name=id_tag + 'desc_embed') # Context repr has shape (batch_size, seq_len, context_len * repr_size) l_context_repr, context_inputs = self.color_vec.get_input_layer( context_vars, recurrent_length=self.seq_vec.max_len, cell_size=self.options.listener_cell_size, context_len=self.context_len, id=self.id) l_context_repr = reshape( l_context_repr, ([0], [1], self.context_len, self.color_vec.output_size)) l_hidden_context = dimshuffle(l_context_repr, (0, 3, 1, 2), name=id_tag + 'shuffle_in') for i in range(1, self.options.listener_hidden_color_layers + 1): l_hidden_context = NINLayer( l_hidden_context, num_units=self.options.listener_cell_size, nonlinearity=NONLINEARITIES[ self.options.listener_nonlinearity], b=Constant(0.1), name=id_tag + 'hidden_context%d' % i) l_pool = FeaturePoolLayer(l_hidden_context, pool_size=self.context_len, axis=3, pool_function=T.mean, name=id_tag + 'pool') l_pool_squeezed = reshape(l_pool, ([0], [1], [2]), name=id_tag + 'pool_squeezed') l_pool_shuffle = dimshuffle(l_pool_squeezed, (0, 2, 1), name=id_tag + 'shuffle_out') l_concat = ConcatLayer([l_pool_shuffle, l_in_embed], axis=2, name=id_tag + 'concat_inp_context') cell = CELLS[self.options.listener_cell] cell_kwargs = { 'grad_clipping': self.options.listener_grad_clipping, 'num_units': self.options.listener_cell_size, } if self.options.listener_cell == 'LSTM': cell_kwargs['forgetgate'] = Gate( b=Constant(self.options.listener_forget_bias)) if self.options.listener_cell != 'GRU': cell_kwargs['nonlinearity'] = NONLINEARITIES[ self.options.listener_nonlinearity] # l_rec1_drop = l_concat l_rec1 = cell(l_concat, name=id_tag + 'rec1', **cell_kwargs) if self.options.listener_dropout > 0.0: l_rec1_drop = DropoutLayer(l_rec1, p=self.options.listener_dropout, name=id_tag + 'rec1_drop') else: l_rec1_drop = l_rec1 l_rec2 = cell(l_rec1_drop, name=id_tag + 'rec2', only_return_final=True, **cell_kwargs) if self.options.listener_dropout > 0.0: l_rec2_drop = DropoutLayer(l_rec2, p=self.options.listener_dropout, name=id_tag + 'rec2_drop') else: l_rec2_drop = l_rec2 l_rec2_drop = NINLayer(l_rec2_drop, num_units=self.options.listener_cell_size, nonlinearity=None, name=id_tag + 'rec2_dense') # Context is fed into the RNN as one copy for each time step; just use # the first time step for output. # Input shape: (batch_size, repr_size, seq_len, context_len) # Output shape: (batch_size, repr_size, context_len) l_context_nonrec = SliceLayer(l_hidden_context, indices=0, axis=2, name=id_tag + 'context_nonrec') l_pool_nonrec = SliceLayer(l_pool_squeezed, indices=0, axis=2, name=id_tag + 'pool_nonrec') # Output shape: (batch_size, repr_size, context_len) l_sub = broadcast_sub_layer( l_pool_nonrec, l_context_nonrec, feature_dim=self.options.listener_cell_size, id_tag=id_tag) # Output shape: (batch_size, repr_size * 2, context_len) l_concat_sub = ConcatLayer([l_context_nonrec, l_sub], axis=1, name=id_tag + 'concat_inp_context') # Output shape: (batch_size, cell_size, context_len) l_hidden = NINLayer(l_concat_sub, num_units=self.options.listener_cell_size, nonlinearity=None, name=id_tag + 'hidden') if self.options.listener_dropout > 0.0: l_hidden_drop = DropoutLayer(l_hidden, p=self.options.listener_dropout, name=id_tag + 'hidden_drop') else: l_hidden_drop = l_hidden l_dot = broadcast_dot_layer( l_rec2_drop, l_hidden_drop, feature_dim=self.options.listener_cell_size, id_tag=id_tag) l_dot_bias = l_dot # BiasLayer(l_dot, name=id_tag + 'dot_bias') l_dot_clipped = NonlinearityLayer( l_dot_bias, nonlinearity=NONLINEARITIES[self.options.listener_nonlinearity], name=id_tag + 'dot_clipped') l_scores = NonlinearityLayer(l_dot_clipped, nonlinearity=softmax, name=id_tag + 'scores') return l_scores, [l_in] + context_inputs
def predict(self, input, hidden_state, Ws, bs): npx = self.npx # image size nc = self.input_seqlen filter_size = self.dynamic_filter_size[0] f = 0 ############################### # filter-generating network # ############################### ## encoder output = ConvLayer(input, num_filters=64, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify, untie_biases=True) Ws[f] = output.W bs[f] = output.b f = f + 1 output = ConvLayer(output, num_filters=64, filter_size=(3, 3), stride=(2, 2), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 output = ConvLayer(output, num_filters=128, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 # output = ConvLayer(output, num_filters=64, filter_size=(3,3), stride=(1,1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify); Ws[f] = output.W; bs[f] = output.b; f = f+1 ## mid output = ConvLayer(output, num_filters=128, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 hidden = ConvLayer(hidden_state, num_filters=128, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = hidden.W bs[f] = hidden.b f = f + 1 hidden = ConvLayer(hidden, num_filters=128, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = hidden.W bs[f] = hidden.b f = f + 1 output = ElemwiseSumLayer([output, hidden]) hidden_state = output ## decoder # output = ConvLayer(output, num_filters=64, filter_size=(3,3), stride=(1,1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify); Ws[f] = output.W; bs[f] = output.b; f = f+1 output = ConvLayer(output, num_filters=128, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 output = Upscale2DLayer(output, scale_factor=2) output = ConvLayer(output, num_filters=64, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 output = ConvLayer(output, num_filters=128, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 # output = ConvLayer(output, num_filters=128, filter_size=(1,1), stride=(1,1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify); Ws[f] = output.W; bs[f] = output.b; f = f+1 ## filter-generating layers l_filter = ConvLayer(output, num_filters=filter_size**2 + self.dynamic_bias, filter_size=(1, 1), stride=(1, 1), pad=(0, 0), W=Ws[f], b=bs[f], nonlinearity=identity) Ws[f] = l_filter.W bs[f] = l_filter.b f = f + 1 ######################### # transformer network # ######################### ## get inputs output = SliceLayer( input, indices=slice(self.nInputs - 1, self.nInputs), axis=1) # select the last (most recent) frame from the inputs ## add a bias if self.dynamic_bias: filters_biases = SliceLayer(l_filter, indices=slice(filter_size**2, filter_size**2 + 1), axis=1) output = ConcatLayer([output, filters_biases]) output = FeaturePoolLayer(output, pool_size=2, pool_function=theano.tensor.sum) ## dynamic convolution filters = SliceLayer(l_filter, indices=slice(0, filter_size**2), axis=1) # filters = FeaturePoolLayer(filters, pool_size=9*9, pool_function=theano.tensor.nnet.softmax) filters = DimshuffleLayer(filters, (0, 2, 3, 1)) filters = ReshapeLayer(filters, shape=(-1, filter_size**2)) filters = NonlinearityLayer(filters, nonlinearity=softmax) filters = ReshapeLayer(filters, shape=(-1, npx, npx, filter_size**2)) filters = DimshuffleLayer(filters, (0, 3, 1, 2)) output_dynconv = DynamicFilterLayer([output, filters], filter_size=(filter_size, filter_size, 1), pad=(filter_size // 2, filter_size // 2)) ######################## # refinement network # ######################## if self.refinement_network: output = ConcatLayer([output_dynconv, input]) output = ConvLayer(output, num_filters=32, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 output = ConvLayer(output, num_filters=64, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 output = ConvLayer(output, num_filters=32, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 output = ConvLayer(output, num_filters=1, filter_size=(3, 3), stride=(1, 1), pad='same', W=Ws[f], b=bs[f], nonlinearity=leaky_rectify) Ws[f] = output.W bs[f] = output.b f = f + 1 output = ElemwiseSumLayer([output_dynconv, output ]) # this is a residual connection else: output = output_dynconv return output, hidden_state, filters
def build_model(width=512, height=512, filename=None, n_classes=5, batch_size=None, p_conv=0.0): """Setup network structure for the original formulation of JeffreyDF's network and optionally load pretrained weights Parameters ---------- width : Optional[int] image width height : Optional[int] image height filename : Optional[str] if filename is not None, weights are loaded from filename n_classes : Optional[int] default 5 for transfer learning on Kaggle DR data batch_size : should only be set if all batches have the same size! p_conv: dropout applied to conv. layers, by default turned off (0.0) Returns ------- dict one lasagne layer per key Notes ----- Reference: Jeffrey De Fauw, 2015: http://jeffreydf.github.io/diabetic-retinopathy-detection/ Download pretrained weights from: https://github.com/JeffreyDF/kaggle_diabetic_retinopathy/blob/ master/dumps/2015_07_17_123003_PARAMSDUMP.pkl original net has leaky rectifier units """ net = OrderedDict() net['0'] = InputLayer((batch_size, 3, width, height), name='images') net['1'] = ConvLayer(net['0'], 32, 7, stride=(2, 2), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['1d'] = DropoutLayer(net['1'], p=p_conv) net['2'] = MaxPool2DLayer(net['1d'], 3, stride=(2, 2)) net['3'] = ConvLayer(net['2'], 32, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['3d'] = DropoutLayer(net['3'], p=p_conv) net['4'] = ConvLayer(net['3d'], 32, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['4d'] = DropoutLayer(net['4'], p=p_conv) net['5'] = MaxPool2DLayer(net['4d'], 3, stride=(2, 2)) net['6'] = ConvLayer(net['5'], 64, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['6d'] = DropoutLayer(net['6'], p=p_conv) net['7'] = ConvLayer(net['6d'], 64, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['7d'] = DropoutLayer(net['7'], p=p_conv) net['8'] = MaxPool2DLayer(net['7d'], 3, stride=(2, 2)) net['9'] = ConvLayer(net['8'], 128, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['9d'] = DropoutLayer(net['9'], p=p_conv) net['10'] = ConvLayer(net['9d'], 128, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['10d'] = DropoutLayer(net['10'], p=p_conv) net['11'] = ConvLayer(net['10d'], 128, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['11d'] = DropoutLayer(net['11'], p=p_conv) net['12'] = ConvLayer(net['11d'], 128, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['12d'] = DropoutLayer(net['12'], p=p_conv) net['13'] = MaxPool2DLayer(net['12d'], 3, stride=(2, 2)) net['14'] = ConvLayer(net['13'], 256, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['14d'] = DropoutLayer(net['14'], p=p_conv) net['15'] = ConvLayer(net['14d'], 256, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['15d'] = DropoutLayer(net['15'], p=p_conv) net['16'] = ConvLayer(net['15'], 256, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['16d'] = DropoutLayer(net['16'], p=p_conv) net['17'] = ConvLayer(net['16d'], 256, 3, stride=(1, 1), pad='same', untie_biases=True, nonlinearity=LeakyRectify(leakiness=0.5), W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) net['17d'] = DropoutLayer(net['17'], p=p_conv) net['18'] = MaxPool2DLayer(net['17d'], 3, stride=(2, 2), name='coarse_last_pool') net['19'] = DropoutLayer(net['18'], p=0.5) net['20'] = DenseLayer(net['19'], num_units=1024, nonlinearity=None, W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1), name='first_fc_0') net['21'] = FeaturePoolLayer(net['20'], 2) net['22'] = InputLayer((batch_size, 2), name='imgdim') net['23'] = ConcatLayer([net['21'], net['22']]) # Combine representations of both eyes net['24'] = ReshapeLayer(net['23'], (-1, net['23'].output_shape[1] * 2)) net['25'] = DropoutLayer(net['24'], p=0.5) net['26'] = DenseLayer(net['25'], num_units=1024, nonlinearity=None, W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1), name='combine_repr_fc') net['27'] = FeaturePoolLayer(net['26'], 2) net['28'] = DropoutLayer(net['27'], p=0.5) net['29'] = DenseLayer(net['28'], num_units=n_classes * 2, nonlinearity=None, W=lasagne.init.Orthogonal(1.0), b=lasagne.init.Constant(0.1)) # Reshape back to the number of desired classes net['30'] = ReshapeLayer(net['29'], (-1, n_classes)) net['31'] = NonlinearityLayer(net['30'], nonlinearity=softmax) if filename is not None: with open(filename, 'r') as f: weights = pickle.load(f) set_all_param_values(net['31'], weights) return net
def add_dense_maxout_block(self, network, num_nodes=240, dropout=0.5): network = lasagne.layers.DropoutLayer(network, p=self.dropout) network = DenseLayer(network,nonlinearity=rectify,num_units=self.num_nodes) maxout = FeaturePoolLayer(incoming=network, pool_size=2,axis=1, pool_function=theano.tensor.max) return ConcatLayer([network, maxout], axis=1)