00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include "minkowski_error.h"
00019
00020
00021
00022 #include <string>
00023 #include <sstream>
00024 #include <iostream>
00025 #include <fstream>
00026 #include <cmath>
00027
00028
00029
00030 #include "../../parsers/tinyxml/tinyxml.h"
00031
00032
00033 namespace OpenNN
00034 {
00035
00036
00037
00041
00042 MinkowskiError::MinkowskiError(void) : PerformanceTerm()
00043 {
00044 set_default();
00045 }
00046
00047
00048
00049
00054
00055 MinkowskiError::MinkowskiError(NeuralNetwork* new_neural_network_pointer)
00056 : PerformanceTerm(new_neural_network_pointer)
00057 {
00058 set_default();
00059 }
00060
00061
00062
00063
00068
00069 MinkowskiError::MinkowskiError(DataSet* new_data_set_pointer)
00070 : PerformanceTerm(new_data_set_pointer)
00071 {
00072 set_default();
00073 }
00074
00075
00076
00077
00083
00084 MinkowskiError::MinkowskiError(NeuralNetwork* new_neural_network_pointer, DataSet* new_data_set_pointer)
00085 : PerformanceTerm(new_neural_network_pointer, new_data_set_pointer)
00086 {
00087 set_default();
00088 }
00089
00090
00091
00092
00097
00098 MinkowskiError::MinkowskiError(TiXmlElement* mean_squared_error_element)
00099 : PerformanceTerm(mean_squared_error_element)
00100 {
00101 set_default();
00102
00103 from_XML(mean_squared_error_element);
00104 }
00105
00106
00107
00108
00111
00112 MinkowskiError::~MinkowskiError(void)
00113 {
00114 }
00115
00116
00117
00118
00119
00120
00122
00123 double MinkowskiError::get_Minkowski_parameter(void) const
00124 {
00125 return(Minkowski_parameter);
00126 }
00127
00128
00129
00130
00136
00137 void MinkowskiError::set_default(void)
00138 {
00139 Minkowski_parameter = 1.5;
00140
00141 display = true;
00142 }
00143
00144
00145
00146
00150
00151 void MinkowskiError::set_Minkowski_parameter(const double& new_Minkowski_parameter)
00152 {
00153
00154
00155 if(new_Minkowski_parameter < 1.0 || new_Minkowski_parameter > 2.0)
00156 {
00157 std::ostringstream buffer;
00158
00159 buffer << "OpenNN Error. MinkowskiError class.\n"
00160 << "void set_Minkowski_parameter(const double&) method.\n"
00161 << "The Minkowski parameter must be comprised between 1 and 2\n";
00162
00163 throw std::logic_error(buffer.str().c_str());
00164 }
00165
00166
00167
00168 Minkowski_parameter = new_Minkowski_parameter;
00169 }
00170
00171
00172
00173
00177
00178 void MinkowskiError::check(void) const
00179 {
00180 std::ostringstream buffer;
00181
00182
00183
00184 if(!neural_network_pointer)
00185 {
00186 buffer << "OpenNN Exception: MinkowskiError class.\n"
00187 << "void check(void) const method.\n"
00188 << "Pointer to neural network is NULL.\n";
00189
00190 throw std::logic_error(buffer.str().c_str());
00191 }
00192
00193 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00194
00195 if(!multilayer_perceptron_pointer)
00196 {
00197 buffer << "OpenNN Exception: MinkowskiError class.\n"
00198 << "void check(void) const method.\n"
00199 << "Pointer to multilayer perceptron is NULL.\n";
00200
00201 throw std::logic_error(buffer.str().c_str());
00202 }
00203
00204 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00205 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00206
00207 if(inputs_number == 0)
00208 {
00209 buffer << "OpenNN Exception: MinkowskiError class.\n"
00210 << "void check(void) const method.\n"
00211 << "Number of inputs in multilayer perceptron object is zero.\n";
00212
00213 throw std::logic_error(buffer.str().c_str());
00214 }
00215
00216 if(outputs_number == 0)
00217 {
00218 buffer << "OpenNN Exception: MinkowskiError class.\n"
00219 << "void check(void) const method.\n"
00220 << "Number of outputs in multilayer perceptron object is zero.\n";
00221
00222 throw std::logic_error(buffer.str().c_str());
00223 }
00224
00225
00226
00227 if(!data_set_pointer)
00228 {
00229 buffer << "OpenNN Exception: MinkowskiError class.\n"
00230 << "void check(void) const method.\n"
00231 << "Pointer to data set is NULL.\n";
00232
00233 throw std::logic_error(buffer.str().c_str());
00234 }
00235
00236
00237
00238 const VariablesInformation& variables_information = data_set_pointer->get_variables_information();
00239
00240 const unsigned int targets_number = variables_information.count_targets_number();
00241
00242 if(inputs_number != inputs_number)
00243 {
00244 buffer << "OpenNN Exception: MinkowskiError class.\n"
00245 << "void check(void) const method.\n"
00246 << "Number of inputs in multilayer perceptron must be equal to number of inputs in data set.\n";
00247
00248 throw std::logic_error(buffer.str().c_str());
00249 }
00250
00251 if(outputs_number != targets_number)
00252 {
00253 buffer << "OpenNN Exception: MinkowskiError class.\n"
00254 << "void check(void) const method.\n"
00255 << "Number of outputs in multilayer perceptron must be equal to number of targets in data set.\n";
00256
00257 throw std::logic_error(buffer.str().c_str());
00258 }
00259 }
00260
00261
00262
00263
00267
00268 double MinkowskiError::calculate_evaluation(const Vector<double>& parameters) const
00269 {
00270
00271
00272 #ifdef _DEBUG
00273
00274 check();
00275
00276 #endif
00277
00278 #ifdef _DEBUG
00279
00280 const unsigned int size = parameters.size();
00281
00282 const unsigned int parameters_number = neural_network_pointer->count_parameters_number();
00283
00284 if(size != parameters_number)
00285 {
00286 std::ostringstream buffer;
00287
00288 buffer << "OpenNN Exception: MeanSquaredError class.\n"
00289 << "double calculate_evaluation(const Vector<double>&) const method.\n"
00290 << "Size (" << size << ") must be equal to number of parameters (" << parameters_number << ").\n";
00291
00292 throw std::logic_error(buffer.str().c_str());
00293 }
00294
00295 #endif
00296
00297 NeuralNetwork neural_network_copy(*neural_network_pointer);
00298
00299 neural_network_copy.set_parameters(parameters);
00300
00301 MinkowskiError Minkowski_error_copy(*this);
00302
00303 Minkowski_error_copy.set_neural_network_pointer(&neural_network_copy);
00304
00305 return(Minkowski_error_copy.calculate_evaluation());
00306 }
00307
00308
00309
00310
00312
00313 double MinkowskiError::calculate_evaluation(void) const
00314 {
00315
00316
00317 #ifdef _DEBUG
00318
00319 check();
00320
00321 #endif
00322
00323
00324
00325 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00326
00327 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00328 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00329
00330
00331
00332 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00333 const unsigned int training_instances_number = instances_information.count_training_instances_number();
00334
00335 Vector<double> inputs(inputs_number);
00336 Vector<double> outputs(outputs_number);
00337 Vector<double> targets(outputs_number);
00338
00339 double Minkowski_error = 0.0;
00340
00341 for(unsigned int i = 0; i < training_instances_number; i++)
00342 {
00343
00344
00345 inputs = data_set_pointer->get_training_input_instance(i);
00346
00347
00348
00349 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00350
00351
00352
00353 targets = data_set_pointer->get_training_target_instance(i);
00354
00355
00356
00357 Minkowski_error += outputs.calculate_Minkowski_error(targets, Minkowski_parameter);
00358 }
00359
00360 return(Minkowski_error);
00361 }
00362
00363
00364
00365
00368
00369 double MinkowskiError::calculate_generalization_evaluation(void) const
00370 {
00371
00372
00373 #ifdef _DEBUG
00374
00375 check();
00376
00377 #endif
00378
00379 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00380
00381 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00382 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00383
00384 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00385
00386 const unsigned int generalization_instances_number = instances_information.count_generalization_instances_number();
00387
00388 Vector<double> inputs(inputs_number);
00389 Vector<double> outputs(outputs_number);
00390 Vector<double> targets(outputs_number);
00391
00392 double generalization_evaluation = 0.0;
00393
00394 for(unsigned int i = 0; i < generalization_instances_number; i++)
00395 {
00396
00397
00398 inputs = data_set_pointer->get_generalization_input_instance(i);
00399
00400
00401
00402 outputs = multilayer_perceptron_pointer->calculate_outputs(inputs);
00403
00404
00405
00406 targets = data_set_pointer->get_generalization_target_instance(i);
00407
00408
00409
00410 generalization_evaluation = outputs.calculate_Minkowski_error(targets, Minkowski_parameter);
00411 }
00412
00413 return(generalization_evaluation);
00414 }
00415
00416
00417
00418
00422
00423 Vector<double> MinkowskiError::calculate_gradient(void) const
00424 {
00425
00426
00427 #ifdef _DEBUG
00428
00429 check();
00430
00431 #endif
00432
00433
00434
00435 const MultilayerPerceptron* multilayer_perceptron_pointer = neural_network_pointer->get_multilayer_perceptron_pointer();
00436
00437 const unsigned int inputs_number = multilayer_perceptron_pointer->count_inputs_number();
00438 const unsigned int outputs_number = multilayer_perceptron_pointer->count_outputs_number();
00439
00440 const unsigned int parameters_number = multilayer_perceptron_pointer->count_parameters_number();
00441
00442
00443
00444 const InstancesInformation& instances_information = data_set_pointer->get_instances_information();
00445
00446 const unsigned int training_instances_number = instances_information.count_training_instances_number();
00447
00448 Vector<double> inputs(inputs_number);
00449 Vector<double> targets(outputs_number);
00450
00451 Vector<double> objective_gradient(parameters_number, 0.0);
00452
00453 for(unsigned int i = 0; i < training_instances_number; i++)
00454 {
00455
00456
00457 inputs = data_set_pointer->get_training_input_instance(i);
00458
00459
00460
00461 targets = data_set_pointer->get_training_target_instance(i);
00462
00463
00464
00465
00466
00467
00468
00469
00470 }
00471
00472 return(objective_gradient);
00473 }
00474
00475
00476
00477
00479
00480 Matrix<double> MinkowskiError::calculate_Hessian(void) const
00481 {
00482 Matrix<double> objective_Hessian;
00483
00484 return(objective_Hessian);
00485 }
00486
00487
00488
00489
00491
00492 std::string MinkowskiError::write_performance_term_type(void) const
00493 {
00494 return("MINKOWSKI_ERROR");
00495 }
00496
00497
00498
00499
00502
00503 TiXmlElement* MinkowskiError::to_XML(void) const
00504 {
00505 std::ostringstream buffer;
00506
00507
00508
00509 TiXmlElement* Minkowski_error_element = new TiXmlElement("MinkowskiError");
00510 Minkowski_error_element->SetAttribute("Version", 4);
00511
00512
00513 {
00514 TiXmlElement* Minkowski_parameter_element = new TiXmlElement("MinkowskiParameter");
00515 Minkowski_error_element->LinkEndChild(Minkowski_parameter_element);
00516
00517 buffer.str("");
00518 buffer << Minkowski_parameter;
00519
00520 TiXmlText* Minkowski_parameter_text = new TiXmlText(buffer.str().c_str());
00521 Minkowski_parameter_element->LinkEndChild(Minkowski_parameter_text);
00522 }
00523
00524
00525 {
00526 TiXmlElement* display_element = new TiXmlElement("Display");
00527 Minkowski_error_element->LinkEndChild(display_element);
00528
00529 buffer.str("");
00530 buffer << display;
00531
00532 TiXmlText* display_text = new TiXmlText(buffer.str().c_str());
00533 display_element->LinkEndChild(display_text);
00534 }
00535
00536 return(Minkowski_error_element);
00537 }
00538
00539
00540
00541
00543
00544 void MinkowskiError::from_XML(TiXmlElement* Minkoski_error_element)
00545 {
00546 if(Minkoski_error_element)
00547 {
00548
00549 {
00550 TiXmlElement* element = Minkoski_error_element->FirstChildElement("MinkowskiParameter");
00551
00552 if(element)
00553 {
00554 const double new_Minkowski_parameter = atof(element->GetText());
00555
00556 try
00557 {
00558 set_Minkowski_parameter(new_Minkowski_parameter);
00559 }
00560 catch(std::exception& e)
00561 {
00562 std::cout << e.what() << std::endl;
00563 }
00564 }
00565
00566 }
00567
00568
00569 {
00570 TiXmlElement* display_element = Minkoski_error_element->FirstChildElement("Display");
00571
00572 if(display_element)
00573 {
00574 std::string new_display_string = display_element->GetText();
00575
00576 try
00577 {
00578 set_display(new_display_string != "0");
00579 }
00580 catch(std::exception& e)
00581 {
00582 std::cout << e.what() << std::endl;
00583 }
00584 }
00585 }
00586 }
00587 }
00588
00589
00590
00591
00594
00595 int MinkowskiError::calculate_sign(const double& value) const
00596 {
00597 if(value < 0.0)
00598 {
00599 return(-1);
00600 }
00601 else
00602 {
00603 return(1);
00604 }
00605 }
00606 }
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624