A LocalVariance is an implementation of the abstract ILinearReduct class. More...

#include <STK_LocalVariance.h>

Inheritance diagram for STK::LocalVariance< Array >:

Public Types
typedef hidden::Traits< Array >::Row	RowVector

typedef ILinearReduct< Array, VectorX >	Base

Public Types inherited from STK::ILinearReduct< Array, VectorX >
typedef IReducer< Array, VectorX >	Base

Public Member Functions
	LocalVariance (Array const *p_data, Reduct::TypeGraph type=Reduct::distance_, int nbNeighbor=1)
	Constructor.

	LocalVariance (Array const &data, Reduct::TypeGraph type=Reduct::distance_, int nbNeighbor=1)
	Constructor.

	LocalVariance (LocalVariance const &reducer)
	copy Constructor.

virtual LocalVariance *	clone () const
	clone pattern

virtual	~LocalVariance ()
	Destructor.

int	nbNeighbor () const

ArrayXXi const &	pred () const

ArraySquareX const &	covariance () const

ArraySquareX const &	localCovariance () const

Public Member Functions inherited from STK::ILinearReduct< Array, VectorX >
	ILinearReduct ()
	Default Constructor.

	ILinearReduct (Array const *p_data)
	Constructor.

	ILinearReduct (Array const &data)
	Constructor.

	ILinearReduct (ILinearReduct const &reducer)
	copy Constructor.

virtual	~ILinearReduct ()
	virtual destructor

VectorX const &	criteriaValues () const

Array const &	axis () const

virtual bool	run ()
	Compute the projection matrix `axis_` by maximizing the criteria and project the data set in order to obtain `p_projected_`.

virtual bool	run (VectorX const &weights)
	Compute the projection matrix set by maximizing the weighted criteria and project the data set in order to obtain `p_projected_`.

Public Member Functions inherited from STK::IReducer< Array, Weights >
virtual	~IReducer ()
	virtual destructor.

int	dim () const
	get the number of dimension.

Array *	p_reduced () const
	get a pointer on the reduced data set

void	setDimension (const int &dim)
	set the number of dimension.

void	clear ()
	clear allocated memory

Public Member Functions inherited from STK::IRunnerUnsupervised< Array, Weights >
Array const *	p_data () const
	get the data set

virtual void	setData (Array const *p_data)
	Set the data set.

virtual void	setData (Array const &data)
	Set the data set.

Public Member Functions inherited from STK::IRunnerBase
String const &	error () const
	get the last error message.

Protected Member Functions
virtual void	update ()
	Compute the proximity graph if the data set is modified.

virtual void	maximizeStep ()
	Compute the axis by maximizing the ratio of the local variance on the total variance of the data set.

virtual void	maximizeStep (VectorX const &weights)
	Compute the axis by maximizing the ratio of the weighted local variance on the weighted total variance of the data set.

void	prim ()
	compute the minimal spanning tree

void	minimalDistance ()
	compute the minimal distance graph

void	computeCovarianceMatrices ()
	compute the covariances matrices of the data set

void	computeCovarianceMatrices (VectorX const &weights)
	compute the weighted covariances matrices of the data set

Protected Member Functions inherited from STK::IReducer< Array, Weights >
	IReducer ()
	Default constructor.

	IReducer (Array const *p_data)
	Constructor with a pointer on the constant data set.

	IReducer (Array const &data)
	Constructor with a constant reference on the data set.

	IReducer (IReducer const &reducer)
	Copy constructor.

Protected Member Functions inherited from STK::IRunnerUnsupervised< Array, Weights >
	IRunnerUnsupervised ()
	default constructor.

	IRunnerUnsupervised (Array const *const p_data)
	constructor with a pointer on the constant data set

	IRunnerUnsupervised (Array const &data)
	constructor with a constant reference on the data set

	IRunnerUnsupervised (IRunnerUnsupervised const &runner)
	copy constructor

	~IRunnerUnsupervised ()
	destructor

Protected Member Functions inherited from STK::IRunnerBase
	IRunnerBase ()
	default constructor

	IRunnerBase (IRunnerBase const &runner)
	copy constructor

virtual	~IRunnerBase ()
	destructor

