Crate sklears_kernel_approximation 

Kernel approximation methods

This module is part of sklears, providing scikit-learn compatible machine learning algorithms in Rust.

Re-exports

pub use adaptive_bandwidth_rbf::AdaptiveBandwidthRBFSampler;

pub use adaptive_bandwidth_rbf::BandwidthSelectionStrategy;

pub use adaptive_bandwidth_rbf::ObjectiveFunction;

pub use adaptive_dimension::AdaptiveDimensionConfig;

pub use adaptive_dimension::AdaptiveRBFSampler;

pub use adaptive_dimension::DimensionSelectionResult;

pub use adaptive_dimension::FittedAdaptiveRBFSampler;

pub use adaptive_dimension::QualityMetric as AdaptiveQualityMetric;

pub use adaptive_dimension::SelectionStrategy;

pub use adaptive_nystroem::AdaptiveNystroem;

pub use adaptive_nystroem::ComponentSelectionStrategy;

pub use adaptive_nystroem::ErrorBoundMethod as AdaptiveErrorBoundMethod;

pub use advanced_testing::ApproximationError;

pub use advanced_testing::BaselineMethod;

pub use advanced_testing::BoundType as TestingBoundType;

pub use advanced_testing::BoundValidation;

pub use advanced_testing::ConvergenceAnalyzer;

pub use advanced_testing::ConvergenceResult;

pub use advanced_testing::ErrorBoundsResult;

pub use advanced_testing::ErrorBoundsValidator;

pub use advanced_testing::QualityAssessment;

pub use advanced_testing::QualityMetric as TestingQualityMetric;

pub use advanced_testing::QualityResult;

pub use advanced_testing::ReferenceMethod;

pub use anisotropic_rbf::AnisotropicRBFSampler;

pub use anisotropic_rbf::FittedAnisotropicRBF;

pub use anisotropic_rbf::FittedMahalanobisRBF;

pub use anisotropic_rbf::FittedRobustAnisotropicRBF;

pub use anisotropic_rbf::MahalanobisRBFSampler;

pub use anisotropic_rbf::RobustAnisotropicRBFSampler;

pub use anisotropic_rbf::RobustEstimator;

pub use benchmarking::BenchmarkConfig;

pub use benchmarking::BenchmarkDataset;

pub use benchmarking::BenchmarkResult;

pub use benchmarking::BenchmarkSummary;

pub use benchmarking::BenchmarkableKernelMethod;

pub use benchmarking::BenchmarkableTransformer;

pub use benchmarking::KernelApproximationBenchmark;

pub use benchmarking::PerformanceMetric;

pub use benchmarking::QualityMetric;

pub use bioinformatics_kernels::GenomicKernel;

pub use bioinformatics_kernels::MetabolicNetworkKernel;

pub use bioinformatics_kernels::MultiOmicsKernel;

pub use bioinformatics_kernels::OmicsIntegrationMethod;

pub use bioinformatics_kernels::PhylogeneticKernel;

pub use bioinformatics_kernels::ProteinKernel;

pub use budget_constrained::BudgetConstrainedConfig;

pub use budget_constrained::BudgetConstrainedNystroem;

pub use budget_constrained::BudgetConstrainedRBFSampler;

pub use budget_constrained::BudgetConstraint;

pub use budget_constrained::BudgetOptimizationResult;

pub use budget_constrained::BudgetUsage;

pub use budget_constrained::FittedBudgetConstrainedNystroem;

pub use budget_constrained::FittedBudgetConstrainedRBFSampler;

pub use budget_constrained::OptimizationStrategy;

pub use cache_optimization::AlignedBuffer;

pub use cache_optimization::CacheAwareTransform;

pub use cache_optimization::CacheConfig;

pub use cache_optimization::CacheFriendlyMatrix;

pub use cache_optimization::MemoryLayout;

pub use causal_kernels::CausalKernel;

pub use causal_kernels::CausalKernelConfig;

pub use causal_kernels::CausalMethod;

pub use causal_kernels::CounterfactualKernel;

pub use chi2_samplers::AdditiveChi2Sampler;

pub use chi2_samplers::SkewedChi2Sampler;

pub use computer_vision_kernels::ActivationFunction;

pub use computer_vision_kernels::ConvolutionalKernelFeatures;

