ClassicTrainingVectors Class Reference

#include <training_vector.h>

Inheritance diagram for ClassicTrainingVectors:

Collaboration diagram for ClassicTrainingVectors:

Classes
struct	stats

Public Types
typedef struct ClassicTrainingVectors::stats	statsStruct
Public Types inherited from ClassificationTrainingSet< FeatureVector, Label >
enum	splitMode
	Ways the training set can be used. More...
enum	useMode
	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
	ClassicTrainingVectors (unsigned _vecSize=0, bool _calib=true)
	ClassicTrainingVectors (std::istream &_is)
	ClassicTrainingVectors (const ClassicTrainingVectors &op1)
virtual	~ClassicTrainingVectors ()
unsigned	dimension () const
void	clear ()
virtual void	printSelf (std::ostream &_os) const
virtual void	readSelf (std::istream &_is)
void	read (const FileName &fnIn)
virtual void	saveObject (std::ostream &_os) const
virtual void	loadObject (std::istream &_is)
ClassicTrainingVectors &	operator= (const ClassicTrainingVectors &op1)
virtual void	normalizeFeature (unsigned _i)
void	normalize ()
virtual void	unNormalize ()
bool	isNormalized () const
virtual const std::vector< statsStruct > &	getNormalizationInfo () const
void	getFeatureStats (unsigned _i, floatFeature &_mean, floatFeature &_sd)
Public Member Functions inherited from ClassificationTrainingSet< FeatureVector, Label >
	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 FeatureVector &_i, const Label &_tg)
virtual void	add (const FeatureVector &_i)
virtual bool	remove (unsigned int _idx)
size_t	size () const
const Label &	targetAt (unsigned _i) const
Label &	targetAt (unsigned _i)
const FeatureVector &	itemAt (unsigned _i) const
FeatureVector &	itemAt (unsigned _i)
bool	calibrated () const
void	calibrated (const bool &_calib)
void	clear ()
unsigned	numTargets () const
virtual bool	swapItems (unsigned _i, unsigned _j)

Protected Attributes
std::vector< statsStruct >	varStats
bool	normalized
Protected Attributes inherited from ClassificationTrainingSet< FeatureVector, Label >
bool	isCalibrated
splitTS	splitTrainingSet
unsigned	nTargets

Additional Inherited Members
Public Attributes inherited from ClassificationTrainingSet< FeatureVector, Label >
std::vector< FeatureVector >	theItems
std::vector< Label >	theTargets
Protected Member Functions inherited from ClassificationTrainingSet< FeatureVector, Label >
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< FeatureVector >::const_iterator	itemsBegin () const
std::vector< FeatureVector >::const_iterator	itemsEnd () const
std::vector< Label >::const_iterator	targetsBegin () const
std::vector< Label >::const_iterator	targetsEnd () const

Detailed Description

This class implements all the necessary functionality for classic training vectors.

Definition at line 46 of file training_vector.h.

Member Typedef Documentation

statsStruct

typedef struct ClassicTrainingVectors::stats ClassicTrainingVectors::statsStruct

Constructor & Destructor Documentation

ClassicTrainingVectors() [1/3]

ClassicTrainingVectors::ClassicTrainingVectors ( unsigned  _vecSize = 0, bool  _calib = true  )

inline

Default constructor Parameter: _vecSize Vector dimension; required to dim the feature and types vector Parameter: _calib calibration which should be true if the data set has labels

Definition at line 63 of file training_vector.h.

            : ClassificationTrainingSet<FeatureVector, Label>(_calib),  /*varStats(_vecSize),*/
            normalized(false)
    {}

ClassicTrainingVectors() [2/3]

ClassicTrainingVectors::ClassicTrainingVectors

(

std::istream &

_is

)

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

Exceptions

runtime_error

If there are problems with the stream

TrainingSet for ClassicTrainingVectors Constructs a training set given a stream Parameter: _is The input stream

Exceptions

runtime_error

If there are problems with the stream

Definition at line 46 of file training_vector.cpp.

{
    try
    {
        clear();
        readSelf(_is);
    }
    catch (std::exception& e)
    {
        std::ostringstream msg;
        msg << e.what() << std::endl << "Error reading the training vector";
        throw std::runtime_error(msg.str());
    }
}

ClassicTrainingVectors() [3/3]

ClassicTrainingVectors::ClassicTrainingVectors

(

const ClassicTrainingVectors &

op1

)

Copy Constructor. Useful when returning a ClassicTrainingVectors Class. Parameter: op1 ClassicTrainingVectors

Definition at line 67 of file training_vector.cpp.

{

    calibrated(op1.calibrated());

    for (size_t i = 0; i < op1.size(); i++)
        if (calibrated())
            add(op1.itemAt(i), op1.targetAt(i));
        else
            add(op1.itemAt(i));

    normalized = op1.normalized;
    varStats = op1.varStats;
}

~ClassicTrainingVectors()

virtual ClassicTrainingVectors::~ClassicTrainingVectors ( )

inlinevirtual

