TapkeeOutput embed(RandomAccessIterator begin, RandomAccessIterator end,
KernelCallback kernel_callback, DistanceCallback distance_callback,
FeaturesCallback features_callback, ParametersSet parameters)
{
#if EIGEN_VERSION_AT_LEAST(3,1,0)
Eigen::initParallel();
#endif
TapkeeOutput output;
parameters.merge(tapkee_internal::defaults);
DimensionReductionMethod selected_method = parameters(keywords::method);
void (*progress_function)(double) = parameters(keywords::progress_function);
bool (*cancel_function)() = parameters(keywords::cancel_function);
tapkee_internal::Context context(progress_function,cancel_function);
try
{
LoggingSingleton::instance().message_info("Using the " + get_method_name(selected_method) + " method.");
output = tapkee_internal::initialize(begin,end,kernel_callback,distance_callback,features_callback,parameters,context)
.embedUsing(selected_method);
}
catch (const std::bad_alloc&)
{
throw not_enough_memory_error("Not enough memory");
}
return output;
}
TapkeeOutput embed(RandomAccessIterator begin, RandomAccessIterator end,
KernelCallback kernel_callback, DistanceCallback distance_callback,
FeaturesCallback features_callback, stichwort::ParametersSet parameters)
{
#if EIGEN_VERSION_AT_LEAST(3,1,0)
Eigen::initParallel();
#endif
TapkeeOutput output;
try
{
parameters.check();
parameters.merge(tapkee_internal::defaults);
DimensionReductionMethod selected_method = parameters[method];
void (*progress_function_ptr)(double) = parameters[progress_function];
bool (*cancel_function_ptr)() = parameters[cancel_function];
tapkee_internal::Context context(progress_function_ptr,cancel_function_ptr);
LoggingSingleton::instance().message_info(formatting::format("Using the {} method.", get_method_name(selected_method)));
output = tapkee_internal::initialize(begin,end,kernel_callback,distance_callback,features_callback,parameters,context)
.embedUsing(selected_method);
}
catch (const std::bad_alloc&)
{
throw not_enough_memory_error("Not enough memory");
}
catch (const stichwort::wrong_parameter_error& ex)
{
throw tapkee::wrong_parameter_error(ex.what());
}
catch (const stichwort::wrong_parameter_type_error& ex)
{
throw tapkee::wrong_parameter_type_error(ex.what());
}
catch (const stichwort::multiple_parameter_error& ex)
{
throw tapkee::multiple_parameter_error(ex.what());
}
catch (const stichwort::missed_parameter_error& ex)
{
throw tapkee::missed_parameter_error(ex.what());
}
return output;
}
ReturnResult embed(RandomAccessIterator begin, RandomAccessIterator end,
KernelCallback kernel_callback, DistanceCallback distance_callback,
FeatureVectorCallback feature_vector_callback, ParametersMap options)
{
ReturnResult return_result;
TAPKEE_METHOD method;
try
{
method = options[REDUCTION_METHOD].cast<TAPKEE_METHOD>();
}
catch (const anyimpl::bad_any_cast&)
{
throw wrong_parameter_error("Wrong method specified.");
}
#define CALL_IMPLEMENTATION(X) \
tapkee_internal::implementation<RandomAccessIterator,KernelCallback,DistanceCallback,FeatureVectorCallback,X>()(\
begin,end,kernel_callback,distance_callback,feature_vector_callback,options)
#define HANDLE_IMPLEMENTATION(X) \
case X: return_result = CALL_IMPLEMENTATION(X); break
try
{
LoggingSingleton::instance().message_info("Using " + tapkee_internal::get_method_name(method) + " method.");
switch (method)
{
HANDLE_IMPLEMENTATION(KERNEL_LOCALLY_LINEAR_EMBEDDING);
HANDLE_IMPLEMENTATION(KERNEL_LOCAL_TANGENT_SPACE_ALIGNMENT);
HANDLE_IMPLEMENTATION(DIFFUSION_MAP);
HANDLE_IMPLEMENTATION(MULTIDIMENSIONAL_SCALING);
HANDLE_IMPLEMENTATION(LANDMARK_MULTIDIMENSIONAL_SCALING);
HANDLE_IMPLEMENTATION(ISOMAP);
HANDLE_IMPLEMENTATION(LANDMARK_ISOMAP);
HANDLE_IMPLEMENTATION(NEIGHBORHOOD_PRESERVING_EMBEDDING);
HANDLE_IMPLEMENTATION(LINEAR_LOCAL_TANGENT_SPACE_ALIGNMENT);
HANDLE_IMPLEMENTATION(HESSIAN_LOCALLY_LINEAR_EMBEDDING);
HANDLE_IMPLEMENTATION(LAPLACIAN_EIGENMAPS);
HANDLE_IMPLEMENTATION(LOCALITY_PRESERVING_PROJECTIONS);
HANDLE_IMPLEMENTATION(PCA);
HANDLE_IMPLEMENTATION(KERNEL_PCA);
HANDLE_IMPLEMENTATION(RANDOM_PROJECTION);
HANDLE_IMPLEMENTATION(STOCHASTIC_PROXIMITY_EMBEDDING);
HANDLE_IMPLEMENTATION(PASS_THRU);
HANDLE_IMPLEMENTATION(FACTOR_ANALYSIS);
case UNKNOWN_METHOD:
throw wrong_parameter_error("unknown method");
break;
}
}
catch (const std::bad_alloc& ba)
{
LoggingSingleton::instance().message_error("Not enough memory available.");
throw not_enough_memory_error("Not enough memory");
}
#undef CALL_IMPLEMENTATION
#undef HANDLE_IMPLEMENTATION
return return_result;
};