Protected Attributes
Reduct::TypeGraph	type_
	number of neighbors

int	nbNeighbor_
	number of neighbors

ArrayXXi	neighbors_
	Predecessor array : store the spanning tree or the minimal distance to the neighbors.

ArrayXX	dist_
	distance matrix : store the minimal distance to the neighbors

ArraySquareX	localCovariance_
	the local covariance Array

ArraySquareX	covariance_
	the covariance Array

Protected Attributes inherited from STK::ILinearReduct< Array, VectorX >
VectorX	idx_values_
	The values of the index for each axis.

Array	axis_
	The computed axis.

Protected Attributes inherited from STK::IReducer< Array, Weights >
int	dim_
	dimension of the reduced data set

Array *	p_reduced_
	The reduced data set.

Protected Attributes inherited from STK::IRunnerUnsupervised< Array, Weights >
Array const *	p_data_
	A pointer on the original data set.

Protected Attributes inherited from STK::IRunnerBase
String	msg_error_
	String with the last error message.

bool	hasRun_
	`true` if run has been used, `false` otherwise

Private Member Functions
void	computeAxis ()
	compute the axis using the first eigenvectors of the matrix of covariance and local covariance

	LocalVariance (Reduct::TypeGraph type=Reduct::distance_, int nbNeighbor=1)
	Default constructor.

Additional Inherited Members
Public Attributes inherited from STK::ILinearReduct< Array, VectorX >
Array *	p_reduced_
	The reduced data set.

Protected Types inherited from STK::IReducer< Array, Weights >
typedef IRunnerUnsupervised< Array, Weights >	Runner

Detailed Description

template<class Array>
class STK::LocalVariance< Array >

A LocalVariance is an implementation of the abstract ILinearReduct class.

A LocalVariance is an Index which maximize the projected local variance of the data set. The class can use the algorithm of Prim or the minimal distance in order to compute the proximity graph defining the local variance.

This class derive from ILinearReduct which derive itself from IRunnerUnsupervised. The run() and run(weights) methods have been implemented in the ILinearReduct interface using the pure virtual methods maximizeStep() and MaximizeCriteria(weights).

Definition at line 62 of file STK_LocalVariance.h.

Member Typedef Documentation

◆ Base

template<class Array >

typedef ILinearReduct<Array, VectorX> STK::LocalVariance< Array >::Base

Definition at line 66 of file STK_LocalVariance.h.

◆ RowVector

template<class Array >

typedef hidden::Traits<Array>::Row STK::LocalVariance< Array >::RowVector

Definition at line 65 of file STK_LocalVariance.h.

Constructor & Destructor Documentation

◆ LocalVariance() [1/4]

template<class Array >

STK::LocalVariance< Array >::LocalVariance	(	Array const *	p_data,
		Reduct::TypeGraph	type = `Reduct::distance_`,
		int	nbNeighbor = `1`
	)

Constructor.

the TypeGraph and the number of neighbors are given by the user and cannot modified.

Parameters

p_data	pointyer on the data set to process
type	type of proximity graph to build
nbNeighbor	number of neighbors to use in the proximity graph

Definition at line 165 of file STK_LocalVariance.h.

                                  : Base(p_data)
                                   , type_(type)
                                   , nbNeighbor_(nbNeighbor)
                                   , neighbors_()
                                   , dist_()
 
{
  if (!p_data) return;
  neighbors_.resize(p_data->rows(), Range(1,nbNeighbor_));
  dist_.resize(p_data->rows(), Range(1,nbNeighbor_));
  dist_ = Arithmetic<Real>::max();
  // compute minimal proximity graph of the data set
  switch (type_)
  {
    case Reduct::prim_:
      prim();
      break;
    case Reduct::distance_:
      minimalDistance();
      break;
    case Reduct::unknown_graph_:
      STKRUNTIME_ERROR_NO_ARG(LocalVariance::LocalVariance(data, type, nbNeighbor),unknown proximity graph);
      break;
  };
}

Referenced by STK::LocalVariance< Array >::LocalVariance(), and STK::LocalVariance< Array >::LocalVariance().

◆ LocalVariance() [2/4]

