Ejemplos de calculate_error en C++ (Cpp)

Ejemplo n.º 1

Archivo: normalized_squared_error.cpp Proyecto: Artelnics/OpenNN

std::string NormalizedSquaredError::write_information(void) const
{
    std::ostringstream buffer;

    buffer << "Normalized squared error: " << calculate_error() << "\n";

    return(buffer.str());

}

Ejemplo n.º 2

Archivo: yslim.cpp Proyecto: alanzw/LiveRender

void YSlim::add_error(int v1, int v2) {
	if(v1 >= vertices.size() || v2 >= vertices.size()) return;

	if(is_border(v1, v2)) return;

	errors.push( Error(v1, v2, calculate_error(v1, v2)) );
	
	adj[v1].push_back(v2);
	adj[v2].push_back(v1);
}

Ejemplo n.º 3

Archivo: root_mean_squared_error.cpp Proyecto: PuchoDeepLearningLabs/OpenNN

Matrix<double> RootMeanSquaredError::calculate_output_Hessian(const Vector<double>& output, const Vector<double>& target) const
{
    const Instances& instances = data_set_pointer->get_instances();

    const size_t training_instances_number = instances.count_training_instances_number();

    const double loss = calculate_error();

    const size_t outputs_number = neural_network_pointer->get_multilayer_perceptron_pointer()->get_outputs_number();

    const Vector<double> one_vector(outputs_number,1.0);

    const Vector<double> diagonal = one_vector-((output-target)*(output-target))/(training_instances_number*training_instances_number*loss*loss);

    Matrix<double> output_Hessian(outputs_number, outputs_number,0.0);
    output_Hessian.set_diagonal(diagonal);

    return(output_Hessian);
}

Ejemplo n.º 4

Archivo: root_mean_squared_error.cpp Proyecto: PuchoDeepLearningLabs/OpenNN

Vector<double> RootMeanSquaredError::calculate_gradient(void) const
{
    // Control sentence

       #ifdef __OPENNN_DEBUG__

       check();

       #endif

       // Neural network stuff

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

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

       const size_t layers_number = multilayer_perceptron_pointer->get_layers_number();

       const size_t parameters_number = multilayer_perceptron_pointer->count_parameters_number();

       // Data set stuff

       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 size_t training_instances_number = instances.count_training_instances_number();

       const Vector<size_t> training_indices = instances.arrange_training_indices();

       size_t training_index;

       const Variables& variables = data_set_pointer->get_variables();

       const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();
       const Vector<size_t> targets_indices = variables.arrange_targets_indices();

       const MissingValues& missing_values = data_set_pointer->get_missing_values();

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

       // Loss index stuff

       const double loss = calculate_error();

       Vector< Vector<double> > layers_delta;

       Vector<double> output_gradient(outputs_number);

       Vector<double> point_gradient(parameters_number, 0.0);

       // Main loop

       Vector<double> gradient(parameters_number, 0.0);

       int i = 0;

       #pragma omp parallel for private(i, training_index, inputs, targets, first_order_forward_propagation, output_gradient, \
        layers_delta, particular_solution, homogeneous_solution, point_gradient)

       for(i = 0; i < (int)training_instances_number; i++)
       {
           training_index = training_indices[i];

           if(missing_values.has_missing_values(training_index))
           {
               continue;
           }

          inputs = data_set_pointer->get_instance(training_index, inputs_indices);

          targets = data_set_pointer->get_instance(training_index, targets_indices);

          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_gradient = (layers_activation[layers_number-1]-targets)/(training_instances_number*loss);

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

             output_gradient = (particular_solution+homogeneous_solution*layers_activation[layers_number-1] - targets)/(training_instances_number*loss);

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

          point_gradient = calculate_point_gradient(inputs, layers_activation, layers_delta);

          #pragma omp critical

          gradient += point_gradient;
       }

       return(gradient);
}