NPE Class Reference

#include <npe.h>

Inheritance diagram for NPE:

Collaboration diagram for NPE:

Public Member Functions
void	setSpecificParameters (int k=12)
	Set specific parameters. More...
void	reduceDimensionality ()
	Reduce dimensionality. More...
Public Member Functions inherited from DimRedAlgorithm
	DimRedAlgorithm ()
	Empty constructor. More...
void	setInputData (Matrix2D< double > &X)
	Set input data. More...
void	setOutputDimensionality (size_t outputDim)
	Set output dimensionality. More...
const Matrix2D< double > &	getReducedData ()
	Get reduced data. More...

Public Attributes
int	k
double	tol
Public Attributes inherited from DimRedAlgorithm
Matrix2D< double > *	X
	Pointer to input data. More...
size_t	outputDim
	Output dim. More...
Matrix2D< double >	Y
	Output data. More...
DimRedDistance2	distance
	Distance function. More...
FileName	fnMapping
	Save mapping. More...

Detailed Description

Definition at line 34 of file npe.h.

Member Function Documentation

reduceDimensionality()

void NPE::reduceDimensionality ( )

virtual

Reduce dimensionality.

Implements DimRedAlgorithm.

Definition at line 39 of file npe.cpp.

{
    if (MAT_YSIZE(*X) <= MAT_XSIZE(*X))
            REPORT_ERROR(ERR_MATRIX_DIM, "Number of samples should be higher than number of dimensions.");

    int n = MAT_YSIZE(*X);

    //Find nearest neighbours
    Matrix2D<double> D;
    Matrix2D<int> idx;
    kNearestNeighbours(*X,k,idx,D,distance,false);

    Matrix2D<double> W(k,n), Xi, C, M;
    Matrix1D<double> wi;

    PseudoInverseHelper h;
    h.b.resizeNoCopy(k);
    h.b.initConstant(1);

    double tol=1e-5;
    for (int ip=0; ip<n; ++ip)
    {
        extractNearestNeighbours(*X, idx, ip, Xi);

        // Move the origin to observation ip
        FOR_ALL_ELEMENTS_IN_MATRIX2D(Xi)
            MAT_ELEM(Xi,i,j)-=MAT_ELEM(*X,ip,j);

        matrixOperation_AAt(Xi,C);

        double K=C.trace()*tol;
        for (int ii=0; ii<MAT_XSIZE(C); ++ii)
            MAT_ELEM(C,ii,ii)+=K;

        h.A=C;

        solveLinearSystem(h,wi);
        wi/=wi.sum();

        W.setCol(ip,wi);
    }

    //Find the sparse cost matrix
    M.initIdentity(n);
    Matrix1D<int> neighboursi;

    for(int i=0;i<n; ++i)
    {
        // Get wi for this observation
        W.getCol(i,wi);

        // Get the neighbours of this observation
        idx.getRow(i,neighboursi);

        for(size_t p1=0;p1<VEC_XSIZE(neighboursi); p1++)
        {
            int j1=VEC_ELEM(neighboursi,p1); // j is the index of the neighbour
            double w1=VEC_ELEM(wi,p1);
            MAT_ELEM(M,i,j1)-=w1;
            MAT_ELEM(M,j1,i)-=w1;
            for (size_t p2=0; p2<VEC_XSIZE(neighboursi); p2++)
            {
                int j2=VEC_ELEM(neighboursi,p2);
                MAT_ELEM(M,j1,j2)+=w1*VEC_ELEM(wi,p2);
            }

        }
    }

    //Check symmetry
    Matrix2D<double> DP, WP;

    X->transpose();
    matrixOperation_XtAX_symmetric(*X,M,WP);
    matrixOperation_AtA(*X, DP);

    //Solve eigenvector problem
    Matrix2D<double> Peigvec, eigvector;
    Matrix1D<double> Deigval;
    generalizedEigs(WP,DP,Deigval,Peigvec);

    //Sort eigenvalues
    Matrix1D<int> idx2;
    Deigval.indexSort(idx2);

    eigvector.resizeNoCopy(MAT_YSIZE(Peigvec),outputDim);
    for(size_t j =0;j<outputDim;++j){
        int idxj=VEC_ELEM(idx2,j)-1;
        for(size_t i=0;i<MAT_YSIZE(Peigvec);++i)
            MAT_ELEM(eigvector, i, j)=MAT_ELEM(Peigvec,i,idxj);
    }

    //Compute results
    Y=*X*eigvector;
    if (fnMapping!="")
        eigvector.write(fnMapping);
}

setSpecificParameters()

void NPE::setSpecificParameters

(

int

k = 12

)

Set specific parameters.

Definition at line 32 of file npe.cpp.

                                    {
    this->k=k;
}

Member Data Documentation

k

int NPE::k

Definition at line 37 of file npe.h.

tol

double NPE::tol

Definition at line 38 of file npe.h.

---

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

• xmipp/libraries/dimred/npe.h
• xmipp/libraries/dimred/npe.cpp