template<class Array >

STK::LocalVariance< Array >::LocalVariance	(	Array const &	data,
		Reduct::TypeGraph	type = `Reduct::distance_`,
		int	nbNeighbor = `1`
	)

Constructor.

the TypeGraph and the number of neighbors are given by the user and cannot modified.

Parameters

data	data set to process
type	type of proximity graph to build
nbNeighbor	number of neighbors to use in the proximity graph

Definition at line 198 of file STK_LocalVariance.h.

                                 : Base(data)
                                  , type_(type)
                                  , nbNeighbor_(nbNeighbor)
                                  , neighbors_(data.rows(), Range(1,nbNeighbor_))
                                  , dist_(data.rows(), Range(1,nbNeighbor_), Arithmetic<Real>::max())
{
  // compute minimal proximity graph of the data set
  switch (type_)
  {
    case Reduct::prim_:
      prim();
      break;
    case Reduct::distance_:
      minimalDistance();
      break;
    case Reduct::unknown_graph_:
      STKRUNTIME_ERROR_NO_ARG(LocalVariance::LocalVariance(data, type, nbNeighbor),unknown proximity graph);
      break;
  };
}

References STK::Reduct::distance_, STK::LocalVariance< Array >::LocalVariance(), STK::LocalVariance< Array >::minimalDistance(), STK::LocalVariance< Array >::nbNeighbor(), STK::LocalVariance< Array >::prim(), STK::Reduct::prim_, STKRUNTIME_ERROR_NO_ARG, STK::LocalVariance< Array >::type_, and STK::Reduct::unknown_graph_.

◆ LocalVariance() [3/4]

template<class Array >

STK::LocalVariance< Array >::LocalVariance ( LocalVariance< Array > const & reducer )

copy Constructor.

Parameters

reducer the reducer to copy

Definition at line 225 of file STK_LocalVariance.h.

                                 : Base(reducer)
                                  , type_(reducer.type_)
                                  , nbNeighbor_(reducer.nbNeighbor_)
                                  , neighbors_(reducer.neighbors_)
                                  , dist_(reducer.dist_)
{}

◆ ~LocalVariance()

template<class Array >

STK::LocalVariance< Array >::~LocalVariance ( )

virtual

Destructor.

Definition at line 237 of file STK_LocalVariance.h.

237{}

◆ LocalVariance() [4/4]

template<class Array >

STK::LocalVariance< Array >::LocalVariance	(	Reduct::TypeGraph	type = `Reduct::distance_`,
		int	nbNeighbor = `1`
	)

private

Default constructor.

The TypeGraph and the number of neighbors are given by the user and are not modified.

Parameters

type	type of proximity graph to build
nbNeighbor	number of neighbors to use in the proximity graph

Member Function Documentation

◆ clone()

template<class Array >

virtual LocalVariance * STK::LocalVariance< Array >::clone ( ) const

inlinevirtual

clone pattern

Definition at line 95 of file STK_LocalVariance.h.

95{ return new LocalVariance(*this);}

◆ computeAxis()

template<class Array >

void STK::LocalVariance< Array >::computeAxis ( )

private

compute the axis using the first eigenvectors of the matrix of covariance and local covariance

Definition at line 370 of file STK_LocalVariance.h.

{
  // compute the number of axis, cannot be greater than the dimension of the data
  Range range(p_data_->beginCols(), std::min(this->dim_, p_data_->sizeCols()));
  // compute the eigenvalues decomposition of the local covariance
  SymEigen<ArraySquareX>* decomp = new SymEigen<ArraySquareX>(localCovariance_);
  decomp->run();
  // compute the generalized inverse of the local covariance
  ArraySquareX inv_local;
  decomp->ginv(inv_local);
  // compute the product
  ArraySquareX prod = inv_local * covariance_;
  // compute the eigenvalues decomposition of the product
  decomp->setData(prod);
  decomp->run();
  // save axis and index values
  axis_.resize(p_data_->cols(), range);
  idx_values_.resize(range);
  axis_       = decomp->rotation().col(range);
  idx_values_ = decomp->eigenValues()[range];
  // we can safely remove the decomposition
  delete decomp;
}

