FuzzySOM Class Reference

#include <fuzzy_som.h>

Inheritance diagram for FuzzySOM:

Collaboration diagram for FuzzySOM:

Public Member Functions
	FuzzySOM (double _m0, double _m1, unsigned long _annSteps, double _reg, double _epsilon, unsigned long _nSteps)
virtual	~FuzzySOM ()
virtual void	train (FuzzyMap &_som, const TS &_examples)
virtual double	test (const FuzzyMap &_som, const TS &_examples) const
virtual double	functional (const TS &_examples, const FuzzyMap &_som, double _m, double _reg, double &_fidelity, double &_penalty)
Public Member Functions inherited from ClassificationAlgorithm< FuzzyMap >
	ClassificationAlgorithm (const std::string &_ID="")
virtual	~ClassificationAlgorithm ()
virtual void	train (DS &_ds, const TS &_examples) const
virtual void	train (DS &_ds, TS &_examples) const
virtual double	test (const DS &_ds, const TS &_examples) const=0
virtual void	printSelf (std::ostream &_os) const
virtual const std::string &	setID () const
virtual std::string &	setID ()
void	setListener (BaseListener *_listener)

Additional Inherited Members
Public Types inherited from ClassificationAlgorithm< FuzzyMap >
typedef FuzzyMap	DS
typedef DS::TS	TS
Protected Attributes inherited from ClassificationAlgorithm< FuzzyMap >
std::string	ID
BaseListener *	listener

Detailed Description

This class trains a Smoothly Distributed Fuzzy c-Means Self Organizing Map

Definition at line 43 of file fuzzy_som.h.

Constructor & Destructor Documentation

FuzzySOM()

FuzzySOM::FuzzySOM ( double  _m0, double  _m1, unsigned long  _annSteps, double  _reg, double  _epsilon, unsigned long  _nSteps  )

inline

Constructs the algorithm Parameter: _m0 Initial Fuzzy Membership constant Parameter: _m1 Final Fuzzy Membership constant Parameter: _annSteps Number of steps in deterministic annealing Parameter: _reg Regularization constant Parameter: _epsilon Stopping criterion Parameter: _nSteps Number of training steps

Definition at line 56 of file fuzzy_som.h.

            : ClassificationAlgorithm<FuzzyMap>(), m0(_m0), m1(_m1), annSteps(_annSteps),
            reg(_reg), epsilon(_epsilon), somNSteps(_nSteps)
    {};

~FuzzySOM()

virtual FuzzySOM::~FuzzySOM ( )

inlinevirtual

Virtual destructor

Definition at line 65 of file fuzzy_som.h.

    {};

Member Function Documentation

functional()

double FuzzySOM::functional ( const TS &  _examples, const FuzzyMap &  _som, double  _m, double  _reg, double &  _fidelity, double &  _penalty  )

virtual

Determines the functional value Returns the fidelity to the data and penalty parts of the functional

Definition at line 344 of file fuzzy_som.cpp.

{
    unsigned j;
    unsigned vv;
    unsigned cc;
    double t;
    double t1;
    double t2 = 0;
    _fidelity = 0;
    for (vv = 0; vv < numVectors; vv++)
    {
        for (cc = 0; cc < numNeurons; cc++)
        {
            t = 0;
            for (size_t j = 0; j < dim; j++)
                t += ((double)(_examples.theItems[vv][j]) - (double)(_som.theItems[cc][j])) * ((double)(_examples.theItems[vv][j]) - (double)(_som.theItems[cc][j]));
            t1 = (double) pow((double)_som.memb[vv][cc], (double) _m);
            t2 += t1;
            _fidelity += t1 * t;
        }
    }
    _fidelity /= t2;
    _penalty = 0;

    if (reg != 0)
    {
        for (cc = 0; cc < numNeurons; cc++)
        {
            _som.localAve(_som.indexToPos(cc), tmpV);
            for (j = 0; j < dim; j++)
            {
                _penalty += (_som.theItems[cc][j] - tmpV[j]) * (_som.theItems[cc][j] - tmpV[j]);
            }
        }
        _penalty /= (double)(numNeurons);
    }

    return (_fidelity - _reg*_penalty);
}

test()

double FuzzySOM::test ( const FuzzyMap &  _som, const TS &  _examples  ) const

virtual

