PCAAnalyzer Class Reference

#include <pca.h>

Public Member Functions
	PCAAnalyzer (void)
	PCAAnalyzer (ClassicTrainingVectors const &ts)
	PCAAnalyzer (ClassicTrainingVectors const &ts, std::vector< unsigned > const &idx)
void	reset (ClassicTrainingVectors const &ts)
void	reset (ClassicTrainingVectors const &ts, std::vector< unsigned > const &idx)
void	clear ()
void	set_Dimension (int _D)
int	get_Dimension () const
int	get_eigenDimension () const
void	setListener (BaseListener *_listener)

Public Attributes
std::vector< FeatureVector >	eigenvec
FeatureVector	eigenval
FeatureVector	mean
int	D
double	prod_mean_mean
std::vector< double >	prod_ei_mean
std::vector< double >	prod_ei_ei
double	avg_mean
std::vector< double >	avg_ei

Friends
std::ostream &	operator<< (std::ostream &out, const PCAAnalyzer &PC)
std::istream &	operator>> (std::istream &in, PCAAnalyzer &PC)

Detailed Description

Basic PCA class

Definition at line 36 of file pca.h.

Constructor & Destructor Documentation

PCAAnalyzer() [1/3]

PCAAnalyzer::PCAAnalyzer ( void  )

inline

Make an empty PCAAnalyzer

Definition at line 42 of file pca.h.

    {}

PCAAnalyzer() [2/3]

PCAAnalyzer::PCAAnalyzer ( ClassicTrainingVectors const &  ts )

inline

Construct a PCAAnalyzer object with eigenvectors & eigenvalues from ts. Parameter: ts The vectors.

Definition at line 50 of file pca.h.

    {
        reset(ts);
    }

PCAAnalyzer() [3/3]

PCAAnalyzer::PCAAnalyzer ( ClassicTrainingVectors const &  ts, std::vector< unsigned > const &  idx  )

inline

Construct a PCAAnalyzer object with eigenvectors & eigenvalues from ts, using only the items given in idx. Parameter: ts The vectors. Parameter: idx The indexes of the vectors to use

Definition at line 61 of file pca.h.

    {
        reset(ts, idx);
    }

Member Function Documentation

clear()

void PCAAnalyzer::clear

(

)

Clear. Clean the eigenvector, eigenvalues and D

Definition at line 360 of file pca.cpp.

{
    set_Dimension(0);
    mean.clear();
    eigenvec.clear();
    eigenval.clear();
}

get_Dimension()

int PCAAnalyzer::get_Dimension ( ) const

inline

Get the number of relevant eigenvalues.

Definition at line 136 of file pca.h.

    {
        return D;
    }

get_eigenDimension()

int PCAAnalyzer::get_eigenDimension ( ) const

inline

Get the dimension of the eigenvectors.

Definition at line 142 of file pca.h.

    {
        if (eigenvec.size() > 1)
            return eigenvec[0].size();
        else
            return 0;
    }

reset() [1/2]

void PCAAnalyzer::reset

(

ClassicTrainingVectors const &

ts

)

Calculate the eigenval/vecs Parameter: ts The vectors.

Definition at line 40 of file pca.cpp.

{
    std::vector<unsigned> dummy;
    for (unsigned i = 0;i < ts.size();i++)
        dummy.push_back(i);
    reset(ts, dummy);
}

reset() [2/2]

void PCAAnalyzer::reset	(	ClassicTrainingVectors const &	ts,
		std::vector< unsigned > const &	idx
	)

Calculate the eigenval/vecs Parameter: ts The vectors. Parameter: idx The indexes of the vectors to use

Definition at line 53 of file pca.cpp.