pub use computer_vision_kernels::FittedConvolutionalKernelFeatures;

pub use computer_vision_kernels::FittedScaleInvariantFeatures;

pub use computer_vision_kernels::FittedSpatialPyramidFeatures;

pub use computer_vision_kernels::FittedTextureKernelApproximation;

pub use computer_vision_kernels::PoolingMethod;

pub use computer_vision_kernels::ScaleInvariantFeatures;

pub use computer_vision_kernels::SpatialPyramidFeatures;

pub use computer_vision_kernels::TextureKernelApproximation;

pub use cross_validation::CVSplitter;

pub use cross_validation::CVStrategy;

pub use cross_validation::CrossValidationConfig;

pub use cross_validation::CrossValidationResult as CVResult;

pub use cross_validation::CrossValidator;

pub use cross_validation::KFoldSplitter;

pub use cross_validation::MonteCarloCVSplitter;

pub use cross_validation::ScoringMetric;

pub use cross_validation::TimeSeriesSplitter;

pub use custom_kernel::CustomExponentialKernel;

pub use custom_kernel::CustomKernelSampler;

pub use custom_kernel::CustomLaplacianKernel;

pub use custom_kernel::CustomPolynomialKernel;

pub use custom_kernel::CustomRBFKernel;

pub use custom_kernel::KernelFunction;

pub use deep_learning_kernels::Activation as DeepLearningActivation;

pub use deep_learning_kernels::DKLConfig;

pub use deep_learning_kernels::DeepKernelLearning;

pub use deep_learning_kernels::InfiniteWidthKernel;

pub use deep_learning_kernels::NTKConfig;

pub use deep_learning_kernels::NeuralTangentKernel;

pub use distributed_kernel::AggregationMethod;

pub use distributed_kernel::CommunicationPattern;

pub use distributed_kernel::DistributedConfig;

pub use distributed_kernel::DistributedNystroem;

pub use distributed_kernel::DistributedRBFSampler;

pub use distributed_kernel::PartitionStrategy;

pub use distributed_kernel::Worker;

pub use ensemble_nystroem::EnsembleMethod;

pub use ensemble_nystroem::EnsembleNystroem;

pub use ensemble_nystroem::QualityMetric as EnsembleQualityMetric;

pub use error_bounded::ErrorBound;

pub use error_bounded::ErrorBoundMethod;

pub use error_bounded::ErrorBoundedConfig;

pub use error_bounded::ErrorBoundedNystroem;

pub use error_bounded::ErrorBoundedRBFSampler;

pub use error_bounded::FittedErrorBoundedNystroem;

pub use error_bounded::FittedErrorBoundedRBFSampler;

pub use fastfood::FastfoodKernel;

pub use fastfood::FastfoodKernelParams;

pub use fastfood::FastfoodTransform;

pub use feature_generation::CompositeGenerator;

pub use feature_generation::FeatureGenerator;

pub use feature_generation::FeatureGeneratorBuilder;

pub use feature_generation::PolynomialGenerator;

pub use feature_generation::RandomFourierGenerator;

pub use finance_kernels::EconometricKernel;

pub use finance_kernels::FinancialKernel;

pub use finance_kernels::PortfolioKernel;

pub use finance_kernels::RiskKernel;

pub use finance_kernels::VolatilityKernel;

pub use finance_kernels::VolatilityModel;

pub use gpu_acceleration::FittedGpuNystroem;

pub use gpu_acceleration::FittedGpuRBFSampler;

pub use gpu_acceleration::GpuBackend;

pub use gpu_acceleration::GpuConfig;

pub use gpu_acceleration::GpuContext;

pub use gpu_acceleration::GpuDevice;

pub use gpu_acceleration::GpuNystroem;

pub use gpu_acceleration::GpuProfiler;

pub use gpu_acceleration::GpuRBFSampler;

pub use gpu_acceleration::MemoryStrategy;

pub use gpu_acceleration::Precision;

pub use gradient_kernel_learning::GradientConfig;

pub use gradient_kernel_learning::GradientKernelLearner;

pub use gradient_kernel_learning::GradientMultiKernelLearner;

pub use gradient_kernel_learning::GradientOptimizer;

pub use gradient_kernel_learning::GradientResult;

