def __init__(self, input_shape, output_dim, hidden_sizes, conv_filters, conv_filter_sizes, conv_strides, conv_pads, hidden_W_init=LI.GlorotUniform(), hidden_b_init=LI.Constant(0.), output_W_init=LI.GlorotUniform(), output_b_init=LI.Constant(0.), # conv_W_init=LI.GlorotUniform(), conv_b_init=LI.Constant(0.), hidden_nonlinearity=LN.rectify, output_nonlinearity=LN.softmax, name=None, input_var=None): if name is None: prefix = "" else: prefix = name + "_" if len(input_shape) == 3: l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var) l_hid = L.reshape(l_in, ([0],) + input_shape) elif len(input_shape) == 2: l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var) input_shape = (1,) + input_shape l_hid = L.reshape(l_in, ([0],) + input_shape) else: l_in = L.InputLayer(shape=(None,) + input_shape, input_var=input_var) l_hid = l_in for idx, conv_filter, filter_size, stride, pad in izip( xrange(len(conv_filters)), conv_filters, conv_filter_sizes, conv_strides, conv_pads, ): l_hid = L.Conv2DLayer( l_hid, num_filters=conv_filter, filter_size=filter_size, stride=(stride, stride), pad=pad, nonlinearity=hidden_nonlinearity, name="%sconv_hidden_%d" % (prefix, idx), convolution=wrapped_conv, ) for idx, hidden_size in enumerate(hidden_sizes): l_hid = L.DenseLayer( l_hid, num_units=hidden_size, nonlinearity=hidden_nonlinearity, name="%shidden_%d" % (prefix, idx), W=hidden_W_init, b=hidden_b_init, ) l_out = L.DenseLayer( l_hid, num_units=output_dim, nonlinearity=output_nonlinearity, name="%soutput" % (prefix,), W=output_W_init, b=output_b_init, ) self._l_in = l_in self._l_out = l_out self._input_var = l_in.input_var
def build_model(): ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, ( -1, 1, ) + data_sizes["sliced:data:ax"][-2:]) # first do the segmentation steps l1a = ConvLayer( l0r, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b = ConvLayer( l1a, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1c = ConvLayer( l1b, num_filters=64, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1f = ConvLayer(l1c, num_filters=1, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.sigmoid) l_1r = reshape(l1f, data_sizes["sliced:data:ax"]) l_d3 = lasagne.layers.DenseLayer(l_1r, num_units=2) l_systole = MuLogSigmaErfLayer(l_d3) l_d3b = lasagne.layers.DenseLayer(l_1r, num_units=2) l_diastole = MuLogSigmaErfLayer(l_d3b) return { "inputs": { "sliced:data:ax": l0, }, "outputs": { "systole": l_systole, "diastole": l_diastole } }
def build_cnn(): data_size = (None, 10, 100) # Batch size x Img Channels x Height x Width input_var = T.tensor3(name="input", dtype='int64') values = np.array(np.random.randint(0, 1, (5, 10, 100))) input_var.tag.test_value = values input_layer = L.InputLayer(data_size, input_var=input_var) W = create_char_embedding_matrix() embed_layer = L.EmbeddingLayer(input_layer, input_size=102, output_size=101, W=W) reshape = L.reshape(embed_layer, (-1, 100, 101)) dim_shuffle = L.dimshuffle(reshape, (0, 2, 1)) #conv_layer_1 = L.Conv2DLayer(embed_layer, 4, (1), 1, 0) #pool_layer_1 = L.MaxPool1DLayer(conv_layer_1, pool_size=1) print L.get_output(dim_shuffle).tag.test_value.shape conv_layer_1 = L.Conv1DLayer(dim_shuffle, 50, 2, 1) print L.get_output(conv_layer_1).tag.test_value.shape print "TEST" pool_layer_1 = L.MaxPool1DLayer(conv_layer_1, pool_size=99) print L.get_output(pool_layer_1).tag.test_value.shape reshape_conv_1 = L.reshape(pool_layer_1, (-1, 50)) conv_layer_2 = L.Conv1DLayer(dim_shuffle, 50, 3, 1) pool_layer_2 = L.MaxPool1DLayer(conv_layer_2, pool_size=98) reshape_conv_2 = L.reshape(pool_layer_2, (-1, 50)) merge_layer = L.ConcatLayer([reshape_conv_1, reshape_conv_2], 1) print L.get_output(merge_layer).tag.test_value.shape reshape_output = L.reshape(merge_layer, (-1, 10, 100)) print L.get_output(reshape_output).tag.test_value.shape x = T.tensor3(name="testname", dtype='int32') #x = T.imatrix() #output = L.get_output(conv_layer_1,x) #f = theano.function([x],output) word = unicode("Tat") word_index = np.array([]) #print word_index #x_test = np.array([word_index]).astype('int32') #print f(x_test) return reshape_output
def _remove_all_first_tokens(input_layer, unflatten_sequences_shape, flatten_input=True): """ Helper function that creates a sequence of layers to clean up the tensor from all elements, corresponding to the first token in the sequence """ new_flattened_shape = (unflatten_sequences_shape[0] * (unflatten_sequences_shape[1] - 1),) \ + unflatten_sequences_shape[2:] sliced = SliceLayer( incoming=reshape(input_layer, unflatten_sequences_shape) if flatten_input else input_layer, indices=slice(1, None), axis=1) # sequence axis return reshape(sliced, new_flattened_shape)
def build_model(): ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, (-1, 1, ) + data_sizes["sliced:data:ax"][-2:]) # first do the segmentation steps l1a = ConvLayer(l0r, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b = ConvLayer(l1a, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1c = ConvLayer(l1b, num_filters=64, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1f = ConvLayer(l1c, num_filters=1, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.sigmoid) l_1r = reshape(l1f, data_sizes["sliced:data:ax"]) l_d3 = lasagne.layers.DenseLayer(l_1r, num_units=2, nonlinearity=lasagne.nonlinearities.identity) l_systole = MuLogSigmaErfLayer(l_d3) l_d3b = lasagne.layers.DenseLayer(l_1r, num_units=2, nonlinearity=lasagne.nonlinearities.identity) l_diastole = MuLogSigmaErfLayer(l_d3b) return { "inputs":{ "sliced:data:ax": l0 }, "outputs":{ "systole": l_systole, "diastole": l_diastole } }
def build_cnn(input): #data_size = (None,103,130) # Batch size x Img Channels x Height x Width #input_var = T.tensor3(name = "input",dtype='int64') input_var = input #values = np.array(np.random.randint(0,102,(1,9,50))) #input_var.tag.test_value = values #number sentences x words x characters input_layer = L.InputLayer((None,9,50), input_var=input) W = create_char_embedding_matrix() embed_layer = L.EmbeddingLayer(input_layer, input_size=103,output_size=101, W=W) #print "EMBED", L.get_output(embed_layer).tag.test_value.shape reshape_embed = L.reshape(embed_layer,(-1,50,101)) #print "reshap embed", L.get_output(reshape_embed).tag.test_value.shape conv_layer_1 = L.Conv1DLayer(reshape_embed, 55, 2) conv_layer_2 = L.Conv1DLayer(reshape_embed, 55, 3) #print "TEST" #print "Convolution Layer 1", L.get_output(conv_layer_1).tag.test_value.shape #print "Convolution Layer 2", L.get_output(conv_layer_2).tag.test_value.shape #flatten_conv_1 = L.flatten(conv_layer_1,3) #flatten_conv_2 = L.flatten(conv_layer_2,3) #reshape_max_1 = L.reshape(flatten_conv_1,(-1,49)) #reshape_max_2 = L.reshape(flatten_conv_2, (-1,48)) #print "OUTPUT Flatten1", L.get_output(flatten_conv_1).tag.test_value.shape #print "OUTPUT Flatten2", L.get_output(flatten_conv_2).tag.test_value.shape #print "OUTPUT reshape_max_1", L.get_output(reshape_max_1).tag.test_value.shape #print "OUTPUT reshape_max_2", L.get_output(reshape_max_2).tag.test_value.shape pool_layer_1 = L.MaxPool1DLayer(conv_layer_1, pool_size=54) pool_layer_2 = L.MaxPool1DLayer(conv_layer_2, pool_size=53) #print "OUTPUT POOL1", L.get_output(pool_layer_1).tag.test_value.shape #print "OUTPUT POOL2",L.get_output(pool_layer_2).tag.test_value.shape merge_layer = L.ConcatLayer([pool_layer_1, pool_layer_2], 1) flatten_merge = L.flatten(merge_layer, 2) reshape_merge = L.reshape(flatten_merge, (1,9,110)) print L.get_output(reshape_embed).shape #print L.get_output(reshape_merge).tag.test_value.shape return reshape_merge, char_index_lookup
def build_net(nz=10): # nz = size of latent code #N.B. using batch_norm applies bn before non-linearity! F = 32 enc = InputLayer(shape=(None, 1, 28, 28)) enc = Conv2DLayer(incoming=enc, num_filters=F * 2, filter_size=5, stride=2, nonlinearity=lrelu(0.2), pad=2) enc = Conv2DLayer(incoming=enc, num_filters=F * 4, filter_size=5, stride=2, nonlinearity=lrelu(0.2), pad=2) enc = Conv2DLayer(incoming=enc, num_filters=F * 4, filter_size=5, stride=1, nonlinearity=lrelu(0.2), pad=2) enc = reshape(incoming=enc, shape=(-1, F * 4 * 7 * 7)) enc = DenseLayer(incoming=enc, num_units=nz, nonlinearity=sigmoid) #Generator networks dec = InputLayer(shape=(None, nz)) dec = DenseLayer(incoming=dec, num_units=F * 4 * 7 * 7) dec = reshape(incoming=dec, shape=(-1, F * 4, 7, 7)) dec = Deconv2DLayer(incoming=dec, num_filters=F * 4, filter_size=4, stride=2, nonlinearity=relu, crop=1) dec = Deconv2DLayer(incoming=dec, num_filters=F * 4, filter_size=4, stride=2, nonlinearity=relu, crop=1) dec = Deconv2DLayer(incoming=dec, num_filters=1, filter_size=3, stride=1, nonlinearity=sigmoid, crop=1) return enc, dec
def _add_context_encoder(self): self._net['batched_enc'] = reshape( self._net['enc'], (self._batch_size, self._input_context_size, get_output_shape(self._net['enc'])[-1])) self._net['context_enc'] = GRULayer(incoming=self._net['batched_enc'], num_units=self._hidden_layer_dim, grad_clipping=self._grad_clip, only_return_final=True, name='context_encoder') self._net['switch_enc_to_tv'] = T.iscalar(name='switch_enc_to_tv') self._net['thought_vector'] = InputLayer( shape=(None, self._hidden_layer_dim), input_var=T.fmatrix(name='thought_vector'), name='thought_vector') self._net['enc_result'] = SwitchLayer( incomings=[self._net['thought_vector'], self._net['context_enc']], condition=self._net['switch_enc_to_tv']) # We need the following to pass as 'givens' argument when compiling theano functions: self._default_thoughts_vector = T.zeros( (self._batch_size, self._hidden_layer_dim)) self._default_input_x = T.zeros( shape=(self._net['thought_vector'].input_var.shape[0], 1, 1), dtype=np.int32)
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 make_broadcasted_heads(incoming,head_size,name=None): ndim = len(incoming.output_shape) assert ndim in (2,3), "incoming must be 2-dimensional (query) or 3-dimensional (key or value)" heads = DenseLayer(incoming,head_size*num_heads,nonlinearity=None, num_leading_axes=ndim-1,name=name) #[batch,time,head_size*num_heads] if ndim == 3: heads = reshape(heads,([0],[1],head_size,num_heads), name=name) #[batch,time,head_size,num_heads] broadcasted_heads = BroadcastLayer(heads, (0, 3), name=name) #[batch*heads,time,head_size] else: #ndim == 2 heads = reshape(heads, ([0], head_size, num_heads), name=name) # [batch,head_size,num_heads] broadcasted_heads = BroadcastLayer(heads, (0, 2), name=name) # [batch*heads, head_size] return broadcasted_heads
def build_sequence_summarizing_layer(input_var, input_layer, num_units, num_layers, output_dim): # input_layer: n_batch, n_time_steps, n_feat n_batch, n_time_steps, _ = input_var.shape # n_batch, n_feat prev_layer = reshape(input_layer, (-1, [2])) for i in range(num_layers): prev_layer = DenseLayer(prev_layer, num_units=num_units, nonlinearity=nonlinearities.tanh) dense_layer = DenseLayer(prev_layer, num_units=output_dim, nonlinearity=nonlinearities.identity) return SummarizingLayer( reshape(dense_layer, (n_batch, n_time_steps, output_dim)))
def score_fused_convnets(self, fusion_type, input_var1=None, input_var2=None, weights_dir_depth=None, weights_dir_rgb=None, bottleneck_W=None, weights_dir=None): net = OrderedDict() rgb_net = self.simple_convnet(4, input_var=input_var1, bottleneck_W=bottleneck_W) depth_net = self.simple_convnet(1, input_var=input_var2, bottleneck_W=bottleneck_W) if weights_dir_depth is not None and weights_dir_rgb is not None: lw_depth = LoadWeights(weights_dir_depth, depth_net) lw_depth.load_weights_numpy() lw_rgb = LoadWeights(weights_dir_rgb, rgb_net) lw_rgb.load_weights_numpy() if fusion_type == self.LOCAL: net['reshape_depth'] = reshape(depth_net['output'], ([0], 1, 1, [1])) net['reshape_rgb'] = reshape(rgb_net['output'], ([0], 1, 1, [1])) net['concat'] = concat([net['reshape_depth'], net['reshape_rgb']]) net['lcl'] = LocallyConnected2DLayer(net['concat'], 1, (1, 1), untie_biases=True, nonlinearity=None) net['output'] = reshape(net['lcl'], ([0], [3])) elif fusion_type == self.SUM: net['output'] = ElemwiseSumLayer( [depth_net['output'], rgb_net['output']], coeffs=0.5) if weights_dir is not None: lw = LoadWeights(weights_dir, net) lw.load_weights_numpy() return net
def build_network(W, number_unique_tags, longest_word, longest_sentence, input_var=None): print("Building network ...") input_layer = L.InputLayer((None, longest_sentence, longest_word), input_var=input_var) embed_layer = L.EmbeddingLayer(input_layer, input_size=103, output_size=101, W=W) reshape_embed = L.reshape(embed_layer, (-1, longest_word, 101)) conv_layer_1 = L.Conv1DLayer(reshape_embed, longest_word, 2) conv_layer_2 = L.Conv1DLayer(reshape_embed, longest_word, 3) pool_layer_1 = L.MaxPool1DLayer(conv_layer_1, pool_size=longest_word - 1) pool_layer_2 = L.MaxPool1DLayer(conv_layer_2, pool_size=longest_word - 2) merge_layer = L.ConcatLayer([pool_layer_1, pool_layer_2], 1) flatten_merge = L.flatten(merge_layer, 2) reshape_merge = L.reshape(flatten_merge, (-1, longest_sentence, int(longest_word * 2))) l_re = lasagne.layers.RecurrentLayer( reshape_merge, N_HIDDEN, nonlinearity=lasagne.nonlinearities.sigmoid, mask_input=None) l_out = lasagne.layers.DenseLayer( l_re, number_unique_tags, nonlinearity=lasagne.nonlinearities.softmax) print "DONE BUILDING NETWORK" return l_out
def __init__(self, input_shape, output_dim, servoing_pol, name=None, input_var=None): if name is None: prefix = "" else: prefix = name + "_" if len(input_shape) == 3: l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var) l_hid = L.reshape(l_in, ([0],) + input_shape) elif len(input_shape) == 2: l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var) input_shape = (1,) + input_shape l_hid = L.reshape(l_in, ([0],) + input_shape) else: l_in = L.InputLayer(shape=(None,) + input_shape, input_var=input_var) l_hid = l_in l_out = TheanoServoingPolicyLayer(l_hid, servoing_pol) self._l_in = l_in self._l_out = l_out self._input_var = l_in.input_var
def _add_word_embeddings(self): self._net['input_x'] = InputLayer(shape=(None, None, None), input_var=T.itensor3(name='input_x'), name='input_x') self._net['input_y'] = InputLayer(shape=(None, None), input_var=T.imatrix(name='input_y'), name='input_y') # Infer these variables from data passed to computation graph since batch shape may differ in training and # prediction phases self._batch_size = self._net['input_x'].input_var.shape[0] self._input_context_size = self._net['input_x'].input_var.shape[1] self._input_seq_len = self._net['input_x'].input_var.shape[2] self._output_seq_len = self._net['input_y'].input_var.shape[1] self._net['input_x_batched'] = \ reshape(self._net['input_x'], (self._batch_size * self._input_context_size, self._input_seq_len)) self._net['input_x_mask'] = NotEqualMaskLayer( incoming=self._net['input_x_batched'], x=self._skip_token_id, name='mask_x') self._net['emb_x'] = EmbeddingLayer( incoming=self._net['input_x_batched'], input_size=self._vocab_size, output_size=self._word_embedding_dim, W=self._W_init_embedding, name='emb_x') # output shape (batch_size, input_context_size, input_seq_len, embedding_dimension) self._net['input_y_mask'] = NotEqualMaskLayer( incoming=self._net['input_y'], x=self._skip_token_id, name='mask_y') self._net['emb_y'] = EmbeddingLayer( incoming=self._net['input_y'], input_size=self._vocab_size, output_size=self._word_embedding_dim, W=self._W_init_embedding, name='emb_y') # output shape (batch_size, output_seq_len, embedding_dimension) if not self._train_word_embedding: self._net['emb_x'].params[self._net['emb_x'].W].remove('trainable') self._net['emb_y'].params[self._net['emb_y'].W].remove('trainable')
def get_input_layer(self, input_vars, recurrent_length=0, cell_size=20, context_len=1, id=None): id_tag = (id + '/') if id else '' (input_var,) = input_vars shape = ((None, context_len * len(self.buckets)) if recurrent_length == 0 else (None, recurrent_length, context_len * len(self.buckets))) l_color = InputLayer(shape=shape, input_var=input_var, name=id_tag + 'color_input') l_color_embed = EmbeddingLayer(l_color, input_size=sum(b.num_types for b in self.buckets), output_size=cell_size, name=id_tag + 'color_embed') dims = (([0], -1) if recurrent_length == 0 else ([0], [1], -1)) l_color_flattened = reshape(l_color_embed, dims) return l_color_flattened, [l_color]
def _add_word_embeddings(self): self._net['input_x'] = InputLayer(shape=(None, None, None), input_var=T.itensor3(name='input_x'), name='input_x') self._net['input_y'] = InputLayer(shape=(None, None), input_var=T.imatrix(name='input_y'), name='input_y') # These are theano variables and they are computed dynamically as data is passed into the computational graph self._batch_size = self._net['input_x'].input_var.shape[0] self._input_context_size = self._net['input_x'].input_var.shape[1] self._input_seq_len = self._net['input_x'].input_var.shape[2] self._output_seq_len = self._net['input_y'].input_var.shape[1] self._net['input_x_batched'] = \ reshape(self._net['input_x'], (self._batch_size * self._input_context_size, self._input_seq_len)) self._net['input_x_mask'] = NotEqualMaskLayer( incoming=self._net['input_x_batched'], x=self._skip_token_id, name='mask_x') self._net['emb_x'] = EmbeddingLayer( incoming=self._net['input_x_batched'], input_size=self._vocab_size, output_size=self._word_embedding_dim, W=self._W_init_embedding, name='emb_x') # output shape (batch_size, input_context_size, input_seq_len, embedding_dimension) self._net['input_y_mask'] = NotEqualMaskLayer( incoming=self._net['input_y'], x=self._skip_token_id, name='mask_y') self._net['emb_y'] = EmbeddingLayer( incoming=self._net['input_y'], input_size=self._vocab_size, output_size=self._word_embedding_dim, W=self._W_init_embedding, name='emb_y') # output shape (batch_size, output_seq_len, embedding_dimension) if not self._train_word_embedding: self._net['emb_x'].params[self._net['emb_x'].W].remove('trainable') self._net['emb_y'].params[self._net['emb_y'].W].remove('trainable')
def get_input_layer(self, input_vars, recurrent_length=0, cell_size=20, context_len=1, id=None): id_tag = (id + '/') if id else '' (input_var,) = input_vars input_shape = ((None, context_len) if recurrent_length == 0 else (None, recurrent_length, context_len)) l_color = InputLayer(shape=input_shape, input_var=input_var, name=id_tag + 'color_input') l_color_embed = EmbeddingLayer(l_color, input_size=self.num_types, output_size=cell_size, name=id_tag + 'color_embed') output_shape = (([0], context_len * cell_size) if recurrent_length == 0 else ([0], recurrent_length, context_len * cell_size)) l_color_shape = reshape(l_color_embed, output_shape, name=id_tag + 'color_embed_flattened') return l_color_shape, [l_color]
def get_input_layer(self, input_vars, recurrent_length=0, cell_size=20, context_len=1, id=None): id_tag = (id + '/') if id else '' (input_var,) = input_vars context_repr_size = None if context_len is None else len(self.buckets) * context_len shape = ((None, context_repr_size) if recurrent_length == 0 else (None, recurrent_length, context_repr_size)) l_color = InputLayer(shape=shape, input_var=input_var, name=id_tag + 'color_input') l_color_embed = EmbeddingLayer(l_color, input_size=sum(b.num_types for b in self.buckets), output_size=cell_size, name=id_tag + 'color_embed') dims = (([0], -1) if recurrent_length == 0 else ([0], [1], -1)) l_color_flattened = reshape(l_color_embed, dims) return l_color_flattened, [l_color]
def get_input_layer(self, input_vars, recurrent_length=0, cell_size=20, context_len=1, id=None): id_tag = (id + '/') if id else '' (input_var,) = input_vars input_shape = ((None, context_len) if recurrent_length == 0 else (None, recurrent_length, context_len)) l_color = InputLayer(shape=input_shape, input_var=input_var, name=id_tag + 'color_input') l_color_embed = EmbeddingLayer(l_color, input_size=self.num_types, output_size=cell_size, name=id_tag + 'color_embed') context_repr_size = -1 if context_len is None else context_len * cell_size output_shape = (([0], context_repr_size) if recurrent_length == 0 else ([0], recurrent_length, context_repr_size)) l_color_shape = reshape(l_color_embed, output_shape, name=id_tag + 'color_embed_flattened') return l_color_shape, [l_color]
def _add_output_dense(self): """ Adds a dense layer on top of the decoder to convert hidden_state vector to probs distribution over vocabulary. For every prob sequence last prob vectors are cut off since they correspond to the tokens that go after EOS_TOKEN and we are not interested in them. Doesn't need to reshape back the cut tensor since it's convenient to compare this "long" output with true one-hot vectors. """ self._net['dec_dropout'] = DropoutLayer(incoming=reshape( self._net['dec'], (-1, self._hidden_layer_dim)), p=self._dense_dropout_ratio, name='decoder_dropout_layer') self._net['target'] = self._remove_all_first_tokens( self._net['input_y'], unflatten_sequences_shape=(self._batch_size, self._output_seq_len), flatten_input=False) self._net['dec_dropout_nolast'] = self._remove_all_last_tokens( self._net['dec_dropout'], unflatten_sequences_shape=(self._batch_size, self._output_seq_len, self._hidden_layer_dim)) self._net['dist_nolast'] = DenseLayer( incoming=self._net['dec_dropout_nolast'], num_units=self._vocab_size, nonlinearity=lasagne.nonlinearities.softmax, name='dense_output_probs') dist_layer_params = get_all_params(self._net['dist_nolast']) param_name_to_param = {p.name: p for p in dist_layer_params} self._net['dist'] = DenseLayer( incoming=self._net['dec_dropout'], num_units=self._vocab_size, nonlinearity=lasagne.nonlinearities.softmax, W=param_name_to_param['dense_output_probs.W'], b=param_name_to_param['dense_output_probs.b'], name='dense_output_probs')
def build_model(): ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, (-1, 1, ) + data_sizes["sliced:data:ax"][1:]) # (batch, channel, time, axis, x, y) # convolve over time l1 = ConvolutionOverAxisLayer(l0r, num_filters=2, filter_size=(5,), axis=(2,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1m = MaxPoolOverAxisLayer(l1, pool_size=(2,), axis=(2,)) # convolve over x and y l2a = ConvolutionOver2DAxisLayer(l1m, num_filters=32, filter_size=(5, 5), stride=(2,2), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l2b = ConvolutionOver2DAxisLayer(l2a, num_filters=32, filter_size=(5, 5), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l2m = MaxPoolOver2DAxisLayer(l2b, pool_size=(3, 3), axis=(4,5)) # convolve over x, y and axis l3a = ConvolutionOver3DAxisLayer(l2m, num_filters=32, filter_size=(3, 3, 3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l3b = ConvolutionOver3DAxisLayer(l3a, num_filters=32, filter_size=(3, 3, 3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l3m = MaxPoolOver3DAxisLayer(l3b, pool_size=(2, 2, 2), axis=(3,4,5)) # convolve over time l4 = ConvolutionOverAxisLayer(l3m, num_filters=32, filter_size=(5,), axis=(2,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l4m = MaxPoolOverAxisLayer(l4, pool_size=(2,), axis=(2,)) # convolve over axis l5 = ConvolutionOverAxisLayer(l4m, num_filters=32, filter_size=(3,), axis=(3,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) """ l_d3 = lasagne.layers.DenseLayer(l3m, num_units=2, nonlinearity=lasagne.nonlinearities.identity) l_systole = MuLogSigmaErfLayer(l_d3) l_d3b = lasagne.layers.DenseLayer(l3m, num_units=2, nonlinearity=lasagne.nonlinearities.identity) l_diastole = MuLogSigmaErfLayer(l_d3b) """ l_d3 = lasagne.layers.DenseLayer(l5, num_units=600, nonlinearity=lasagne.nonlinearities.softmax) l_systole = CumSumLayer(l_d3) l_d3b = lasagne.layers.DenseLayer(l5, num_units=600, nonlinearity=lasagne.nonlinearities.softmax) l_diastole = CumSumLayer(l_d3b) return { "inputs":{ "sliced:data:ax": l0 }, "outputs":{ "systole": l_systole, "diastole": l_diastole } }
def get_char2word(self, ic, avg=False): suf = '_avg' if avg else '' ec = L.EmbeddingLayer( ic, self.args.vc, self.args.nc, name='ec' + suf, W=HeNormal() if not avg else Constant()) # (100, 24, 32, 16) ec.params[ec.W].remove('regularizable') if self.args.char_model == 'CNN': lds = L.dimshuffle(ec, (0, 3, 1, 2)) # (100, 16, 24, 32) ls = [] for n in self.args.ngrams: lconv = L.Conv2DLayer( lds, self.args.nf, (1, n), untie_biases=True, W=HeNormal('relu') if not avg else Constant(), name='conv_%d' % n + suf) # (100, 64/4, 24, 32-n+1) lpool = L.MaxPool2DLayer( lconv, (1, self.args.max_len - n + 1)) # (100, 64, 24, 1) lpool = L.flatten(lpool, outdim=3) # (100, 16, 24) lpool = L.dimshuffle(lpool, (0, 2, 1)) # (100, 24, 16) ls.append(lpool) xc = L.concat(ls, axis=2) # (100, 24, 64) return xc elif self.args.char_model == 'LSTM': ml = L.ExpressionLayer( ic, lambda x: T.neq(x, 0)) # mask layer (100, 24, 32) ml = L.reshape(ml, (-1, self.args.max_len)) # (2400, 32) gate_params = L.recurrent.Gate(W_in=Orthogonal(), W_hid=Orthogonal()) cell_params = L.recurrent.Gate(W_in=Orthogonal(), W_hid=Orthogonal(), W_cell=None, nonlinearity=tanh) lstm_in = L.reshape( ec, (-1, self.args.max_len, self.args.nc)) # (2400, 32, 16) lstm_f = L.LSTMLayer( lstm_in, self.args.nw / 2, mask_input=ml, grad_clipping=10., learn_init=True, peepholes=False, precompute_input=True, ingate=gate_params, forgetgate=gate_params, cell=cell_params, outgate=gate_params, # unroll_scan=True, only_return_final=True, name='forward' + suf) # (2400, 64) lstm_b = L.LSTMLayer( lstm_in, self.args.nw / 2, mask_input=ml, grad_clipping=10., learn_init=True, peepholes=False, precompute_input=True, ingate=gate_params, forgetgate=gate_params, cell=cell_params, outgate=gate_params, # unroll_scan=True, only_return_final=True, backwards=True, name='backward' + suf) # (2400, 64) remove_reg(lstm_f) remove_reg(lstm_b) if avg: set_zero(lstm_f) set_zero(lstm_b) xc = L.concat([lstm_f, lstm_b], axis=1) # (2400, 128) xc = L.reshape(xc, (-1, self.args.sw, self.args.nw)) # (100, 24, 256) return xc
def build_model(input_layer = None): ################# # Regular model # ################# l_4ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:4ch"]) l_2ch = nn.layers.InputLayer(data_sizes["sliced:data:chanzoom:2ch"]) # l_4chr = reshape(l_4ch, (-1, 1, ) + l_4ch.output_shape[1:]) l_2chr = reshape(l_2ch, (-1, 1, ) + l_2ch.output_shape[1:]) # batch, features, timesteps, width, height l_4ch_2a = deep_learning_layers.ConvolutionOver2DAxisLayer(l_4chr, num_filters=16, filter_size=(3, 3), axis=(3,4), channel=1, pad=(1,1), W=nn.init.Orthogonal(), b=nn.init.Constant(0.0), ) l_4ch_2b = deep_learning_layers.ConvolutionOver2DAxisLayer(l_4ch_2a, num_filters=16, filter_size=(3, 3), axis=(3,4), channel=1, pad=(1,1), W=nn.init.Orthogonal(), b=nn.init.Constant(0.0), ) l_4ch_2m = deep_learning_layers.MaxPoolOverAxisLayer(l_4ch_2b, pool_size=(2,), axis=(4,)) l_4ch_2r = nn.layers.DimshuffleLayer(l_4ch_2m, (0,2,3,1,4)) l_4ch_2r = reshape(l_4ch_2r, (-1, ) + l_4ch_2m.output_shape[1:2] + l_4ch_2m.output_shape[-1:]) l_4ch_d1 = nn.layers.DenseLayer(l_4ch_2r, num_units=64, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) l_4ch_d2 = nn.layers.DenseLayer(l_4ch_d1, num_units=64, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) l_4ch_mu = nn.layers.DenseLayer(l_4ch_d2, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) l_4ch_sigma = nn.layers.DenseLayer(l_4ch_d2, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) l_4ch_mu = reshape(l_4ch_mu, (-1, ) + l_4ch.output_shape[-3:-1]) l_4ch_sigma = reshape(l_4ch_sigma, (-1, ) + l_4ch.output_shape[-3:-1]) l_2ch_2a = deep_learning_layers.ConvolutionOver2DAxisLayer(l_2chr, num_filters=16, filter_size=(3, 3), axis=(3,4), channel=1, pad=(1,1), W=nn.init.Orthogonal(), b=nn.init.Constant(0.0), ) l_2ch_2b = deep_learning_layers.ConvolutionOver2DAxisLayer(l_2ch_2a, num_filters=16, filter_size=(3, 3), axis=(3,4), channel=1, pad=(1,1), W=nn.init.Orthogonal(), b=nn.init.Constant(0.0), ) l_2ch_2m = deep_learning_layers.MaxPoolOverAxisLayer(l_2ch_2b, pool_size=(2,), axis=(4,)) l_2ch_2r = nn.layers.DimshuffleLayer(l_2ch_2m, (0,2,3,1,4)) l_2ch_2r = reshape(l_2ch_2r, (-1, ) + l_2ch_2m.output_shape[1:2] + l_2ch_2m.output_shape[-1:]) l_2ch_d1 = nn.layers.DenseLayer(l_2ch_2r, num_units=64, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) l_2ch_d2 = nn.layers.DenseLayer(l_2ch_d1, num_units=64, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) l_2ch_mu = nn.layers.DenseLayer(l_2ch_d2, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) l_2ch_sigma = nn.layers.DenseLayer(l_2ch_d2, num_units=1, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify) l_2ch_mu = reshape(l_2ch_mu, (-1, ) + l_2ch.output_shape[-3:-1]) l_2ch_sigma = reshape(l_2ch_sigma, (-1, ) + l_2ch.output_shape[-3:-1]) l_sys_and_dia = layers.IraLayer(l_4ch_mu, l_4ch_sigma, l_2ch_mu, l_2ch_sigma) l_systole = nn.layers.SliceLayer(l_sys_and_dia, indices=0, axis=2) l_diastole = nn.layers.SliceLayer(l_sys_and_dia, indices=1, axis=2) return { "inputs":{ "sliced:data:chanzoom:4ch": l_4ch, "sliced:data:chanzoom:2ch": l_2ch, }, "outputs": { "systole": l_systole, "diastole": l_diastole, }, "regularizable": { }, "meta_outputs": { } }
def build_model(): ############### # Sunny model # ############### l0_sunny = InputLayer(data_sizes["sunny"]) l1a_sunny = ConvLayer(l0_sunny, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b_sunny = WideConv2DDNNLayer(l1a_sunny, num_filters=32, filter_size=(3, 3), skip=2, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1c_sunny = WideConv2DDNNLayer(l1b_sunny, num_filters=32, filter_size=(3, 3), skip=4, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1d_sunny = WideConv2DDNNLayer(l1c_sunny, num_filters=32, filter_size=(3, 3), skip=8, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1e_sunny = WideConv2DDNNLayer(l1d_sunny, num_filters=32, filter_size=(3, 3), skip=16, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1f_sunny = WideConv2DDNNLayer(l1e_sunny, num_filters=1, filter_size=(3, 3), skip=32, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.sigmoid) #l_sunny_segmentation = lasagne.layers.reshape(l1d_sunny, data_sizes["sunny"][:1] + l1d_sunny.output_shape[-2:]) l_sunny_segmentation = lasagne.layers.SliceLayer(l1f_sunny, indices=0, axis=1) ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, (-1, 1, ) + data_sizes["sliced:data:ax"][-2:]) # first do the segmentation steps l1a = ConvLayer(l0r, num_filters=32, filter_size=(3, 3), pad='same', W=l1a_sunny.W, b=l1a_sunny.b) l1b = WideConv2DDNNLayer(l1a, num_filters=32, filter_size=(3, 3), skip=2, pad='same', W=l1b_sunny.W, b=l1b_sunny.b) l1c = WideConv2DDNNLayer(l1b, num_filters=64, filter_size=(3, 3), skip=4, pad='same', W=l1c_sunny.W, b=l1c_sunny.b) l1d = WideConv2DDNNLayer(l1c, num_filters=64, filter_size=(3, 3), skip=8, pad='same', W=l1d_sunny.W, b=l1d_sunny.b) l1e = WideConv2DDNNLayer(l1d, num_filters=32, filter_size=(3, 3), skip=16, pad='same', W=l1e_sunny.W, b=l1e_sunny.b) l1f = WideConv2DDNNLayer(l1e, num_filters=1, filter_size=(3, 3), skip=32, pad='same', W=l1f_sunny.W, b=l1f_sunny.b, nonlinearity=lasagne.nonlinearities.sigmoid) l_1r = reshape(l1f, data_sizes["sliced:data:ax"]) # returns (batch, time, 600) of probabilities # TODO: it should also take into account resolution, etc. volume_layer = GaussianApproximationVolumeLayer(l_1r) # then use max and min over time for systole and diastole l_systole = lasagne.layers.FlattenLayer( lasagne.layers.FeaturePoolLayer(volume_layer, pool_size=volume_layer.output_shape[1], axis=1, pool_function=T.min), outdim=2) l_diastole = lasagne.layers.FlattenLayer( lasagne.layers.FeaturePoolLayer(volume_layer, pool_size=volume_layer.output_shape[1], axis=1, pool_function=T.max), outdim=2) return { "inputs":{ "sliced:data:ax": l0, "sunny": l0_sunny, }, "outputs":{ "systole": l_systole, "diastole": l_diastole, "segmentation": l_sunny_segmentation, } }
def dense_fused_convnets(self, fusion_level, fusion_type, input_var1=None, input_var2=None, bottleneck_W=None, weights_dir=None): net = OrderedDict() net['input_rgb'] = InputLayer((None, 4, 128, 128), input_var=input_var1) layer = 0 for i in range(self._net_specs_dict['num_conv_layers']): # Add convolution layers net['conv_rgb{0:d}'.format(i + 1)] = Conv2DLayer( net.values()[layer], num_filters=self._net_specs_dict['num_conv_filters'][i], filter_size=(self._net_specs_dict['conv_filter_size'][i], ) * 2, pad='same') layer += 1 if self._net_specs_dict['num_conv_layers'] <= 2: # Add pooling layers net['pool_rgb{0:d}'.format(i + 1)] = MaxPool2DLayer( net.values()[layer], pool_size=(3, 3)) layer += 1 else: if i < 4: if (i + 1) % 2 == 0: # Add pooling layers net['pool_rgb{0:d}'.format(i + 1)] = MaxPool2DLayer( net.values()[layer], pool_size=(3, 3)) layer += 1 else: if (i + 1) == 7: # Add pooling layers net['pool_rgb{0:d}'.format(i + 1)] = MaxPool2DLayer( net.values()[layer], pool_size=(3, 3)) layer += 1 # Fc-layers net['fc1_rgb'] = DenseLayer(net.values()[layer], self._net_specs_dict['num_fc_units'][0]) layer += 1 if fusion_level == 2: # Add dropout layer net['dropout1_rgb'] = dropout(net['fc1_rgb'], p=self._model_hp_dict['p']) layer += 1 net['fc2_rgb'] = DenseLayer( net['dropout1_rgb'], self._net_specs_dict['num_fc_units'][1]) layer += 1 net['input_depth'] = InputLayer((None, 1, 128, 128), input_var=input_var2) layer += 1 for i in range(self._net_specs_dict['num_conv_layers']): # Add convolution layers net['conv_depth{0:d}'.format(i + 1)] = Conv2DLayer( net.values()[layer], num_filters=self._net_specs_dict['num_conv_filters'][i], filter_size=(self._net_specs_dict['conv_filter_size'][i], ) * 2, pad='same') layer += 1 if self._net_specs_dict['num_conv_layers'] <= 2: # Add pooling layers net['pool_depth{0:d}'.format(i + 1)] = MaxPool2DLayer( net.values()[layer], pool_size=(3, 3)) layer += 1 else: if i < 4: if (i + 1) % 2 == 0: # Add pooling layers net['pool_depth{0:d}'.format(i+1)] =\ MaxPool2DLayer(net.values()[layer], pool_size=(3, 3)) layer += 1 else: if (i + 1) == 7: # Add pooling layers net['pool_depth{0:d}'.format(i+1)] =\ MaxPool2DLayer(net.values()[layer], pool_size=(3, 3)) layer += 1 # Fc-layers net['fc1_depth'] = DenseLayer(net.values()[layer], self._net_specs_dict['num_fc_units'][0]) layer += 1 if fusion_level == 2: # Add dropout layer net['dropout1_depth'] = dropout(net['fc1_depth'], p=self._model_hp_dict['p']) layer += 1 net['fc2_depth'] = DenseLayer( net['dropout1_depth'], self._net_specs_dict['num_fc_units'][1]) layer += 1 # Fuse ConvNets by fusion_level and fusion_type if fusion_type == self.MAX: net['merge'] =\ ElemwiseMergeLayer([net['fc%i_rgb' % fusion_level], net['fc%i_depth' % fusion_level]], T.maximum) layer += 1 elif fusion_type == self.SUM: net['merge'] =\ ElemwiseMergeLayer([net['fc%i_rgb' % fusion_level], net['fc%i_depth' % fusion_level]], T.add) layer += 1 elif fusion_type == self.CONCAT: net['merge'] = concat([ net['fc%i_rgb' % fusion_level], net['fc%i_depth' % fusion_level] ]) layer += 1 elif fusion_type == self.CONCATCONV: net['fc%i_rgb_res' % fusion_level] =\ reshape(net['fc%i_rgb' % fusion_level], ([0], 1, [1])) layer += 1 net['fc%i_depth_res' % fusion_level] =\ reshape(net['fc%i_depth' % fusion_level], ([0], 1, [1])) layer += 1 net['concat'] = concat([ net['fc%i_rgb_res' % fusion_level], net['fc%i_depth_res' % fusion_level] ]) layer += 1 net['merge_con'] = Conv1DLayer(net['concat'], num_filters=1, filter_size=(1, ), nonlinearity=None) layer += 1 net['merge'] = reshape(net['merge_con'], ([0], [2])) layer += 1 if fusion_level == 1: # Add dropout layer net['dropout1'] = dropout(net['merge'], p=self._model_hp_dict['p']) layer += 1 net['fc2'] = DenseLayer(net['dropout1'], self._net_specs_dict['num_fc_units'][1]) layer += 1 # Add dropout layer net['dropout2'] = dropout(net['fc2'], p=self._model_hp_dict['p']) layer += 1 else: # Add dropout layer net['dropout2'] = dropout(net['merge'], p=self._model_hp_dict['p']) layer += 1 # Add output layer(linear activation because it's regression) if bottleneck_W is not None: # Add bottleneck layer net['bottleneck'] = DenseLayer(net['dropout2'], 30) # Add output layer(linear activation because it's regression) net['output'] = DenseLayer( net['bottleneck'], 3 * self._num_joints, W=bottleneck_W[0:30], nonlinearity=lasagne.nonlinearities.tanh) else: # Add output layer(linear activation because it's regression) net['output'] = DenseLayer( net['dropout2'], 3 * self._num_joints, nonlinearity=lasagne.nonlinearities.tanh) if weights_dir is not None: lw = LoadWeights(weights_dir, net) lw.load_weights_numpy() return net
def __init__( self, input_shape, output_dim, hidden_sizes, conv_filters, conv_filter_sizes, conv_strides, conv_pads, hidden_W_init=LI.GlorotUniform(), hidden_b_init=LI.Constant(0.), output_W_init=LI.GlorotUniform(), output_b_init=LI.Constant(0.), # conv_W_init=LI.GlorotUniform(), conv_b_init=LI.Constant(0.), hidden_nonlinearity=LN.rectify, output_nonlinearity=LN.softmax, name=None, input_var=None): """ Network of convolution layers followd by dense layers. :param input_shape: input shape, i.e. for 3D images it should be (channels, rows, cols) :type input_shape: tuple :param output_dim: number of output units/neurons :type output_dim: int :param hidden_sizes: list of unit numbers :type hidden_sizes: int-tuple :param conv_filters: number of convolution filters (in literature depth of conv layer) :type conv_filters: tuple :param conv_filter_sizes: :type conv_filter_sizes: tuple :param conv_strides: :param conv_pads: :param hidden_W_init: :param hidden_b_init: :param output_W_init: :param output_b_init: :param hidden_nonlinearity: :param output_nonlinearity: :param name: :param input_var: Note ---- The trick here is that it flattens the input. """ if name is None: prefix = "" else: prefix = name + "_" if len(input_shape) == 3: l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var) l_hid = L.reshape(l_in, ([0], ) + input_shape) elif len(input_shape) == 2: l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var) input_shape = (1, ) + input_shape l_hid = L.reshape(l_in, ([0], ) + input_shape) else: l_in = L.InputLayer(shape=(None, ) + input_shape, input_var=input_var) l_hid = l_in for idx, conv_filter, filter_size, stride, pad in zip( range(len(conv_filters)), conv_filters, conv_filter_sizes, conv_strides, conv_pads, ): l_hid = L.Conv2DLayer( l_hid, num_filters=conv_filter, filter_size=filter_size, stride=(stride, stride), pad=pad, nonlinearity=hidden_nonlinearity, name="%sconv_hidden_%d" % (prefix, idx), W=hidden_W_init, b=hidden_b_init, ) for idx, hidden_size in enumerate(hidden_sizes): l_hid = L.DenseLayer( l_hid, num_units=hidden_size, nonlinearity=hidden_nonlinearity, name="%shidden_%d" % (prefix, idx), W=hidden_W_init, b=hidden_b_init, ) l_out = L.DenseLayer( l_hid, num_units=output_dim, nonlinearity=output_nonlinearity, name="%soutput" % (prefix, ), W=output_W_init, b=output_b_init, ) self._l_in = l_in self._l_out = l_out self._input_var = l_in.input_var
def build_net(nz=200): gen = InputLayer(shape=(None, nz)) gen = DenseLayer(incoming=gen, num_units=1024 * 4 * 4) gen = reshape(incoming=gen, shape=(-1, 1024, 4, 4)) gen = batch_norm( Deconv2DLayer(incoming=gen, num_filters=512, filter_size=4, stride=2, nonlinearity=relu, crop=1)) gen = batch_norm( Deconv2DLayer(incoming=gen, num_filters=256, filter_size=4, stride=2, nonlinearity=relu, crop=1)) gen = batch_norm( Deconv2DLayer(incoming=gen, num_filters=128, filter_size=4, stride=2, nonlinearity=relu, crop=1)) gen = Deconv2DLayer(incoming=gen, num_filters=1, filter_size=4, stride=2, nonlinearity=sigmoid, crop=1) ### or tanh? dis = InputLayer(shape=(None, 1, 64, 64)) dis = batch_norm( Conv2DLayer(incoming=dis, num_filters=128, filter_size=5, stride=2, nonlinearity=lrelu(0.2), pad=2)) dis = batch_norm( Conv2DLayer(incoming=dis, num_filters=256, filter_size=5, stride=2, nonlinearity=lrelu(0.2), pad=2)) dis = batch_norm( Conv2DLayer(incoming=dis, num_filters=512, filter_size=5, stride=2, nonlinearity=lrelu(0.2), pad=2)) dis = batch_norm( Conv2DLayer(incoming=dis, num_filters=1024, filter_size=5, stride=2, nonlinearity=lrelu(0.2), pad=2)) dis = reshape(incoming=dis, shape=(-1, 1024 * 4 * 4)) dis = DenseLayer(incoming=dis, num_units=1, nonlinearity=None) return gen, dis
def __init__( self, input_shape, output_dim, hidden_sizes, conv_filters, conv_filter_sizes, conv_strides, conv_pads, hidden_W_init=LI.GlorotUniform(), hidden_b_init=LI.Constant(0.), output_W_init=LI.GlorotUniform(), output_b_init=LI.Constant(0.), # conv_W_init=LI.GlorotUniform(), conv_b_init=LI.Constant(0.), hidden_nonlinearity=LN.rectify, output_nonlinearity=LN.softmax, name=None, input_var=None): if name is None: prefix = "" else: prefix = name + "_" if len(input_shape) == 3: l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var) l_hid = L.reshape(l_in, ([0], ) + input_shape) elif len(input_shape) == 2: l_in = L.InputLayer(shape=(None, np.prod(input_shape)), input_var=input_var) input_shape = (1, ) + input_shape l_hid = L.reshape(l_in, ([0], ) + input_shape) else: l_in = L.InputLayer(shape=(None, ) + input_shape, input_var=input_var) l_hid = l_in for idx, conv_filter, filter_size, stride, pad in zip( range(len(conv_filters)), conv_filters, conv_filter_sizes, conv_strides, conv_pads, ): l_hid = L.Conv2DLayer( l_hid, num_filters=conv_filter, filter_size=filter_size, stride=(stride, stride), pad=pad, nonlinearity=hidden_nonlinearity, name="%sconv_hidden_%d" % (prefix, idx), convolution=wrapped_conv, ) conv_out = l_hid for idx, hidden_size in enumerate(hidden_sizes): l_hid = L.DenseLayer( l_hid, num_units=hidden_size, nonlinearity=hidden_nonlinearity, name="%shidden_%d" % (prefix, idx), W=hidden_W_init, b=hidden_b_init, ) l_out = L.DenseLayer( l_hid, num_units=output_dim, nonlinearity=output_nonlinearity, name="%soutput" % (prefix, ), W=output_W_init, b=output_b_init, ) self._l_in = l_in self._l_out = l_out self._input_var = l_in.input_var self._conv_out = conv_out
def build_model(): ################# # Regular model # ################# data_size = data_sizes["sliced:data:ax:noswitch"] l0 = InputLayer(data_size) l0r = batch_norm(reshape(l0, ( -1, 1, ) + data_size[1:])) # (batch, channel, axis, time, x, y) # convolve over time l1 = batch_norm( ConvolutionOverAxisLayer( l0r, num_filters=4, filter_size=(3, ), axis=(3, ), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l1m = batch_norm(MaxPoolOverAxisLayer(l1, pool_size=(4, ), axis=(3, ))) # convolve over x and y l2a = batch_norm( ConvolutionOver2DAxisLayer( l1m, num_filters=8, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l2b = batch_norm( ConvolutionOver2DAxisLayer( l2a, num_filters=8, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l2m = batch_norm(MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2), axis=(4, 5))) # convolve over x, y, time l3a = batch_norm( ConvolutionOver3DAxisLayer( l2m, num_filters=64, filter_size=(3, 3, 3), axis=(3, 4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l3b = batch_norm( ConvolutionOver2DAxisLayer( l3a, num_filters=64, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l3m = batch_norm(MaxPoolOver2DAxisLayer(l3b, pool_size=(2, 2), axis=(4, 5))) # convolve over time l4 = batch_norm( ConvolutionOverAxisLayer( l3m, num_filters=64, filter_size=(3, ), axis=(3, ), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l4m = batch_norm(MaxPoolOverAxisLayer(l4, pool_size=(2, ), axis=(2, ))) # maxpool over axis l5 = batch_norm(MaxPoolOverAxisLayer(l3m, pool_size=(4, ), axis=(2, ))) # convolve over x and y l6a = batch_norm( ConvolutionOver2DAxisLayer( l5, num_filters=128, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l6b = batch_norm( ConvolutionOver2DAxisLayer( l6a, num_filters=128, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l6m = batch_norm(MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2), axis=(4, 5))) # convolve over time and x,y l7 = ConvolutionOver3DAxisLayer( l6m, num_filters=128, filter_size=(3, 3, 3), axis=(3, 4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l8 = lasagne.layers.DropoutLayer(l7, p=0.5) l_d3a = lasagne.layers.DenseLayer(l8, num_units=128) l_d3b = lasagne.layers.DropoutLayer(l_d3a) l_systole = CumSumLayer( lasagne.layers.DenseLayer(l_d3b, num_units=600, nonlinearity=lasagne.nonlinearities.softmax)) l_d3c = lasagne.layers.DenseLayer(l8, num_units=128) l_d3d = lasagne.layers.DropoutLayer(l_d3c) l_diastole = CumSumLayer( lasagne.layers.DenseLayer(l_d3d, num_units=600, nonlinearity=lasagne.nonlinearities.softmax)) return { "inputs": { "sliced:data:ax:noswitch": l0 }, "outputs": { "systole": l_systole, "diastole": l_diastole, }, "regularizable": { l_d3a: 0.25, l_d3c: 0.25, l_systole: 0.25, l_diastole: 0.25, } }
def build_model(): ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, (-1, 1, ) + data_sizes["sliced:data:ax"][1:]) # (batch, channel, time, axis, x, y) # convolve over time with small filter l0t = ConvolutionOverAxisLayer(l0r, num_filters=2, filter_size=(5,), stride=(3,), axis=2, channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l0r = reshape(l0t, (-1, 1, ) + data_sizes["sliced:data:ax"][-2:]) # first do the segmentation steps l1a = ConvLayer(l0r, num_filters=32, filter_size=(5, 5), stride=2, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b = ConvLayer(l1a, num_filters=32, filter_size=(5, 5), stride=2, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b_m = MaxPoolLayer(l1b, pool_size=(2,2)) l1c = ConvLayer(l1b_m, num_filters=64, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1f = ConvLayer(l1c, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1)) l1f_m = MaxPoolLayer(l1f, pool_size=(2,2)) l1f_r = reshape(l1f_m, (batch_size, 2, 9, 15, 32, 4, 4)) l0t = ConvolutionOverAxisLayer(l1f_r, num_filters=32, filter_size=(3,), stride=(1,), axis=3, channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l_d3 = lasagne.layers.DenseLayer(l0t, num_units=2, nonlinearity=lasagne.nonlinearities.identity) l_systole = MuLogSigmaErfLayer(l_d3) l_d3b = lasagne.layers.DenseLayer(l0t, num_units=2, nonlinearity=lasagne.nonlinearities.identity) l_diastole = MuLogSigmaErfLayer(l_d3b) return { "inputs":{ "sliced:data:ax": l0 }, "outputs":{ "systole": l_systole, "diastole": l_diastole } }
def build_model(): ''' Adapted from https://github.com/Lasagne/Recipes/tree/master/papers/deep_residual_learning. Tweaked to be consistent with 'Identity Mappings in Deep Residual Networks', Kaiming He et al. 2016 (https://arxiv.org/abs/1603.05027) And 'Wide Residual Networks', Sergey Zagoruyko, Nikos Komodakis 2016 (http://arxiv.org/pdf/1605.07146v1.pdf) Depth = 6n + 2 ''' n = 6 k = 4 n_filters = {0: 16, 1: 16 * k, 2: 32 * k, 3: 64 * k} l_in = InputLayer(shape=(None, ) + nn_input_shape) l = DimshuffleLayer(l_in, pattern=(0, 'x', 1, 2, 3)) # first layer, output is 16 x 64 x 64 l = batch_norm( ConvLayer(l, num_filters=n_filters[0], filter_size=3, stride=1, nonlinearity=rectify, pad='same', W=he_norm)) # first stack of residual blocks, output is 32 x 64 x 64 l = residual_block(l, first=True, filters=n_filters[1]) for _ in range(1, n): l = residual_block(l, filters=n_filters[1]) # second stack of residual blocks, output is 64 x 32 x 32 l = residual_block(l, increase_dim=True, filters=n_filters[2]) for _ in range(1, (n + 2)): l = residual_block(l, filters=n_filters[2]) # third stack of residual blocks, output is 128 x 16 x 16 l = residual_block(l, increase_dim=True, filters=n_filters[3]) for _ in range(1, (n + 2)): l = residual_block(l, filters=n_filters[3]) bn_post_conv = BatchNormLayer(l) bn_post_relu = NonlinearityLayer(bn_post_conv, rectify) # average pooling avg_pool = GlobalPoolLayer(bn_post_relu) # average pooling avg_pool = GlobalPoolLayer(bn_post_relu) sigm = DenseLayer(avg_pool, num_units=1, W=lasagne.init.Constant(0.0), b=None, nonlinearity=lasagne.nonlinearities.sigmoid) l_out = reshape(sigm, shape=(-1, )) return { "inputs": { "bcolzall:3d": l_in, }, "outputs": { "predicted_probability": l_out }, }
def build_model(): ################# # Regular model # ################# input_key = "sliced:data:ax:noswitch" data_size = data_sizes[input_key] l0 = InputLayer(data_size) l0r = batch_norm(reshape(l0, (-1, 1, ) + data_size[1:])) # (batch, channel, axis, time, x, y) # convolve over time l1 = batch_norm(ConvolutionOverAxisLayer(l0r, num_filters=8, filter_size=(3,), axis=(3,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l1m = batch_norm(MaxPoolOverAxisLayer(l1, pool_size=(4,), axis=(3,))) # convolve over x and y l2a = batch_norm(ConvolutionOver2DAxisLayer(l1m, num_filters=8, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l2b = batch_norm(ConvolutionOver2DAxisLayer(l2a, num_filters=8, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l2m = batch_norm(MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2), axis=(4,5))) # convolve over x, y, time l3a = batch_norm(ConvolutionOver3DAxisLayer(l2m, num_filters=32, filter_size=(3, 3, 3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l3b = batch_norm(ConvolutionOver2DAxisLayer(l3a, num_filters=32, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l3m = batch_norm(MaxPoolOver2DAxisLayer(l3b, pool_size=(2, 2), axis=(4,5))) # convolve over time l4 = batch_norm(ConvolutionOverAxisLayer(l3m, num_filters=32, filter_size=(3,), axis=(3,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l4m = batch_norm(MaxPoolOverAxisLayer(l4, pool_size=(2,), axis=(2,))) # maxpool over axis l5 = batch_norm(MaxPoolOverAxisLayer(l3m, pool_size=(4,), axis=(2,))) # convolve over x and y l6a = batch_norm(ConvolutionOver2DAxisLayer(l5, num_filters=128, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l6b = batch_norm(ConvolutionOver2DAxisLayer(l6a, num_filters=128, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l6m = batch_norm(MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2), axis=(4,5))) # convolve over time and x,y, is sparse reduction layer l7 = ConvolutionOver3DAxisLayer(l6m, num_filters=32, filter_size=(3,3,3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) key_scale = "area_per_pixel:sax" l_scale = InputLayer(data_sizes[key_scale]) # Systole Dense layers ldsys1 = lasagne.layers.DenseLayer(l7, num_units=512, W=lasagne.init.Orthogonal("relu"), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.rectify) ldsys1drop = lasagne.layers.dropout(ldsys1, p=0.5) ldsys2 = lasagne.layers.DenseLayer(ldsys1drop, num_units=128, W=lasagne.init.Orthogonal("relu"), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.rectify) ldsys2drop = lasagne.layers.dropout(ldsys2, p=0.5) ldsys3 = lasagne.layers.DenseLayer(ldsys2drop, num_units=1, b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.identity) l_systole = layers.MuConstantSigmaErfLayer(layers.ScaleLayer(ldsys3, scale=l_scale), sigma=0.0) # Diastole Dense layers lddia1 = lasagne.layers.DenseLayer(l7, num_units=512, W=lasagne.init.Orthogonal("relu"), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.rectify) lddia1drop = lasagne.layers.dropout(lddia1, p=0.5) lddia2 = lasagne.layers.DenseLayer(lddia1drop, num_units=128, W=lasagne.init.Orthogonal("relu"), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.rectify) lddia2drop = lasagne.layers.dropout(lddia2, p=0.5) lddia3 = lasagne.layers.DenseLayer(lddia2drop, num_units=1, b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.identity) l_diastole = layers.MuConstantSigmaErfLayer(layers.ScaleLayer(lddia3, scale=l_scale), sigma=0.0) return { "inputs":{ input_key: l0, key_scale: l_scale, }, "outputs": { "systole": l_systole, "diastole": l_diastole, }, "regularizable": { ldsys1: l2_weight, ldsys2: l2_weight, ldsys3: l2_weight, lddia1: l2_weight, lddia2: l2_weight, lddia3: l2_weight, }, }
def _get_l_out(self, input_vars, multi_utt=None): check_options(self.options) id_tag = (self.id + '/') if self.id else '' input_var = input_vars[0] extra_vars = input_vars[1:] if multi_utt is None: l_in = InputLayer(shape=(None, self.seq_vec.max_len), input_var=input_var, name=id_tag + 'desc_input') l_in_flattened = l_in else: l_in = InputLayer(shape=(None, multi_utt, self.seq_vec.max_len), input_var=input_var, name=id_tag + 'desc_input') l_in_flattened = reshape(l_in, (-1, self.seq_vec.max_len), name=id_tag + 'input_flattened') l_in_embed, context_vars = self.get_embedding_layer(l_in_flattened, extra_vars) 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 = cell(l_in_embed, name=id_tag + 'rec1', only_return_final=True, **cell_kwargs) if self.options.listener_bidi: l_rec1_backwards = cell(l_in_embed, name=id_tag + 'rec1_back', backwards=True, only_return_final=True, **cell_kwargs) l_rec1 = ConcatLayer([l_rec1, l_rec1_backwards], axis=1, name=id_tag + 'rec1_bidi_concat') 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 # (batch_size [ * multi_utt], repr_size) l_pred_mean = DenseLayer(l_rec1_drop, num_units=self.color_vec.output_size, nonlinearity=None, name=id_tag + 'pred_mean') # (batch_size [ * multi_utt], repr_size * repr_size) l_pred_covar_vec = DenseLayer(l_rec1_drop, num_units=self.color_vec.output_size ** 2, # initially produce identity matrix b=np.eye(self.color_vec.output_size, dtype=theano.config.floatX).ravel(), nonlinearity=None, name=id_tag + 'pred_covar_vec') # (batch_size [ * multi_utt], repr_size, repr_size) l_pred_covar = reshape(l_pred_covar_vec, ([0], self.color_vec.output_size, self.color_vec.output_size), name=id_tag + 'pred_covar') if multi_utt is not None: l_pred_mean = reshape(l_pred_mean, (-1, multi_utt, self.color_vec.output_size), name=id_tag + 'pred_mean_reshape') l_pred_covar = reshape(l_pred_covar, (-1, multi_utt, self.color_vec.output_size, self.color_vec.output_size), name=id_tag + 'pred_covar_reshape') # Context repr has shape (batch_size, context_len * repr_size) l_context_repr, context_inputs = self.color_vec.get_input_layer( context_vars, cell_size=self.options.listener_cell_size, context_len=self.context_len, id=self.id ) l_context_points = reshape(l_context_repr, ([0], self.context_len, self.color_vec.output_size)) # (batch_size, [multi_utt,] context_len) l_unnorm_scores = GaussianScoreLayer(l_context_points, l_pred_mean, l_pred_covar, name=id_tag + 'gaussian_score') if multi_utt is not None: l_unnorm_scores = reshape(l_unnorm_scores, (-1, self.context_len), name=id_tag + 'gaussian_score_reshape') # (batch_size [ * multi_utt], context_len) # XXX: returning probs for normal models, log probs for AC model! # This is really surprising and definitely not the best solution. # We should be using log probs everywhere for stability... final_softmax = (softmax if multi_utt is None else logit_softmax_nd(axis=2)) l_scores = NonlinearityLayer(l_unnorm_scores, nonlinearity=final_softmax, name=id_tag + 'scores') if multi_utt is not None: l_scores = reshape(l_unnorm_scores, (-1, multi_utt, self.context_len), name=id_tag + 'scores_reshape') self.gaussian_fn = theano.function(input_vars, [get_output(l_pred_mean, deterministic=True), get_output(l_pred_covar, deterministic=True), get_output(l_context_points, deterministic=True), get_output(l_unnorm_scores, deterministic=True)], name=id_tag + 'gaussian', on_unused_input='ignore') self.repr_fn = theano.function(input_vars, get_output(l_rec1_drop, deterministic=True), name=id_tag + 'repr', on_unused_input='ignore') return l_scores, [l_in] + context_inputs
def build_model(): ############### # Sunny model # ############### l0_sunny = InputLayer(data_sizes["sunny"]) sunny_layers = [l0_sunny] for i in xrange(1,21): layer = ConvLayer(sunny_layers[-1], num_filters=8, filter_size=((1, 7) if i%2==0 else (7, 1)), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) sunny_layers.append(layer) l1_sunny = ConvLayer(sunny_layers[-1], num_filters=1, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.sigmoid) #l_sunny_segmentation = lasagne.layers.reshape(l1d_sunny, data_sizes["sunny"][:1] + l1d_sunny.output_shape[-2:]) l_sunny_segmentation = lasagne.layers.SliceLayer(l1_sunny, indices=0, axis=1) ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, (-1, 1, ) + data_sizes["sliced:data:ax"][-2:]) # first do the segmentation steps layers = [l0r] for i in xrange(1,21): layer = ConvLayer(layers[-1], num_filters=8, filter_size=((1, 7) if i%2==0 else (7, 1)), pad='same', W=sunny_layers[i].W, b=sunny_layers[i].b, ) layers.append(layer) l1f = ConvLayer(layers[-1], num_filters=1, filter_size=(3, 3), pad='same', W=l1_sunny.W, b=l1_sunny.b, nonlinearity=lasagne.nonlinearities.sigmoid) l_1r = reshape(l1f, data_sizes["sliced:data:ax"]) # returns (batch, time, 600) of probabilities # TODO: it should also take into account resolution, etc. volume_layer = GaussianApproximationVolumeLayer(l_1r) # then use max and min over time for systole and diastole l_systole = lasagne.layers.FlattenLayer( lasagne.layers.FeaturePoolLayer(volume_layer, pool_size=volume_layer.output_shape[1], axis=1, pool_function=T.min), outdim=2) l_diastole = lasagne.layers.FlattenLayer( lasagne.layers.FeaturePoolLayer(volume_layer, pool_size=volume_layer.output_shape[1], axis=1, pool_function=T.max), outdim=2) return { "inputs":{ "sliced:data:ax": l0, "sunny": l0_sunny, }, "outputs":{ "systole": l_systole, "diastole": l_diastole, "segmentation": l_sunny_segmentation, } }
def build_model(): ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, (-1, 1, ) + data_sizes["sliced:data:ax"][1:]) # (batch, channel, time, axis, x, y) # convolve over time l1 = ConvolutionOverAxisLayer(l0r, num_filters=4, filter_size=(3,), axis=(2,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b = ConvolutionOverAxisLayer(l1, num_filters=4, filter_size=(3,), axis=(2,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1m = MaxPoolOverAxisLayer(l1b, pool_size=(2,), axis=(2,)) # convolve over x and y l2a = ConvolutionOver2DAxisLayer(l1m, num_filters=32, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l2b = ConvolutionOver2DAxisLayer(l2a, num_filters=32, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l2m = MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2), axis=(4,5)) # convolve over x, y and axis l3a = ConvolutionOver3DAxisLayer(l2m, num_filters=64, filter_size=(3, 3, 3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l3b = ConvolutionOver3DAxisLayer(l3a, num_filters=64, filter_size=(3, 3, 3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l3c = ConvolutionOver3DAxisLayer(l3b, num_filters=64, filter_size=(3, 3, 3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l3m = MaxPoolOver3DAxisLayer(l3c, pool_size=(2, 2, 2), axis=(3,4,5)) # convolve over time l4 = ConvolutionOverAxisLayer(l3m, num_filters=64, filter_size=(3,), axis=(2,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l4m = MaxPoolOverAxisLayer(l4, pool_size=(2,), axis=(2,)) # convolve over axis l5 = ConvolutionOverAxisLayer(l4m, num_filters=128, filter_size=(3,), axis=(3,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) # convolve over x and y l6a = ConvolutionOver2DAxisLayer(l5, num_filters=128, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l6b = ConvolutionOver2DAxisLayer(l6a, num_filters=128, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l6m = MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2), axis=(4,5)) # convolve over time and x,y l7 = ConvolutionOver3DAxisLayer(l6m, num_filters=64, filter_size=(3,3,3), axis=(2,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l8 = lasagne.layers.DropoutLayer(l7) l_d3a = lasagne.layers.DenseLayer(l8, num_units=100) l_d3b = lasagne.layers.DropoutLayer(l_d3a) l_systole = lasagne.layers.DenseLayer(l_d3b, num_units=600, nonlinearity=lasagne.nonlinearities.softmax) l_diastole = lasagne.layers.DenseLayer(l_d3b, num_units=600, nonlinearity=lasagne.nonlinearities.softmax) return { "inputs":{ "sliced:data:ax": l0 }, "outputs": { "systole:onehot": l_systole, "diastole:onehot": l_diastole, } }
def build_model(): ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, ( -1, 1, ) + data_sizes["sliced:data:ax"][1:]) # (batch, channel, time, axis, x, y) # convolve over time l1 = ConvolutionOverAxisLayer( l0r, num_filters=4, filter_size=(3, ), axis=(2, ), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b = ConvolutionOverAxisLayer( l1, num_filters=4, filter_size=(3, ), axis=(2, ), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1m = MaxPoolOverAxisLayer(l1b, pool_size=(2, ), axis=(2, )) # convolve over x and y l2a = ConvolutionOver2DAxisLayer( l1m, num_filters=32, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l2b = ConvolutionOver2DAxisLayer( l2a, num_filters=32, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l2m = MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2), axis=(4, 5)) # convolve over x, y and axis l3a = ConvolutionOver3DAxisLayer( l2m, num_filters=64, filter_size=(3, 3, 3), axis=(3, 4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l3b = ConvolutionOver3DAxisLayer( l3a, num_filters=64, filter_size=(3, 3, 3), axis=(3, 4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l3c = ConvolutionOver3DAxisLayer( l3b, num_filters=64, filter_size=(3, 3, 3), axis=(3, 4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l3m = MaxPoolOver3DAxisLayer(l3c, pool_size=(2, 2, 2), axis=(3, 4, 5)) # convolve over time l4 = ConvolutionOverAxisLayer( l3m, num_filters=64, filter_size=(3, ), axis=(2, ), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l4m = MaxPoolOverAxisLayer(l4, pool_size=(2, ), axis=(2, )) # convolve over axis l5 = ConvolutionOverAxisLayer( l4m, num_filters=128, filter_size=(3, ), axis=(3, ), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) # convolve over x and y l6a = ConvolutionOver2DAxisLayer( l5, num_filters=128, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l6b = ConvolutionOver2DAxisLayer( l6a, num_filters=128, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l6m = MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2), axis=(4, 5)) # convolve over time and x,y l7 = ConvolutionOver3DAxisLayer( l6m, num_filters=32, filter_size=(3, 3, 3), axis=(2, 4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l8 = lasagne.layers.DropoutLayer(l7) l_d3a = lasagne.layers.DenseLayer(l8, num_units=600) l_d3b = lasagne.layers.DropoutLayer(l_d3a) l_systole = lasagne.layers.DenseLayer( l_d3b, num_units=600, nonlinearity=lasagne.nonlinearities.softmax) l_d3c = lasagne.layers.DenseLayer(l8, num_units=600) l_d3d = lasagne.layers.DropoutLayer(l_d3c) l_diastole = lasagne.layers.DenseLayer( l_d3d, num_units=600, nonlinearity=lasagne.nonlinearities.softmax) return { "inputs": { "sliced:data:ax": l0 }, "outputs": { "systole:onehot": l_systole, "diastole:onehot": l_diastole, }, "regularizable": { l_d3a: 0.25, l_d3c: 0.25, l_systole: 0.25, l_diastole: 0.25, } }
def build_model(): ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = batch_norm(reshape(l0, (-1, 1) + data_sizes["sliced:data:ax"][1:])) # (batch, channel, time, axis, x, y) # convolve over time l1 = batch_norm( ConvolutionOverAxisLayer( l0r, num_filters=16, filter_size=(3,), axis=(2,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), ) ) l1b = batch_norm( ConvolutionOverAxisLayer( l1, num_filters=16, filter_size=(3,), axis=(2,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), ) ) l1m = batch_norm(MaxPoolOverAxisLayer(l1b, pool_size=(4,), axis=(2,))) # convolve over x and y l2a = batch_norm( ConvolutionOver2DAxisLayer( l1m, num_filters=32, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), ) ) l2b = batch_norm( ConvolutionOver2DAxisLayer( l2a, num_filters=32, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), ) ) l2m = batch_norm(MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2), axis=(4, 5))) # convolve over x, y, time l3a = batch_norm( ConvolutionOver3DAxisLayer( l2m, num_filters=64, filter_size=(3, 3, 3), axis=(2, 4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) ) l3b = batch_norm( ConvolutionOver2DAxisLayer( l3a, num_filters=64, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) ) l3m = batch_norm(MaxPoolOver2DAxisLayer(l3b, pool_size=(2, 2), axis=(4, 5))) # convolve over time l4 = batch_norm( ConvolutionOverAxisLayer( l3m, num_filters=64, filter_size=(3,), axis=(2,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) ) l4m = batch_norm(MaxPoolOverAxisLayer(l4, pool_size=(2,), axis=(2,))) # maxpool over axis l5 = batch_norm(MaxPoolOverAxisLayer(l3m, pool_size=(4,), axis=(3,))) # convolve over x and y l6a = batch_norm( ConvolutionOver2DAxisLayer( l5, num_filters=128, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) ) l6b = batch_norm( ConvolutionOver2DAxisLayer( l6a, num_filters=128, filter_size=(3, 3), axis=(4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) ) l6m = batch_norm(MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2), axis=(4, 5))) # convolve over time and x,y l7 = ConvolutionOver3DAxisLayer( l6m, num_filters=128, filter_size=(3, 3, 3), axis=(2, 4, 5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l8 = lasagne.layers.DropoutLayer(l7, p=0.5) l_d3a = lasagne.layers.DenseLayer(l8, num_units=128) l_d3b = lasagne.layers.DropoutLayer(l_d3a) l_systole = lasagne.layers.DenseLayer(l_d3b, num_units=600, nonlinearity=lasagne.nonlinearities.softmax) l_d3c = lasagne.layers.DenseLayer(l8, num_units=128) l_d3d = lasagne.layers.DropoutLayer(l_d3c) l_diastole = lasagne.layers.DenseLayer(l_d3d, num_units=600, nonlinearity=lasagne.nonlinearities.softmax) return { "inputs": {"sliced:data:ax": l0}, "outputs": {"systole:onehot": l_systole, "diastole:onehot": l_diastole}, "regularizable": {l_d3a: 0.25, l_d3c: 0.25, l_systole: 0.25, l_diastole: 0.25}, }
def _get_l_out(self, input_vars, multi_utt='ignored'): 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 multihead_attention(input_sequence, query, key_sequence=None, mask_input=None, num_heads=1,key_size=None,value_size=None, attn_class=DotAttentionLayer, name='multihead_attn', **kwargs): """ A convenience function that computes K attention "heads" in parallel and concatenates them. Each "head" is based on num_heads linear transformations of input sequence, query, and keys :param attn_class: what kind of attention layer to apply in multi-headed mode (Attention or DotAttention) :param num heads: the amount of parallel "heads" :param key_size: num units in attention query and key, defaults to key_sequence.shape[-1] :param value_size: num units in attention values, defaults to input_sequence.shape[-1] :param input_sequence: sequence of inputs to be processed with attention :type input_sequence: lasagne.layers.Layer with shape [batch,seq_length,units] :param query: single time-step state of decoder that is used as query (usually custom layer or lstm/gru/rnn hid) If it matches input_sequence one-step size, query is used as is. Otherwise, DotAttention is performed from DenseLayer(query,input_units,nonlinearity=None). :type query: lasagne.layers.Layer with shape [batch,units] :param key_sequence: a sequence of keys to compute dot_product with. By default, uses input_sequence instead. :type key_sequence: lasagne.layers.Layer with shape [batch,seq_length,units] or None :param mask_input: mask for input_sequence (like other lasagne masks). Default is no mask :type mask_input: lasagne.layers.Layer with shape [batch,seq_length] Heavily inspired by https://arxiv.org/abs/1706.03762 and http://bit.ly/2vsYX0R """ assert len(input_sequence.output_shape) == 3, "input_sequence must be a 3-dimensional (batch,time,units)" assert len(query.output_shape) == 2, "query must be a 2-dimensional for single tick (batch,units)" assert mask_input is None or len( mask_input.output_shape) == 2, "mask_input must be 2-dimensional (batch,time) or None" assert key_sequence is None or len(key_sequence.output_shape) == 3, "key_sequence must be 3-dimensional " \ "of shape (batch,time,units) or None" key_sequence = key_sequence or input_sequence key_size = key_size or key_sequence.output_shape[-1] value_size = value_size or input_sequence.output_shape[-1] def make_broadcasted_heads(incoming,head_size,name=None): ndim = len(incoming.output_shape) assert ndim in (2,3), "incoming must be 2-dimensional (query) or 3-dimensional (key or value)" heads = DenseLayer(incoming,head_size*num_heads,nonlinearity=None, num_leading_axes=ndim-1,name=name) #[batch,time,head_size*num_heads] if ndim == 3: heads = reshape(heads,([0],[1],head_size,num_heads), name=name) #[batch,time,head_size,num_heads] broadcasted_heads = BroadcastLayer(heads, (0, 3), name=name) #[batch*heads,time,head_size] else: #ndim == 2 heads = reshape(heads, ([0], head_size, num_heads), name=name) # [batch,head_size,num_heads] broadcasted_heads = BroadcastLayer(heads, (0, 2), name=name) # [batch*heads, head_size] return broadcasted_heads query_heads = make_broadcasted_heads(query, key_size,name=name + "_query_heads") value_heads = make_broadcasted_heads(input_sequence, value_size, name=name + "_value_heads") if key_sequence is not None: key_heads = make_broadcasted_heads(key_sequence, key_size, name=name + "_key_heads") else: key_heads = None if mask_input is not None: mask_heads = UpcastLayer(mask_input,broadcast_layer=query_heads) else: mask_heads = None attn_heads = attn_class(value_heads,query_heads,key_sequence=key_heads, mask_input=mask_heads,name=name,**kwargs) #[batch*heads,value_size] attn_vectors = UnbroadcastLayer(attn_heads['attn'],broadcast_layer=query_heads) #[batch,value,heads] attn_vectors = flatten(attn_vectors,outdim=2) attn_probs = reshape(attn_heads['probs'],(-1,num_heads,[1])) #[batch,head,probs] return {'attn': attn_vectors, #[batch, value*heads] 'probs': attn_probs}
def build_model(): ################# # Regular model # ################# input_key = "sliced:data:ax:noswitch" data_size = data_sizes[input_key] l0 = InputLayer(data_size) l0r = batch_norm(reshape(l0, (-1, 1, ) + data_size[1:])) # (batch, channel, axis, time, x, y) # convolve over time l1 = batch_norm(ConvolutionOverAxisLayer(l0r, num_filters=4, filter_size=(3,), axis=(3,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l1m = batch_norm(MaxPoolOverAxisLayer(l1, pool_size=(4,), axis=(3,))) # convolve over x and y l2a = batch_norm(ConvolutionOver2DAxisLayer(l1m, num_filters=8, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l2b = batch_norm(ConvolutionOver2DAxisLayer(l2a, num_filters=8, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.0), )) l2m = batch_norm(MaxPoolOver2DAxisLayer(l2b, pool_size=(2, 2), axis=(4,5))) # convolve over x, y, time l3a = batch_norm(ConvolutionOver3DAxisLayer(l2m, num_filters=32, filter_size=(3, 3, 3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l3b = batch_norm(ConvolutionOver2DAxisLayer(l3a, num_filters=32, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l3m = batch_norm(MaxPoolOver2DAxisLayer(l3b, pool_size=(2, 2), axis=(4,5))) # convolve over time l4 = batch_norm(ConvolutionOverAxisLayer(l3m, num_filters=32, filter_size=(3,), axis=(3,), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l4m = batch_norm(MaxPoolOverAxisLayer(l4, pool_size=(2,), axis=(2,))) # maxpool over axis l5 = batch_norm(MaxPoolOverAxisLayer(l3m, pool_size=(4,), axis=(2,))) # convolve over x and y l6a = batch_norm(ConvolutionOver2DAxisLayer(l5, num_filters=128, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l6b = batch_norm(ConvolutionOver2DAxisLayer(l6a, num_filters=128, filter_size=(3, 3), axis=(4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), )) l6m = batch_norm(MaxPoolOver2DAxisLayer(l6b, pool_size=(2, 2), axis=(4,5))) # convolve over time and x,y l7 = ConvolutionOver3DAxisLayer(l6m, num_filters=128, filter_size=(3,3,3), axis=(3,4,5), channel=1, W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l8 = lasagne.layers.DropoutLayer(l7, p=0.5) l_systole = CumSumLayer(lasagne.layers.DenseLayer(l8, num_units=600, nonlinearity=lasagne.nonlinearities.softmax)) l_diastole = CumSumLayer(lasagne.layers.DenseLayer(l8, num_units=600, nonlinearity=lasagne.nonlinearities.softmax)) return { "inputs":{ input_key: l0 }, "outputs": { "systole": l_systole, "diastole": l_diastole, }, "regularizable": { } }
def build_model(): ############### # Sunny model # ############### l0_sunny = InputLayer(data_sizes["sunny"]) l1a_sunny = ConvLayer( l0_sunny, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b_sunny = ConvLayer( l1a_sunny, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1c_sunny = ConvLayer( l1b_sunny, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1f_sunny = ConvLayer(l1c_sunny, num_filters=1, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.sigmoid) #l_sunny_segmentation = lasagne.layers.reshape(l1d_sunny, data_sizes["sunny"][:1] + l1d_sunny.output_shape[-2:]) l_sunny_segmentation = lasagne.layers.SliceLayer(l1f_sunny, indices=0, axis=1) ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, ( -1, 1, ) + data_sizes["sliced:data:ax"][-2:]) # first do the segmentation steps l1a = ConvLayer(l0r, num_filters=32, filter_size=(3, 3), pad='same', W=l1a_sunny.W, b=l1a_sunny.b) l1b = ConvLayer(l1a, num_filters=32, filter_size=(3, 3), pad='same', W=l1b_sunny.W, b=l1b_sunny.b) l1c = ConvLayer(l1b, num_filters=64, filter_size=(3, 3), pad='same', W=l1c_sunny.W, b=l1c_sunny.b) l1f = ConvLayer(l1c, num_filters=1, filter_size=(3, 3), pad='same', W=l1f_sunny.W, b=l1f_sunny.b, nonlinearity=lasagne.nonlinearities.sigmoid) l_1r = reshape(l1f, data_sizes["sliced:data:ax"]) l_d3 = lasagne.layers.DenseLayer(l_1r, num_units=2) l_systole = MuLogSigmaErfLayer(l_d3) l_d3b = lasagne.layers.DenseLayer(l_1r, num_units=2) l_diastole = MuLogSigmaErfLayer(l_d3b) return { "inputs": { "sliced:data:ax": l0, "sunny": l0_sunny, }, "outputs": { "systole": l_systole, "diastole": l_diastole, "segmentation": l_sunny_segmentation, } }
def build_model(): ############### # Sunny model # ############### l0_sunny = InputLayer(data_sizes["sunny"]) l1a_sunny = ConvLayer( l0_sunny, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b_sunny = WideConv2DDNNLayer( l1a_sunny, num_filters=32, filter_size=(3, 3), skip=2, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1c_sunny = WideConv2DDNNLayer( l1b_sunny, num_filters=32, filter_size=(3, 3), skip=4, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1d_sunny = WideConv2DDNNLayer( l1c_sunny, num_filters=32, filter_size=(3, 3), skip=8, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1e_sunny = WideConv2DDNNLayer( l1d_sunny, num_filters=32, filter_size=(3, 3), skip=16, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1f_sunny = WideConv2DDNNLayer(l1e_sunny, num_filters=1, filter_size=(3, 3), skip=32, pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.sigmoid) #l_sunny_segmentation = lasagne.layers.reshape(l1d_sunny, data_sizes["sunny"][:1] + l1d_sunny.output_shape[-2:]) l_sunny_segmentation = lasagne.layers.SliceLayer(l1f_sunny, indices=0, axis=1) ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, ( -1, 1, ) + data_sizes["sliced:data:ax"][-2:]) # first do the segmentation steps l1a = ConvLayer(l0r, num_filters=32, filter_size=(3, 3), pad='same', W=l1a_sunny.W, b=l1a_sunny.b) l1b = WideConv2DDNNLayer(l1a, num_filters=32, filter_size=(3, 3), skip=2, pad='same', W=l1b_sunny.W, b=l1b_sunny.b) l1c = WideConv2DDNNLayer(l1b, num_filters=64, filter_size=(3, 3), skip=4, pad='same', W=l1c_sunny.W, b=l1c_sunny.b) l1d = WideConv2DDNNLayer(l1c, num_filters=64, filter_size=(3, 3), skip=8, pad='same', W=l1d_sunny.W, b=l1d_sunny.b) l1e = WideConv2DDNNLayer(l1d, num_filters=32, filter_size=(3, 3), skip=16, pad='same', W=l1e_sunny.W, b=l1e_sunny.b) l1f = WideConv2DDNNLayer(l1e, num_filters=1, filter_size=(3, 3), skip=32, pad='same', W=l1f_sunny.W, b=l1f_sunny.b, nonlinearity=lasagne.nonlinearities.sigmoid) l_1r = reshape(l1f, data_sizes["sliced:data:ax"]) # returns (batch, time, 600) of probabilities # TODO: it should also take into account resolution, etc. volume_layer = GaussianApproximationVolumeLayer(l_1r) # then use max and min over time for systole and diastole l_systole = lasagne.layers.FlattenLayer(lasagne.layers.FeaturePoolLayer( volume_layer, pool_size=volume_layer.output_shape[1], axis=1, pool_function=T.min), outdim=2) l_diastole = lasagne.layers.FlattenLayer(lasagne.layers.FeaturePoolLayer( volume_layer, pool_size=volume_layer.output_shape[1], axis=1, pool_function=T.max), outdim=2) return { "inputs": { "sliced:data:ax": l0, "sunny": l0_sunny, }, "outputs": { "systole": l_systole, "diastole": l_diastole, "segmentation": l_sunny_segmentation, } }
def build_sequence_dense_layer(input_var, input_layer, output_dim): n_batch, n_time_steps, _ = input_var.shape dense_layer = DenseLayer(reshape(input_layer, (-1, [2])), num_units=output_dim, nonlinearity=nonlinearities.softmax) return reshape(dense_layer, (n_batch, n_time_steps, output_dim))
def build_model(): ############### # Sunny model # ############### l0_sunny = InputLayer(data_sizes["sunny"]) l1a_sunny = ConvLayer(l0_sunny, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1b_sunny = ConvLayer(l1a_sunny, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1c_sunny = ConvLayer(l1b_sunny, num_filters=32, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), ) l1f_sunny = ConvLayer(l1c_sunny, num_filters=1, filter_size=(3, 3), pad='same', W=lasagne.init.Orthogonal(), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.sigmoid) #l_sunny_segmentation = lasagne.layers.reshape(l1d_sunny, data_sizes["sunny"][:1] + l1d_sunny.output_shape[-2:]) l_sunny_segmentation = lasagne.layers.SliceLayer(l1f_sunny, indices=0, axis=1) ################# # Regular model # ################# l0 = InputLayer(data_sizes["sliced:data:ax"]) l0r = reshape(l0, (-1, 1, ) + data_sizes["sliced:data:ax"][-2:]) # first do the segmentation steps l1a = ConvLayer(l0r, num_filters=32, filter_size=(3, 3), pad='same', W=l1a_sunny.W, b=l1a_sunny.b) l1b = ConvLayer(l1a, num_filters=32, filter_size=(3, 3), pad='same', W=l1b_sunny.W, b=l1b_sunny.b) l1c = ConvLayer(l1b, num_filters=64, filter_size=(3, 3), pad='same', W=l1c_sunny.W, b=l1c_sunny.b) l1f = ConvLayer(l1c, num_filters=1, filter_size=(3, 3), pad='same', W=l1f_sunny.W, b=l1f_sunny.b, nonlinearity=lasagne.nonlinearities.sigmoid) l_1r = reshape(l1f, data_sizes["sliced:data:ax"]) l_d3 = lasagne.layers.DenseLayer(l_1r, num_units=2) l_systole = MuLogSigmaErfLayer(l_d3) l_d3b = lasagne.layers.DenseLayer(l_1r, num_units=2) l_diastole = MuLogSigmaErfLayer(l_d3b) return { "inputs":{ "sliced:data:ax": l0, "sunny": l0_sunny, }, "outputs":{ "systole": l_systole, "diastole": l_diastole, "segmentation": l_sunny_segmentation, } }