GNG.h

Go to the documentation of this file.

#ifndef _GNG_H
#define _GNG_H

#include "../Classifier.h"
#include "Unit.h"

struct meta_cluster {

        unsigned int cluster_id;
        list<Unit*> units;
        unsigned int winner_hits;
};

typedef list<meta_cluster> meta_cluster_list;

class CLASSIFIER_EXPORT_CLASS GNG : public ClassifierAlgorithm
{
        public:

                // these are needed in the GNG class
                static unsigned lambda;          
                static double minimal_deletion_age;  
                static double deletion_threshold;    
                static double deletion_threshold_lq; 

                // these are only needed in the Unit class, but defined here for consistency
                static unsigned long edge_age_max;   
                static double T_short;               
                static double T_long;                
                static double T_youth;               
                static double T_insert_threshold;
                static double adaptation_threshold;
                static double insertion_tolerance;
                static double lr_winner;             
                static double lr_neighbor;           
                static double minimum_lr;            
                static double lr_insert_threshold;   

                // these helper functions are used for better performance
                static double helper_T_short;              // helper variable for decreasing short term error, defined es helper_T = e^(-1/T)
                static double helper_T_long;               // helper variable for decreasing long term error, defined es helper_T = e^(-1/T)
                static double helper_T_youth;              // helper variable for decreasing youth, defined es helper_T = e^(-1/T)
                static double helper_T_insertion_threshold;


                /*static double e_b(double dist);*/                     /* returns the distance by which the current cluster is moved
                                                                * into the direction of the input sample based on the euclidean
                                                                * distance to it
                                                                */
                //static double e_n(double dist);                       // same as above for direct neighbours

                GNG(classifierparams &params);

                virtual ~GNG();

                virtual void init(FeatureContainer *fc);
                virtual membershiplist getClusterMembership(const featurevector *sample);
                virtual unsigned long nextSample();
                virtual unsigned long nextSample(const featurevector* sample);
                virtual string serialize() const;
                virtual void unserialize(string data);
                //virtual cluster_table* getCluster();
                //virtual connection_table* getConnections();

                // these are for testing and for quantitative evaluations
                virtual double getWinnerDistance(const featurevector *sample, unsigned int &cluster_id, unsigned int &meta_cluster_id) const;
                virtual unit_list::size_type getNumberNodes() const;

                virtual meta_cluster_list getMetaClusters(); // the connected meta clusters in the graph

#if _DEBUG_CLASSIFIERS

                virtual string toString() const;
#endif

        private:
                const char *algo;

                FeatureContainer *container;

                unit_list units;

                bit_vector feature_mask;

                const classifierparams params;

                featurevector maskFeatureVector(const featurevector* sample, bool freeUnused = false) const;

                void writeToDisk();
};

#endif

---