ClassificationTrainingSet< Item, Target > Class Template Reference

#include <training_set.h>

Public Types
enum	splitMode { CROSSVAL, SPLITSAMPLE, JACKKNIFE, BOOTSTRAP }
	Ways the training set can be used. More...
enum	useMode { TRAIN = 0, VALIDATION = 1, TEST = 2 }
	use of samples More...
typedef std::multimap< unsigned, unsigned, std::less< unsigned > >	splitTS
	Training sets mode. More...
typedef splitTS::iterator	splitIt
	iterator More...

Public Member Functions
	ClassificationTrainingSet (const bool &_calib=true, unsigned _n=0)
	ClassificationTrainingSet (std::istream &_is)
virtual	~ClassificationTrainingSet ()
void	setSplit (float _tp, float _vp)
splitIt	beginSubset (unsigned _um)
splitIt	endSubset (unsigned _um)
	Returns an iterator to the end of the subset. More...
virtual void	add (const Item &_i, const Target &_tg)
virtual void	add (const Item &_i)
virtual bool	remove (unsigned int _idx)
size_t	size () const
const Target &	targetAt (unsigned _i) const
Target &	targetAt (unsigned _i)
const Item &	itemAt (unsigned _i) const
Item &	itemAt (unsigned _i)
bool	calibrated () const
void	calibrated (const bool &_calib)
void	clear ()
virtual void	printSelf (std::ostream &_os) const
virtual void	readSelf (std::istream &_is)
virtual void	saveObject (std::ostream &_os) const
virtual void	loadObject (std::istream &_is)
unsigned	numTargets () const
virtual bool	swapItems (unsigned _i, unsigned _j)

Public Attributes
std::vector< Item >	theItems
std::vector< Target >	theTargets

Protected Member Functions
void	computeNumTargets ()
void	checkCalibrated (std::istream &_is)
void	readItems (std::istream &_is)
void	writeCalibrated (std::ostream &_os) const
void	writeItems (std::ostream &_os, bool _delim=false) const
void	skipComments (std::istream &_is) const
std::vector< Item >::const_iterator	itemsBegin () const
std::vector< Item >::const_iterator	itemsEnd () const
std::vector< Target >::const_iterator	targetsBegin () const
std::vector< Target >::const_iterator	targetsEnd () const

Protected Attributes
bool	isCalibrated
splitTS	splitTrainingSet
unsigned	nTargets

Friends
std::ostream &	operator<< (std::ostream &_os, const ClassificationTrainingSet &_ts)
std::istream &	operator>> (std::istream &_is, ClassificationTrainingSet &_ts)

Detailed Description

template<class Item, class Target>
class ClassificationTrainingSet< Item, Target >

Generic training sets. This is the parent class for all possible training sets that can be used by the classification algorithms. It provides the library with the basic functionality of training vectors. This a template class that takes as input the type of the training vectors and the type of the target variable (for supervised analysis) \The following example shows the declaration of a training set formed by a vector of doubles and a target variable of type string. \ \ClassificationTrainingSet<double, string> myTS;

Definition at line 61 of file training_set.h.

Member Typedef Documentation

splitIt

template<class Item, class Target>

typedef splitTS::iterator ClassificationTrainingSet< Item, Target >::splitIt

iterator

Definition at line 69 of file training_set.h.

splitTS

template<class Item, class Target>

typedef std::multimap<unsigned, unsigned, std::less<unsigned> > ClassificationTrainingSet< Item, Target >::splitTS

Training sets mode.

Definition at line 66 of file training_set.h.

Member Enumeration Documentation

splitMode

template<class Item, class Target>

enum ClassificationTrainingSet::splitMode

Ways the training set can be used.

Enumerator
CROSSVAL
SPLITSAMPLE
JACKKNIFE
BOOTSTRAP

Definition at line 72 of file training_set.h.

{ CROSSVAL, SPLITSAMPLE, JACKKNIFE, BOOTSTRAP } splitMode;

useMode

template<class Item, class Target>

enum ClassificationTrainingSet::useMode

use of samples

Enumerator
TRAIN
VALIDATION
TEST

Definition at line 75 of file training_set.h.

{ TRAIN = 0, VALIDATION = 1, TEST = 2 } useMode;

Constructor & Destructor Documentation

ClassificationTrainingSet() [1/2]

template<class Item, class Target>

ClassificationTrainingSet< Item, Target >::ClassificationTrainingSet ( const bool &  _calib = true, unsigned  _n = 0  )

inline

