#include <gaussian_kerdensom.h>

Inheritance diagram for GaussianKerDenSOM:

Collaboration diagram for GaussianKerDenSOM:

Public Member Functions
	GaussianKerDenSOM (double _reg0, double _reg1, unsigned long _annSteps, double _epsilon, unsigned long _nSteps)

virtual	~GaussianKerDenSOM ()

virtual void	train (FuzzyMap &_som, TS &_examples, FileName &_fn_vectors, bool _update=false, double _sigma=0, bool _saveIntermediate=false)

virtual double	functional (const TS _examples, const FuzzyMap _som, double _sigma, double _reg, double &_likelihood, double &_penalty)

Public Member Functions inherited from KerDenSOM
	KerDenSOM (double _reg0, double _reg1, unsigned long _annSteps, double _epsilon, unsigned long _nSteps)

virtual	~KerDenSOM ()

void	nSteps (const unsigned long &_nSteps)

void	setAnnSteps (const unsigned long &_annSteps)

virtual void	train (FuzzyMap &_som, TS &_examples, FileName &_fn_vectors, bool _update=false, double _sigma=0, bool _saveIntermediate=false)=0

virtual double	test (const FuzzyMap &_som, const TS &_examples) const

virtual double	functional (const TS _examples, const FuzzyMap _som, double _sigma, double _reg, double &_likelihood, double &_penalty)=0

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)

Protected Member Functions
virtual double	updateU (FuzzyMap _som, const TS _examples, const double &_sigma, double &_alpha)

virtual double	updateSigmaII (FuzzyMap _som, const TS _examples, const double &_reg, const double &_alpha)

virtual double	codeDens (const FuzzyMap _som, const FeatureVector _example, double _sigma) const

Protected Member Functions inherited from KerDenSOM
virtual void	train (FuzzyMap &_som, const TS &_examples) const

virtual double	updateU (FuzzyMap _som, const TS _examples, const double &_sigma, double &_alpha)=0

virtual double	updateSigmaII (FuzzyMap _som, const TS _examples, const double &_reg, const double &_alpha)=0

virtual void	updateV (FuzzyMap _som, const TS _examples, const double &_sigma)

virtual double	mainIterations (FuzzyMap _som, const TS _examples, double &_sigma, const double &_reg)

virtual void	initU (FuzzyMap *_som)

virtual void	updateV1 (FuzzyMap _som, const TS _examples)

virtual void	updateU1 (FuzzyMap _som, const TS _examples)

virtual double	updateSigmaI (FuzzyMap _som, const TS _examples)

void	showX (const TS *_ts)

void	showV (FuzzyMap *_som)

void	showU (FuzzyMap _som, const TS _ts)

Additional Inherited Members
Public Types inherited from ClassificationAlgorithm< FuzzyMap >
typedef FuzzyMap	DS

typedef DS::TS	TS

Protected Attributes inherited from KerDenSOM
double	sigma

size_t	annSteps

double	reg0

double	reg1

double	epsilon

size_t	somNSteps

size_t	numNeurons

size_t	numVectors

size_t	dim

std::vector< std::vector< double > >	tmpMap

std::vector< double >	tmpD

std::vector< double >	tmpD1

std::vector< double >	tmpDens

std::vector< double >	tmpV

Protected Attributes inherited from ClassificationAlgorithm< FuzzyMap >
std::string	ID

BaseListener *	listener

Detailed Description

This class trains a Smoothly Distributed Kernel Probability Density Estimator Self Organizing Map using a Gaussian Kernel function

Definition at line 44 of file gaussian_kerdensom.h.

Constructor & Destructor Documentation

◆ GaussianKerDenSOM()

GaussianKerDenSOM::GaussianKerDenSOM	(	double	_reg0,
		double	_reg1,
		unsigned long	_annSteps,
		double	_epsilon,
		unsigned long	_nSteps
	)

inline

Constructs the algorithm Parameter: _reg0 Initial regularization factor Parameter: _reg1 Final regularization factor Parameter: _annSteps Number of steps in deterministic annealing Parameter: _epsilon Stopping criterion Parameter: _nSteps Number of training steps

Definition at line 56 of file gaussian_kerdensom.h.

58 : KerDenSOM(_reg0, _reg1, _annSteps, _epsilon, _nSteps)

59 {};

KerDenSOM::KerDenSOM

KerDenSOM(double _reg0, double _reg1, unsigned long _annSteps, double _epsilon, unsigned long _nSteps)

Definition: kerdensom.h:56

◆ ~GaussianKerDenSOM()

virtual GaussianKerDenSOM::~GaussianKerDenSOM ( )

inlinevirtual

Virtual destructor

Definition at line 64 of file gaussian_kerdensom.h.

