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; };