Virtual destructor

Definition at line 85 of file training_vector.h.

    {}

Member Function Documentation

clear()

void ClassicTrainingVectors::clear

(

)

Clears the training set

Definition at line 105 of file training_vector.cpp.

{
    ClassificationTrainingSet<FeatureVector, Label>::clear();
    varStats.clear();
    normalized = false;
}

dimension()

unsigned ClassicTrainingVectors::dimension

(

)

const

Returns the dimension of the vectors (number of features)

Returns dimension (the same as above)

Definition at line 97 of file training_vector.cpp.

{
    return itemAt(0).size();
}

getFeatureStats()

void ClassicTrainingVectors::getFeatureStats	(	unsigned	_i,
		floatFeature &	_mean,
		floatFeature &	_sd
	)

Calcualtes the average and SD of a feature in the training set Parameter: _i The index to the feature

Returns a const reference to the normalization vector Calcualtes the average and SD of a feature in the training set Parameter: _i The index to the feature

Definition at line 505 of file training_vector.cpp.

{
    using namespace std;

    // Do some validation
    if (_i > itemAt(0).size())
    {
        std::ostringstream msg;
        msg << "Out of range. No variable at position " << _i;
        throw std::out_of_range(msg.str());
    }

    // first calculates the mean
    _mean = 0;
    int nn = 0;
    for (size_t it = 0; it < size(); it++)
    {
        if (!isnan(itemAt(it)[_i]))
        {
            _mean += itemAt(it)[_i];
            nn++;
        }

    }
    _mean /= (floatFeature) nn;

    // Then calculates SD
    _sd = 0;
    for (size_t it = 0; it < size(); it++)
    {
        if (!isnan(itemAt(it)[_i]))
            _sd += (itemAt(it)[_i] - _mean) * (itemAt(it)[_i] - _mean);
    }
    _sd = sqrt(_sd / (floatFeature)(nn - 1));
}

getNormalizationInfo()

virtual const std::vector<statsStruct>& ClassicTrainingVectors::getNormalizationInfo ( ) const

inlinevirtual

Returns a const reference to the normalization vector

Definition at line 205 of file training_vector.h.

    {
        return varStats;
    };

isNormalized()

bool ClassicTrainingVectors::isNormalized

(

)

const

Returns TRUE if recordset is normalized.

Definition at line 487 of file training_vector.cpp.

{
    return normalized;
}

loadObject()

void ClassicTrainingVectors::loadObject ( std::istream &  _is )

virtual

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

Reimplemented from ClassificationTrainingSet< FeatureVector, Label >.

Definition at line 252 of file training_vector.cpp.

{
    clear();
    int dim;
    _is >> dim;
    _is >> normalized;
    if (normalized)
        varStats.clear();
    varStats.resize(dim);
    for (size_t i = 0; i < varStats.size(); i++)
    {
        _is >> varStats[i].mean;
        _is >> varStats[i].sd;
    }
    ClassificationTrainingSet<FeatureVector, Label>::loadObject((std::istream&)_is);
}

normalize()

void ClassicTrainingVectors::normalize

(

)

Normalize all features in the training set

Definition at line 417 of file training_vector.cpp.

{
    varStats.clear();
    varStats.resize(itemAt(0).size());
    for (unsigned i = 0; i < itemAt(0).size(); i++)
        normalizeFeature(i);
    normalized = true;
}

normalizeFeature()

void ClassicTrainingVectors::normalizeFeature ( unsigned  _i )

virtual

Normalize a feature in the training set Parameter: _i The index to the feature

Normalize all features in the training set Parameter: _i The index to the feature

Definition at line 362 of file training_vector.cpp.

{
    using namespace std;

    // Do some validation

    if (_i > itemAt(0).size())
    {
        std::ostringstream msg;
        msg << "Out of range. No variable at position " << _i;
        throw std::out_of_range(msg.str());
    }

    // first calculates the mean
    floatFeature mean = 0;
    int nn = 0;
    for (size_t it = 0; it < size(); it++)
    {
        if (!isnan(itemAt(it)[_i]))
        {
            mean += itemAt(it)[_i];
            nn++;
        }

    }
    mean /= (floatFeature) nn;

    // Then calculates SD
    floatFeature sd = 0;
    for (size_t it = 0; it < size(); it++)
    {
        if (!isnan(itemAt(it)[_i]))
            sd += (itemAt(it)[_i] - mean) * (itemAt(it)[_i] - mean);
    }
    sd = sqrt(sd / (floatFeature)(nn - 1));

    // Now normalize the variable
    if (sd != 0)
    {
        for (size_t it = 0; it < size(); it++)
        {
            if (!isnan(itemAt(it)[_i]))
                itemAt(it)[_i] = (itemAt(it)[_i] - mean) / sd;
        }
    }

    varStats[_i].mean = mean;
    varStats[_i].sd = sd;
}

operator=()

ClassicTrainingVectors & ClassicTrainingVectors::operator=

(

const ClassicTrainingVectors &

op1

)

