training_set.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:     Alberto Pascual Montano (pascual@cnb.csic.es)
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/

//-----------------------------------------------------------------------------
// ClassificationTrainingSet.hh
// Xmipp Classification Training Sets
//-----------------------------------------------------------------------------

#ifndef XMIPPTS_H
#define XMIPPTS_H

#include <cctype>
#include <vector>
#include <map>
#include <sstream>
#include <stdexcept>

#include "data_types.h"
#include "vector_ops.h"

#include <core/args.h>

template<class Item, class Target>
class ClassificationTrainingSet
{
public:

    typedef std::multimap<unsigned, unsigned, std::less<unsigned> > splitTS;

    typedef splitTS::iterator splitIt;

    typedef enum { CROSSVAL, SPLITSAMPLE, JACKKNIFE, BOOTSTRAP } splitMode;

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

protected:
    bool isCalibrated;
    splitTS splitTrainingSet;
    /*  std::vector<Item> theItems;
      std::vector<Target> theTargets;*/
    unsigned nTargets;  // Number of targets in the training set
public:
    std::vector<Item> theItems;
    std::vector<Target> theTargets;

    ClassificationTrainingSet(const bool& _calib = true, unsigned _n = 0)
            :isCalibrated(_calib), /* splitTrainingSet(), */nTargets(0), theItems(_n) /*theTargets(_n), */
    {};

    ClassificationTrainingSet(std::istream & _is) :  isCalibrated(false), splitTrainingSet(), theItems(), theTargets()
    {
        loadObject(_is);
        computeNumTargets();
    };

    virtual ~ClassificationTrainingSet()
    {};

    void setSplit(float _tp, float _vp)
    {
        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));
        }
    }



    splitIt beginSubset(unsigned _um)
    {
        return splitTrainingSet.lower_bound(_um);
    }

    splitIt  endSubset(unsigned _um)
    {
        return splitTrainingSet.upper_bound(_um);
    }


    virtual void add(const Item& _i, const Target& _tg/* = Target()*/)
    {
        theItems.push_back(_i);
        theTargets.push_back(_tg);
    };



    virtual void add(const Item& _i)
    {
        theItems.push_back(_i);
    };


    virtual bool remove(unsigned int _idx)
    {

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

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

        return true;
    };


    size_t size() const
    {
        return theItems.size();
    };


    const Target& targetAt(unsigned _i) const
    {
        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];
    };


    Target& targetAt(unsigned _i)
    {
        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];
    };



    const Item& itemAt(unsigned _i) const
    {
        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];
    };



    Item& itemAt(unsigned _i)
    {
        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];
    };



    bool calibrated() const
    {
        return isCalibrated;
    }


    void calibrated(const bool& _calib)
    {
        isCalibrated = _calib;
    };

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


    virtual void printSelf(std::ostream& _os) const
    {
        writeItems(_os);
    }

    virtual void readSelf(std::istream& _is)
    {}

    virtual void saveObject(std::ostream& _os) const
    {
        writeCalibrated(_os);
        writeItems(_os, true);
    }

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

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

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

    friend std::ostream& operator << (std::ostream& _os, const ClassificationTrainingSet& _ts)
    {
        _ts.printSelf(_os);
        return _os;
    }

    friend std::istream& operator >> (std::istream& _is, ClassificationTrainingSet& _ts)
    {
        _ts.readSelf(_is);
        return _is;
    }

protected:

    void computeNumTargets()
    {
        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;
    }

    void checkCalibrated(std::istream& _is)
    {
        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);
        }
    };


    void readItems(std::istream& _is)
    {
        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);
                }
            }
        }
    };



    void writeCalibrated(std::ostream& _os) const
    {
        if (isCalibrated)
            _os << "calibrated" << std::endl;
    };


    void writeItems(std::ostream& _os, bool _delim = false) const
    {
        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;
        }
    };


    void skipComments(std::istream& _is) const
    {
        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);
    };


    typename std::vector<Item>::const_iterator itemsBegin() const
    {
        return theItems.begin();
    }


    typename std::vector<Item>::const_iterator itemsEnd() const
    {
        return theItems.end();
    }


    typename std::vector<Target>::const_iterator targetsBegin() const
    {
        return theTargets.begin();
    }

    typename std::vector<Target>::const_iterator targetsEnd() const
    {
        return theTargets.end();
    }
};
#endif