pub use gradient_kernel_learning::KernelObjective;

pub use graph_kernels::FittedRandomWalkKernel;

pub use graph_kernels::FittedShortestPathKernel;

pub use graph_kernels::FittedSubgraphKernel;

pub use graph_kernels::FittedWeisfeilerLehmanKernel;

pub use graph_kernels::Graph;

pub use graph_kernels::RandomWalkKernel;

pub use graph_kernels::ShortestPathKernel;

pub use graph_kernels::SubgraphKernel;

pub use graph_kernels::WeisfeilerLehmanKernel;

pub use homogeneous_polynomial::CoefficientMethod;

pub use homogeneous_polynomial::HomogeneousPolynomialFeatures;

pub use homogeneous_polynomial::NormalizationMethod;

pub use incremental_nystroem::IncrementalNystroem;

pub use incremental_nystroem::UpdateStrategy;

pub use information_theoretic::EntropyFeatureSelector;

pub use information_theoretic::EntropySelectionMethod;

pub use information_theoretic::FittedEntropyFeatureSelector;

pub use information_theoretic::FittedInformationBottleneckExtractor;

pub use information_theoretic::FittedKLDivergenceKernel;

pub use information_theoretic::FittedMutualInformationKernel;

pub use information_theoretic::InformationBottleneckExtractor;

pub use information_theoretic::KLDivergenceKernel;

pub use information_theoretic::KLReferenceDistribution;

pub use information_theoretic::MutualInformationKernel;

pub use kernel_framework::ApproximationQuality;

pub use kernel_framework::BoundType as FrameworkBoundType;

pub use kernel_framework::CombinationStrategy as FrameworkCombinationStrategy;

pub use kernel_framework::Complexity;

pub use kernel_framework::CompositeKernelMethod;

pub use kernel_framework::ErrorBound as FrameworkErrorBound;

pub use kernel_framework::FeatureMap;

pub use kernel_framework::KMeansSampling;

pub use kernel_framework::KernelAlignmentMetric;

pub use kernel_framework::KernelMethod;

pub use kernel_framework::KernelType as FrameworkKernelType;

pub use kernel_framework::SamplingStrategy as SamplingStrategyTrait;

pub use kernel_framework::UniformSampling;

pub use kernel_ridge_regression::ApproximationMethod as KRRApproximationMethod;

pub use kernel_ridge_regression::KernelRidgeRegression;

pub use kernel_ridge_regression::MultiTaskKernelRidgeRegression;

pub use kernel_ridge_regression::OnlineKernelRidgeRegression;

pub use kernel_ridge_regression::RobustKernelRidgeRegression;

pub use kernel_ridge_regression::RobustLoss;

pub use kernel_ridge_regression::Solver;

pub use kernel_ridge_regression::TaskRegularization;

pub use memory_efficient::FittedMemoryEfficientNystroem;

pub use memory_efficient::FittedMemoryEfficientRBFSampler;

pub use memory_efficient::MemoryConfig;

pub use memory_efficient::MemoryEfficientNystroem;

pub use memory_efficient::MemoryEfficientRBFSampler;

pub use memory_efficient::MemoryMonitor;

pub use meta_learning_kernels::DatasetMetaFeatures;

pub use meta_learning_kernels::MetaKernelType;

pub use meta_learning_kernels::MetaLearningConfig;

pub use meta_learning_kernels::MetaLearningKernelSelector;

pub use meta_learning_kernels::MetaLearningStrategy;

pub use meta_learning_kernels::PerformanceMetric as MetaPerformanceMetric;

pub use meta_learning_kernels::TaskMetadata;

pub use middleware::Hook;

pub use middleware::HookContext;

pub use middleware::LoggingHook;

pub use middleware::Middleware;

pub use middleware::NormalizationMiddleware;

pub use middleware::PerformanceHook;

pub use middleware::Pipeline;

pub use middleware::PipelineBuilder;

pub use middleware::PipelineStage;

pub use middleware::ValidationHook;

pub use multi_kernel_learning::ApproximationMethod as MKLApproximationMethod;

pub use multi_kernel_learning::BaseKernel;

pub use multi_kernel_learning::CombinationStrategy as MKLCombinationStrategy;

pub use multi_kernel_learning::KernelStatistics;