Default constructor Parameter: _calib: True if the trainign set is calibrated (labeled) Parameter: _n: Number of items that the trained set should contain

Definition at line 92 of file training_set.h.

            :isCalibrated(_calib), /* splitTrainingSet(), */nTargets(0), theItems(_n) /*theTargets(_n), */
    {};

ClassificationTrainingSet() [2/2]

template<class Item, class Target>

ClassificationTrainingSet< Item, Target >::ClassificationTrainingSet ( std::istream &  _is )

inline

Constructs a training set given a stream Parameter: _is The input stream

Definition at line 101 of file training_set.h.

                                                :  isCalibrated(false), splitTrainingSet(), theItems(), theTargets()
    {
        loadObject(_is);
        computeNumTargets();
    };

~ClassificationTrainingSet()

template<class Item, class Target>

virtual ClassificationTrainingSet< Item, Target >::~ClassificationTrainingSet ( )

inlinevirtual

Virtual destructor

Definition at line 110 of file training_set.h.

    {};

Member Function Documentation

add() [1/2]

template<class Item, class Target>

virtual void ClassificationTrainingSet< Item, Target >::add ( const Item &  _i, const Target &  _tg  )

inlinevirtual

Adds an item to the training set Parameter: _i The item Parameter: _tg The target (Used only if the TS is calibrated).

Reimplemented in FuzzyMap, and ClassificationMap.

Definition at line 171 of file training_set.h.

    {
        theItems.push_back(_i);
        theTargets.push_back(_tg);
    };

add() [2/2]

template<class Item, class Target>

virtual void ClassificationTrainingSet< Item, Target >::add ( const Item &  _i )

inlinevirtual

Adds an item to a non calibrated training set Parameter: _i The item

Definition at line 183 of file training_set.h.

    {
        theItems.push_back(_i);
    };

beginSubset()

template<class Item, class Target>

splitIt ClassificationTrainingSet< Item, Target >::beginSubset ( unsigned  _um )

inline

Returns an iterator to the beginning of the subset Parameter: _um is the mode: training, testing or validation

Returns

an iterator to the beginning of the subset;

Definition at line 154 of file training_set.h.

    {
        return splitTrainingSet.lower_bound(_um);
    }

calibrated() [1/2]

template<class Item, class Target>

bool ClassificationTrainingSet< Item, Target >::calibrated ( ) const

inline

Returns true if the training set is calibreted or not

Definition at line 301 of file training_set.h.

    {
        return isCalibrated;
    }

calibrated() [2/2]

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::calibrated ( const bool &  _calib )

inline

Sets the calibrated flag.

Definition at line 310 of file training_set.h.

    {
        isCalibrated = _calib;
    };

checkCalibrated()

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::checkCalibrated ( std::istream &  _is )

inlineprotected

Checks if the training set is calibrated or not Parameter: _is The input stream

Exceptions

runtime_error

If there are problems with the stream

Definition at line 442 of file training_set.h.

    {
        skipComments(_is);

        if (_is)
        {
            std::string s;
            _is >> s;

            // Comments skipped, read calibrated
            if (_is)
            {
                std::string s2 = "";

                // uppercase s
                for (std::string::iterator i = s.begin() ; i != s.end() ; i++)
                    s2 += toupper(*i);

                if (s2 == "CALIBRATED")
                    isCalibrated = true;
                else
                    for (std::string::iterator i = s.end() ; i > s.begin() ; _is.putback(*(--i)));
            }
        }

        if (!_is)
        {
            std::string msg;
            msg = "Error reading the file";
            throw std::runtime_error(msg);
        }
    };

clear()

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::clear ( )

inline

Clears the training set: all items and targets are suppresed; all other variables remain the same

Definition at line 318 of file training_set.h.

    {
        theItems.clear();
        theTargets.clear();
        nTargets = 0;
    };

computeNumTargets()

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::computeNumTargets ( )

inlineprotected

Compute the number of different targets in the training set

Definition at line 420 of file training_set.h.

    {
        if (calibrated())
        {
            typedef std::set< Target, std::less<Target> > STB;
            STB targetSet;
            for (unsigned i = 0; i < size(); i ++)
            {
                targetSet.insert(targetAt(i));
            }
            // Assign the number of targets
            nTargets = targetSet.size();
        }
        else
            nTargets = 0;
    }

endSubset()

template<class Item, class Target>

splitIt ClassificationTrainingSet< Item, Target >::endSubset ( unsigned  _um )

inline

