Unit.h

Go to the documentation of this file.

#ifndef _UNIT_H
#define _UNIT_H

#include "../../FeatureContainer/FeatureContainer.h"
#include "../../util/splaytree.h"

class Unit;

#if NO_OPTIMIZATIONS
# undef OPTIMIZATIONS_SPLAYTREE
# undef OPTIMIZATIONS_CACHE_SIMILARITY
# undef OPTIMIZATIONS_SPLIT_MERGE

# define OPTIMIZATIONS_SPLAYTREE 0
# define OPTIMIZATIONS_CACHE_SIMILARITY 0
# define OPTIMIZATIONS_SPLIT_MERGE 0
#endif

template <class comparator>
class unittree : public splaytree<comparator>
{ public: unittree() : splaytree<comparator>(NULL) {} };

typedef map<Unit*, unsigned long> edge_map;


#if OPTIMIZATIONS_SPLAYTREE
typedef unittree<Unit*> unit_list;
#else
typedef list<Unit*> unit_list;
#endif


class Unit
{
        private:

                // this is ugly, ugly, ugly
                unit_list const*const all_units;

                static list<unsigned long> used_meta_ids;       // remember the meta ids which have already been used (just to speed things up a bit)
                unsigned long meta_id;

                featurevector position;
                edge_map edge;
                                                                // the hash map keeps track of all edges and their age
                double error_short;                             // accumulated short-term error
                double error_long;                              // accumulated long-term error
                double error_insert;                            // the inherited error at the time of insertion of this node
                double insertion_threshold;
                double youth;
                double radius;

                mutable bool traversing;
                mutable double helper_local_similarity;         // this is a cache for performance reasons

                void insertEdge(Unit* u);
                void eraseEdge(Unit* u);

                static unsigned long getNextMetaId();           // serach for the next unused meta id

                void movePositionTowards(const featurevector *sample, bool isWinner);
                void setMetaId(unsigned long id);
                void updateMetaId();
                bool isConnectedHelper(Unit* u) const;          // used by isConnected
                bool isConnected(Unit* u) const;                // this should be used to check if a unit is connected to another one
                void updateRadius();

        public:
                Unit(unit_list const*const units, const featurevector pos);
                Unit(unit_list const*const units, const featurevector pos, unsigned long id);
                virtual ~Unit();

                Unit *splitUnit();

                double getShortTermError() const;
                void setShortTermError(double error);
                double getLongTermError() const;
                void setLongTermError(double error);
                //void decreaseErrors();                                // decreases both the short and the long term errors according to their time constants (called for the winning unit)
                void updateErrors(const featurevector *sample);

                double getInsertionError() const;
                void setInsertionError(double error);

                double getInsertionThreshold() const;
                void setInsertionThreshold(double threshold);
                void updateInsertionThreshold();

                double getYouth() const;
                void setYouth(double youth);
                void decreaseYouth();                           // decreases the youth (called for the winning unit)

                void decreaseInsertionThreshold();              // decreases the insertion threshold (called for the winning neuron)

                const featurevector* getPosition() const;
                double getDistance(const featurevector *sample) const; // returns the distance to the given sample, normlized to [0; 1]
                void moveTowards(const featurevector *sample);

                double getQualityLearning() const;              // compute the quality measure for learning at this unit (B^L)
                double getQualityInsertion() const;             // compute the quality measure for insertion (B^I)
                double getLearningRate(bool isWinner) const;    // compute the learning rate (called for the winning neuron and its neighbors)

                void calculateLocalSimilarity() const;          // compute the local similarity of input weights (the average difference of this unit's position to allits neighbors)
                                                                                                                // this has to be called whenever a node (or one of its neighbors is moved) !

                double getLocalSimilarity() const;              // return the pre-computed local similarity of input weights (the average difference of this unit's position to all its neighbors)

                static size_t getNumMetaIds();
                static unsigned long getMaxMetaId();
                static void clearMetaIds();             // clear the list - only used for unserialization
                static void reserveMetaId(unsigned long meta_id);       // reserve this meta id
                static void releaseMetaId(unsigned long meta_id); // release a meta id so that it can be used again
                unsigned long getMetaId() const;

                void ageEdge(Unit* u);                          // increments the age of a single adge
                void ageEdges();                                // increments the age of all connected edges by one (and also for the edges to this node, i.e. symmetrically)
                void addEdge(Unit* u);
                void removeEdge(Unit* u);
                void setEdgeAge(Unit* u, unsigned long age);            // sets the edge age (symmetrically), only used for unserialize in GNG
                edge_map::size_type getEdgeCount() const;       // returns the number of edges, i.e. the number of neighbors
                edge_map* getEdges();                   // return the edge map

                string serialize() const;
                size_t unserialize(const featurevector& features, const string data);

                bool operator < (Unit *u);
                bool operator > (Unit *u) { return u < this; }
                bool operator != (Unit *u) { return (this < u) || (this > u); }
                bool operator == (Unit *u) { return !(this != u); }
};

#endif /* _UNIT_H */

---