pub use multi_kernel_learning::MultiKernelConfig;

pub use multi_kernel_learning::MultipleKernelLearning;

pub use multi_kernel_learning::WeightLearningAlgorithm;

pub use multi_scale_rbf::BandwidthStrategy;

pub use multi_scale_rbf::CombinationStrategy;

pub use multi_scale_rbf::MultiScaleRBFSampler;

pub use nlp_kernels::AggregationMethod as NLPAggregationMethod;

pub use nlp_kernels::DocumentKernelApproximation;

pub use nlp_kernels::FittedDocumentKernelApproximation;

pub use nlp_kernels::FittedSemanticKernelApproximation;

pub use nlp_kernels::FittedSyntacticKernelApproximation;

pub use nlp_kernels::FittedTextKernelApproximation;

pub use nlp_kernels::SemanticKernelApproximation;

pub use nlp_kernels::SimilarityMeasure;

pub use nlp_kernels::SyntacticKernelApproximation;

pub use nlp_kernels::TextKernelApproximation;

pub use nlp_kernels::TreeKernelType;

pub use numerical_stability::stable_kernel_matrix;

pub use numerical_stability::NumericalStabilityMonitor;

pub use numerical_stability::StabilityConfig;

pub use numerical_stability::StabilityMetrics;

pub use numerical_stability::StabilityWarning;

pub use nystroem::Kernel;

pub use nystroem::Nystroem;

pub use nystroem::SamplingStrategy;

pub use optimal_transport::EMDKernelSampler;

pub use optimal_transport::GWLossFunction;

pub use optimal_transport::GromovWassersteinSampler;

pub use optimal_transport::GroundMetric;

pub use optimal_transport::TransportMethod;

pub use optimal_transport::WassersteinKernelSampler;

pub use out_of_core::OutOfCoreConfig;

pub use out_of_core::OutOfCoreKernelPipeline;

pub use out_of_core::OutOfCoreLoader;

pub use out_of_core::OutOfCoreNystroem;

pub use out_of_core::OutOfCoreRBFSampler;

pub use out_of_core::OutOfCoreStrategy;

pub use parameter_learning::ObjectiveFunction as ParameterObjectiveFunction;

pub use parameter_learning::OptimizationResult;

pub use parameter_learning::ParameterBounds;

pub use parameter_learning::ParameterLearner;

pub use parameter_learning::ParameterLearningConfig;

pub use parameter_learning::ParameterSet;

pub use parameter_learning::SearchStrategy;

pub use plugin_architecture::create_global_plugin_instance;

pub use plugin_architecture::list_global_plugins;

pub use plugin_architecture::register_global_plugin;

pub use plugin_architecture::FittedPluginWrapper;

pub use plugin_architecture::KernelApproximationInstance;

pub use plugin_architecture::KernelApproximationPlugin;

pub use plugin_architecture::LinearKernelInstance;

pub use plugin_architecture::LinearKernelPlugin;

pub use plugin_architecture::PluginConfig;

pub use plugin_architecture::PluginError;

pub use plugin_architecture::PluginFactory;

pub use plugin_architecture::PluginMetadata;

pub use plugin_architecture::PluginWrapper;

pub use polynomial_count_sketch::PolynomialCountSketch;

pub use polynomial_features::PolynomialFeatures;

pub use progressive::FittedProgressiveNystroem;

pub use progressive::FittedProgressiveRBFSampler;

pub use progressive::ProgressiveConfig;

pub use progressive::ProgressiveNystroem;

pub use progressive::ProgressiveQualityMetric;

pub use progressive::ProgressiveRBFSampler;

pub use progressive::ProgressiveResult;

pub use progressive::ProgressiveStep;

pub use progressive::ProgressiveStrategy;

pub use progressive::StoppingCriterion;

pub use quantum_kernel_methods::EntanglementPattern;

pub use quantum_kernel_methods::QuantumFeatureMap;

pub use quantum_kernel_methods::QuantumKernelApproximation;

pub use quantum_kernel_methods::QuantumKernelConfig;

pub use quasi_random_features::QuasiRandomRBFSampler;

pub use quasi_random_features::QuasiRandomSequence;

pub use rbf_sampler::ArcCosineSampler;

