Tapkee
methods.hpp
Go to the documentation of this file.
1 /* This software is distributed under BSD 3-clause license (see LICENSE file).
2  *
3  * Copyright (c) 2012-2013 Sergey Lisitsyn, Fernando Iglesias
4  */
5 
6 #ifndef TAPKEE_METHODS_H_
7 #define TAPKEE_METHODS_H_
8 
9 /* Tapkee includes */
10 #include <tapkee/defines.hpp>
11 #include <tapkee/utils/naming.hpp>
12 #include <tapkee/utils/time.hpp>
13 #include <tapkee/utils/logging.hpp>
25 #include <tapkee/routines/pca.hpp>
27 #include <tapkee/routines/spe.hpp>
28 #include <tapkee/routines/fa.hpp>
32 /* End of Tapkee includes */
33 
34 namespace tapkee
35 {
37 namespace tapkee_internal
38 {
39 
40 template <typename T>
41 struct Positivity
42 {
43  inline bool operator()(T v) const
44  {
45  return v>0;
46  }
47  inline std::string failureMessage(const stichwort::Parameter& p) const
48  {
49  return formatting::format("Positivity check failed for {}, its value is {}", p.name(), p.repr());
50  }
51 };
52 
53 template <typename T>
55 {
56  inline bool operator()(T v) const
57  {
58  return v>=0;
59  }
60  inline std::string failureMessage(const stichwort::Parameter& p) const
61  {
62  return formatting::format("Non-negativity check failed for {}, its value is {}", p.name(), p.repr());
63  }
64 };
65 
66 template <typename T>
67 struct InRange
68 {
69  InRange(T l, T u) : lower(l), upper(u) { }
70  inline bool operator()(T v) const
71  {
72  return (v>=lower) && (v<upper);
73  }
74  T lower;
75  T upper;
76  inline std::string failureMessage(const stichwort::Parameter& p) const
77  {
78  return formatting::format("[{}, {}) range check failed for {}, its value is {}", lower, upper, p.name(), p.repr());
79  }
80 };
81 
82 template <typename T>
84 {
85  InClosedRange(T l, T u) : lower(l), upper(u) { }
86  inline bool operator()(T v) const
87  {
88  return (v>=lower) && (v<=upper);
89  }
90  T lower;
91  T upper;
92  inline std::string failureMessage(const stichwort::Parameter& p) const
93  {
94  return formatting::format("[{}, {}] range check failed for {}, its value is {}", lower, upper, p.name(), p.repr());
95  }
96 };
97 
98 template <class RandomAccessIterator, class KernelCallback,
99  class DistanceCallback, class FeaturesCallback>
101 {
102 public:
103 
104  ImplementationBase(RandomAccessIterator b, RandomAccessIterator e,
105  KernelCallback k, DistanceCallback d, FeaturesCallback f,
106  ParametersSet& pmap, const Context& ctx) :
107  parameters(pmap), context(ctx), kernel(k), distance(d), features(f),
108  plain_distance(PlainDistance<RandomAccessIterator,DistanceCallback>(distance)),
109  kernel_distance(KernelDistance<RandomAccessIterator,KernelCallback>(kernel)),
110  begin(b), end(e), p_computation_strategy(),
116  {
117  n_vectors = (end-begin);
118 
119  p_target_dimension = parameters[target_dimension];
120  p_n_neighbors = parameters[num_neighbors].checked().satisfies(Positivity<IndexType>());
121 
122  if (n_vectors > 0)
123  {
126  }
127  if (n_vectors == 0)
128  throw no_data_error();
129 
130 
131  p_computation_strategy = parameters[computation_strategy];
132  p_eigen_method = parameters[eigen_method];
133  p_neighbors_method = parameters[neighbors_method];
134  p_check_connectivity = parameters[check_connectivity];
135  p_width = parameters[gaussian_kernel_width].checked().satisfies(Positivity<ScalarType>());
136  p_timesteps = parameters[diffusion_map_timesteps].checked().satisfies(Positivity<IndexType>());
137  p_eigenshift = parameters[nullspace_shift];
138  p_traceshift = parameters[klle_shift];
139  p_max_iteration = parameters[max_iteration];
140  p_tolerance = parameters[spe_tolerance].checked().satisfies(Positivity<ScalarType>());
141  p_n_updates = parameters[spe_num_updates].checked().satisfies(Positivity<IndexType>());
142  p_theta = parameters[sne_theta].checked().satisfies(NonNegativity<ScalarType>());
143  p_squishing_rate = parameters[squishing_rate];
144  p_global_strategy = parameters[spe_global_strategy];
145  p_epsilon = parameters[fa_epsilon].checked().satisfies(NonNegativity<ScalarType>());
146  p_perplexity = parameters[sne_perplexity].checked().satisfies(NonNegativity<ScalarType>());
147  p_ratio = parameters[landmark_ratio];
148 
150  current_dimension = features.dimension();
151  else
152  current_dimension = 0;
153  }
154 
156  {
157  if (context.is_cancelled())
158  throw cancelled_exception();
159 
160  using std::mem_fun_ref_t;
161  using std::mem_fun_ref;
162  typedef std::mem_fun_ref_t<TapkeeOutput,ImplementationBase> ImplRef;
163 
164 #define tapkee_method_handle(X) \
165  case X: \
166  { \
167  timed_context tctx__("[+] embedding with " # X); \
168  ImplRef ref = conditional_select< \
169  ((!MethodTraits<X>::needs_kernel) || (!is_dummy<KernelCallback>::value)) && \
170  ((!MethodTraits<X>::needs_distance) || (!is_dummy<DistanceCallback>::value)) && \
171  ((!MethodTraits<X>::needs_features) || (!is_dummy<FeaturesCallback>::value)), \
172  ImplRef>()(mem_fun_ref(&ImplementationBase::embed##X), \
173  mem_fun_ref(&ImplementationBase::embedEmpty)); \
174  return ref(*this); \
175  } \
176  break \
177 
178  switch (method)
179  {
200  }
201 #undef tapkee_method_handle
202  return TapkeeOutput();
203  }
204 
205 private:
206 
209  KernelCallback kernel;
210  DistanceCallback distance;
211  FeaturesCallback features;
214 
215  RandomAccessIterator begin;
216  RandomAccessIterator end;
217 
237 
240 
241  template<class Distance>
243  {
245  }
246 
248  {
250  }
251 
253  {
254  throw unsupported_method_error("Some callback is missed");
255  return TapkeeOutput();
256  }
257 
259  {
261  SparseWeightMatrix weight_matrix =
263  DenseMatrix embedding =
265  weight_matrix,p_target_dimension).first;
266 
267  return TapkeeOutput(embedding, unimplementedProjectingFunction());
268  }
269 
271  {
273  SparseWeightMatrix weight_matrix =
275  DenseMatrix embedding =
277  weight_matrix,p_target_dimension).first;
278 
279  return TapkeeOutput(embedding, unimplementedProjectingFunction());
280  }
281 
283  {
284  IndexType target_dimension = static_cast<IndexType>(p_target_dimension);
285  Parameter target_dimension_add = Parameter::create("target_dimension", target_dimension + 1);
286  DenseSymmetricMatrix diffusion_matrix =
289  LargestEigenvalues,diffusion_matrix,target_dimension_add);
290  DenseMatrix embedding = (decomposition_result.first).leftCols(target_dimension);
291  // scaling with lambda_i^t
292  for (IndexType i=0; i<target_dimension; i++)
293  embedding.col(i).array() *= pow(decomposition_result.second(i), static_cast<IndexType>(p_timesteps));
294  // scaling by eigenvector to largest eigenvalue 1
295  for (IndexType i=0; i<target_dimension; i++)
296  embedding.col(i).array() /= decomposition_result.first.col(target_dimension).array();
297  return TapkeeOutput(embedding, unimplementedProjectingFunction());
298  }
299 
301  {
303  centerMatrix(distance_matrix);
304  distance_matrix.array() *= -0.5;
305  EigendecompositionResult embedding =
307  distance_matrix,p_target_dimension);
308 
309  for (IndexType i=0; i<static_cast<IndexType>(p_target_dimension); i++)
310  embedding.first.col(i).array() *= sqrt(embedding.second(i));
311  return TapkeeOutput(embedding.first, unimplementedProjectingFunction());
312  #undef MDS_MATRIX_OP
313  }
314 
316  {
318 
319  Landmarks landmarks =
321  DenseSymmetricMatrix distance_matrix =
323  DenseVector landmark_distances_squared = distance_matrix.colwise().mean();
324  centerMatrix(distance_matrix);
325  distance_matrix.array() *= -0.5;
326  EigendecompositionResult landmarks_embedding =
328  distance_matrix,p_target_dimension);
329  for (IndexType i=0; i<static_cast<IndexType>(p_target_dimension); i++)
330  landmarks_embedding.first.col(i).array() *= sqrt(landmarks_embedding.second(i));
331  return TapkeeOutput(triangulate(begin,end,distance,landmarks,
332  landmark_distances_squared,landmarks_embedding,p_target_dimension), unimplementedProjectingFunction());
333  }
334 
336  {
338  DenseSymmetricMatrix shortest_distances_matrix =
340  shortest_distances_matrix = shortest_distances_matrix.array().square();
341  centerMatrix(shortest_distances_matrix);
342  shortest_distances_matrix.array() *= -0.5;
343 
344  EigendecompositionResult embedding =
346  shortest_distances_matrix,p_target_dimension);
347 
348  for (IndexType i=0; i<static_cast<IndexType>(p_target_dimension); i++)
349  embedding.first.col(i).array() *= sqrt(embedding.second(i));
350 
351  return TapkeeOutput(embedding.first, unimplementedProjectingFunction());
352  }
353 
355  {
357 
359  Landmarks landmarks =
361  DenseMatrix distance_matrix =
363  distance_matrix = distance_matrix.array().square();
364 
365  DenseVector col_means = distance_matrix.colwise().mean();
366  DenseVector row_means = distance_matrix.rowwise().mean();
367  ScalarType grand_mean = distance_matrix.mean();
368  distance_matrix.array() += grand_mean;
369  distance_matrix.colwise() -= row_means;
370  distance_matrix.rowwise() -= col_means.transpose();
371  distance_matrix.array() *= -0.5;
372 
373  EigendecompositionResult landmarks_embedding;
374 
375  if (p_eigen_method.is(Dense))
376  {
377  DenseMatrix distance_matrix_sym = distance_matrix*distance_matrix.transpose();
379  LargestEigenvalues,distance_matrix_sym,p_target_dimension);
380  }
381  else
382  {
385  }
386 
387  DenseMatrix embedding = distance_matrix.transpose()*landmarks_embedding.first;
388 
389  for (IndexType i=0; i<static_cast<IndexType>(p_target_dimension); i++)
390  embedding.col(i).array() /= sqrt(sqrt(landmarks_embedding.second(i)));
391  return TapkeeOutput(embedding,unimplementedProjectingFunction());
392  }
393 
395  {
397  SparseWeightMatrix weight_matrix =
399  DenseSymmetricMatrixPair eig_matrices =
402  EigendecompositionResult projection_result =
404  SmallestEigenvalues,eig_matrices.first,eig_matrices.second,p_target_dimension);
405  DenseVector mean_vector =
407  tapkee::ProjectingFunction projecting_function(new tapkee::MatrixProjectionImplementation(projection_result.first,mean_vector));
408  return TapkeeOutput(project(projection_result.first,mean_vector,begin,end,features,current_dimension),projecting_function);
409  }
410 
412  {
414  SparseWeightMatrix weight_matrix =
417  SmallestEigenvalues,weight_matrix,p_target_dimension).first,
419  }
420 
422  {
424  Laplacian laplacian =
427  SmallestEigenvalues,laplacian.first,laplacian.second,p_target_dimension).first,
429  }
430 
432  {
434  Laplacian laplacian =
436  DenseSymmetricMatrixPair eigenproblem_matrices =
437  construct_locality_preserving_eigenproblem(laplacian.first,laplacian.second,begin,end,
439  EigendecompositionResult projection_result =
441  SmallestEigenvalues,eigenproblem_matrices.first,eigenproblem_matrices.second,p_target_dimension);
442  DenseVector mean_vector =
444  tapkee::ProjectingFunction projecting_function(new tapkee::MatrixProjectionImplementation(projection_result.first,mean_vector));
445  return TapkeeOutput(project(projection_result.first,mean_vector,begin,end,features,current_dimension), projecting_function);
446  }
447 
449  {
450  DenseVector mean_vector =
452  DenseSymmetricMatrix centered_covariance_matrix =
454  EigendecompositionResult projection_result =
456  LargestEigenvalues,centered_covariance_matrix,p_target_dimension);
457  tapkee::ProjectingFunction projecting_function(new tapkee::MatrixProjectionImplementation(projection_result.first,mean_vector));
458  return TapkeeOutput(project(projection_result.first,mean_vector,begin,end,features,current_dimension), projecting_function);
459  }
460 
462  {
463  DenseMatrix projection_matrix =
465  DenseVector mean_vector =
467 
468  tapkee::ProjectingFunction projecting_function(new tapkee::MatrixProjectionImplementation(projection_matrix,mean_vector));
469  return TapkeeOutput(project(projection_matrix,mean_vector,begin,end,features,current_dimension), projecting_function);
470  }
471 
473  {
474  DenseSymmetricMatrix centered_kernel_matrix =
477  LargestEigenvalues,centered_kernel_matrix,p_target_dimension);
478  for (IndexType i=0; i<static_cast<IndexType>(p_target_dimension); i++)
479  embedding.first.col(i).array() *= sqrt(embedding.second(i));
480  return TapkeeOutput(embedding.first, unimplementedProjectingFunction());
481  }
482 
484  {
486  SparseWeightMatrix weight_matrix =
488  DenseSymmetricMatrixPair eig_matrices =
489  construct_lltsa_eigenproblem(weight_matrix,begin,end,
491  EigendecompositionResult projection_result =
493  eig_matrices.first,eig_matrices.second,p_target_dimension);
494  DenseVector mean_vector =
496  tapkee::ProjectingFunction projecting_function(new tapkee::MatrixProjectionImplementation(projection_result.first,mean_vector));
497  return TapkeeOutput(project(projection_result.first,mean_vector,begin,end,features,current_dimension),
498  projecting_function);
499  }
500 
502  {
503  Neighbors neighbors;
504  if (p_global_strategy.is(false))
505  {
506  neighbors = findNeighborsWith(plain_distance);
507  }
508 
509  return TapkeeOutput(spe_embedding(begin,end,distance,neighbors,
511  }
512 
514  {
515  DenseMatrix feature_matrix =
517  return TapkeeOutput(feature_matrix.transpose(),tapkee::ProjectingFunction());
518  }
519 
521  {
525  }
526 
528  {
530 
531  DenseMatrix data =
533 
534  DenseMatrix embedding(static_cast<IndexType>(p_target_dimension),n_vectors);
536  tsne.run(data,data.cols(),data.rows(),embedding.data(),p_target_dimension,p_perplexity,p_theta);
537 
538  return TapkeeOutput(embedding.transpose(), unimplementedProjectingFunction());
539  }
540 
542  {
544 
545  DenseMatrix embedding =
547 
549 
551 
552  return TapkeeOutput(embedding, tapkee::ProjectingFunction());
553  }
554 
555 };
556 
557 template <class RandomAccessIterator, class KernelCallback,
558  class DistanceCallback, class FeaturesCallback>
559 ImplementationBase<RandomAccessIterator,KernelCallback,DistanceCallback,FeaturesCallback>
560  initialize(RandomAccessIterator begin, RandomAccessIterator end,
561  KernelCallback kernel, DistanceCallback distance, FeaturesCallback features,
562  stichwort::ParametersSet& pmap, const Context& ctx)
563 {
565  begin,end,kernel,distance,features,pmap,ctx);
566 }
567 
568 } // End of namespace tapkee_internal
569 } // End of namespace tapkee
570 
571 #endif
ImplementationBase(RandomAccessIterator b, RandomAccessIterator e, KernelCallback k, DistanceCallback d, FeaturesCallback f, ParametersSet &pmap, const Context &ctx)
Definition: methods.hpp:104
static const EigenMethod Dense("Dense")
Eigen library dense method (could be useful for debugging). Computes all eigenvectors thus can be ver...
static const EigendecompositionStrategy SmallestEigenvalues("Smallest eigenvalues", 1)
std::string failureMessage(const stichwort::Parameter &p) const
Definition: methods.hpp:92
ScalarType distance(Callback &cb, const CoverTreePoint< RandomAccessIterator > &l, const CoverTreePoint< RandomAccessIterator > &r, ScalarType upper_bound)
static const EigendecompositionStrategy SquaredLargestEigenvalues("Largest eigenvalues of squared matrix", 0)
CheckedParameter checked()
Definition: parameter.hpp:228
void centerMatrix(DenseMatrix &matrix)
Definition: matrix.hpp:14
Neighbors find_neighbors(NeighborsMethod method, const RandomAccessIterator &begin, const RandomAccessIterator &end, const Callback &callback, IndexType k, bool check_connectivity)
Definition: neighbors.hpp:173
Eigen::Matrix< tapkee::ScalarType, Eigen::Dynamic, Eigen::Dynamic > DenseMatrix
dense matrix type (non-overridable)
Definition: types.hpp:23
EigendecompositionResult eigendecomposition(const EigenMethod &method, const ComputationStrategy &strategy, const EigendecompositionStrategy &eigen_strategy, const MatrixType &m, IndexType target_dimension)
Multiple implementation handler method for various eigendecomposition methods.
DenseSymmetricMatrix compute_centered_kernel_matrix(RandomAccessIterator begin, RandomAccessIterator end, KernelCallback callback)
Definition: pca.hpp:76
void manifold_sculpting_embed(RandomAccessIterator begin, RandomAccessIterator end, DenseMatrix &data, IndexType target_dimension, const Neighbors &neighbors, DistanceCallback callback, IndexType max_iteration, ScalarType squishing_rate)
Parameter & satisfies(const F< Q > &cond) const
Definition: parameter.hpp:208
DenseSymmetricMatrix compute_covariance_matrix(RandomAccessIterator begin, RandomAccessIterator end, const DenseVector &mean, FeatureVectorCallback callback, IndexType dimension)
Definition: pca.hpp:57
Namespace containing implementation of t-SNE algorithm.
Definition: quadtree.hpp:41
DenseSymmetricMatrixPair construct_lltsa_eigenproblem(SparseWeightMatrix W, RandomAccessIterator begin, RandomAccessIterator end, FeatureVectorCallback feature_vector_callback, IndexType dimension)
SparseWeightMatrix hessian_weight_matrix(RandomAccessIterator begin, RandomAccessIterator end, const Neighbors &neighbors, PairwiseCallback callback, const IndexType target_dimension)
DenseSymmetricMatrix compute_shortest_distances_matrix(RandomAccessIterator begin, RandomAccessIterator end, Neighbors &neighbors, DistanceCallback callback)
Computes shortest distances (so-called geodesic distances) using Dijkstra algorithm.
Definition: isomap.hpp:44
static Parameter create(const std::string &name, const T &value)
Definition: parameter.hpp:64
TAPKEE_INTERNAL_PAIR< tapkee::SparseWeightMatrix, tapkee::DenseDiagonalMatrix > Laplacian
Definition: synonyms.hpp:43
double ScalarType
default scalar value (can be overrided with TAPKEE_CUSTOM_INTERNAL_NUMTYPE define) ...
Definition: types.hpp:15
EigendecompositionResult generalized_eigendecomposition(const EigenMethod &method, const ComputationStrategy &strategy, const EigendecompositionStrategy &eigen_strategy, const LMatrixType &lhs, const RMatrixType &rhs, IndexType target_dimension)
ParameterName name() const
Definition: parameter.hpp:144
An exception type that is thrown when no data is given.
TAPKEE_INTERNAL_PAIR< tapkee::DenseSymmetricMatrix, tapkee::DenseSymmetricMatrix > DenseSymmetricMatrixPair
Definition: synonyms.hpp:44
DenseSymmetricMatrix compute_distance_matrix(RandomAccessIterator begin, RandomAccessIterator, Landmarks &landmarks, PairwiseCallback callback)
DenseSymmetricMatrixPair construct_neighborhood_preserving_eigenproblem(SparseWeightMatrix W, RandomAccessIterator begin, RandomAccessIterator end, FeatureVectorCallback feature_vector_callback, IndexType dimension)
SparseWeightMatrix tangent_weight_matrix(RandomAccessIterator begin, RandomAccessIterator end, const Neighbors &neighbors, PairwiseCallback callback, const IndexType target_dimension, const ScalarType shift)
An exception type that is thrown when computations were cancelled.
Eigen::SparseMatrix< tapkee::ScalarType > SparseWeightMatrix
sparse weight matrix type (non-overridable)
Definition: types.hpp:29
TapkeeOutput embedtDistributedStochasticNeighborEmbedding()
Definition: methods.hpp:527
std::string format(const std::string &fmt, const ValueWrapper a)
Definition: formatting.hpp:411
DenseMatrix triangulate(RandomAccessIterator begin, RandomAccessIterator end, PairwiseCallback distance_callback, Landmarks &landmarks, DenseVector &landmark_distances_squared, EigendecompositionResult &landmarks_embedding, IndexType target_dimension)
Eigen::Matrix< tapkee::ScalarType, Eigen::Dynamic, 1 > DenseVector
dense vector type (non-overridable)
Definition: types.hpp:21
DenseMatrix dense_matrix_from_features(FeaturesCallback features, IndexType dimension, RandomAccessIterator begin, RandomAccessIterator end)
Definition: features.hpp:19
Laplacian compute_laplacian(RandomAccessIterator begin, RandomAccessIterator end, const Neighbors &neighbors, DistanceCallback callback, ScalarType width)
Computes laplacian of neighborhood graph.
int IndexType
indexing type (non-overridable) set to int for compatibility with OpenMP 2.0
Definition: types.hpp:19
TapkeeOutput embedUsing(DimensionReductionMethod method)
Definition: methods.hpp:155
PlainDistance< RandomAccessIterator, DistanceCallback > plain_distance
Definition: methods.hpp:212
DimensionReductionMethod
Dimension reduction methods.
std::string failureMessage(const stichwort::Parameter &p) const
Definition: methods.hpp:60
DenseVector compute_mean(RandomAccessIterator begin, RandomAccessIterator end, FeatureVectorCallback callback, IndexType dimension)
Definition: pca.hpp:42
DenseMatrix project(RandomAccessIterator begin, RandomAccessIterator end, FeatureVectorCallback callback, IndexType dimension, const IndexType max_iter, const ScalarType epsilon, const IndexType target_dimension, const DenseVector &mean_vector)
Definition: fa.hpp:15
DenseSymmetricMatrix compute_diffusion_matrix(RandomAccessIterator begin, RandomAccessIterator end, DistanceCallback callback, const ScalarType width)
Computes diffusion process matrix. Uses the following algorithm:
static const EigendecompositionStrategy LargestEigenvalues("Largest eigenvalues", 0)
A pimpl wrapper for projecting function.
Definition: projection.hpp:25
static tapkee::ProjectingFunction unimplementedProjectingFunction()
Definition: methods.hpp:247
Return result of the library - a pair of DenseMatrix (embedding) and ProjectingFunction.
Definition: defines.hpp:43
TAPKEE_INTERNAL_VECTOR< tapkee::tapkee_internal::LocalNeighbors > Neighbors
Definition: synonyms.hpp:40
ImplementationBase< RandomAccessIterator, KernelCallback, DistanceCallback, FeaturesCallback > initialize(RandomAccessIterator begin, RandomAccessIterator end, KernelCallback kernel, DistanceCallback distance, FeaturesCallback features, stichwort::ParametersSet &pmap, const Context &ctx)
Definition: methods.hpp:560
SparseWeightMatrix linear_weight_matrix(const RandomAccessIterator &begin, const RandomAccessIterator &end, const Neighbors &neighbors, PairwiseCallback callback, const ScalarType shift, const ScalarType trace_shift)
#define tapkee_method_handle(X)
std::string failureMessage(const stichwort::Parameter &p) const
Definition: methods.hpp:76
An exception type that is thrown when unsupported method is called.
TAPKEE_INTERNAL_PAIR< tapkee::DenseMatrix, tapkee::DenseVector > EigendecompositionResult
Definition: synonyms.hpp:41
std::string repr() const
Definition: parameter.hpp:149
Landmarks select_landmarks_random(RandomAccessIterator begin, RandomAccessIterator end, ScalarType ratio)
std::string failureMessage(const stichwort::Parameter &p) const
Definition: methods.hpp:47
TAPKEE_INTERNAL_VECTOR< tapkee::IndexType > Landmarks
Definition: synonyms.hpp:42
KernelDistance< RandomAccessIterator, KernelCallback > kernel_distance
Definition: methods.hpp:213
tapkee::DenseMatrix DenseSymmetricMatrix
dense symmetric matrix (non-overridable, currently just dense matrix, can be improved later) ...
Definition: types.hpp:25
DenseSymmetricMatrixPair construct_locality_preserving_eigenproblem(SparseWeightMatrix &L, DenseDiagonalMatrix &D, RandomAccessIterator begin, RandomAccessIterator end, FeatureVectorCallback feature_vector_callback, IndexType dimension)
DenseMatrix gaussian_projection_matrix(IndexType target_dimension, IndexType current_dimension)
DenseMatrix spe_embedding(RandomAccessIterator begin, RandomAccessIterator end, PairwiseCallback callback, const Neighbors &neighbors, IndexType target_dimension, bool global_strategy, ScalarType tolerance, int nupdates, IndexType max_iter)
Definition: spe.hpp:20
Basic ProjectionImplementation that subtracts mean from the vector and multiplies projecting matrix w...
Definition: projection.hpp:46