---

learning.cc

Go to the documentation of this file.

#include <magic/mmath.h> 
#include "inanna/patternset.h"
#include "inanna/termination.h"
#include "inanna/annetwork.h"


//                                                                           //
//                   |                                                       //
//                   |      ___   ___        _    ___                        //
//                   |     /   )  ___| |/\ |/ \  /   ) |/\                   //
//                   |     |---  (   | |   |   | |---  |                     //
//                   |____  \__   \__| |   |   |  \__  |                     //
//                                                                           //

Learner::Learner ()
{
}

double Learner::train (const PatternSet& set, int cycles, int cycint, int vsize)
{
    MUST_OVERLOAD;
    return 0.0;
}

double Learner::train (const PatternSet& trainSet,
                       const PatternSet& validationSet,
                       int cycles,
                       int cycint)
{
    NOT_IMPLEMENTED;
    return 0.0;
}

double Learner::trainOnce (const PatternSet& trainset)
{
    MUST_OVERLOAD;
    return 0.0;
}

Vector Learner::testPattern (const PatternSource& set, 
                             int pattern               ) const
{
    MUST_OVERLOAD;
    return Vector(1);
}

double Learner::test (const PatternSource& set) const
{
    ASSERT (set.patterns>0);
    
    double errorSum = 0.0; // Sum of squared errors (SSE)
    for (int p=0; p<set.patterns; p++) {
        Vector res = testPattern (set, p);
        ASSERT (res.size() == set.outputs);
        
        for (int j=0; j<res.size(); j++)
            errorSum += sqr (res[j] - set.output (p, j));
    }
    
    return errorSum / (set.patterns * set.outputs); // Mean of squared errors (MSE)
}

ClassifResults* Learner::testClassify (const PatternSource& set) const
{
    ASSERT (set.patterns>0);

    ClassifResults* result = new ClassifResults;

    // Determine the number of classes (not so trivial)
    int classes = (set.outputs>1)? set.outputs : 2;
                   
    // Initialize the class hit counter
    result->classcnts.make (classes);
    for (int i=0; i<classes; i++)
        result->classcnts[i] = 0;

    // Initialize the class instance counter
    result->classSizes.make (classes);
    for (int i=0; i<classes; i++)
        result->classSizes[i] = 0;
    
    // Classify each pattern in the set
    int failures=0;
    double errorSum = 0.0; // Sum of squared errors (SSE)
    for (int p=0; p<set.patterns; p++) {
        // Find the correct class 
        int correctClass = set.getClass (p);
        
        // Determine success
        bool success=false;

        Vector res = testPattern (set, p);

        // Record the SSE
        for (int j=0; j<res.size(); j++)
            errorSum += sqr (res[j] - set.output (p, j));

        if (set.outputs==1) {
            if (correctClass == int(res[0]+0.5))
                success = true;
        } else {
            int highestClass = maxIndex (res);
            if (highestClass == correctClass)
                success = true;
        }
        
        // Record the success
        if (!success) {
            failures++;
            
            // For the particular class
            result->classcnts[correctClass]++;
        }

        // And increment the number of instances for this particular class
        result->classSizes[correctClass]++;
    }
    
    // Return the mean
    result->mse = errorSum/(set.patterns*set.outputs); // Mean of squared errors (MSE)
    result->failures = failures;

    return result;
}

void Learner::copyFreeNet (const ANNetwork& fnet,
                           bool             onlyWeights)
{
    copy (static_cast<const Learner&> (fnet));
}

void Learner::copy (const Learner& fnet,
                    bool           onlyWeights)
{
}

ANNetwork* Learner::toANNetwork () const
{
    MUST_OVERLOAD;
    return NULL;
}

---