Returns an iterator to the end of the subset.

Definition at line 160 of file training_set.h.

    {
        return splitTrainingSet.upper_bound(_um);
    }

itemAt() [1/2]

template<class Item, class Target>

const Item& ClassificationTrainingSet< Item, Target >::itemAt ( unsigned  _i ) const

inline

Returns a const reference to the specified item Parameter: _i The index

Exceptions

out_of_range

If _i is out of range

Definition at line 264 of file training_set.h.

    {
        if (_i >= size())
        {
            std::string msg;
            msg = "Out of range. No item at position " + integerToString(_i);
            throw std::out_of_range(msg);
        }

        return theItems[_i];
    };

itemAt() [2/2]

template<class Item, class Target>

Item& ClassificationTrainingSet< Item, Target >::itemAt ( unsigned  _i )

inline

Returns a recerence to an item. Parameter: _i The index Parameter: _item The item

Exceptions

out_of_range

If _i is out of range

Definition at line 284 of file training_set.h.

    {
        if (_i >= size())
        {
            std::string msg;
            msg = "Out of range. No item at position " + integerToString(_i);
            throw std::out_of_range(msg);
        }

        return theItems[_i];
    };

itemsBegin()

template<class Item, class Target>

std::vector<Item>::const_iterator ClassificationTrainingSet< Item, Target >::itemsBegin ( ) const

inlineprotected

Protected interface to the items

Returns

a const_iterator that points to the first Item in the set

Definition at line 624 of file training_set.h.

    {
        return theItems.begin();
    }

itemsEnd()

template<class Item, class Target>

std::vector<Item>::const_iterator ClassificationTrainingSet< Item, Target >::itemsEnd ( ) const

inlineprotected

Protected interface to the items

Returns

a const_iterator that points to the last Item in the set

Definition at line 633 of file training_set.h.

    {
        return theItems.end();
    }

loadObject()

template<class Item, class Target>

virtual void ClassificationTrainingSet< Item, Target >::loadObject ( std::istream &  _is )

inlinevirtual

Loads the class from a stream. this method can be used to load the status of the class. Parameter: _is The output stream

Reimplemented in FuzzyMap, ClassificationMap, FuzzyCodeBook, CodeBook, and ClassicTrainingVectors.

Definition at line 360 of file training_set.h.

    {
        clear();
        // first of all, check if the training set is calibrated or not
        checkCalibrated(_is);
        //afterwards, we have to read the item
        readItems(_is);
    }

numTargets()

template<class Item, class Target>

unsigned ClassificationTrainingSet< Item, Target >::numTargets ( ) const

inline

Returns the number of different classes in the (calibrated) training set

Exceptions

runtime_error

If the training set is not calibrated

Definition at line 373 of file training_set.h.

    {
        if (!calibrated())
            throw std::runtime_error("TS not calibrated");
        return nTargets;
    }

printSelf()

template<class Item, class Target>

virtual void ClassificationTrainingSet< Item, Target >::printSelf ( std::ostream &  _os ) const

inlinevirtual

Standard output for a training set Parameter: _os The output stream

Reimplemented in FuzzyMap, ClassificationMap, CodeBook, and ClassicTrainingVectors.

Definition at line 330 of file training_set.h.

    {
        writeItems(_os);
    }

readItems()

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::readItems ( std::istream &  _is )

inlineprotected

Read the items Parameter: _is The input stream

Exceptions

runtime_error

If there are problems with the stream

Definition at line 481 of file training_set.h.

    {
        while (_is)
        {
            skipComments(_is);
            if (_is)
            {
                Item item;
                try
                {
                    _is >> item;
                }
                catch (std::exception&)
                {
                    std::string msg;
                    msg = "Error reading the item";
                    throw std::runtime_error(msg);
                }

                if (_is)
                {
                    theItems.push_back(item);
                    if (isCalibrated)
                    {
                        Target target;
                        try
                        {
                            char c;
                            if (_is) _is >> c;
                            // go back to the beginning of the line
                            if (_is) _is.putback(c);
                            // check for next line "<"
                            if (c == '<')
                                target = Target();
                            else
                                if (_is)
                                    _is >> target;
                                else
                                    target = Target();
                        }
                        catch (std::exception&)
                        {
                            std::string msg;
                            msg = "Error reading the item";
                            throw std::runtime_error(msg);
                        }

                        theTargets.push_back(target);
                    }
                    else
                        theTargets.push_back(Target());
                }
                else
                {
                    std::string msg;
                    msg = "Error reading the item";
                    throw std::runtime_error(msg);
                }
            }
        }
    };

