Skip to content

Commit

Permalink
Dispatch methods with maps instead of strcmp
Browse files Browse the repository at this point in the history
  • Loading branch information
@lisitsyn
lisitsyn committed May 18, 2024
1 parent ab4176e commit 82cb8e2
Show file tree
Hide file tree
Showing 2 changed files with 86 additions and 94 deletions.
32 changes: 8 additions & 24 deletions src/cli/main.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -139,24 +139,14 @@ int run(int argc, const char **argv)
)
(
either("m", METHOD_KEYWORD),
"Dimension reduction method (default locally_linear_embedding). \n One of the following: \n"
"locally_linear_embedding (lle), neighborhood_preserving_embedding (npe), \n"
"local_tangent_space_alignment (ltsa), linear_local_tangent_space_alignment (lltsa), \n"
"hessian_locally_linear_embedding (hlle), laplacian_eigenmaps (la), locality_preserving_projections (lpp), \n"
"diffusion_map (dm), isomap, landmark_isomap (l-isomap), multidimensional_scaling (mds), \n"
"landmark_multidimensional_scaling (l-mds), stochastic_proximity_embedding (spe), \n"
"kernel_pca (kpca), pca, random_projection (ra), factor_analysis (fa), \n"
"t-stochastic_neighborhood_embedding (t-sne), manifold_sculpting (ms).",
"Dimension reduction method. One of the following: " +
comma_separated_keys(DIMENSION_REDUCTION_METHODS.begin(), DIMENSION_REDUCTION_METHODS.end()),
with_default("locally_linear_embedding"s)
)
(
either("nm", NEIGHBORS_METHOD_KEYWORD),
"Neighbors search method (default is 'covertree' if available, 'vptree' otherwise). One of the following: "
"brute,vptree"
#ifdef TAPKEE_USE_LGPL_COVERTREE
",covertree"
#endif
".",
"Neighbors search method. One of the following: " +
comma_separated_keys(NEIGHBORS_METHODS.begin(), NEIGHBORS_METHODS.end()),
#ifdef TAPKEE_USE_LGPL_COVERTREE
with_default("covertree"s)
#else
Expand All @@ -165,11 +155,8 @@ int run(int argc, const char **argv)
)
(
either("em", EIGEN_METHOD_KEYWORD),
"Eigendecomposition method (default is 'arpack' if available, 'dense' otherwise). One of the following: "
#ifdef TAPKEE_WITH_ARPACK
"arpack, "
#endif
"randomized, dense.",
"Eigendecomposition method. One of the following: " +
comma_separated_keys(EIGEN_METHODS.begin(), EIGEN_METHODS.end()),
#ifdef TAPKEE_WITH_ARPACK
with_default("arpack"s)
#else
Expand All @@ -178,11 +165,8 @@ int run(int argc, const char **argv)
)
(
either("cs", COMPUTATION_STRATEGY_KEYWORD),
"Computation strategy (default is 'cpu'). One of the following: "
#ifdef TAPKEE_WITH_VIENNACL
"opencl, "
#endif
"cpu.",
"Computation strategy. One of the following: " +
comma_separated_keys(COMPUTATION_STRATEGIES.begin(), COMPUTATION_STRATEGIES.end()),
with_default("cpu"s)
)
(
Expand Down
148 changes: 78 additions & 70 deletions src/cli/util.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,20 @@ inline bool is_wrong_char(char c)
return false;
}

template <typename Iterator>
std::string comma_separated_keys(Iterator begin, Iterator end) {
std::ostringstream oss;
for (Iterator it = begin; it != end; ++it)
{
oss << it->first;
if (std::next(it) != end)
{
oss << ", ";
}
}
return oss.str();
}

tapkee::DenseMatrix read_data(ifstream& ifs, char delimiter)
{
string str;
Expand Down Expand Up @@ -95,92 +109,86 @@ void write_vector(tapkee::DenseVector* matrix, ofstream& of)
}
}