References STK::IRegression< YArray, XArray, Weights >::run(), and STK::IRunnerSupervised< YArray_, XArray_, Weights_ >::setData().

◆ computeCovarianceMatrices() [1/2]

template<class Array >

void STK::LocalVariance< Array >::computeCovarianceMatrices ( )

protected

compute the covariances matrices of the data set

Definition at line 304 of file STK_LocalVariance.h.

{
  Stat::Multivariate<Array, Real> stats_;
  // compute the covariance matrix
  stats_.setData(p_data_);
  stats_.run();
  covariance_.move(stats_.covariance());
  // constants
  const Real pond = 2* nbNeighbor_ * p_data_->sizeRows();
 
  // compute local covariance matrix
  localCovariance_.resize(p_data_->cols());
  for (int j=p_data_->beginCols(); j<p_data_->endCols(); j++)
  {
    for (int k=p_data_->beginCols(); k<p_data_->endCols(); k++)
    {
      Real sum = 0.0;
      for (int i=p_data_->beginRows(); i<p_data_->endRows(); i++)
      {
        for (int l = 1; l <= nbNeighbor_; ++l)
        {
          sum += ((*p_data_)(i, j) - (*p_data_)(neighbors_(i, l), j))
               * ((*p_data_)(i, k) - (*p_data_)(neighbors_(i, l), k));
        }
      }
      localCovariance_(j, k) = sum/pond;
    }
  }
}

References STK::IRegression< YArray, XArray, Weights >::run(), STK::IRunnerSupervised< YArray_, XArray_, Weights_ >::setData(), and STK::sum().

◆ computeCovarianceMatrices() [2/2]

template<class Array >

void STK::LocalVariance< Array >::computeCovarianceMatrices ( VectorX const & weights )

protected

compute the weighted covariances matrices of the data set

Definition at line 336 of file STK_LocalVariance.h.

{
  Stat::Multivariate<Array, Real> stats_;
  // compute the covariance matrix
  stats_.setData(p_data_);
  stats_.run(weights);
  covariance_.move(stats_.covariance());
 
  // get dimensions
  const Real pond = 2* nbNeighbor_ * p_data_->sizeRows() ;
  // compute weighted local covariance matrix
  localCovariance_.resize(p_data_->cols());
  for (int i=p_data_->beginCols(); i<p_data_->endCols(); i++)
  {
    for (int j=p_data_->beginCols(); j<p_data_->endCols(); j++)
    {
      Real sum = 0.0;
      for (int k=p_data_->beginRows(); k<p_data_->endRows(); k++)
      {
        for (int l = 1; l <= nbNeighbor_; ++l)
        {
          sum += (weights[k] * weights[neighbors_(k, l)])
               * ((*p_data_)(k, i) - (*p_data_)(neighbors_(k, l), i))
               * ((*p_data_)(k, j) - (*p_data_)(neighbors_(k, l), j));
        }
      }
      localCovariance_(i, j) = sum / pond;
    }
  }
}

References STK::IRegression< YArray, XArray, Weights >::run(), STK::IRunnerSupervised< YArray_, XArray_, Weights_ >::setData(), and STK::sum().

◆ covariance()

template<class Array >

ArraySquareX const & STK::LocalVariance< Array >::covariance ( ) const

inline

Returns: the covariance matrix of the data set

Definition at line 103 of file STK_LocalVariance.h.

103{ return covariance_;}

References STK::LocalVariance< Array >::covariance_.

◆ localCovariance()

template<class Array >

ArraySquareX const & STK::LocalVariance< Array >::localCovariance ( ) const

inline

Returns: the local covariance matrix computed using the proximity graph.

Definition at line 105 of file STK_LocalVariance.h.

105{ return localCovariance_;}

References STK::LocalVariance< Array >::localCovariance_.

◆ maximizeStep() [1/2]

template<class Array >

void STK::LocalVariance< Array >::maximizeStep ( )

protectedvirtual

Compute the axis by maximizing the ratio of the local variance on the total variance of the data set.

Implements STK::ILinearReduct< Array, VectorX >.

Definition at line 271 of file STK_LocalVariance.h.