Operator "=" Parameter: op1 ClassicTrainingVectors

Definition at line 287 of file training_vector.cpp.

{

    // This avoids memory leakage in assignments like v=v
    if (&op1 != this)
    {

        calibrated(op1.calibrated());

        for (size_t i = 0; i < op1.size(); i++)
            if (calibrated())
                add(op1.itemAt(i), op1.targetAt(i));
            else
                add(op1.itemAt(i));

        normalized = op1.normalized;
        varStats = op1.varStats;
    }
    return *this;
}

printSelf()

void ClassicTrainingVectors::printSelf ( std::ostream &  _os ) const

virtual

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

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

Reimplemented from ClassificationTrainingSet< FeatureVector, Label >.

Definition at line 117 of file training_vector.cpp.

{
    _os << dimension() << " " << theItems.size() << std::endl;
    ClassificationTrainingSet<FeatureVector, Label>::printSelf(_os);
}

read()

void ClassicTrainingVectors::read

(

const FileName &

fnIn

)

Read data from a metadata.

Definition at line 182 of file training_vector.cpp.

{
    clear();

    // Read header and content
    MetaDataVec vectorHeader(formatString("vectorHeader@%s",fnIn.c_str()));
    MetaDataVec vectorContent(formatString("vectorContent@%s",fnIn.c_str()));
    size_t Nvectors;
    size_t vectorSize;
    size_t id = vectorHeader.firstRowId();
    vectorHeader.getValue(MDL_CLASSIFICATION_DATA_SIZE,vectorSize,id);
    vectorHeader.getValue(MDL_COUNT,Nvectors,id);
    theItems.reserve(Nvectors);
    theTargets.reserve(Nvectors);

    // Read the data
    FileName fnInRaw=formatString("%s.vec",fnIn.withoutExtension().c_str());
    std::ifstream fhInRaw(fnInRaw.c_str(),std::ios::binary);
    if (!fhInRaw)
        REPORT_ERROR(ERR_IO_NOTEXIST,fnInRaw);
    std::vector<floatFeature> v;
    v.resize(vectorSize);
    auto *buffer=new float[vectorSize];
    String fnImg;
    size_t order;

    for (size_t objId : vectorContent.ids())
    {
        vectorContent.getValue(MDL_IMAGE, fnImg, objId);
        vectorContent.getValue(MDL_ORDER, order, objId);

        // Read raw values
        fhInRaw.seekg(order*vectorSize*sizeof(float));
        fhInRaw.read((char*)buffer,vectorSize*sizeof(float));
        if (!fhInRaw)
            REPORT_ERROR(ERR_IO_NOREAD,
                         formatString("Could not read image %lu from %s",
                                      order,fnInRaw.c_str()));
        for (size_t i=0; i<vectorSize; ++i)
            v[i]=buffer[i];
        theTargets.push_back(fnImg);
        theItems.push_back(v);
    }
    delete []buffer;
}

readSelf()

void ClassicTrainingVectors::readSelf ( std::istream &  _is )

virtual

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

Exceptions

runtime_error

If there are problems with the stream

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

Reimplemented from ClassificationTrainingSet< FeatureVector, Label >.

Definition at line 129 of file training_vector.cpp.

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

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

        long dim;
        long size;
        _is >> dim;
        _is >> line;
        if (!sscanf(line.c_str(), "%ld", &size))
        {
            int x;
            int y;
            _is >> x;
            _is >> y;
            size = x * y;
        }
        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] = removeSpaces(line);
        }

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

saveObject()

void ClassicTrainingVectors::saveObject ( std::ostream &  _os ) const

virtual

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

Reimplemented from ClassificationTrainingSet< FeatureVector, Label >.

Definition at line 233 of file training_vector.cpp.

{
    _os << dimension() << std::endl;
    _os << normalized << std::endl;
    if (normalized)
        for (size_t i = 0; i < varStats.size(); i++)
        {
            _os << varStats[i].mean << std::endl;
            _os << varStats[i].sd << std::endl;
        }
    ClassificationTrainingSet<FeatureVector, Label>::saveObject(_os);
}

unNormalize()

void ClassicTrainingVectors::unNormalize ( )

virtual

UnNormalize all features in the training set

Definition at line 431 of file training_vector.cpp.

{
    using namespace std;
    for (unsigned it = 0; it < size(); it++)
    {
        for (unsigned i = 0; i < itemAt(0).size(); i++)
        {
            if (!isnan(itemAt(it)[i]))
                itemAt(it)[i] = itemAt(it)[i] * varStats[i].sd + varStats[i].mean;
        }
    }
    varStats.clear();
    normalized = false;
}

Member Data Documentation

normalized

bool ClassicTrainingVectors::normalized

protected

Definition at line 226 of file training_vector.h.

varStats

std::vector<statsStruct> ClassicTrainingVectors::varStats

protected

Definition at line 225 of file training_vector.h.

---

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

• xmipp/libraries/classification/training_vector.h
• xmipp/libraries/classification/training_vector.cpp