readSelf()

template<class Item, class Target>

virtual void ClassificationTrainingSet< Item, Target >::readSelf ( std::istream &  _is )

inlinevirtual

Standard input for a training set Parameter: _is The input stream

Exceptions

runtime_error

If there are problems with the stream NOTE: This method is empty, it should be defined.

Reimplemented in ClassificationMap, and ClassicTrainingVectors.

Definition at line 341 of file training_set.h.

    {}

remove()

template<class Item, class Target>

virtual bool ClassificationTrainingSet< Item, Target >::remove ( unsigned int  _idx )

inlinevirtual

Deletes an item from the training set Parameter: _idx The index

Definition at line 193 of file training_set.h.

    {

        if (_idx > theItems.size())
            return false;

        theItems.erase(theItems.begin() + _idx);
        if (isCalibrated)
            theTargets.erase(theTargets.begin() + _idx);

        return true;
    };

saveObject()

template<class Item, class Target>

virtual void ClassificationTrainingSet< Item, Target >::saveObject ( std::ostream &  _os ) const

inlinevirtual

Saves the class into a stream. this method can be used to save the status of the class. Parameter: _os The output stream

Reimplemented in FuzzyMap, ClassificationMap, FuzzyCodeBook, CodeBook, and ClassicTrainingVectors.

Definition at line 349 of file training_set.h.

    {
        writeCalibrated(_os);
        writeItems(_os, true);
    }

setSplit()

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::setSplit ( float  _tp, float  _vp  )

inline

Sets the proportion of training, validation and testing and creates the map. Used for split-sample training and validation. Parameters must be between 0 and 1 and must add to less than 1; the rest will be used for testing Parameter: _tp proportion over 1 of samples devoted to training Parameter: _vp proportion over 1 of samples devoted to validation

Definition at line 120 of file training_set.h.

    {
        if ((_tp > 1) || (_tp <= 0) || (_vp > 1) || (_vp <= 0) || (_tp + _vp > 1))
        {
            throw std::invalid_argument("Split mode proportions must be < 1");
        }
        std::vector<float> acc(2); // 3 modes
        acc[TRAIN] = _tp;
        acc[VALIDATION] = _tp + _vp;
        std::random_device rd;  //Will be used to obtain a seed for the random number engine
        std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
        std::uniform_real_distribution<> dist(0.f, 1.f);
        for (unsigned i = 0; i < size(); i ++)
        {
            float aRnd = dist(gen);
            unsigned rw = TEST;
            for (unsigned j = TRAIN; j < TEST; j ++)
            {
                if (aRnd < acc[j])
                {
                    rw = j;
                    break;
                }
            }
            splitTrainingSet.insert(std::pair<unsigned, unsigned>(rw, i));
        }
    }

size()

template<class Item, class Target>

size_t ClassificationTrainingSet< Item, Target >::size ( ) const

inline

Returns the number of items in the training set

Definition at line 210 of file training_set.h.

    {
        return theItems.size();
    };

skipComments()

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::skipComments ( std::istream &  _is ) const

inlineprotected

Skip the comments if the stream Parameter: _is The input stream

Definition at line 598 of file training_set.h.

    {
        char c;
        if (_is)
            _is >> c;

        // check for comments
        while (_is && c == '#')
        {
            // skip the comment
            while (_is && _is.get() != '\n');

            // read beginning of next line
            if (_is)
                _is >> c;
        }

        // go back to the beginning of the line
        if (_is)
            _is.putback(c);
    };

swapItems()

template<class Item, class Target>

virtual bool ClassificationTrainingSet< Item, Target >::swapItems ( unsigned  _i, unsigned  _j  )

inlinevirtual

Swaps two items in the vector

Definition at line 383 of file training_set.h.

    {
        if (_i > size() || _j > size() || _i == _j)
            return false;
        swap(theItems[_i], theItems[_j]);
        if (isCalibrated)
            swap(theTargets[_i], theTargets[_j]);
        return true;
    }

targetAt() [1/2]

template<class Item, class Target>

const Target& ClassificationTrainingSet< Item, Target >::targetAt ( unsigned  _i ) const

inline

Returns a const reference to the specified target Parameter: _i The index

Exceptions

out_of_range

If _i is out of range

