Split validation and embedding of methods (#102)

lisitsyn · May 22, 2024 · e7efda8 · e7efda8
1 parent 941c412
commit e7efda8
Show file tree

Hide file tree

Showing 21 changed files with 85 additions and 9 deletions.
diff --git a/include/tapkee/methods.hpp b/include/tapkee/methods.hpp
@@ -48,6 +48,7 @@ class DynamicImplementation : public ImplementationBase<RandomAccessIterator, Ke
     if (method == X) {                                                                                                 \
         auto implementation =                                                                                          \
                 X ## Implementation<RandomAccessIterator, KernelCallback, DistanceCallback, FeaturesCallback>(self);   \
+        implementation.validate();                                                                                     \
         return implementation.embed();                                                                                 \
     }
         tapkee_method_handle(KernelLocallyLinearEmbedding);

diff --git a/include/tapkee/methods/all.hpp b/include/tapkee/methods/all.hpp
@@ -33,6 +33,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(PassThru)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         DenseMatrix feature_matrix = dense_matrix_from_features(this->features, this->current_dimension, this->begin, this->end);

diff --git a/include/tapkee/methods/diffusion_map.hpp b/include/tapkee/methods/diffusion_map.hpp
@@ -15,11 +15,14 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(DiffusionMap)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[diffusion_map_timesteps].checked().satisfies(Positivity<IndexType>()).orThrow();
         parameters[gaussian_kernel_width].checked().satisfies(Positivity<ScalarType>()).orThrow();
+    }
 
+    TapkeeOutput embed()
+    {
         IndexType target_dimension_value = static_cast<IndexType>(parameters[target_dimension]);
         Parameter target_dimension_add = Parameter::create("target_dimension", target_dimension_value + 1);
         DenseSymmetricMatrix diffusion_matrix =

diff --git a/include/tapkee/methods/factor_analysis.hpp b/include/tapkee/methods/factor_analysis.hpp
@@ -15,10 +15,13 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(FactorAnalysis)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[fa_epsilon].checked().satisfies(NonNegativity<ScalarType>()).orThrow();
+    }
 
