def __init__(self, input_layer, loss_function=None, aggregation='mean', **args): Objective.__init__(self, input_layer, loss_function, aggregation) self.alpha = args['alpha']
def create_iter_functions(self, dataset, output_layer, X_tensor_type=T.matrix): batch_index = T.iscalar('batch_index') X_batch = X_tensor_type('x') y_batch = T.ivector('y') batch_slice = slice(batch_index * self.batch_size, (batch_index + 1) * self.batch_size) objective = Objective(output_layer, loss_function=categorical_crossentropy) loss_train = objective.get_loss(X_batch, target=y_batch) loss_eval = objective.get_loss(X_batch, target=y_batch, deterministic=True) pred = T.argmax(lasagne.layers.get_output(output_layer, X_batch, deterministic=True), axis=1) proba = lasagne.layers.get_output(output_layer, X_batch, deterministic=True) accuracy = T.mean(T.eq(pred, y_batch), dtype=theano.config.floatX) all_params = get_all_params(output_layer) updates = lasagne.updates.nesterov_momentum(loss_train, all_params, self.lr, self.momentum) iter_train = theano.function( [batch_index], loss_train, updates=updates, givens={ X_batch: dataset['X_train'][batch_slice], y_batch: dataset['y_train'][batch_slice], }, on_unused_input='ignore', ) iter_valid = None if self.use_valid: iter_valid = theano.function( [batch_index], [loss_eval, accuracy, proba], givens={ X_batch: dataset['X_valid'][batch_slice], y_batch: dataset['y_valid'][batch_slice], }, ) return dict(train=iter_train, valid=iter_valid)
def test_objective_no_target(self): from lasagne.objectives import Objective input_layer = mock.Mock() loss_function = mock.Mock() input = object() objective = Objective(input_layer, loss_function) result = objective.get_loss(input) input_layer.get_output.assert_called_with(input) network_output = input_layer.get_output.return_value loss_function.assert_called_with(network_output, objective.target_var) assert result == loss_function.return_value.mean.return_value
def test_objective_no_target(): from lasagne.objectives import Objective input_layer = mock.Mock() loss_function = mock.Mock() input = object() objective = Objective(input_layer, loss_function) result = objective.get_loss(input) input_layer.get_output.assert_called_with(input) network_output = input_layer.get_output.return_value loss_function.assert_called_with(network_output, objective.target_var) assert result == loss_function.return_value
def test_objective_no_target(self): from lasagne.objectives import Objective from lasagne.layers.input import Layer, InputLayer input_layer = mock.Mock(InputLayer((None,))) layer = mock.Mock(Layer(input_layer)) layer.input_layer = input_layer loss_function = mock.Mock() input = theano.tensor.vector() objective = Objective(layer, loss_function) result = objective.get_loss(input) layer.get_output_for.assert_called_with(input) network_output = layer.get_output_for.return_value loss_function.assert_called_with(network_output, objective.target_var) assert result == loss_function.return_value.mean.return_value
def test_objective_no_target(self): from lasagne.objectives import Objective from lasagne.layers.input import Layer, InputLayer input_layer = mock.Mock(InputLayer((None, )), output_shape=(None, )) layer = mock.Mock(Layer(input_layer), output_shape=(None, )) layer.input_layer = input_layer loss_function = mock.Mock() input = theano.tensor.vector() objective = Objective(layer, loss_function) result = objective.get_loss(input) layer.get_output_for.assert_called_with(input) network_output = layer.get_output_for.return_value loss_function.assert_called_with(network_output, objective.target_var) assert result == loss_function.return_value.mean.return_value
def test_objective(): from lasagne.objectives import Objective input_layer = mock.Mock() loss_function = mock.Mock() input, target, arg1, kwarg1 = (object(),) * 4 objective = Objective(input_layer, loss_function) result = objective.get_loss(input, target, arg1, kwarg1=kwarg1) # We expect that the input layer's `get_output` was called with # the `input` argument we provided, plus the extra positional and # keyword arguments. input_layer.get_output.assert_called_with(input, arg1, kwarg1=kwarg1) network_output = input_layer.get_output.return_value # The `network_output` and `target` are fed into the loss # function: loss_function.assert_called_with(network_output, target) assert result == loss_function.return_value
def test_objective(self): from lasagne.objectives import Objective input_layer = mock.Mock() loss_function = mock.Mock() input, target, kwarg1 = object(), object(), object() objective = Objective(input_layer, loss_function) result = objective.get_loss(input, target, 'mean', kwarg1=kwarg1) # We expect that the input layer's `get_output` was called with # the `input` argument we provided, plus the extra positional and # keyword arguments. input_layer.get_output.assert_called_with(input, kwarg1=kwarg1) network_output = input_layer.get_output.return_value # The `network_output` and `target` are fed into the loss # function: loss_function.assert_called_with(network_output, target) assert result == loss_function.return_value.mean.return_value
def create_iter_functions(self, dataset, output_layer, X_tensor_type=T.matrix): batch_index = T.iscalar('batch_index') X_batch = X_tensor_type('x') y_batch = T.ivector('y') batch_slice = slice(batch_index * self.batch_size, (batch_index + 1) * self.batch_size) objective = Objective(output_layer, loss_function=categorical_crossentropy) loss_train = objective.get_loss(X_batch, target=y_batch) loss_eval = objective.get_loss(X_batch, target=y_batch, deterministic=True) pred = T.argmax(output_layer.get_output(X_batch, deterministic=True), axis=1) proba = output_layer.get_output(X_batch, deterministic=True) accuracy = T.mean(T.eq(pred, y_batch), dtype=theano.config.floatX) all_params = get_all_params(output_layer) updates = adagrad(loss_train, all_params, self.lr, self.rho) iter_train = theano.function( [batch_index], loss_train, updates=updates, givens={ X_batch: dataset['X_train'][batch_slice], y_batch: dataset['y_train'][batch_slice], }, on_unused_input='ignore', ) iter_valid = None if self.use_valid: iter_valid = theano.function( [batch_index], [loss_eval, accuracy, proba], givens={ X_batch: dataset['X_valid'][batch_slice], y_batch: dataset['y_valid'][batch_slice], }, ) return dict(train=iter_train, valid=iter_valid)
def test_objective(self): from lasagne.objectives import Objective from lasagne.layers.input import Layer, InputLayer input_layer = mock.Mock(InputLayer((None,))) layer = mock.Mock(Layer(input_layer)) layer.input_layer = input_layer loss_function = mock.Mock() input, target, kwarg1 = theano.tensor.vector(), object(), object() objective = Objective(layer, loss_function) result = objective.get_loss(input, target, 'mean', kwarg1=kwarg1) # We expect that the layer's `get_output_for` was called with # the `input` argument we provided, plus the extra positional and # keyword arguments. layer.get_output_for.assert_called_with(input, kwarg1=kwarg1) network_output = layer.get_output_for.return_value # The `network_output` and `target` are fed into the loss # function: loss_function.assert_called_with(network_output, target) assert result == loss_function.return_value.mean.return_value
def test_objective(self): from lasagne.objectives import Objective from lasagne.layers.input import Layer, InputLayer input_layer = mock.Mock(InputLayer((None, )), output_shape=(None, )) layer = mock.Mock(Layer(input_layer), output_shape=(None, )) layer.input_layer = input_layer loss_function = mock.Mock() input, target, kwarg1 = theano.tensor.vector(), object(), object() objective = Objective(layer, loss_function) result = objective.get_loss(input, target, 'mean', kwarg1=kwarg1) # We expect that the layer's `get_output_for` was called with # the `input` argument we provided, plus the extra positional and # keyword arguments. layer.get_output_for.assert_called_with(input, kwarg1=kwarg1) network_output = layer.get_output_for.return_value # The `network_output` and `target` are fed into the loss # function: loss_function.assert_called_with(network_output, target) assert result == loss_function.return_value.mean.return_value
def get_loss(self, loss_function, output, target, aggregation=None): from lasagne.objectives import Objective input_layer = self.input_layer(output) obj = Objective(input_layer, loss_function) return obj.get_loss(target=target, aggregation=aggregation)
def get_loss(self, loss_function, output, target, aggregation=None): from lasagne.objectives import Objective input_layer = self.input_layer(output) obj = Objective(input_layer, loss_function) return obj.get_loss(target=target, aggregation=aggregation)
def __init__(self, input_layer, loss_function=None, aggregation='mean',**args): Objective.__init__(self, input_layer, loss_function, aggregation) if 'alpha' in args: self.alpha=args['alpha'] else: self.alpha=0.0
min_sigma=0 ) ) print("Total parameters: {}".format( sum([p.get_value().size for p in lasagne.layers.get_all_params(layers[-1])]))) X = T.tensor3('X') t = T.matrix('t') # add test values X.tag.test_value = floatX(np.random.rand(*SHAPE)) t.tag.test_value = floatX(np.random.rand(N_SEQ_PER_BATCH * SEQ_LENGTH, 1)) objective = Objective(layers[-1], loss_function=mdn_nll) loss = objective.get_loss(X, t) all_params = lasagne.layers.get_all_params(layers[-1]) updates = lasagne.updates.momentum(loss, all_params, learning_rate) # Theano functions for training, getting output, and computing loss print("Compiling Theano functions...") train = theano.function([X, t], loss, updates=updates) y_pred = theano.function([X], layers[-1].get_output(X)) compute_loss = theano.function([X, t], loss) print("Done compiling Theano functions.") # Train the net costs = [] t_val = t_val.reshape((N_SEQ_PER_BATCH * SEQ_LENGTH, 1))
def __init__(self, input_layer, loss_function=None, aggregation='mean',**args): Objective.__init__(self, input_layer, loss_function, aggregation)
num_components=N_COMPONENTS, min_sigma=0)) print("Total parameters: {}".format( sum([ p.get_value().size for p in lasagne.layers.get_all_params(layers[-1]) ]))) X = T.tensor3('X') t = T.matrix('t') # add test values X.tag.test_value = floatX(np.random.rand(*SHAPE)) t.tag.test_value = floatX(np.random.rand(N_SEQ_PER_BATCH * SEQ_LENGTH, 1)) objective = Objective(layers[-1], loss_function=mdn_nll) loss = objective.get_loss(X, t) all_params = lasagne.layers.get_all_params(layers[-1]) updates = lasagne.updates.momentum(loss, all_params, learning_rate) # Theano functions for training, getting output, and computing loss print("Compiling Theano functions...") train = theano.function([X, t], loss, updates=updates) y_pred = theano.function([X], layers[-1].get_output(X)) compute_loss = theano.function([X, t], loss) print("Done compiling Theano functions.") # Train the net costs = [] t_val = t_val.reshape((N_SEQ_PER_BATCH * SEQ_LENGTH, 1))