EarlyStopping.cpp

Go to the documentation of this file.

#include <SharkDefs.h>
#include <ReClaM/EarlyStopping.h>


//===========================================================================
EarlyStopping::EarlyStopping(unsigned sl = 5)
{
    GLvalue     = 0;
    e_opt       = MAXDOUBLE;
    e_va_old    = MAXDOUBLE;
    time        = 0;
    UPvalue     = 0;
    striplength = sl;
    e_tr.resize(striplength, false);
}

//===========================================================================
void EarlyStopping::update(double e, double e_va)
{
    double e_tr_av,   // Average training set error.
    e_tr_min;  // Minimal training set error.


    // evaluate generalization loss: GL
    if (e_va < e_opt)
        e_opt = e_va;
    GLvalue = 100. * (e_va / e_opt - 1.);

    // evaluate trainings-progress: TP
    if (time == 0) e_tr = e; // initialize error memory vector with first
    // error value
    // this implies a TPvalue == 1 when time == 0
    // this does not affect the TP(), see below
    e_tr(time % striplength) = e;
    e_tr_av = e_tr_min = e_tr(0);
    for (unsigned j = 1; j < striplength; j++)
    {
        e_tr_av += e_tr(j);
        if (e_tr(j) < e_tr_min)
            e_tr_min = e_tr(j);
    }
    e_tr_av /= (double)striplength;
    TPvalue = 1000. * (e_tr_av / e_tr_min - 1.);

    // evaluate increase of generalization error: UP
    if (time % striplength == 0)
    {
        if (e_va_old < e_va)
            UPvalue++;
        else
            UPvalue = 0;
        e_va_old = e_va;
    }

    // update time
    time++;
}


//===========================================================================
double EarlyStopping::getGL()
{
    return GLvalue;
}


//===========================================================================
double EarlyStopping::getTP()
{
    if (time >= striplength)
        return TPvalue;
    else
        return MAXDOUBLE;
}

//===========================================================================
double EarlyStopping::getPQ()
{
    if (time >= striplength)
        return GLvalue / TPvalue;
    else
        return 0.;
}


//===========================================================================
unsigned EarlyStopping::getUP()
{
    return UPvalue;
}


//===========================================================================
bool EarlyStopping::GL(double alpha = 1.0)
{
    return (GLvalue > alpha);
}


//===========================================================================
bool EarlyStopping::TP(double alpha = 0.1)
{
    if (time >= striplength)
        return (TPvalue < alpha);
    else
        return false;
}

//===========================================================================
bool EarlyStopping::PQ(double alpha = 0.5)
{
    if (time >= striplength)
        return (GLvalue / TPvalue > alpha);
    else
        return false;
}


//===========================================================================
bool EarlyStopping::UP(unsigned s = 3)
{
    return (UPvalue >= s);
}


//===========================================================================
bool EarlyStopping::one_of_all(double alpha1 = 1.0, double alpha2 = 1.0, double alpha3 = 1.0, unsigned s = 3)
{
    return (GL(alpha1) || TP(alpha2) || PQ(alpha3) || UP(s));
}