+    TapkeeOutput embed()
+    {
         DenseVector mean_vector = compute_mean(begin, end, features, current_dimension);
         return TapkeeOutput(project(begin, end, features, current_dimension, parameters[max_iteration],
                                     parameters[fa_epsilon], parameters[target_dimension], mean_vector),

diff --git a/include/tapkee/methods/hessian_locally_linear_embedding.hpp b/include/tapkee/methods/hessian_locally_linear_embedding.hpp
@@ -15,6 +15,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(HessianLocallyLinearEmbedding)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         Neighbors neighbors = find_neighbors_with(kernel_distance);

diff --git a/include/tapkee/methods/isomap.hpp b/include/tapkee/methods/isomap.hpp
@@ -16,6 +16,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(Isomap)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         Neighbors neighbors = find_neighbors_with(plain_distance);

diff --git a/include/tapkee/methods/kernel_local_tangent_space_alignment.hpp b/include/tapkee/methods/kernel_local_tangent_space_alignment.hpp
@@ -15,6 +15,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(KernelLocalTangentSpaceAlignment)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         Neighbors neighbors = find_neighbors_with(kernel_distance);

diff --git a/include/tapkee/methods/kernel_locally_linear_embedding.hpp b/include/tapkee/methods/kernel_locally_linear_embedding.hpp
@@ -15,6 +15,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(KernelLocallyLinearEmbedding)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         Neighbors neighbors = find_neighbors_with(kernel_distance);

diff --git a/include/tapkee/methods/kernel_pca.hpp b/include/tapkee/methods/kernel_pca.hpp
@@ -15,6 +15,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(KernelPrincipalComponentAnalysis)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         DenseSymmetricMatrix centered_kernel_matrix = compute_centered_kernel_matrix(begin, end, kernel);

diff --git a/include/tapkee/methods/landmark_isomap.hpp b/include/tapkee/methods/landmark_isomap.hpp
@@ -17,9 +17,13 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(LandmarkIsomap)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[landmark_ratio].checked().satisfies(InClosedRange<ScalarType>(3.0 / n_vectors, 1.0)).orThrow();
+    }
+
+    TapkeeOutput embed()
+    {
 
         Neighbors neighbors = find_neighbors_with(plain_distance);
         Landmarks landmarks = select_landmarks_random(begin, end, parameters[landmark_ratio]);

diff --git a/include/tapkee/methods/landmark_multidimensional_scaling.hpp b/include/tapkee/methods/landmark_multidimensional_scaling.hpp
@@ -16,9 +16,13 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(LandmarkMultidimensionalScaling)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[landmark_ratio].checked().satisfies(InClosedRange<ScalarType>(3.0 / n_vectors, 1.0)).orThrow();
+    }
+
+    TapkeeOutput embed()
+    {
 
         Landmarks landmarks = select_landmarks_random(begin, end, parameters[landmark_ratio]);
         DenseSymmetricMatrix distance_matrix = compute_distance_matrix(begin, end, landmarks, distance);

diff --git a/include/tapkee/methods/laplacian_eigenmaps.hpp b/include/tapkee/methods/laplacian_eigenmaps.hpp
@@ -16,10 +16,13 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(LaplacianEigenmaps)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[gaussian_kernel_width].checked().satisfies(Positivity<ScalarType>()).orThrow();
+    }
 
+    TapkeeOutput embed()
+    {
         Neighbors neighbors = find_neighbors_with(plain_distance);
         Laplacian laplacian = compute_laplacian(begin, end, neighbors, distance, parameters[gaussian_kernel_width]);
         return TapkeeOutput(generalized_eigendecomposition(parameters[eigen_method], parameters[computation_strategy],

diff --git a/include/tapkee/methods/linear_local_tangent_space_alignment.hpp b/include/tapkee/methods/linear_local_tangent_space_alignment.hpp
@@ -16,6 +16,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(LinearLocalTangentSpaceAlignment)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         Neighbors neighbors = find_neighbors_with(kernel_distance);

diff --git a/include/tapkee/methods/locality_preserving_projections.hpp b/include/tapkee/methods/locality_preserving_projections.hpp
@@ -17,10 +17,13 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(LocalityPreservingProjections)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[gaussian_kernel_width].checked().satisfies(Positivity<ScalarType>()).orThrow();
+    }
 
+    TapkeeOutput embed()
+    {
         Neighbors neighbors = find_neighbors_with(plain_distance);
         Laplacian laplacian = compute_laplacian(begin, end, neighbors, distance, parameters[gaussian_kernel_width]);
         DenseSymmetricMatrixPair eigenproblem_matrices = construct_locality_preserving_eigenproblem(

diff --git a/include/tapkee/methods/manifold_sculpting.hpp b/include/tapkee/methods/manifold_sculpting.hpp
@@ -15,9 +15,13 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(ManifoldSculpting)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[squishing_rate].checked().satisfies(InRange<ScalarType>(0.0, 1.0)).orThrow();
+    }
+
+    TapkeeOutput embed()
+    {
 
         DenseMatrix embedding = dense_matrix_from_features(features, current_dimension, begin, end);
 

diff --git a/include/tapkee/methods/multidimensional_scaling.hpp b/include/tapkee/methods/multidimensional_scaling.hpp
@@ -15,6 +15,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(MultidimensionalScaling)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         DenseSymmetricMatrix distance_matrix = compute_distance_matrix(begin, end, distance);

diff --git a/include/tapkee/methods/neighborhood_preserving_embedding.hpp b/include/tapkee/methods/neighborhood_preserving_embedding.hpp
@@ -17,6 +17,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(NeighborhoodPreservingEmbedding)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         Neighbors neighbors = find_neighbors_with(kernel_distance);

diff --git a/include/tapkee/methods/pca.hpp b/include/tapkee/methods/pca.hpp
@@ -15,6 +15,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(PrincipalComponentAnalysis)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         DenseVector mean_vector = compute_mean(begin, end, features, current_dimension);

diff --git a/include/tapkee/methods/random_projection.hpp b/include/tapkee/methods/random_projection.hpp
@@ -15,6 +15,10 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(RandomProjection)
+    void validate()
+    {
+    }
+
     TapkeeOutput embed()
     {
         DenseMatrix projection_matrix = gaussian_projection_matrix(current_dimension, parameters[target_dimension]);

diff --git a/include/tapkee/methods/stochastic_proximity_embedding.hpp b/include/tapkee/methods/stochastic_proximity_embedding.hpp
@@ -15,10 +15,14 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(StochasticProximityEmbedding)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[spe_tolerance].checked().satisfies(Positivity<ScalarType>()).orThrow();
         parameters[spe_num_updates].checked().satisfies(Positivity<IndexType>()).orThrow();
+    }
+
+    TapkeeOutput embed()
+    {
         Neighbors neighbors;
         if (parameters[spe_global_strategy].is(false))
         {

diff --git a/include/tapkee/methods/tsne.hpp b/include/tapkee/methods/tsne.hpp
@@ -15,11 +15,14 @@ namespace tapkee_internal
 {
 
 __TAPKEE_IMPLEMENTATION(tDistributedStochasticNeighborEmbedding)
-    TapkeeOutput embed()
+    void validate()
     {
         parameters[sne_perplexity].checked().satisfies(InClosedRange<ScalarType>(0.0, (n_vectors - 1) / 3.0)).orThrow();
         parameters[sne_theta].checked().satisfies(NonNegativity<ScalarType>()).orThrow();
+    }
 
+    TapkeeOutput embed()
+    {
         DenseMatrix data = dense_matrix_from_features(features, current_dimension, begin, end);
 
         DenseMatrix embedding(static_cast<IndexType>(parameters[target_dimension]), n_vectors);