static const std::map<const char*, tapkee::DimensionReductionMethod> DIMENSION_REDUCTION_METHODS = {
{"local_tangent_space_alignment", tapkee::KernelLocalTangentSpaceAlignment},
{"ltsa", tapkee::KernelLocalTangentSpaceAlignment},
{"locally_linear_embedding", tapkee::KernelLocallyLinearEmbedding},
{"lle", tapkee::KernelLocallyLinearEmbedding},
{"hessian_locally_linear_embedding", tapkee::HessianLocallyLinearEmbedding},
{"hlle", tapkee::HessianLocallyLinearEmbedding},
{"multidimensional_scaling", tapkee::MultidimensionalScaling},
{"mds", tapkee::MultidimensionalScaling},
{"landmark_multidimensional_scaling", tapkee::LandmarkMultidimensionalScaling},
{"l-mds", tapkee::LandmarkMultidimensionalScaling},
{"isomap", tapkee::Isomap},
{"landmark_isomap", tapkee::LandmarkIsomap},
{"l-isomap", tapkee::LandmarkIsomap},
{"diffusion_map", tapkee::DiffusionMap},
{"dm", tapkee::DiffusionMap},
{"kernel_pca", tapkee::KernelPrincipalComponentAnalysis},
{"kpca", tapkee::KernelPrincipalComponentAnalysis},
{"pca", tapkee::PrincipalComponentAnalysis},
{"random_projection", tapkee::RandomProjection},
{"ra", tapkee::RandomProjection},
{"laplacian_eigenmaps", tapkee::LaplacianEigenmaps},
{"la", tapkee::LaplacianEigenmaps},
{"locality_preserving_projections", tapkee::LocalityPreservingProjections},
{"lpp", tapkee::LocalityPreservingProjections},
{"neighborhood_preserving_embedding", tapkee::NeighborhoodPreservingEmbedding},
{"npe", tapkee::NeighborhoodPreservingEmbedding},
{"linear_local_tangent_space_alignment", tapkee::LinearLocalTangentSpaceAlignment},
{"lltsa", tapkee::LinearLocalTangentSpaceAlignment},
{"stochastic_proximity_embedding", tapkee::StochasticProximityEmbedding},
{"spe", tapkee::StochasticProximityEmbedding},
{"passthru", tapkee::PassThru},
{"factor_analysis", tapkee::FactorAnalysis},
{"fa", tapkee::FactorAnalysis},
{"t-stochastic_proximity_embedding", tapkee::tDistributedStochasticNeighborEmbedding},
{"t-sne", tapkee::tDistributedStochasticNeighborEmbedding},
{"manifold_sculpting", tapkee::ManifoldSculpting},
};