{
    std::vector<FeatureVector> a;
    int n = ts.dimension();
    a.resize(n);
    int verbosity = listener->getVerbosity();

    {
        if (verbosity)
            listener->OnReportOperation((std::string) "Normalizing....\n");
        if (verbosity == 1)
            listener->OnInitOperation(n);

        //Get the mean of the given cluster of vectors
        for (int k = 0;k < n;k++)
        {
            a[k].resize(n);
            floatFeature sum = 0.0;
            int l = 0;
            for (std::vector<unsigned>::const_iterator i = idx.begin();i != idx.end();i++)
            {
                if (finite(ts.itemAt(*i)[k]))
                {
                    sum += ts.itemAt(*i)[k];
                    l++;
                }
            }
            mean.push_back(sum / l);
            if (verbosity == 1)
                listener->OnProgress(k);
        }
        if (verbosity == 1)
            listener->OnProgress(n);

        if (verbosity == 1)
            listener->OnInitOperation(n);
        for (int i = 0;i < n;i++)
        {
            for (int j = 0;j <= i;j++)
            {
                floatFeature sum = 0.0;
                int l = 0;
                for (std::vector<unsigned>::const_iterator it = idx.begin();it != idx.end();it++)
                {
                    floatFeature d1 = ts.itemAt(*it)[i] - mean[i];
                    floatFeature d2 = ts.itemAt(*it)[j] - mean[j];
                    if (finite(d1) && finite(d2))
                    {
                        sum += d1 * d2;
                        l++;
                    }
                }
                if (l)
                    a[i][j] = a[j][i] = sum / l;
                else
                    a[i][j] = a[j][i] = 0;
            }
            if (verbosity == 1)
                listener->OnProgress(i);
        }
        if (verbosity == 1)
            listener->OnProgress(n);

        //  for(int i=0;i<n;i++)
        //   std::cout << a[i] << std::endl;
    }

    eigenval.resize(n);
    eigenvec.resize(n);
    set_Dimension(n);

    FeatureVector b;
    b.resize(n);
    FeatureVector z;
    z.resize(n);
    FeatureVector &d = eigenval;
    std::vector<FeatureVector> &v = eigenvec;

    for (int i = 0;i < n;i++)
    {
        v[i].resize(n);
        v[i][i] = 1.0;
        b[i] = d[i] = a[i][i];
    }

    int nrot = 0;

    if (verbosity)
        listener->OnReportOperation((std::string) "Diagonalizing matrix....\n");
    if (verbosity == 1)
        listener->OnInitOperation(50);

    //Jacobi method (it=iterationn number)
    for (int it = 1;it <= 50;it++)
    {
        if ((verbosity == 1) && (it == 1))
            listener->OnProgress(0);

        floatFeature tresh;
        floatFeature sm = 0.0;
        for (int ip = 0; ip < n - 1; ip++)
        {
            for (int iq = ip + 1; iq < n; iq++)
                sm += fabs(a[iq][ip]);
        }
        if (sm == 0.0)
        {//Done. Sort vectors
            for (int i = 0; i < n - 1; i++)
            {
                int k = i;
                floatFeature p = d[i];

                for (int j = i + 1; j < n; j++)
                    if (d[j] >= p)
                        p = d[k = j];

                if (k != i)
                {//Swap i<->k
                    d[k] = d[i];
                    d[i] = p;
                    FeatureVector t = v[i];
                    v[i] = v[k];
                    v[k] = t;
                }
            }
            if (verbosity == 1)
                listener->OnProgress(50);
            return;
        }

        if (it < 4)
            tresh = 0.2 * sm / (n * n);
        else
            tresh = 0;

        for (int ip = 0; ip < n - 1; ip++)
        {
            for (int iq = ip + 1; iq < n; iq++)
            {
                floatFeature g = 100.0 * fabs(a[iq][ip]);

                if (it > 4
                    && fabs(d[ip]) + g == fabs(d[ip])
                    && fabs(d[iq]) + g == fabs(d[iq]))
                    a[iq][ip] = 0.0;
                else if (fabs(a[iq][ip]) > tresh)
                {
                    floatFeature tau;
                    floatFeature t;
                    floatFeature s;
                    floatFeature c;
                    floatFeature h = d[iq] - d[ip];
                    if (fabs(h) + g == fabs(h))
                        t = a[iq][ip] / h;
                    else
                    {
                        floatFeature theta = 0.5 * h / a[iq][ip];
                        t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
                        if (theta < 0.0)
                            t = -t;
                    }
                    c = 1.0 / sqrt(1 + t * t);
                    s = t * c;
                    tau = s / (1.0 + c);
                    h = t * a[iq][ip];
                    z[ip] -= h;
                    z[iq] += h;
                    d[ip] -= h;
                    d[iq] += h;
                    a[iq][ip] = 0.0;

#define rotate(a,i,j,k,l) \
    g = a[i][j]; \
    h = a[k][l]; \
    a[i][j] = g - s *(h + g*tau); \
    a[k][l] = h + s*(g - h*tau);

                    int j;
                    for (j = 0; j < ip; j++)
                    {
                        rotate(a, ip, j, iq, j)
                    }
                    for (j = ip + 1; j < iq; j++)
                    {
                        rotate(a, j, ip, iq, j)
                    }
                    for (j = iq + 1; j < n; j++)
                    {
                        rotate(a, j, ip, j, iq)
                    }
                    for (j = 0; j < n; j++)
                    {
                        rotate(v, ip, j, iq, j)
                    }

                    nrot += 1;
                }//if
            }//for iq
        }//for ip
        for (int ip = 0; ip < n; ip++)
        {
            b[ip] += z[ip];
            d[ip] = b[ip];
            z[ip] = 0.0;
        }

        if (verbosity == 1)
            listener->OnProgress(it - 1);

    }//for it

    if (verbosity == 1)
        listener->OnProgress(50);


    REPORT_ERROR(ERR_NUMERICAL, "too many Jacobi iterations");
}

