code: def objective(layers,
                loss_function,
                target,
                aggregate=aggregate,
                deterministic=False,
                l1=0,
                l2=0,
                get_output_kw=None):
      
      if get_output_kw is None:
          get_output_kw = {}
      output_layer = layers[-1]
      network_output = get_output(
          output_layer, deterministic=deterministic, **get_output_kw)
      loss = aggregate(loss_function(network_output, target))
  
      if l1:
          loss += regularization.regularize_layer_params(
              layers.values(), regularization.l1) * l1
      if l2:
          loss += regularization.regularize_layer_params(
              layers.values(), regularization.l2) * l2
      return loss
docs: Default implementation of the NeuralNet objective.
  
      :param layers: The underlying layers of the NeuralNetwork
      :param loss_function: The callable loss function to use
      :param target: the expected output
  
      :param aggregate: the aggregation function to use
      :param deterministic: Whether or not to get a deterministic output
      :param l1: Optional l1 regularization parameter
      :param l2: Optional l2 regularization parameter
      :param get_output_kw: optional kwargs to pass to
                            :meth:`NeuralNetwork.get_output`
      :return: The total calculated loss