65 {};

Member Function Documentation

◆ codeDens()

double GaussianKerDenSOM::codeDens	(	const FuzzyMap *	_som,
		const FeatureVector *	_example,
		double	_sigma
	)		const

protectedvirtual

Estimate the PD (Method 1: Using the code vectors)

Implements KerDenSOM.

Definition at line 339 of file gaussian_kerdensom.cpp.

 {
     double s = 0;
     double K=-1.0/(2*_sigma);
     const floatFeature *ptrExample=&((*_example)[0]);
     for (size_t cc = 0; cc < numNeurons; cc++)
     {
         double t = 0;
         const floatFeature *ptrCodeVector=&(_som->theItems[cc][0]);
         for (size_t j = 0; j < dim; j++)
         {
             double diff=(double)(ptrExample[j]) - (double)(ptrCodeVector[j]);
             t += diff*diff;
         }
         t *= K;
         if (t < MAXZ)
             t = 0;
         else
             t = exp(t);
         s += t;
     }
     return std::pow(2*PI*_sigma, -0.5*dim)*s / numNeurons;
 }

◆ functional()

double GaussianKerDenSOM::functional	(	const TS *	_examples,
		const FuzzyMap *	_som,
		double	_sigma,
		double	_reg,
		double &	_likelihood,
		double &	_penalty
	)

virtual

Determines the functional value. Returns the likelihood and penalty parts of the functional

Determines the functional value Returns the likelihood and penalty parts of the functional

Definition at line 395 of file gaussian_kerdensom.cpp.

 {
     unsigned j;
     unsigned vv;
     unsigned cc;
     double t;
     _likelihood = 0;
     for (vv = 0; vv < numVectors; vv++)
     {
         t = codeDens(_som, &(_examples->theItems[vv]), _sigma);
         if (t == 0)
         {
             t = 1e-300;
         }
         _likelihood += log(t);
     }
     _likelihood = -_likelihood;
     _penalty = 0;
 
     if (_reg != 0)
     {
         for (cc = 0; cc < numNeurons; cc++)
         {
             _som->localAve(_som->indexToPos(cc), tmpV);
             t = _som->getLayout().numNeig(_som, (SomPos) _som->indexToPos(cc));
             for (j = 0; j < dim; j++)
             {
                 _penalty += (t * (double)(_som->theItems[cc][j]) -
                                  (double)(tmpV[j])) * (double)(_som->theItems[cc][j]);
             }
         }
         _penalty = _reg * _penalty / (2.0 * _sigma);
     }
     return (_likelihood + _penalty);
 }

◆ train()

void GaussianKerDenSOM::train	(	FuzzyMap &	_som,
		TS &	_examples,
		FileName &	_fn,
		bool	_update = `false`,
		double	_sigma = `0`,
		bool	_saveIntermediate = `false`
	)

virtual

Trains the GaussianKerDenSOM Parameter: _som The KerDenSom to train Parameter: _ts The training set Parameter: _update True if uses _som as starting point for training. Parameter: _sigma If update = true, uses this sigma for the training.

Trains the GaussianDenSOM Parameter: _som The KerDenSom to train Parameter: _ts The training set Parameter: _update True if uses _som as starting point for training. Parameter: _sigma If update = true, uses this sigma for the training.

