ValidationError.cpp

Go to the documentation of this file.

//===========================================================================
//===========================================================================


#include <vector>
#include <Rng/GlobalRng.h>
#include <ReClaM/ValidationError.h>


ValidationError::ValidationError(ErrorFunction* base, Optimizer* opt, int iter, double holdOutFraction)
{
    this->baseError = base;
    this->optimizer = opt;
    this->iterations = iter;
    this->holdOut = holdOutFraction;
}

ValidationError::~ValidationError()
{
}


double ValidationError::error(Model& model, const Array<double>& input, const Array<double>& target)
{
    // split the data into training and validation set
    int i, ic = input.dim(0);
    int dim = input.dim(1);
    int tdim = target.dim(1);
    int train = (int)((1.0 - holdOut) * ic);
    int validation = ic - train;
    std::vector<int> tr(ic);
    std::vector<int> val(validation);
    for (i=0; i<ic; i++) tr[i] = i;
    for (i=0; i<validation; i++)
    {
        int n = Rng::discrete(0, tr.size() - 1);
        val[i] = tr[n];
        tr.erase(tr.begin() + n);
    }
    Array<double> trainD(train, dim);
    Array<double> trainT(train, tdim);
    Array<double> validationD(validation, dim);
    Array<double> validationT(validation, tdim);
    for (i=0; i<train; i++)
    {
        trainD[i] = input[tr[i]];
        trainT[i] = target[tr[i]];
    }
    for (i=0; i<validation; i++)
    {
        validationD[i] = input[val[i]];
        validationT[i] = target[val[i]];
    }

    // train the model on the training subset
    optimizer->init(model);
    for (i=0; i<iterations; i++) optimizer->optimize(model, *baseError, trainD, trainT);

    // return the validation error
    return baseError->error(model, validationD, validationT);
}

double ValidationError::errorDerivative(Model& model, const Array<double>& input, const Array<double>& target, Array<double>& derivative)
{
    // split the data into training and validation set
    int i, ic = input.dim(0);
    int dim = input.dim(1);
    int tdim = target.dim(1);
    int train = (int)(holdOut * ic);
    int validation = ic - train;
    std::vector<int> tr(ic);
    std::vector<int> val(validation);
    for (i=0; i<ic; i++) tr[i] = i;
    for (i=0; i<validation; i++)
    {
        int n = Rng::discrete(0, tr.size() - 1);
        val[i] = tr[n];
        tr.erase(tr.begin() + n);
    }
    Array<double> trainD(train, dim);
    Array<double> trainT(train, tdim);
    Array<double> validationD(validation, dim);
    Array<double> validationT(validation, tdim);
    for (i=0; i<train; i++)
    {
        trainD[i] = input[tr[i]];
        trainT[i] = target[tr[i]];
    }
    for (i=0; i<validation; i++)
    {
        validationD[i] = input[val[i]];
        validationT[i] = target[val[i]];
    }

    // train the model on the training subset
    optimizer->init(model);
    for (i=0; i<iterations; i++) optimizer->optimize(model, *baseError, trainD, trainT);

    // return the validation error
    return baseError->errorDerivative(model, validationD, validationT, derivative);
}