pub use rbf_sampler::LaplacianSampler;

pub use rbf_sampler::PolynomialSampler;

pub use rbf_sampler::RBFSampler;

pub use robust_kernels::BreakdownPointAnalysis;

pub use robust_kernels::InfluenceFunctionDiagnostics;

pub use robust_kernels::RobustEstimator as RobustKernelEstimator;

pub use robust_kernels::RobustKernelConfig;

pub use robust_kernels::RobustLoss as RobustKernelLoss;

pub use robust_kernels::RobustNystroem;

pub use robust_kernels::RobustRBFSampler;

pub use scientific_computing_kernels::MultiscaleKernel;

pub use scientific_computing_kernels::PhysicalSystem;

pub use scientific_computing_kernels::PhysicsInformedConfig;

pub use scientific_computing_kernels::PhysicsInformedKernel;

pub use sparse_gp::simd_sparse_gp;

pub use sparse_gp::FittedSKI;

pub use sparse_gp::FittedSparseGP;

pub use sparse_gp::FittedTensorSKI;

pub use sparse_gp::InducingPointSelector;

pub use sparse_gp::InducingPointStrategy;

pub use sparse_gp::InterpolationMethod;

pub use sparse_gp::KernelOps;

pub use sparse_gp::LanczosMethod;

pub use sparse_gp::MaternKernel;

pub use sparse_gp::PreconditionedCG;

pub use sparse_gp::PreconditionerType;

pub use sparse_gp::RBFKernel as SparseRBFKernel;

pub use sparse_gp::ScalableInference;

pub use sparse_gp::ScalableInferenceMethod;

pub use sparse_gp::SparseApproximation;

pub use sparse_gp::SparseApproximationMethods;

pub use sparse_gp::SparseGaussianProcess;

pub use sparse_gp::SparseKernel;

pub use sparse_gp::StochasticVariationalInference;

pub use sparse_gp::StructuredKernelInterpolation;

pub use sparse_gp::TensorSKI;

pub use sparse_gp::VariationalFreeEnergy;

pub use sparse_gp::VariationalParams;

pub use sparse_polynomial::SparseFormat;

pub use sparse_polynomial::SparseMatrix;

pub use sparse_polynomial::SparsePolynomialFeatures;

pub use sparse_polynomial::SparsityStrategy;

pub use streaming_kernel::BufferStrategy;

pub use streaming_kernel::FeatureStatistics;

pub use streaming_kernel::ForgettingMechanism;

pub use streaming_kernel::StreamingConfig;

pub use streaming_kernel::StreamingNystroem;

pub use streaming_kernel::StreamingRBFSampler;

pub use streaming_kernel::StreamingSample;

pub use streaming_kernel::UpdateFrequency;

pub use string_kernels::EditDistanceKernel;

pub use string_kernels::FittedEditDistanceKernel;

pub use string_kernels::FittedMismatchKernel;

pub use string_kernels::FittedNGramKernel;

pub use string_kernels::FittedSpectrumKernel;

pub use string_kernels::FittedSubsequenceKernel;

pub use string_kernels::MismatchKernel;

pub use string_kernels::NGramKernel;

pub use string_kernels::NGramMode;

pub use string_kernels::SpectrumKernel;

pub use string_kernels::SubsequenceKernel;

pub use structured_random_features::FastWalshHadamardTransform;

pub use structured_random_features::StructuredMatrix;

pub use structured_random_features::StructuredRFFHadamard;

pub use structured_random_features::StructuredRandomFeatures;

pub use tensor_polynomial::ContractionMethod;

pub use tensor_polynomial::TensorOrdering;

pub use tensor_polynomial::TensorPolynomialFeatures;

pub use time_series_kernels::AutoregressiveKernelApproximation;

pub use time_series_kernels::DTWConfig;

pub use time_series_kernels::DTWDistanceMetric;

pub use time_series_kernels::DTWKernelApproximation;

pub use time_series_kernels::DTWStepPattern;

pub use time_series_kernels::DTWWindowType;

pub use time_series_kernels::GlobalAlignmentKernelApproximation;

pub use time_series_kernels::SpectralKernelApproximation;

pub use time_series_kernels::TimeSeriesKernelConfig;

pub use time_series_kernels::TimeSeriesKernelType;