Definition at line 48 of file gaussian_kerdensom.cpp.

 {
     MetaDataVec MDconvergence;
     FileName tmpN;
     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);
     tmpD1.resize(numNeurons);
     double stopError;
 
     int verbosity = listener->getVerbosity();
     if (verbosity)
         listener->OnReportOperation((std::string) "\nTraining KerDenSOM....\n");
 
     // Initialization
     if (verbosity)
         listener->OnReportOperation((std::string) "\nInitializing....\n");
     if (!_update)
     {
         initU(&_som);
         updateV1(&_som, &_examples);
         sigma = updateSigmaI(&_som, &_examples);
     }
     else
     {
         double alpha;
         sigma = _sigma;
         if (_sigma == 0.0)
         {
             updateU1(&_som, &_examples);
             sigma = updateSigmaI(&_som, &_examples);
         }
         updateU(&_som, &_examples, sigma, alpha);
     }
 
 
     double regtmp;
     double tmpregMax;
     double tmpregMin;
     double pen;
     double lkhood;
     tmpregMax = log(reg0);
     tmpregMin = log(reg1);
 
     if (annSteps == 0)
         annSteps = 1;
     for (size_t iter = 0; iter < annSteps; iter++)
     {
 
         if (verbosity)
         {
             if (annSteps > 1)
             {
                 char s[100];
                 sprintf(s, "\nTraining Deterministic Annealing step %d of %d....\n", (int)(iter + 1), (int)annSteps);
                 listener->OnReportOperation((std::string) s);
             }
             else
                 listener->OnReportOperation((std::string) "Training ....\n");
         }
 
         if (annSteps == 1)
             regtmp = reg1;
         else
             regtmp = exp(tmpregMax - iter * (tmpregMax - tmpregMin) / (annSteps - 1));
         stopError = mainIterations(&_som, &_examples, sigma, regtmp);
         if (verbosity)
             listener->OnReportOperation((std::string) "Calculating cost function....\n");
         double funct = functional(&_examples, &_som, sigma, reg1, lkhood, pen);
 
         size_t id=MDconvergence.addObject();
         MDconvergence.setValue(MDL_KERDENSOM_REGULARIZATION,regtmp,id);
         MDconvergence.setValue(MDL_KERDENSOM_FUNCTIONAL,funct,id);
         MDconvergence.setValue(MDL_KERDENSOM_SIGMA,sigma,id);
 
         if (verbosity)
         {
             char s[100];
             sprintf(s, "Code vectors variation: %g\n", stopError);
             listener->OnReportOperation((std::string) s);
         }
 
 
         if (annSteps > 1)
         {
             // Classifying
             if (verbosity)
                 listener->OnReportOperation((std::string) "Classifying....\n");
             _som.classify(&_examples);
 
             // Calibrating
             if (verbosity)
                 listener->OnReportOperation((std::string) "Calibrating....\n");
             _som.calibrate(_examples);
 
             if (_examples.isNormalized())
             {
                 if (verbosity)
                     listener->OnReportOperation((std::string) "Denormalizing code vectors....\n");
                 _som.unNormalize(_examples.getNormalizationInfo()); // de-normalize codevectors
             }
 
             if (_saveIntermediate)
             {
                 // Saves each codebook (for all iterations)
                 tmpN = _fn.c_str() + (std::string) "_" + integerToString(iter) + (std::string) ".cod";
                 if (verbosity)
                     listener->OnReportOperation((std::string) "Saving code vectors....\n");
                 std::ofstream codS(tmpN.c_str());
                 codS << _som;
                 codS.flush();
 
                 // save .his file (Histogram)
                 if (verbosity)
                     listener->OnReportOperation((std::string) "Saving histogram file....\n");
                 tmpN = _fn.c_str() + (std::string) "_" + integerToString(iter) + (std::string) ".his";
                 std::ofstream hisStream(tmpN.c_str());
                 _som.printHistogram(hisStream);
                 hisStream.flush();
 
                 // save .err file (Average Quantization Error)
                 if (verbosity)
                     listener->OnReportOperation((std::string) "Saving Average Quantization Error file....\n");
                 tmpN = _fn.c_str() + (std::string) "_" + integerToString(iter) + (std::string) ".err";
                 std::ofstream errStream(tmpN.c_str());
                 _som.printQuantError(errStream);
                 errStream.flush();
 
                 // save .vs file to be compatible with SOM_PAK
                 if (verbosity)
                     listener->OnReportOperation((std::string) "Saving visual file....\n");
                 tmpN = _fn.c_str() + (std::string) "_" + integerToString(iter) + (std::string) ".vs";
                 std::ofstream vsStream(tmpN.c_str());
                 vsStream << _examples.theItems[0].size() << " " << _som.layout() << " " << _som.width() << " " << _som.height() << " gaussian" << std::endl;
                 for (size_t i = 0; i < _examples.size(); i++)
                 {
                     int j = _som.fuzzyWinner(i);
                     vsStream << _som.indexToPos(j).first << " " << _som.indexToPos(j).second << " " << _som.memb[i][j] << " " << _examples.theTargets[i] << std::endl;
                 }
                 vsStream.flush();
 
                 // save .inf file
                 if (verbosity)
                     listener->OnReportOperation((std::string) "Saving inf file....\n");
                 tmpN = _fn.c_str() + (std::string) "_" + integerToString(iter) + (std::string) ".inf";
                 std::ofstream infS(tmpN.c_str());
                 infS << "Kernel Probability Density Estimator SOM algorithm" << std::endl << std::endl;
                 infS << "Deterministic annealing step " << iter + 1 << " out of " << annSteps << std::endl;
                 infS << "Number of feature vectors: " << _examples.size() << std::endl;
                 infS << "Number of variables: " << _examples.theItems[0].size() << std::endl;
                 infS << "Horizontal dimension (Xdim) = " << _som.width() << std::endl;
                 infS << "Vertical dimension (Ydim) = " << _som.height() << std::endl;
                 if (_examples.isNormalized())
                     infS << "Input data normalized" << std::endl;
                 else
                     infS << "Input data not normalized" << std::endl;
                 if (_som.layout() == "rect")
                     infS << "Rectangular topology " << std::endl;
                 else
                     infS << "Hexagonal topology " << std::endl;
                 infS << "Gaussian Kernel function " << std::endl;
                 infS << "Total number of iterations = " << somNSteps << std::endl;
                 infS << "Stopping criteria (eps) = " << epsilon << std::endl << std::endl ;
 
                 infS << "Smoothness factor (regularization) = " << regtmp << std::endl;
                 infS << "Functional value = " << funct << std::endl;
                 infS << "Sigma (Kernel width) = " << sigma << std::endl;
                 infS.flush();
             }
 
             if (_examples.isNormalized())
             {
                 if (verbosity)
                     listener->OnReportOperation((std::string) "Normalizing code vectors....\n");
                 _som.Normalize(_examples.getNormalizationInfo());       // normalize code vectors
             }
         } // if annSteps
 
     } // for
     MDconvergence.write(formatString("KerDenSOM_Convergence@%s",_fn.c_str()),MD_APPEND);
 
     tmpV.clear();
     tmpDens.clear();
     tmpMap.clear();
     tmpD.clear();
     tmpD1.clear();
 
 }