Tests the Fuzzy SOM Parameter: _som The fuzzy som to test Parameter: _examples The training set of examples

Definition at line 198 of file fuzzy_som.cpp.

{

    // Defines verbosity level
    int verbosity = listener->getVerbosity();
    if (verbosity)
    {
        listener->OnReportOperation((std::string) "\nEstimating quantization error....\n");
        listener->OnInitOperation(_examples.size());
    }


    /* Scan all data entries */
    double qerror = 0.0;
    for (size_t i = 0; i < _examples.size(); i++)
    {
        SomIn& theBest = _som.fuzzyTest(i); // get the best
        qerror += euclideanDistance(theBest, _examples.theItems[i]);
        if (verbosity)
        {
            if ((i % (int)((_examples.size()*5) / 100)) == 0)
                listener->OnProgress(i);
        }
    }
    if (verbosity)
        listener->OnProgress(_examples.size());
    return (qerror / (double) _examples.size());

}

train()

void FuzzySOM::train ( FuzzyMap &  _som, const TS &  _examples  )

virtual

Trains the Fuzzy SOM Parameter: _som The som to train Parameter: _examples The training set

Trains the Fuzzy SOM Parameter: _som The fuzzy som to train Parameter: _ts The training set

Definition at line 97 of file fuzzy_som.cpp.

{

    numNeurons = _som.size();
    numVectors = _examples.size();
    dim = _examples.theItems[0].size();
    tmpV.resize(dim, 0.);
    tmpDens.resize(numNeurons, 0.);
    tmpMap.resize(numNeurons);
    for (size_t i = 0; i < numNeurons; i++)
        tmpMap[i].resize(dim, 0.);

    tmpD.resize(numNeurons);
    double stopError;

    int verbosity = listener->getVerbosity();
    if (verbosity)
        listener->OnReportOperation((std::string) "\nTraining Fuzzy SOM....\n");

    // Deterministic annealing step
    if (annSteps)
    {

        for (size_t i = 0; i <  _examples.size(); i++)
            for (size_t j = 0; j < _som.size(); j++)
                _som.memb[i][j] = 0.;

        if (verbosity)
            listener->OnReportOperation((std::string) "\nDeterministic annealing steps....\n");
        if (verbosity == 1 || verbosity == 3)
            listener->OnInitOperation(annSteps);

        double fuzz;
        for (size_t iter = 0; iter < annSteps; iter++)
        {

            fuzz = m0 - iter * (m0 - m1) / (annSteps - 1);
            stopError = updateU(_som, _examples, fuzz);
            updateV(_som, _examples, fuzz);
            if (verbosity == 1 || verbosity == 3)
                listener->OnProgress(iter);
            if (verbosity >= 2)
            {
                char s[100];
                sprintf(s, "Iteration %d of %d. Code vectors variation: %g\n", (int)(iter + 1), (int)annSteps, stopError);
                listener->OnReportOperation((std::string) s);
            }
        }
        if (verbosity == 1 || verbosity == 3)
            listener->OnProgress(annSteps);
    }


    // Fixed steps


    for (size_t i = 0; i <  _examples.size(); i++)
        for (size_t j = 0; j < _som.size(); j++)
            _som.memb[i][j] = 0.;


    if (verbosity)
        listener->OnReportOperation((std::string) "\nFinal steps....\n");
    if (verbosity == 1 || verbosity == 3)
        listener->OnInitOperation(somNSteps);

    unsigned t = 0;  // Iteration index
    stopError = epsilon + 1; // Initially must be higher

    while ((stopError > epsilon) && (t < somNSteps))
    {
        stopError = updateU(_som, _examples, m1);
        updateV(_som, _examples, m1);
        t++;
        if (verbosity == 1 || verbosity == 3)
            listener->OnProgress(t);
        if (verbosity >= 2)
        {
            char s[100];
            sprintf(s, "Iteration %d of %d. Code vectors variation: %g\n", (int)t, (int)somNSteps, stopError);
            listener->OnReportOperation((std::string) s);
        }
    } // while
    if (verbosity == 1 || verbosity == 3)
        listener->OnProgress(somNSteps);


    tmpV.clear();
    tmpDens.clear();
    tmpMap.clear();
    tmpD.clear();

}

---

The documentation for this class was generated from the following files:

• xmipp/libraries/classification/fuzzy_som.h
• xmipp/libraries/classification/fuzzy_som.cpp