Exemplos de objective_gradient em C++ (Cpp)

Exemplo n.º 1

Arquivo: minkowski_error.cpp Projeto: mcintst/OpenNNTest

Vector<double> MinkowskiError::calculate_gradient(void) const
{
   // Control sentence (if debug)

   #ifdef _DEBUG 

   check();

   #endif

   // Neural network stuff

   const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();

   const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
   const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();

   const unsigned int parameters_number = multilayer_perceptron_pointer->count_parameters_number();

   // Data set stuff

   const InstancesInformation& instances_information = data_set_pointer->get_instances_information();

   const unsigned int training_instances_number = instances_information.count_training_instances_number();

   Vector<double> inputs(inputs_number);
   Vector<double> targets(outputs_number);

   Vector<double> objective_gradient(parameters_number, 0.0);

   for(unsigned int i = 0; i < training_instances_number; i++)
   {
      // Input vector

	  inputs = data_set_pointer->get_training_input_instance(i);

      // Target vector

      targets = data_set_pointer->get_training_target_instance(i);

      // Minkowski error gradient

//      for(unsigned int j = 0; j < outputs_number; j++)
//      {
//         output_objective_gradient[i] = Minkowski_parameter*pow(fabs(outputs[i] - target[i]), Minkowski_parameter-1.0);		 
//      }
//      objective_gradient += calculate_point_gradient(inputs, targets);           
   }

   return(objective_gradient);
}

Exemplo n.º 2

Arquivo: mean_squared_error.cpp Projeto: jrdodson/opennn

Vector<double> MeanSquaredError::calculate_gradient(void) const {
// Control sentence (if debug)

#ifndef NDEBUG

  check();

#endif

  // Multilayer percepron stuff

  const MultilayerPerceptron* multilayer_perceptron_pointer =
      neural_network_pointer->get_multilayer_perceptron_pointer();

  const unsigned inputs_number =
      multilayer_perceptron_pointer->get_inputs_number();
  const unsigned outputs_number =
      multilayer_perceptron_pointer->get_outputs_number();

  const unsigned layers_number =
      multilayer_perceptron_pointer->get_layers_number();

  const unsigned parameters_number =
      multilayer_perceptron_pointer->count_parameters_number();

  Vector<Vector<Vector<double> > > first_order_forward_propagation(2);

  const bool has_conditions_layer =
      neural_network_pointer->has_conditions_layer();

  const ConditionsLayer* conditions_layer_pointer =
      has_conditions_layer
          ? neural_network_pointer->get_conditions_layer_pointer()
          : NULL;

  Vector<double> particular_solution;
  Vector<double> homogeneous_solution;

  // Data set stuff

  const Instances& instances = data_set_pointer->get_instances();

  const unsigned training_instances_number =
      instances.count_training_instances_number();

  Vector<double> inputs(inputs_number);
  Vector<double> targets(outputs_number);

  // Mean squared error stuff

  Vector<Vector<double> > layers_delta;

  Vector<double> output_objective_gradient(outputs_number);

  Vector<double> point_gradient(parameters_number, 0.0);

  Vector<double> objective_gradient(parameters_number, 0.0);

  // Main loop

  for (unsigned i = 0; i < training_instances_number; i++) {
    inputs = data_set_pointer->get_training_input_instance(i);

    targets = data_set_pointer->get_training_target_instance(i);

    first_order_forward_propagation = multilayer_perceptron_pointer
        ->calculate_first_order_forward_propagation(inputs);

    const Vector<Vector<double> >& layers_activation =
        first_order_forward_propagation[0];
    const Vector<Vector<double> >& layers_activation_derivative =
        first_order_forward_propagation[1];

    if (!has_conditions_layer) {
      output_objective_gradient =
          (layers_activation[layers_number - 1] - targets) *
          (2.0 / (double)training_instances_number);

      layers_delta = calculate_layers_delta(layers_activation_derivative,
                                            output_objective_gradient);
    } else {
      particular_solution =
          conditions_layer_pointer->calculate_particular_solution(inputs);
      homogeneous_solution =
          conditions_layer_pointer->calculate_homogeneous_solution(inputs);

      output_objective_gradient =
          (particular_solution +
           homogeneous_solution * layers_activation[layers_number - 1] -
           targets) *
          (2.0 / (double)training_instances_number);

      layers_delta = calculate_layers_delta(layers_activation_derivative,
                                            homogeneous_solution,
                                            output_objective_gradient);
    }

    point_gradient =
        calculate_point_gradient(inputs, layers_activation, layers_delta);

    objective_gradient += point_gradient;
  }

  return (objective_gradient);
}