set_Dimension()

void PCAAnalyzer::set_Dimension ( int  _D )

inline

Set the number of relevant eigenvalues.

Definition at line 130 of file pca.h.

    {
        D = _D;
    }

setListener()

void PCAAnalyzer::setListener ( BaseListener *  _listener )

inline

Defines Listener class

Definition at line 168 of file pca.h.

    {
        listener = _listener;
    };

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  out, const PCAAnalyzer &  PC  )

friend

Show relevant eigenvectors and eigenvalues

Definition at line 369 of file pca.cpp.

{
    out << "Relevant Dimension: " << PC.get_Dimension() << std::endl;
    out << "Mean vector: ";
    int size = PC.mean.size();
    out << "(" << size << ") ---> ";
    for (int j = 0; j < size; j++)
        out << PC.mean[j] << " ";
    out << std::endl;
    for (int i = 0; i < PC.get_Dimension(); i++)
    {
        out << PC.eigenval[i] << " (" << size << ") ---> ";
        for (int j = 0; j < size; j++)
            out << PC.eigenvec[i][j] << " ";
        out << std::endl;
    }
    return out;
}

operator>>

std::istream& operator>> ( std::istream &  in, PCAAnalyzer &  PC  )

friend

Read a set of PCA just as shown

Definition at line 388 of file pca.cpp.

{
    PC.clear();
    int D;
    std::string read_line;
    getline(in, read_line);
    sscanf(read_line.c_str(), "Relevant Dimension: %d", &D);
    PC.set_Dimension(D);
    PC.eigenval.resize(D);
    PC.eigenvec.resize(D);

    int size;
    getline(in, read_line);
    sscanf(read_line.c_str(), "Mean vector: (%d) --->", &size);
    read_line.erase(0, read_line.find('>') + 1); // remove until --->
    PC.mean.resize(size);
    std::istringstream istr1(read_line.c_str());
    for (int j = 0; j < size; j++)
        istr1 >> PC.mean[j];

    for (int i = 0; i < D; i++)
    {
        getline(in, read_line);
        float f;
        sscanf(read_line.c_str(), "%f (%d) ---> ", &f, &size);
        PC.eigenval[i] = f;
        read_line.erase(0, read_line.find('>') + 1); // remove until --->
        PC.eigenvec[i].resize(size);
        std::istringstream istr2(read_line.c_str());
        for (int j = 0; j < size; j++)
            istr2 >> PC.eigenvec[i][j];
    }

    return in;
}

Member Data Documentation

avg_ei

std::vector<double> PCAAnalyzer::avg_ei

Average of the ei vectors

Definition at line 110 of file pca.h.

avg_mean

double PCAAnalyzer::avg_mean

Average of the mean vector

Definition at line 107 of file pca.h.

D

int PCAAnalyzer::D

Number of relevant eigenvectors

Definition at line 95 of file pca.h.

eigenval

FeatureVector PCAAnalyzer::eigenval

The eigenvalues

Definition at line 87 of file pca.h.

eigenvec

std::vector<FeatureVector> PCAAnalyzer::eigenvec

The eigenvectors

Definition at line 82 of file pca.h.

mean

FeatureVector PCAAnalyzer::mean

Mean of the input training set

Definition at line 92 of file pca.h.

prod_ei_ei

std::vector<double> PCAAnalyzer::prod_ei_ei

Products <ei,ei>

Definition at line 104 of file pca.h.

prod_ei_mean

std::vector<double> PCAAnalyzer::prod_ei_mean

Products <ei,mean>

Definition at line 101 of file pca.h.

prod_mean_mean

double PCAAnalyzer::prod_mean_mean

Product <mean,mean>

Definition at line 98 of file pca.h.

---

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

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