tapkee::DimensionReductionMethod parse_reduction_method(const char* str)
{
if (!strcmp(str, "local_tangent_space_alignment") || !strcmp(str, "ltsa"))
return tapkee::KernelLocalTangentSpaceAlignment;
if (!strcmp(str, "locally_linear_embedding") || !strcmp(str, "lle"))
return tapkee::KernelLocallyLinearEmbedding;
if (!strcmp(str, "hessian_locally_linear_embedding") || !strcmp(str, "hlle"))
return tapkee::HessianLocallyLinearEmbedding;
if (!strcmp(str, "multidimensional_scaling") || !strcmp(str, "mds"))
return tapkee::MultidimensionalScaling;
if (!strcmp(str, "landmark_multidimensional_scaling") || !strcmp(str, "l-mds"))
return tapkee::LandmarkMultidimensionalScaling;
if (!strcmp(str, "isomap"))
return tapkee::Isomap;
if (!strcmp(str, "landmark_isomap") || !strcmp(str, "l-isomap"))
return tapkee::LandmarkIsomap;
if (!strcmp(str, "diffusion_map") || !strcmp(str, "dm"))
return tapkee::DiffusionMap;
if (!strcmp(str, "kernel_pca") || !strcmp(str, "kpca"))
return tapkee::KernelPrincipalComponentAnalysis;
if (!strcmp(str, "pca"))
return tapkee::PrincipalComponentAnalysis;
if (!strcmp(str, "random_projection") || !strcmp(str, "ra"))
return tapkee::RandomProjection;
if (!strcmp(str, "laplacian_eigenmaps") || !strcmp(str, "la"))
return tapkee::LaplacianEigenmaps;
if (!strcmp(str, "locality_preserving_projections") || !strcmp(str, "lpp"))
return tapkee::LocalityPreservingProjections;
if (!strcmp(str, "neighborhood_preserving_embedding") || !strcmp(str, "npe"))
return tapkee::NeighborhoodPreservingEmbedding;
if (!strcmp(str, "linear_local_tangent_space_alignment") || !strcmp(str, "lltsa"))
return tapkee::LinearLocalTangentSpaceAlignment;
if (!strcmp(str, "stochastic_proximity_embedding") || !strcmp(str, "spe"))
return tapkee::StochasticProximityEmbedding;
if (!strcmp(str, "passthru"))
return tapkee::PassThru;
if (!strcmp(str, "factor_analysis") || !strcmp(str, "fa"))
return tapkee::FactorAnalysis;
if (!strcmp(str, "t-stochastic_neighbor_embedding") || !strcmp(str, "t-sne"))
return tapkee::tDistributedStochasticNeighborEmbedding;
if (!strcmp(str, "manifold_sculpting") || !strcmp(str, "ms"))
return tapkee::ManifoldSculpting;

throw std::exception();
return tapkee::PassThru;
return DIMENSION_REDUCTION_METHODS.at(str);
}

tapkee::NeighborsMethod parse_neighbors_method(const char* str)
{
if (!strcmp(str, "brute"))
return tapkee::Brute;
if (!strcmp(str, "vptree"))
return tapkee::VpTree;
static const std::map<const char*, tapkee::NeighborsMethod> NEIGHBORS_METHODS = {
{"brute", tapkee::Brute},
{"vptree", tapkee::VpTree},
#ifdef TAPKEE_USE_LGPL_COVERTREE
if (!strcmp(str, "covertree"))
return tapkee::CoverTree;
{"covertree", tapkee::CoverTree},
#endif
};

throw std::exception();
return tapkee::Brute;
tapkee::NeighborsMethod parse_neighbors_method(const char* str)
{
return NEIGHBORS_METHODS.at(str);
}

tapkee::EigenMethod parse_eigen_method(const char* str)
{
static const std::map<const char*, tapkee::EigenMethod> EIGEN_METHODS = {
{"dense", tapkee::Dense},
{"randomized", tapkee::Randomized},
#ifdef TAPKEE_WITH_ARPACK
if (!strcmp(str, "arpack"))
return tapkee::Arpack;
{"arpack", tapkee::Arpack},
#endif
if (!strcmp(str, "randomized"))
return tapkee::Randomized;
if (!strcmp(str, "dense"))
return tapkee::Dense;
};

throw std::exception();
return tapkee::Dense;
tapkee::EigenMethod parse_eigen_method(const char* str)
{
return EIGEN_METHODS.at(str);
}

tapkee::ComputationStrategy parse_computation_strategy(const char* str)
{
if (!strcmp(str, "cpu"))
return tapkee::HomogeneousCPUStrategy;
static const std::map<const char*, tapkee::ComputationStrategy> COMPUTATION_STRATEGIES = {
{"cpu", tapkee::HomogeneousCPUStrategy},
#ifdef TAPKEE_WITH_VIENNACL
if (!strcmp(str, "opencl"))
return tapkee::HeterogeneousOpenCLStrategy;
{"opencl", tapkee::HeterogeneousOpenCLStrategy},
#endif
return tapkee::HomogeneousCPUStrategy;
};

tapkee::ComputationStrategy parse_computation_strategy(const char* str)
{
return COMPUTATION_STRATEGIES.at(str);
}

template <class PairwiseCallback>
Expand Down

0 comments on commit 82cb8e2

Please sign in to comment.