◆ updateSigmaII()

double GaussianKerDenSOM::updateSigmaII	(	FuzzyMap *	_som,
		const TS *	_examples,
		const double &	_reg,
		const double &	_alpha
	)

protectedvirtual

Definition at line 313 of file gaussian_kerdensom.cpp.

 {
     size_t cc;
     size_t j;
 
     if (_reg == 0)
         return(_alpha / (double)(numVectors*dim));
 
     // Computing Sigma (Part II)
     double q = 0.;
     for (cc = 0; cc < numNeurons; cc++)
     {
         _som->localAve(_som->indexToPos(cc), tmpV);
         auto t1 = (double) _som->getLayout().numNeig(_som, (SomPos) _som->indexToPos(cc));
         for (j = 0; j < dim; j++)
             q += (t1 * ((double)_som->theItems[cc][j]) - (double)(tmpV[j])) * ((double)_som->theItems[cc][j]);
     }
     return (double)((_alpha + _reg*q) / (double)(numVectors*dim));
 }

◆ updateU()

double GaussianKerDenSOM::updateU	(	FuzzyMap *	_som,
		const TS *	_examples,
		const double &	_sigma,
		double &	_alpha
	)

protectedvirtual

Update the U (Membership)

Definition at line 248 of file gaussian_kerdensom.cpp.

 {
     // Create auxiliar stuff
     double auxDist;
     double rr2;
     double max1;
     double d1;
     double tmp;
     double r1;
 
     double irr1 =1.0/( 2.0 * _sigma);
     _alpha = 0;
 
     // Update Membership matrix
     double *ptrTmpD=&tmpD[0];
     double *ptrTmpD1=&tmpD1[0];
     double idim=1.0/dim;
     for (size_t k = 0; k < numVectors; k++)
     {
         max1 = -MAXFLOAT;
         const floatFeature *ptrExample=&(_examples->theItems[k][0]);
         for (size_t i = 0; i < numNeurons; i ++)
         {
             auxDist = 0;
             const floatFeature *ptrCodeVector=&(_som->theItems[i][0]);
             for (size_t j = 0; j < dim; j++)
             {
                 double tmp=((double)ptrExample[j] - (double)ptrCodeVector[j]);
                 auxDist += tmp * tmp;
             }
             auxDist*=idim;
             ptrTmpD[i] = auxDist;
             rr2 = -auxDist * irr1;
             ptrTmpD1[i] = rr2;
             if (max1 < rr2)
                 max1 = rr2;
         }
         r1 = 0;
         for (size_t j = 0; j < numNeurons; j ++)
         {
             rr2 = ptrTmpD1[j] - max1;
             if (rr2 < MAXZ)
                 d1 = 0;
             else
                 d1 = (double)exp(rr2);
             r1 += d1;
             ptrTmpD1[j] = d1;
         }
         double ir1=1.0/r1;
 
         floatFeature *ptrSomMembK=&(_som->memb[k][0]);
         for (size_t j = 0; j < numNeurons; j ++)
         {
             tmp = ptrTmpD1[j] * ir1;
             ptrSomMembK[j] = (floatFeature) tmp;
             _alpha += tmp * ptrTmpD[j];
         }
     } // for k
     return 0.0;
 }

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

xmipp/libraries/classification/gaussian_kerdensom.h
xmipp/libraries/classification/gaussian_kerdensom.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GaussianKerDenSOM()

◆ ~GaussianKerDenSOM()

Member Function Documentation

◆ codeDens()

◆ functional()

◆ train()

◆ updateSigmaII()

◆ updateU()