code_book.cpp

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'
 ***************************************************************************/

//-----------------------------------------------------------------------------
// CodeBook.cc
//-----------------------------------------------------------------------------


#include "code_book.h"
#include <core/xmipp_funcs.h>

CodeBook::CodeBook(unsigned _n, unsigned _size, bool _cal)
        : ClassificationDataSet<FeatureVector, Label>(),
        ClassificationTrainingSet<FeatureVector, Label>(_cal)
{
    // Fill vectors with zeros
    theItems.resize(_n);
    //if (calibrated())
    theTargets.resize(_n, "");
    for (unsigned i = 0 ; i < _n ; i++)
    {
        FeatureVector v;
        v.resize(_size, 0);
        theItems[i] = v;
    }
}



CodeBook::CodeBook(unsigned _n, unsigned _size, floatFeature _lower,
                   floatFeature _upper, bool _cal)
        : ClassificationDataSet<FeatureVector, Label>(),
        ClassificationTrainingSet<FeatureVector, Label>(_cal)
{
    theItems.resize(_n);
    //if (calibrated())
    theTargets.resize(_n, "");
    // Assign random vectors
    for (unsigned i = 0 ; i < _n ; i++)
    {
        std::vector<floatFeature> v;
        v = randomVector(_size, _lower, _upper);
        theItems[i] = v;
    }
}

/* Part of this code were developed by Lorenzo Zampighi and Nelson Tang
   of the department of Physiology of the David Geffen School of Medistd::cine,
   University of California, Los Angeles
*/

CodeBook::CodeBook(unsigned _n, const ClassicTrainingVectors& _ts, const bool _use_rand_cvs)
        : ClassificationDataSet<FeatureVector, Label>(),
        ClassificationTrainingSet<FeatureVector, Label>(_ts.calibrated())
{
    // Take random samples
    //    RandomUniformGenerator<unsigned> chosen( 0, _ts.size() -1 );
    randomize_random_generator();

    theItems.resize(_n);
    //if (_ts.calibrated())
    theTargets.resize(_n, "");
    // Assign random vectors
    std::vector<floatFeature> v;
    for (unsigned i = 0 ; i < _n ; i++)
    {
        auto index = (int) rnd_unif(0, _ts.size() - 1);
        v = _ts.theItems[index];
        if (_use_rand_cvs)
        {
            // NT: Scan this vector for the range of pixel values
            floatFeature minval;
            floatFeature maxval;
            std::vector<floatFeature>::const_iterator viter = v.begin();
            minval = maxval = *viter;
            for (viter++; viter != v.end(); viter++)
            {
                if (*viter < minval)
                    minval = *viter;
                else if (*viter > maxval)
                    maxval = *viter;
            }
            v = randomVector(_ts.theItems[0].size(), minval, maxval);
        }
        theItems[i] = v;
    }

}

CodeBook::CodeBook(std::istream& _is) : ClassificationDataSet<FeatureVector, Label>(),
        ClassificationTrainingSet<FeatureVector, Label>(_is)
{
    readSelf(_is);
}

FeatureVector& CodeBook::test(const FeatureVector& _in) const
{
    // eval the first one to init best & bestDist
    std::vector<FeatureVector>::const_iterator i = itemsBegin();
    std::vector<FeatureVector>::const_iterator best = i;
    double bestDist = euclideanDistance(*i, _in);

    // eval the rest
    for (i++ ; i < itemsEnd() ; i++)
    {
        double dist = euclideanDistance(*i, _in);
        if (dist < bestDist)
        {
            bestDist = dist;
            best = i;
        }
    }

    return (FeatureVector&)*best;
}

unsigned CodeBook::testIndex(const FeatureVector& _in) const
{
    // eval the first one to init best & bestDist
    std::vector<FeatureVector>::const_iterator i = itemsBegin();
    std::vector<FeatureVector>::const_iterator best = i;
    double bestDist = euclideanDistance(*i, _in);

    // eval the rest
    unsigned bestIndex = 0;
    unsigned index = 1;
    for (i++ ; i < itemsEnd() ; i++)
    {
        double dist = euclideanDistance(*i, _in);
        if (dist < bestDist)
        {
            bestDist = dist;
            best = i;
            bestIndex = index;
        }
        index++;
    }

    return bestIndex;
}
#ifdef UNUSED // detected as unused 29.6.2018

unsigned CodeBook::winner(const ClassicTrainingVectors& _ts, unsigned _in) const
{
    return testIndex(_ts.theItems[_in]);
}
#endif

void CodeBook::classify(const ClassicTrainingVectors* _ts)
{
    classifVectors.clear(); // clear previous classification.
    classifVectors.resize(size());
    aveDistances.clear(); // clear previous classification.
    aveDistances.resize(size());
    for (unsigned j = 0 ; j < _ts->size() ; j++)
        classifVectors[testIndex(_ts->theItems[j])].push_back(j);

    for (unsigned i = 0 ; i < size() ; i++)
    {
        double aveDist = 0;
        for (unsigned j = 0 ; j < classifVectors[i].size() ; j++)
            aveDist += euclideanDistance(theItems[i], _ts->theItems[classifVectors[i][j]]);
        if (classifVectors[i].size() != 0)
            aveDist /= (double) classifVectors[i].size();
        aveDistances[i] = (double) aveDist;
    }

}


