def test_specified_rng(self, input_layer): from lasagne.layers.noise import GaussianNoiseLayer input = theano.shared(numpy.ones((100, 100))) seed = 123456789 set_rng(RandomState(seed)) result = GaussianNoiseLayer(input_layer).get_output_for(input) result_eval1 = result.eval() set_rng(RandomState(seed)) result = GaussianNoiseLayer(input_layer).get_output_for(input) result_eval2 = result.eval() assert numpy.allclose(result_eval1, result_eval2)
def build_model(encoder_specs, decoder_specs, p_drop_input, p_drop_hidden, input_shape, batch_size=None, activation=rectify, combinator_type='MILAudem'): net = OrderedDict() net['input'] = InputLayer((batch_size, ) + tuple(input_shape), name='input') # corrupted input net['input_corr'] = GaussianNoiseLayer(net['input'], sigma=p_drop_input, name='input_corr') # dirty encoder train_output_l, dirty_encoder = build_encoder(net, encoder_specs, activation, 'dirty', p_drop_hidden, None) # clean encoder clean_encoder = OrderedDict(net.items()[:1]) eval_output_l, clean_net = build_encoder(clean_encoder, encoder_specs, activation, 'clean', 0., dirty_encoder) # dirty decoder dirty_decoder = build_decoder(dirty_encoder, clean_net, 'dirty', decoder_specs, combinator_type) return (train_output_l, eval_output_l, dirty_encoder, dirty_decoder, clean_encoder)
def create_rnn(input_vars, num_inputs, depth, hidden_layer_size, num_outputs): # network = InputLayer((None, None, num_inputs), input_vars) network = lasagne.layers.InputLayer(shape=(None, 1, 1, num_inputs), input_var=input_vars) batch_size_theano, _, _, seqlen = network.input_var.shape network = GaussianNoiseLayer(network, sigma=0.05) for i in range(depth): network = RecurrentLayer(network, hidden_layer_size, W_hid_to_hid=GlorotUniform(), W_in_to_hid=GlorotUniform(), b=Constant(1.0), nonlinearity=lasagne.nonlinearities.tanh, learn_init=True) network = ReshapeLayer(network, (-1, hidden_layer_size)) network = DenseLayer(network, num_outputs, nonlinearity=softmax) return network
def create_blstm(input_vars, mask_vars, num_inputs, depth, hidden_layer_size, num_outputs): network = lasagne.layers.InputLayer(shape=(None, 1, 1, num_inputs), input_var=input_vars) mask = InputLayer((None, None), mask_vars) network = GaussianNoiseLayer(network, sigma=0.01) for i in range(depth): forward = LSTMLayer(network, hidden_layer_size, mask_input=mask, learn_init=True) backward = LSTMLayer(network, hidden_layer_size, mask_input=mask, learn_init=True, backwards=True) network = ElemwiseSumLayer([forward, backward]) network = ReshapeLayer(network, (-1, hidden_layer_size)) network = DenseLayer(network, num_outputs, nonlinearity=softmax) return network
def test_specified_rng(self, input_layer): from lasagne.layers.noise import GaussianNoiseLayer input = theano.shared(numpy.ones((100, 100))) seed = 123456789 rng = get_rng() set_rng(RandomState(seed)) result = GaussianNoiseLayer(input_layer).get_output_for(input) result_eval1 = result.eval() set_rng(RandomState(seed)) result = GaussianNoiseLayer(input_layer).get_output_for(input) result_eval2 = result.eval() set_rng(rng) # reset to original RNG for other tests assert numpy.allclose(result_eval1, result_eval2)
def layer(self): from lasagne.layers.noise import GaussianNoiseLayer return GaussianNoiseLayer(Mock(output_shape=(None, )))
def build_enc_layer(incoming, name, transform, specs, activation, i, p_drop_hidden, shared_net): net = OrderedDict() lname = 'enc_{}_{}'.format(i, transform if 'pool' in transform else 'affine') nbatchn_lname = 'enc_batchn_{}_norm'.format(i) noise_lname = 'enc_noise_{}'.format(i) lbatchn_lname = 'enc_batchn_{}_learn'.format(i) if shared_net is None: # affine pars W = lasagne.init.GlorotUniform() # batchnorm pars beta = lasagne.init.Constant(0) gamma = None if activation == rectify else lasagne.init.Constant(1) else: # batchnorm pars beta = shared_net[lbatchn_lname + '_beta'].get_params()[0] gamma = None if activation == rectify else \ shared_net[lbatchn_lname + '_gamma'].get_params()[0] if not isinstance(shared_net[lname], (pool, unpool)): # affine weights W = shared_net[lname].get_params()[0] else: W = None # affine (conv/dense/deconv) or (un)pooling transformation: $W \hat{h}$ net[lname] = get_transform_layer(incoming, name + '_' + lname, transform, specs, W) # 1. batchnormalize without learning -> goes to combinator layer layer2bn = net.values()[-1] l_name = '{}_{}'.format(name, nbatchn_lname) bn_broadcast_cond = layer2bn.output_shape[1] == 1 if len(layer2bn.output_shape) == 4 and bn_broadcast_cond: ax = (0, 1, 2, 3) elif len(layer2bn.output_shape) == 2 and bn_broadcast_cond: ax = (0, 1) else: ax = 'auto' net[nbatchn_lname] = BatchNormLayer(layer2bn, axes=ax, alpha=0.1, beta=None, gamma=None, name=l_name) if shared_net is None: # for dirty encoder -> add noise net[noise_lname] = GaussianNoiseLayer(net.values()[-1], sigma=p_drop_hidden, name='{}_{}'.format( name, noise_lname)) # 2. scaling & offsetting batchnormalization + noise l_name = '{}_{}'.format(name, lbatchn_lname) # offset by beta net[lbatchn_lname + '_beta'] = BiasLayer(net.values()[-1], b=beta, name=l_name + '_beta') if gamma is not None: # if not rectify, scale by gamma net[lbatchn_lname + '_gamma'] = ScaleLayer(net.values()[-1], scales=gamma, name=l_name + '_gamma') return net
def layer(self): from lasagne.layers.noise import GaussianNoiseLayer return GaussianNoiseLayer(Mock())