Definition at line 221 of file training_set.h.

    {
        if (!isCalibrated)
        {
            std::string msg;
            msg = "The training set is not calibrated.";
            throw std::out_of_range(msg);
        }
        if (_i >= size())
        {
            std::string msg;
            msg = "Out of range. No target at position " + integerToString(_i);
            throw std::out_of_range(msg);
        }

        return theTargets[_i];
    };

targetAt() [2/2]

template<class Item, class Target>

Target& ClassificationTrainingSet< Item, Target >::targetAt ( unsigned  _i )

inline

Returns a reference to a target. Parameter: _i The index

Exceptions

out_of_range

If _i is out of range

Definition at line 245 of file training_set.h.

    {
        if (_i >= size())
        {
            std::string msg;
            msg = "Out of range. No target at position " + integerToString(_i);
            throw std::out_of_range(msg);
        }

        return theTargets[_i];
    };

targetsBegin()

template<class Item, class Target>

std::vector<Target>::const_iterator ClassificationTrainingSet< Item, Target >::targetsBegin ( ) const

inlineprotected

Protected interface to the targets

Returns

a const_iterator that points to the first Target in the set

Definition at line 643 of file training_set.h.

    {
        return theTargets.begin();
    }

targetsEnd()

template<class Item, class Target>

std::vector<Target>::const_iterator ClassificationTrainingSet< Item, Target >::targetsEnd ( ) const

inlineprotected

Protected interface to the targets

Returns

a const_iterator that points to the last Target in the set

Definition at line 651 of file training_set.h.

    {
        return theTargets.end();
    }

writeCalibrated()

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::writeCalibrated ( std::ostream &  _os ) const

inlineprotected

Writes if the training set is calibrated or not Parameter: _os The output stream

Definition at line 549 of file training_set.h.

    {
        if (isCalibrated)
            _os << "calibrated" << std::endl;
    };

writeItems()

template<class Item, class Target>

void ClassificationTrainingSet< Item, Target >::writeItems ( std::ostream &  _os, bool  _delim = false  ) const

inlineprotected

Writes the items Parameter: _os The output stream Parameter: _delim Flag to use "<" delimiters (false by default)

Definition at line 561 of file training_set.h.

    {
        typename std::vector<Item>::const_iterator i;
        typename std::vector<Target>::const_iterator j;
        for (i = theItems.begin(), j = theTargets.begin() ; i < theItems.end() ;
             i++, j++)
        {

            if (_delim)
                _os << *i;
            else
            {
                for (size_t d = 0; d < (*i).size(); d++)
                {
                    _os << (*i)[d];
                    if (d != (*i).size() - 1) _os << " ";
                }
            }

            /*      if (isCalibrated) {
                    if ((*j == " " || *j == "") && _delim)
                _os << "|";
                    else
                      _os << " " << *j;
                  }*/
            if (isCalibrated)
                _os << " " << *j;

            _os << std::endl;
        }
    };

Friends And Related Function Documentation

operator<<

template<class Item, class Target>

std::ostream& operator<< ( std::ostream &  _os, const ClassificationTrainingSet< Item, Target > &  _ts  )

friend

Standard output for a training set Parameter: _os The output stream Parameter: _ts The training set to be printed

Definition at line 397 of file training_set.h.

    {
        _ts.printSelf(_os);
        return _os;
    }

operator>>

template<class Item, class Target>

std::istream& operator>> ( std::istream &  _is, ClassificationTrainingSet< Item, Target > &  _ts  )

friend

Standard input for a training set Parameter: _is The input stream Parameter: _ts The training set to be read

Exceptions

runtime_error

If there are problems with the stream

Definition at line 409 of file training_set.h.

    {
        _ts.readSelf(_is);
        return _is;
    }

Member Data Documentation

isCalibrated

template<class Item, class Target>

bool ClassificationTrainingSet< Item, Target >::isCalibrated

protected

Definition at line 78 of file training_set.h.

nTargets

template<class Item, class Target>

unsigned ClassificationTrainingSet< Item, Target >::nTargets

protected

Definition at line 82 of file training_set.h.

splitTrainingSet

template<class Item, class Target>

splitTS ClassificationTrainingSet< Item, Target >::splitTrainingSet

protected

Definition at line 79 of file training_set.h.

theItems

template<class Item, class Target>

std::vector<Item> ClassificationTrainingSet< Item, Target >::theItems

Definition at line 84 of file training_set.h.

theTargets

template<class Item, class Target>

std::vector<Target> ClassificationTrainingSet< Item, Target >::theTargets

Definition at line 85 of file training_set.h.

---

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

• xmipp/libraries/classification/training_set.h