Skip to content
Snippets Groups Projects
Commit 723600f8 authored by Martin Beseda's avatar Martin Beseda
Browse files

ENH: Added method for evaluation errors on an arbitrary data-set. Several... 

ENH: Added method for evaluation errors on an arbitrary data-set. Several methods overloaded to be able to output into the file according to the open handler.
parent d93352d2
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/ErrorFunction/ErrorFunctions.cpp
+ 214
− 66
View file @ 723600f8
......@@ -8,6 +8,8 @@
#include <boost/random/uniform_int_distribution.hpp>
#include "ErrorFunctions.h"
#include "exceptions.h"
#include "message.h"
namespace lib4neuro {
......@@ -41,12 +43,12 @@ namespace lib4neuro {
std::vector<std::pair<std::vector<double>, std::vector<double>>> test_data, train_data;
/* Copy all the data to train_data */
for(auto e : *this->ds_full->get_data()) {
for (auto e : *this->ds_full->get_data()) {
train_data.emplace_back(e);
}
/* Move the testing data from train_data to test_data */
for(auto ind : test_indices) {
for (auto ind : test_indices) {
test_data.emplace_back(train_data.at(ind));
train_data.erase(train_data.begin() + ind);
}
......@@ -59,18 +61,47 @@ namespace lib4neuro {
}
void ErrorFunction::return_full_data_set_for_training() {
if(this->ds_test) {
if (this->ds_test) {
this->ds = this->ds_full;
}
}
MSE::MSE(NeuralNetwork *net, DataSet *ds) {
DataSet* ErrorFunction::get_dataset() {
return this->ds;
}
DataSet* ErrorFunction::get_test_dataset() {
return this->ds_test;
}
std::vector<double>* ErrorFunction::get_parameters() {
std::vector<double>* output = new std::vector<double>(this->net->get_n_weights() + this->net->get_n_biases());
size_t i = 0;
for (auto el: *this->net->get_parameter_ptr_weights()) {
output->at(i) = el;
++i;
}
for (auto el: *this->net->get_parameter_ptr_biases()) {
output->at(i) = el;
++i;
}
return output;
}
MSE::MSE(NeuralNetwork* net, DataSet* ds) {
this->net = net;
this->ds = ds;
this->dimension = net->get_n_weights() + net->get_n_biases();
}
double MSE::eval_general(DataSet* data_set, std::vector<double> *weights) {
double MSE::eval_on_data_set(lib4neuro::DataSet* data_set, std::ofstream* results_file_path,
std::vector<double>* weights) {
//TODO do NOT duplicate code - rewrite the function in a better way
size_t dim_out = data_set->get_output_dim();
size_t n_elements = data_set->get_n_elements();
double error = 0.0, val;
......@@ -80,27 +111,140 @@ namespace lib4neuro {
//TODO instead use something smarter
std::vector<double> output(dim_out);
for (auto el: *data) { // Iterate through every element in the test set
COUT_DEBUG(
"Evaluation of the error function MSE on the given data-set (format 'input' 'real output' 'predicted output'):"
<< std::endl);
*results_file_path << "[Element index] [Input] [Real output] [Predicted output]" << std::endl;
for (auto i = 0; i < data->size(); i++) { // Iterate through every element in the test set
this->net->eval_single(el.first,
/* Compute the net output and store it into 'output' variable */
this->net->eval_single(data->at(i).first,
output,
weights); // Compute the net output and store it into 'output' variable
weights);
for (size_t j = 0; j < dim_out; ++j) { // Compute difference for every element of the output vector
val = output[j] - el.second[j];
/* Compute difference for every element of the output vector */
for (size_t j = 0; j < dim_out; ++j) {
COUT_DEBUG("Element " << i << ": "
<< data->at(i).first.at(j) << " "
<< data->at(i).second.at(j) << " "
<< output.at(j) << std::endl);
*results_file_path << "Element " << i << ": "
<< data->at(i).first.at(j) << " "
<< data->at(i).second.at(j) << " "
<< output.at(j);// << std::endl;
val = output.at(j) - data->at(i).second.at(j);
error += val * val;
}
*results_file_path << std::endl;
}
double result = error / n_elements;
*results_file_path << "MSE = " << result << std::endl;
return result;
}
double MSE::eval_on_data_set(DataSet* data_set, std::string results_file_path, std::vector<double>* weights) {
//TODO do NOT duplicate code - rewrite the function in a better way
size_t dim_out = data_set->get_output_dim();
size_t n_elements = data_set->get_n_elements();
double error = 0.0, val;
std::vector<std::pair<std::vector<double>, std::vector<double>>>* data = data_set->get_data();
//TODO instead use something smarter
std::vector<double> output(dim_out);
COUT_DEBUG(
"Evaluation of the error function MSE on the given data-set (format 'input' 'real output' 'predicted output'):"
<< std::endl);
std::ofstream ofs(results_file_path);
if (!ofs.is_open()) {
THROW_RUNTIME_ERROR("File path: " + results_file_path + " was not successfully opened!");
}
ofs << "[Input] [Real output] [Predicted output]" << std::endl;
for (auto i = 0; i < data->size(); i++) { // Iterate through every element in the test set
/* Compute the net output and store it into 'output' variable */
this->net->eval_single(data->at(i).first,
output,
weights);
/* Compute difference for every element of the output vector */
for (size_t j = 0; j < dim_out; ++j) {
COUT_DEBUG("Element " << i << ": "
<< data->at(i).first.at(j) << " "
<< data->at(i).second.at(j) << " "
<< output.at(j) << std::endl);
ofs << data->at(i).first.at(j) << " "
<< data->at(i).second.at(j) << " "
<< output.at(j) << std::endl;
val = output.at(j) - data->at(i).second.at(j);
error += val * val;
}
ofs << std::endl;
}
ofs.close();
return error / n_elements;
}
double MSE::eval(std::vector<double> *weights) {
double MSE::eval_on_data_set(DataSet* data_set, std::vector<double>* weights) {
size_t dim_out = data_set->get_output_dim();
size_t n_elements = data_set->get_n_elements();
double error = 0.0, val;
std::vector<std::pair<std::vector<double>, std::vector<double>>>* data = data_set->get_data();
//TODO instead use something smarter
std::vector<double> output(dim_out);
COUT_DEBUG(
"Evaluation of the error function MSE on the given data-set (format 'input' 'real output' 'predicted output'):"
<< std::endl);
for (auto i = 0; i < data->size(); i++) { // Iterate through every element in the test set
/* Compute the net output and store it into 'output' variable */
this->net->eval_single(data->at(i).first,
output,
weights);
/* Compute difference for every element of the output vector */
for (size_t j = 0; j < dim_out; ++j) {
COUT_DEBUG("Element " << i << ": "
<< data->at(i).first.at(j) << " "
<< data->at(i).second.at(j) << " "
<< output.at(j) << std::endl);
val = output.at(j) - data->at(i).second.at(j);
error += val * val;
}
}
return error / n_elements;
}
double MSE::eval(std::vector<double>* weights) {
size_t dim_out = this->ds->get_output_dim();
// unsigned int dim_in = this->ds->get_input_dim();
size_t n_elements = this->ds->get_n_elements();
double error = 0.0, val;
std::vector<std::pair<std::vector<double>, std::vector<double>>> *data = this->ds->get_data();
std::vector<std::pair<std::vector<double>, std::vector<double>>>* data = this->ds->get_data();
// //TODO instead use something smarter
// this->net->copy_weights(weights);
......@@ -114,47 +258,33 @@ namespace lib4neuro {
for (size_t j = 0; j < dim_out; ++j) { // Compute difference for every element of the output vector
val = output[j] - el.second[j];
val = output.at(j) - el.second.at(j);
error += val * val;
}
}
return error / n_elements;
}
double MSE::eval_on_test_data(std::vector<double> *weights) {
return this->eval_general(this->ds_test, weights);
double MSE::eval_on_test_data(std::vector<double>* weights) {
return this->eval_on_data_set(this->ds_test, weights);
}
// void MSE::calculate_error_gradient(std::vector<double> &params, std::vector<double> &grad, double alpha) {
//
// size_t dim_out = this->ds->get_output_dim();
// size_t n_elements = this->ds->get_n_elements();
//
// std::vector<std::pair<std::vector<double>, std::vector<double>>> *data = this->ds->get_data();
//
// std::vector<double> error_derivative(dim_out);
//
//
// for (auto el: *data) { // Iterate through every element in the test set
//
// this->net->eval_single(el.first, error_derivative,
// &params); // Compute the net output and store it into 'output' variable
//
// for (size_t j = 0; j < dim_out; ++j) {
// error_derivative[j] = 2.0 * (error_derivative[j] - el.second[j]); //real - expected result
// }
//
// this->net->add_to_gradient_single(el.first, error_derivative, alpha / n_elements, grad);
// }
// }
double MSE::eval_on_test_data(std::string results_file_path, std::vector<double>* weights) {
return this->eval_on_data_set(this->ds_test, results_file_path, weights);
}
double MSE::eval_on_test_data(std::ofstream* results_file_path, std::vector<double>* weights) {
return this->eval_on_data_set(this->ds_test, results_file_path, weights);
}
void MSE::calculate_error_gradient(std::vector<double> &params, std::vector<double> &grad, double alpha, size_t batch) {
void
MSE::calculate_error_gradient(std::vector<double>& params, std::vector<double>& grad, double alpha, size_t batch) {
size_t dim_out = this->ds->get_output_dim();
size_t n_elements = this->ds->get_n_elements();
std::vector<std::pair<std::vector<double>, std::vector<double>>> *data = this->ds->get_data();
std::vector<std::pair<std::vector<double>, std::vector<double>>>* data = this->ds->get_data();
if(batch) {
if (batch) {
*data = this->ds->get_random_data_batch(batch);
n_elements = data->size();
}
......@@ -174,24 +304,6 @@ namespace lib4neuro {
}
}
std::vector<double> *MSE::get_parameters() {
std::vector<double> *output = new std::vector<double>(this->net->get_n_weights() + this->net->get_n_biases());
size_t i = 0;
for (auto el: *this->net->get_parameter_ptr_weights()) {
output->at(i) = el;
++i;
}
for (auto el: *this->net->get_parameter_ptr_biases()) {
output->at(i) = el;
++i;
}
return output;
}
ErrorSum::ErrorSum() {
this->summand = nullptr;
this->summand_coefficient = nullptr;
......@@ -211,9 +323,9 @@ namespace lib4neuro {
//TODO take care of the case, when there are no test data
double output = 0.0;
ErrorFunction *ef = nullptr;
ErrorFunction* ef = nullptr;
for(unsigned int i = 0; i < this->summand->size(); ++i) {
for (unsigned int i = 0; i < this->summand->size(); ++i) {
ef = this->summand->at(i);
if (ef) {
......@@ -224,9 +336,39 @@ namespace lib4neuro {
return output;
}
double ErrorSum::eval_on_test_data(std::string results_file_path, std::vector<double>* weights) {
THROW_NOT_IMPLEMENTED_ERROR();
return -1;
}
double ErrorSum::eval_on_test_data(std::ofstream* results_file_path, std::vector<double>* weights) {
THROW_NOT_IMPLEMENTED_ERROR();
return -1;
}
double ErrorSum::eval_on_data_set(lib4neuro::DataSet* data_set, std::vector<double>* weights) {
THROW_NOT_IMPLEMENTED_ERROR();
return -1;
}
double ErrorSum::eval_on_data_set(lib4neuro::DataSet* data_set, std::string results_file_path,
std::vector<double>* weights) {
THROW_NOT_IMPLEMENTED_ERROR();
return -1;
}
double ErrorSum::eval_on_data_set(lib4neuro::DataSet* data_set, std::ofstream* results_file_path,
std::vector<double>* weights) {
THROW_NOT_IMPLEMENTED_ERROR();
return -1;
}
double ErrorSum::eval(std::vector<double>* weights) {
double output = 0.0;
ErrorFunction *ef = nullptr;
ErrorFunction* ef = nullptr;
for (unsigned int i = 0; i < this->summand->size(); ++i) {
ef = this->summand->at(i);
......@@ -239,9 +381,10 @@ namespace lib4neuro {
return output;
}
void ErrorSum::calculate_error_gradient(std::vector<double> &params, std::vector<double> &grad, double alpha, size_t batch) {
void ErrorSum::calculate_error_gradient(std::vector<double>& params, std::vector<double>& grad, double alpha,
size_t batch) {
ErrorFunction *ef = nullptr;
ErrorFunction* ef = nullptr;
for (size_t i = 0; i < this->summand->size(); ++i) {
ef = this->summand->at(i);
......@@ -251,9 +394,9 @@ namespace lib4neuro {
}
}
void ErrorSum::add_error_function(ErrorFunction *F, double alpha) {
void ErrorSum::add_error_function(ErrorFunction* F, double alpha) {
if (!this->summand) {
this->summand = new std::vector<ErrorFunction *>(0);
this->summand = new std::vector<ErrorFunction*>(0);
}
this->summand->push_back(F);
......@@ -283,8 +426,13 @@ namespace lib4neuro {
return this->dimension;
}
std::vector<double> *ErrorSum::get_parameters() {
std::vector<double>* ErrorSum::get_parameters() {
return this->summand->at(0)->get_parameters();
}
DataSet* ErrorSum::get_dataset() {
return this->summand->at(0)->get_dataset();
};
}
src/ErrorFunction/ErrorFunctions.h
+ 165
− 28
View file @ 723600f8
......@@ -10,6 +10,8 @@
#include "../Network/NeuralNetwork.h"
#include "../DataSet/DataSet.h"
//TODO HEAVY refactoring needed!
namespace lib4neuro {
enum ErrorFunctionType {
......@@ -25,7 +27,7 @@ namespace lib4neuro {
* @param weights
* @return
*/
virtual double eval(std::vector<double> *weights = nullptr) = 0;
virtual double eval(std::vector<double>* weights = nullptr) = 0;
/**
*
......@@ -41,8 +43,8 @@ namespace lib4neuro {
* @param batch
*/
virtual void
calculate_error_gradient(std::vector<double> &params,
std::vector<double> &grad,
calculate_error_gradient(std::vector<double>& params,
std::vector<double>& grad,
double alpha = 1.0,
size_t batch = 0) = 0;
......@@ -50,13 +52,18 @@ namespace lib4neuro {
*
* @return
*/
virtual std::vector<double> *get_parameters() = 0;
virtual std::vector<double>* get_parameters();
/**
* //TODO delete after gradient learning is debugged
* @return
*/
virtual DataSet* get_dataset() = 0;
virtual DataSet* get_dataset();
/**
*
* @return
*/
virtual DataSet* get_test_dataset();
/**
*
......@@ -81,6 +88,51 @@ namespace lib4neuro {
*/
virtual double eval_on_test_data(std::vector<double>* weights = nullptr) = 0;
/**
*
* @param results_file_path
* @param weights
* @return
*/
virtual double eval_on_test_data(std::string results_file_path, std::vector<double>* weights = nullptr) = 0;
/**
*
* @param results_file_path
* @param weights
* @return
*/
virtual double eval_on_test_data(std::ofstream* results_file_path, std::vector<double>* weights = nullptr) = 0;
/**
*
* @param data_set
* @param weights
* @return
*/
virtual double eval_on_data_set(DataSet* data_set, std::vector<double>* weights = nullptr) = 0;
/**
*
* @param data_set
* @param weights
* @param results_file_path
* @return
*/
virtual double
eval_on_data_set(DataSet* data_set, std::string results_file_path, std::vector<double>* weights = nullptr) = 0;
/**
*
* @param data_set
* @param results_file_path
* @param weights
* @return
*/
virtual double eval_on_data_set(DataSet* data_set, std::ofstream* results_file_path,
std::vector<double>* weights = nullptr) = 0;
protected:
/**
......@@ -109,6 +161,7 @@ namespace lib4neuro {
DataSet* ds_test = nullptr;
};
class MSE : public ErrorFunction {
public:
......@@ -117,14 +170,14 @@ namespace lib4neuro {
* @param net
* @param ds
*/
LIB4NEURO_API MSE(NeuralNetwork *net, DataSet *ds);
LIB4NEURO_API MSE(NeuralNetwork* net, DataSet* ds);
/**
*
* @param weights
* @return
*/
LIB4NEURO_API double eval(std::vector<double> *weights = nullptr) override;
LIB4NEURO_API double eval(std::vector<double>* weights = nullptr) override;
/**
*
......@@ -134,25 +187,62 @@ namespace lib4neuro {
* @param batch
*/
LIB4NEURO_API void
calculate_error_gradient(std::vector<double> &params,
std::vector<double> &grad,
calculate_error_gradient(std::vector<double>& params,
std::vector<double>& grad,
double alpha = 1.0,
size_t batch = 0) override;
/**
*
* @param weights
* @return
*/
LIB4NEURO_API std::vector<double> *get_parameters() override;
LIB4NEURO_API double eval_on_test_data(std::vector<double>* weights = nullptr) override;
LIB4NEURO_API DataSet *get_dataset() override {
return this->ds;
};
/**
*
* @param results_file_path
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_test_data(std::string results_file_path, std::vector<double>* weights = nullptr);
LIB4NEURO_API double eval_on_test_data(std::vector<double> *weights = nullptr) override;
/**
*
* @param results_file_path
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_test_data(std::ofstream* results_file_path, std::vector<double>* weights = nullptr) override;
private:
double eval_general(DataSet* data_set, std::vector<double>* weights = nullptr);
/**
*
* @param data_set
* @param results_file_path
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_data_set(DataSet* data_set,
std::ofstream* results_file_path,
std::vector<double>* weights = nullptr) override;
/**
*
* @param data_set
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_data_set(DataSet* data_set, std::vector<double>* weights = nullptr) override;
/**
*
* @param data_set
* @param results_file_path
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_data_set(DataSet* data_set, std::string results_file_path,
std::vector<double>* weights = nullptr) override;
};
......@@ -173,20 +263,65 @@ namespace lib4neuro {
* @param weights
* @return
*/
LIB4NEURO_API double eval(std::vector<double> *weights = nullptr) override;
LIB4NEURO_API double eval(std::vector<double>* weights = nullptr) override;
/**
*
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_test_data(std::vector<double>* weights = nullptr) override;
/**
*
* @param results_file_path
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_test_data(std::string results_file_path, std::vector<double>* weights = nullptr);
/**
*
* @param results_file_path
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_test_data(std::vector<double> *weights = nullptr) override;
LIB4NEURO_API double eval_on_test_data(std::ofstream* results_file_path, std::vector<double>* weights = nullptr) override;
/**
*
* @param data_set
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_data_set(DataSet* data_set, std::vector<double>* weights = nullptr) override;
/**
*
* @param data_set
* @param results_file_path
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_data_set(DataSet* data_set, std::string results_file_path,
std::vector<double>* weights = nullptr) override;
/**
*
* @param data_set
* @param results_file_path
* @param weights
* @return
*/
LIB4NEURO_API double eval_on_data_set(DataSet* data_set,
std::ofstream* results_file_path,
std::vector<double>* weights = nullptr) override;
/**
*
* @param F
*/
LIB4NEURO_API void add_error_function(ErrorFunction *F, double alpha = 1.0);
LIB4NEURO_API void add_error_function(ErrorFunction* F, double alpha = 1.0);
/**
*
......@@ -202,23 +337,25 @@ namespace lib4neuro {
* @param batch
*/
LIB4NEURO_API void
calculate_error_gradient(std::vector<double> &params,
std::vector<double> &grad,
calculate_error_gradient(std::vector<double>& params,
std::vector<double>& grad,
double alpha = 1.0,
size_t batch = 0) override;
/**
*
* @return
*/
LIB4NEURO_API std::vector<double> *get_parameters() override;
LIB4NEURO_API std::vector<double>* get_parameters() override;
LIB4NEURO_API DataSet *get_dataset() override {
return this->summand->at(0)->get_dataset();
};
/**
*
* @return
*/
LIB4NEURO_API DataSet* get_dataset() override;
private:
std::vector<ErrorFunction *> *summand;
std::vector<double> *summand_coefficient;
std::vector<ErrorFunction*>* summand;
std::vector<double>* summand_coefficient;
};
}
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment