std::string NormalizedSquaredError::write_information(void) const { std::ostringstream buffer; buffer << "Normalized squared error: " << calculate_error() << "\n"; return(buffer.str()); }
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); }
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); }
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); }