SPE Class Reference

#include <spe.h>

Inheritance diagram for SPE:

Collaboration diagram for SPE:

Public Member Functions
void	setSpecificParameters (bool global=true, 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
bool	global
int	k
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

Class for making a SPE dimensionality reduction

Definition at line 37 of file spe.h.

Member Function Documentation

reduceDimensionality()

void SPE::reduceDimensionality ( )

virtual

Reduce dimensionality.

Implements DimRedAlgorithm.

Definition at line 36 of file spe.cpp.

{
    double lambda = 1;  // lambda
    int s = 100; // number of updates per iteration
    int max_iter = 20000 + round(0.04 * MAT_YSIZE(*X) * MAT_YSIZE(*X)); // number of iterations
    double tol = 1e-5;
    int n = MAT_YSIZE(*X);
    Matrix2D<double> R;
    Matrix1D<double> D, Rt, W;
    MultidimArray<int> J;
    Matrix1D<int> ind1,ind2;

    ind1.resize(s);
    ind2.resize(s);
    Rt.initZeros(VEC_XSIZE(ind1));
    D.initZeros(VEC_XSIZE(ind1));
    W.initZeros(VEC_XSIZE(ind1));

    Y.initRandom(MAT_YSIZE(*X),outputDim,0,1);

    // Compute distance all vs. all
    computeDistance(*X, R, distance, true);
    R /= R.computeMax() / sqrt(2);

    if (global)
        max_iter *= 3;
    int ind1_0=0, ind1_F=s;
    int ind2_F=std::min(2*s,n-1);
    for(int nn=0;nn<max_iter;nn++)
    {
        // Compute random points
        randomPermutation(n,J);

        // Get the ind1 and ind2 indexes vectors
        if(n>s){
            memcpy(&VEC_ELEM(ind1, 0),&A1D_ELEM(J,ind1_0),ind1_F*sizeof(int));
            memcpy(&VEC_ELEM(ind2, 0),&A1D_ELEM(J,ind1_F),ind1_F*sizeof(int));
        }
        else{
            memcpy(&VEC_ELEM(ind1, 0),&A1D_ELEM(J,0),ind2_F*sizeof(int));
            memcpy(&VEC_ELEM(ind2, 0),&A1D_ELEM(J,ind1_F),ind2_F*sizeof(int));
        }

        // Compute distances between points in embedded space
        computeRandomPointsDistance(Y,D,ind1,ind2,distance,true);

        // Get corresponding distances in real space
        for (int l=0;l<VEC_XSIZE(ind1);l++)
            VEC_ELEM(Rt,l)= R(VEC_ELEM(ind1,l),VEC_ELEM(ind2,l));

        // Compute (Rt-D) / (D + tol)
        FOR_ALL_ELEMENTS_IN_MATRIX1D(Rt)
            VEC_ELEM(W,i) = (VEC_ELEM(Rt,i)-VEC_ELEM(D,i))/(VEC_ELEM(D,i)+tol);

        // Get the index to update locations
        for(int ii=0;ii<s;ii++)
        {
            int i1 = VEC_ELEM(ind1,ii);
            int i2 = VEC_ELEM(ind2,ii);

            // Update locations
            double factor=lambda * 1/2;
            for (size_t j = 0; j< outputDim; ++j){
                double aux= MAT_ELEM(Y, i1, j) + factor*VEC_ELEM(W,ii)*(MAT_ELEM(Y, i1,j)-MAT_ELEM(Y, i2,j));
                MAT_ELEM(Y, i2, j) += factor*VEC_ELEM(W,ii)*(MAT_ELEM(Y,i2,j)-MAT_ELEM(Y,i1,j));
                MAT_ELEM(Y,i1,j) = aux;
            }
        }
        // Update lambda
        lambda = lambda - (lambda / max_iter);
    }
}

setSpecificParameters()

void SPE::setSpecificParameters	(	bool	global = true,
		int	k = 12
	)

Set specific parameters.

Definition at line 30 of file spe.cpp.

{
    this->global = true;
    this->k = 1;
}

Member Data Documentation

global

bool SPE::global

Definition at line 40 of file spe.h.

k

int SPE::k

Definition at line 41 of file spe.h.

---

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

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