pub use type_safe_kernels::ArcCosineKernel as TypeSafeArcCosineKernel;

pub use type_safe_kernels::FastfoodMethod as TypeSafeFastfoodMethod;

pub use type_safe_kernels::FittedTypeSafeKernelApproximation;

pub use type_safe_kernels::FittedTypeSafeLaplacianRandomFourierFeatures;

pub use type_safe_kernels::FittedTypeSafePolynomialNystrom;

pub use type_safe_kernels::FittedTypeSafeRBFFastfood;

pub use type_safe_kernels::FittedTypeSafeRBFNystrom;

pub use type_safe_kernels::FittedTypeSafeRBFRandomFourierFeatures;

pub use type_safe_kernels::KernelType as TypeSafeKernelType;

pub use type_safe_kernels::LaplacianKernel as TypeSafeLaplacianKernel;

pub use type_safe_kernels::NystromMethod as TypeSafeNystromMethod;

pub use type_safe_kernels::PolynomialKernel as TypeSafePolynomialKernel;

pub use type_safe_kernels::QualityMetrics as TypeSafeQualityMetrics;

pub use type_safe_kernels::RBFKernel as TypeSafeRBFKernel;

pub use type_safe_kernels::RandomFourierFeatures as TypeSafeRandomFourierFeatures;

pub use type_safe_kernels::Trained as TypeSafeTrained;

pub use type_safe_kernels::TypeSafeKernelApproximation;

pub use type_safe_kernels::TypeSafeLaplacianRandomFourierFeatures;

pub use type_safe_kernels::TypeSafePolynomialNystrom;

pub use type_safe_kernels::TypeSafeRBFFastfood;

pub use type_safe_kernels::TypeSafeRBFNystrom;

pub use type_safe_kernels::TypeSafeRBFRandomFourierFeatures;

pub use type_safe_kernels::Untrained as TypeSafeUntrained;

pub use type_safety::ApproximationMethod;

pub use type_safety::ApproximationParameters;

pub use type_safety::ApproximationState;

pub use type_safety::ArcCosineKernel;

pub use type_safety::ComplexityClass;

pub use type_safety::FastfoodMethod;

pub use type_safety::FittableKernel;

pub use type_safety::FittableMethod;

pub use type_safety::FittedLaplacianRandomFourierFeatures;

pub use type_safety::FittedRBFNystrom;

pub use type_safety::FittedRBFRandomFourierFeatures;

pub use type_safety::KernelPresets;

pub use type_safety::KernelType;

pub use type_safety::KernelTypeWithBandwidth;

pub use type_safety::LaplacianKernel;

pub use type_safety::LaplacianRandomFourierFeatures;

pub use type_safety::NystromMethod;

pub use type_safety::OptimizationLevel;

pub use type_safety::PolynomialKernel;

pub use type_safety::PolynomialKernelType;

pub use type_safety::PolynomialNystrom;

pub use type_safety::ProfileGuidedConfig;

pub use type_safety::QualityMetrics;

pub use type_safety::RBFFastfood;

pub use type_safety::RBFKernel;

pub use type_safety::RBFNystrom;

pub use type_safety::RBFRandomFourierFeatures;

pub use type_safety::RandomFourierFeatures;

pub use type_safety::SerializableFittedParams;

pub use type_safety::SerializableKernelApproximation;

pub use type_safety::SerializableKernelConfig;

pub use type_safety::TargetArchitecture;

pub use type_safety::Trained;

pub use type_safety::TransformationParameters;

pub use type_safety::Untrained;

pub use unsafe_optimizations::batch_rbf_kernel_fast;

pub use unsafe_optimizations::dot_product_unrolled;

pub use unsafe_optimizations::elementwise_op_fast;

pub use unsafe_optimizations::fast_cosine_features;

pub use unsafe_optimizations::matvec_multiply_fast;

pub use unsafe_optimizations::rbf_kernel_fast;

pub use unsafe_optimizations::safe_dot_product;

pub use unsafe_optimizations::safe_matvec_multiply;

pub use validation::BoundFunction;

pub use validation::BoundType;

pub use validation::CrossValidationResult;

pub use validation::DimensionDependencyAnalysis;

pub use validation::KernelApproximationValidator;