void CodeBook::printHistogram(std::ostream& _os) const
{
    _os << "1 " << size() << std::endl;
    for (size_t j = 0; j < size(); j++)
        _os << j << " " << classifSizeAt(j) << std::endl;
}


void CodeBook::printQuantError(std::ostream& _os) const
{
    _os << "1 " << size() << std::endl;
    for (size_t j = 0; j < size(); j++)
        _os << j << " " << aveDistances[j] << std::endl;
}

const std::vector< unsigned>& CodeBook::classifAt(const unsigned& _index) const
{
    if (_index < 0 || _index > classifVectors.size())
    {
        std::ostringstream msg;
        msg << "index out of range";
        throw std::runtime_error(msg.str());
    }
    return classifVectors[_index];
}

unsigned CodeBook::classifSizeAt(const unsigned& _index) const
{
    if (_index < 0 || _index > classifVectors.size())
    {
        std::ostringstream msg;
        msg << "index out of range";
        throw std::runtime_error(msg.str());
    }
    return classifVectors[_index].size();
}


Label CodeBook::apply(const FeatureVector& _in) const
{
    return theTargets[testIndex(_in)];
}


void CodeBook::calibrate(ClassicTrainingVectors& _ts,
                         Label _def)
{
    // set the default label
    for (std::vector<FeatureVector>::const_iterator i = itemsBegin() ;
         i < itemsEnd() ; i++)
        theTargets[i - itemsBegin()] = _def;
    if (_ts.calibrated())
    {
        for (unsigned j = 0 ; j < _ts.size() ; j++)
            theTargets[testIndex(_ts.theItems[j])] = _ts.theTargets[j];
        calibrated(true);
    }
    else
        calibrated(false);
}

unsigned CodeBook::output(const FeatureVector& _in)
const
{
    return testIndex(_in);
}


void CodeBook::printSelf(std::ostream& _os) const
{
    ClassificationTrainingSet<FeatureVector, Label>::printSelf(_os);
}

void CodeBook::readSelf(std::istream& _is, long _dim, long _size)
{

#ifndef _NO_EXCEPTION
    try
    {
#endif
        clear();
        std::string line;

        // Determines the number of rows and columns in the training set

        long dim;
        long size;
        if (_dim == -1)
        {
            _is >> dim;
        }
        else
            dim = _dim;
        if (_size == -1)
        {
            _is >> line;
            if (!sscanf(line.c_str(), "%ld", &size))
            {
                int x;
                int y;
                _is >> x;
                _is >> y;
                size = x * y;
            }
        }
        else
            size = _size;
        getline(_is, line);
        theItems.resize(size);
        theTargets.resize(size);

        for (int i = 0; i < size; i++)
        {
            std::vector<floatFeature> v;
            v.resize(dim);
            for (int j = 0; j < dim; j++)
            {
                floatFeature var;
                _is >> var;
                v[j] = var;
            }
            getline(_is, line);
            theItems[i] = v;
            theTargets[i] = line;
        }
#ifndef _NO_EXCEPTION

    }
    catch (std::exception& e)
    {
        std::ostringstream msg;
        msg << e.what() << std::endl << "Error reading the code book";
        throw std::runtime_error(msg.str());
    }
#endif
}


void CodeBook::readClassifVectors(std::istream& _is)
{
    int dim;
    _is >> dim;
    classifVectors.resize(dim);
    for (size_t i = 0; i < classifVectors.size(); i++)
        _is >> classifVectors[i];
}


void CodeBook::writeClassifVectors(std::ostream& _os) const
{
    _os << classifVectors.size() << std::endl;
    for (size_t i = 0; i < classifVectors.size(); i++)
        _os << classifVectors[i] << std::endl;
}


void CodeBook::saveObject(std::ostream& _os) const
{
    writeClassifVectors(_os);
    ClassificationTrainingSet<FeatureVector, Label>::saveObject(_os);
}


void CodeBook::loadObject(std::istream& _is)
{
    clear();
    readClassifVectors(_is);
    ClassificationTrainingSet<FeatureVector, Label>::loadObject(_is);
}


void CodeBook::unNormalize(const std::vector<ClassicTrainingVectors::statsStruct>&  _varStats)
{
    using namespace std;
    if (_varStats.size() != theItems[0].size())
    {
        std::ostringstream msg;
        msg << "Normalization information does not coincide with codebook structure";
        throw std::runtime_error(msg.str());
    }
    for (unsigned it = 0; it < size(); it++)
    {
        for (unsigned i = 0; i < theItems[0].size(); i++)
        {
            if (!isnan(theItems[it][i]))
                theItems[it][i] = theItems[it][i] * _varStats[i].sd + _varStats[i].mean;
        }
    }
}


void CodeBook::Normalize(const std::vector<ClassicTrainingVectors::statsStruct>&  _varStats)
{
    using namespace std;
    if (_varStats.size() != theItems[0].size())
    {
        std::ostringstream msg;
        msg << "Normalization information does not coincide with codebook structure";
        throw std::runtime_error(msg.str());
    }
    for (unsigned it = 0; it < size(); it++)
    {
        for (unsigned i = 0; i < theItems[0].size(); i++)
        {
            if (!isnan(theItems[it][i]))
            {
                if (_varStats[i].sd != 0)
                    theItems[it][i] = (theItems[it][i] - _varStats[i].mean) / _varStats[i].sd;
            }
        }
    }
}


//-----------------------------------------------------------------------------