{
#ifdef STK_REDUCT_DEBUG
  if (!p_data_)
  { STKRUNTIME_ERROR_NO_ARG(LocalVariance::maximizeStep,data is not set);}
#endif
  // compute covariance matrices
  computeCovarianceMatrices();
  // compute the axis
  computeAxis();
}

References STK::LocalVariance< Array >::maximizeStep(), and STKRUNTIME_ERROR_NO_ARG.

Referenced by STK::LocalVariance< Array >::maximizeStep(), and STK::LocalVariance< Array >::maximizeStep().

◆ maximizeStep() [2/2]

template<class Array >

void STK::LocalVariance< Array >::maximizeStep ( VectorX const & weights )

protectedvirtual

Compute the axis by maximizing the ratio of the weighted local variance on the weighted total variance of the data set.

Parameters

weights the weights to use

Implements STK::ILinearReduct< Array, VectorX >.

Definition at line 288 of file STK_LocalVariance.h.

{
#ifdef STK_REDUCT_DEBUG
  if (!p_data_)
  { STKRUNTIME_ERROR_NO_ARG(LocalVariance::maximizeStep,data is not set);}
#endif
  // compute covariance matrices
  computeCovarianceMatrices(weights);
  // compute the axis
  computeAxis();
}

References STK::LocalVariance< Array >::maximizeStep(), and STKRUNTIME_ERROR_NO_ARG.

◆ minimalDistance()

template<class Array >

void STK::LocalVariance< Array >::minimalDistance ( )

protected

compute the minimal distance graph

Definition at line 442 of file STK_LocalVariance.h.

{
  dist_.resize(p_data_->rows(), Range(1,nbNeighbor_));
  dist_ = Arithmetic<Real>::max();
  // get dimensions
  const int begin_ind = p_data_->beginRows();
  const int last_ind = p_data_->lastIdxRows();
  // start minimal distance algorithm
  for (int j = begin_ind; j<last_ind; j++)
  {
    // reference on the current point
    RowVector curPoint(p_data_->row(j), true);
    // update distance of the neighbors point
    for (int i=j+1; i<=last_ind; i++)
    {
      // compute distance between point i and point j
      Real d=dist(curPoint, p_data_->row(i));
      // check if we get a better distance for the point j
      if (dist_(i, nbNeighbor_) > d )
      {
        // check if we get a better distance for the point i
        int pos = nbNeighbor_;
        while (dist_(i, pos) > d && pos-- > 1) {}
        pos++;
        // shift values
        for (int k= nbNeighbor_ -1; k>= pos; k--)
        {
          dist_(i, k+1) = dist_(i, k);
          neighbors_(i, k+1) = neighbors_(i, k);
        }
        // set minimal distance in place
        dist_(i, pos) = d;
        neighbors_(i, pos) = j;
      }
      // check if we get a better distance for the point j
      if (dist_(j, nbNeighbor_) > d )
      {
        // insertion sorting algorihtm
        int pos = nbNeighbor_;
        while (dist_(j, pos) > d && pos-- > 1) {}
        pos++;
        // shift valuesconst
        for (int k= nbNeighbor_ -1; k>= pos; k--)
        {
          dist_(j, k+1) = dist_(j, k);
          neighbors_(j, k+1) = neighbors_(j, k);
        }
        // set minimal distance in place
        dist_(j, pos) = d;
        neighbors_(j, pos) = i;
      }
    }
  }
}

References STK::dist().

Referenced by STK::LocalVariance< Array >::LocalVariance(), and STK::LocalVariance< Array >::LocalVariance().

◆ nbNeighbor()

template<class Array >

int STK::LocalVariance< Array >::nbNeighbor ( ) const

inline

Returns: the number of neighbors used in the local covariance.

Definition at line 99 of file STK_LocalVariance.h.

99{ return nbNeighbor_;}

References STK::LocalVariance< Array >::nbNeighbor_.

Referenced by STK::LocalVariance< Array >::LocalVariance(), and STK::LocalVariance< Array >::LocalVariance().

◆ pred()

template<class Array >

ArrayXXi const & STK::LocalVariance< Array >::pred ( ) const

inline

Returns: an array with the index of the neighbors of an individual