pub use validation::SampleComplexityAnalysis;

pub use validation::StabilityAnalysis;

pub use validation::TheoreticalBound;

pub use validation::ValidatableKernelMethod;

pub use validation::ValidatedFittedMethod;

pub use validation::ValidationConfig;

pub use validation::ValidationResult;

Modules

adaptive_bandwidth_rbf

Adaptive bandwidth RBF kernel approximation methods

adaptive_dimension

Adaptive feature dimension selection for kernel approximations

adaptive_nystroem

Adaptive Nyström method with error bounds and automatic component selection

advanced_testing

Advanced testing and validation for kernel approximations

anisotropic_rbf

Anisotropic RBF Kernel Approximations

benchmarking

Comprehensive Benchmarking Framework for Kernel Approximation Methods

bioinformatics_kernels

Bioinformatics Kernel Methods

budget_constrained

Budget-constrained kernel approximation methods

cache_optimization

Cache-friendly feature layouts for improved performance

causal_kernels

Causal Inference Kernel Methods

chi2_samplers

Chi-squared kernel approximation methods

computer_vision_kernels

Computer vision kernel approximations

cross_validation

Cross-validation framework for kernel parameter selection

custom_kernel

Custom kernel random feature generation framework

deep_learning_kernels

Deep Learning Integration for Kernel Approximation

distributed_kernel

ensemble_nystroem

Ensemble Nyström method for improved kernel approximation

error_bounded

Error-bounded kernel approximation methods

fastfood

Fastfood Transform for efficient random feature approximation

feature_generation

Extensible feature generation framework

finance_kernels

Finance and Economics Kernel Methods

gpu_acceleration

GPU acceleration for kernel approximations

gradient_kernel_learning

Gradient-based kernel learning for automatic parameter optimization

graph_kernels

Graph Kernel Approximations

homogeneous_polynomial

Homogeneous polynomial features with fixed total degree

incremental_nystroem

Incremental Nyström method for online kernel approximation

information_theoretic

Information-Theoretic Kernel Methods

kernel_framework

Comprehensive trait-based framework for kernel approximations

kernel_ridge_regression

Kernel Ridge Regression Module

memory_efficient

Memory-efficient kernel approximation methods

meta_learning_kernels

Meta-Learning for Kernel Selection

middleware

Middleware system for kernel approximation pipelines

multi_kernel_learning

multi_scale_rbf

Multi-scale RBF kernel approximation methods

nlp_kernels

Natural Language Processing kernel approximations

numerical_stability

Numerical Stability Enhancements for Kernel Approximation Methods

nystroem

Nyström method for kernel approximation

optimal_transport

Optimal transport kernel approximation methods

out_of_core

Out-of-core kernel computations for large datasets

parameter_learning

Automatic kernel parameter learning and optimization

plugin_architecture

Plugin architecture for custom kernel approximations

polynomial_count_sketch

Polynomial kernel approximation via Tensor Sketch

polynomial_features

Explicit polynomial feature maps

progressive

Progressive kernel approximation methods

quantum_kernel_methods

Quantum Kernel Methods and Quantum-Inspired Approximations

quasi_random_features

Quasi-random feature generation for improved kernel approximations

rbf_sampler

Random Fourier Features for RBF Kernel Approximation

robust_kernels

Robust kernel methods with outlier resistance

scientific_computing_kernels

Scientific Computing Kernel Methods

simd_kernel

SIMD-accelerated kernel ridge regression operations

simple_test

Simple manual test for kernel approximation implementations

sparse_gp

Sparse Gaussian Process implementations with comprehensive approximation methods

sparse_polynomial

Sparse polynomial features for memory-efficient computation

streaming_kernel

string_kernels

String Kernel Approximations

structured_random_features

Structured orthogonal random features for efficient kernel approximation

tensor_polynomial

Tensor product polynomial features for multi-dimensional feature interactions

time_series_kernels

Time series kernel approximations

type_safe_kernels

Type-safe kernel approximations with phantom types and const generics

type_safety

Type Safety Enhancements for Kernel Approximation Methods

unsafe_optimizations

Performance-critical unsafe optimizations

validation

Advanced Validation Framework for Kernel Approximation Methods

Macros

validated_kernel_approximation

Macro for easy creation of validated kernel approximations