Definition at line 101 of file STK_LocalVariance.h.

101{ return neighbors_;}

References STK::LocalVariance< Array >::neighbors_.

◆ prim()

template<class Array >

void STK::LocalVariance< Array >::prim ( )

protected

compute the minimal spanning tree

Definition at line 395 of file STK_LocalVariance.h.

{
  // get dimensions
  const int begin_ind = p_data_->beginRows();
  const int last_ind = p_data_->lastIdxRows();
  /* value vector : store the minimal value. */
  VectorX value(p_data_->rows(), Arithmetic<Real>::max());
  /* position of the points */
  Array1D<int> ipos(p_data_->rows());
  // Initialization the position array
  for (int i=begin_ind; i<=last_ind; i++) ipos[i] = i;
 
  // start Prim algorithm
  //Initialization of the root
  value[begin_ind] = 0.0;               // the root have value 0.0
  neighbors_(begin_ind, 1) = begin_ind;          // and have itself as predecessor
  int imin = begin_ind;             // the index of the current minimal value
  Real    kmin = 0.0;                   // the current minimal value
  // begin iterations
  for (int iter = last_ind; iter>=begin_ind; iter--)
  {
    // put the minimal key at the end of the array key_
    value.swap(imin, iter);  // put the minimal value to the end
    ipos.swap(imin, iter);   // update the position of current minimal point
    // Update the value for the neighbors points and find minimal value
    imin = begin_ind;
    kmin = value[begin_ind];
    // reference on the current point
    int icur = ipos[iter];
    RowVector P(p_data_->row(icur), true);
    // update distance of the neighbors point
    for (int i=begin_ind; i<iter; i++)
    {
      // check if we have a better distance for the neighbors
      Real d=dist(P, p_data_->row(ipos[i]));
      if (d < value[i])
      {
        value[i] = d;
        neighbors_(ipos[i], 1) = icur;
      }
      // minimal key
      if (kmin>value[i]) { imin=i; kmin = value[i];}
    }
  }
}

References STK::dist(), and STK::IArray2D< Derived >::swap().

Referenced by STK::LocalVariance< Array >::LocalVariance(), and STK::LocalVariance< Array >::LocalVariance().

◆ update()

template<class Array >

void STK::LocalVariance< Array >::update ( )

protectedvirtual

Compute the proximity graph if the data set is modified.

Reimplemented from STK::IRunnerBase.

Definition at line 243 of file STK_LocalVariance.h.

{
#ifdef STK_REDUCT_DEBUG
  if (!p_data_)
  { STKRUNTIME_ERROR_NO_ARG(LocalVariance::update,data is not set);}
#endif
  // update dimensions of the containers for the proximity graph
  neighbors_.resize(p_data_->rows(), Range(1,nbNeighbor_));
  // compute minimal proximity graph of the data set
  switch (type_)
  {
    case Reduct::prim_:
      prim();
      break;
    case Reduct::distance_:
      minimalDistance();
      break;
    case Reduct::unknown_graph_:
      STKRUNTIME_ERROR_NO_ARG(LocalVariance::update,unknown proximity graph);
      break;
  };
}

number of neighbors

Definition at line 114 of file STK_LocalVariance.h.

Referenced by STK::LocalVariance< Array >::LocalVariance(), and STK::LocalVariance< Array >::LocalVariance().

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

STK_LocalVariance.h

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

◆ RowVector

Constructor & Destructor Documentation

◆ LocalVariance() [1/4]

◆ LocalVariance() [2/4]

◆ LocalVariance() [3/4]

◆ ~LocalVariance()

◆ LocalVariance() [4/4]

Member Function Documentation

◆ clone()

◆ computeAxis()

◆ computeCovarianceMatrices() [1/2]

◆ computeCovarianceMatrices() [2/2]

◆ covariance()

◆ localCovariance()

◆ maximizeStep() [1/2]

◆ maximizeStep() [2/2]

◆ minimalDistance()

◆ nbNeighbor()

◆ pred()

◆ prim()

◆ update()

Member Data Documentation

◆ covariance_

◆ dist_

◆ localCovariance_

◆ nbNeighbor_

◆ neighbors_

◆ type_