Crate sklears_discriminant_analysis 

Linear and Quadratic Discriminant Analysis

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

Re-exports

pub use adaptive_discriminant::AdaptationEvent;

pub use adaptive_discriminant::AdaptationStrategy;

pub use adaptive_discriminant::AdaptiveDiscriminantLearning;

pub use adaptive_discriminant::AdaptiveDiscriminantLearningConfig;

pub use adaptive_discriminant::BaseDiscriminant;

pub use adaptive_discriminant::TrainedAdaptiveDiscriminantLearning;

pub use bayesian_discriminant::BayesianDiscriminantAnalysis;

pub use bayesian_discriminant::BayesianDiscriminantAnalysisConfig;

pub use bayesian_discriminant::InferenceMethod;

pub use bayesian_discriminant::PosteriorParameters;

pub use bayesian_discriminant::PriorType;

pub use bayesian_discriminant::TrainedBayesianDiscriminantAnalysis;

pub use canonical_discriminant::CanonicalDiscriminantAnalysis;

pub use canonical_discriminant::CanonicalDiscriminantAnalysisConfig;

pub use canonical_discriminant::TrainedCanonicalDiscriminantAnalysis;

pub use cost_sensitive_discriminant_analysis::CostMatrix;

pub use cost_sensitive_discriminant_analysis::CostSensitiveDiscriminantAnalysis;

pub use cost_sensitive_discriminant_analysis::CostSensitiveDiscriminantAnalysisConfig;

pub use cost_sensitive_discriminant_analysis::CostSensitiveMethod;

pub use cost_sensitive_discriminant_analysis::SimpleDiscriminantModel;

pub use cost_sensitive_discriminant_analysis::TrainedCostSensitiveDiscriminantAnalysis;

pub use cross_modal_discriminant::CrossModalDiscriminantLearningConfig;

pub use cross_modal_discriminant::DomainAdaptationStrategy;

pub use cross_modal_discriminant::DomainInfo;

pub use cross_modal_discriminant::ModalityInfo;

pub use cross_validation::BootstrapConfig;

pub use cross_validation::BootstrapResults;

pub use cross_validation::BootstrapValidator;

pub use cross_validation::CrossValidationConfig;

pub use cross_validation::CrossValidationResults;

pub use cross_validation::GridSearchLDA;

pub use cross_validation::GridSearchQDA;

pub use cross_validation::NestedCVConfig;

pub use cross_validation::NestedCVResults;

pub use cross_validation::NestedCrossValidator;

pub use cross_validation::ParameterGrid;

pub use cross_validation::TemporalValidationConfig;

pub use cross_validation::TemporalValidator;

pub use cross_validation::ValidationMetrics;

pub use deep_discriminant::AttentionConfig;

pub use deep_discriminant::DeepArchitecture;

pub use deep_discriminant::DeepDiscriminantLearning;

pub use deep_discriminant::DeepDiscriminantLearningConfig;

pub use deep_discriminant::DeepLayer;

pub use deep_discriminant::DeepTrainingConfig;

pub use deep_discriminant::LayerType;

pub use deep_discriminant::NormalizationType;

pub use deep_discriminant::TrainedDeepDiscriminantLearning;

pub use diagonal_lda::DiagonalLinearDiscriminantAnalysis;

pub use diagonal_lda::DiagonalLinearDiscriminantAnalysisConfig;

pub use diagonal_lda::TrainedDiagonalLinearDiscriminantAnalysis;

pub use discriminant_locality_alignment::DiscriminantLocalityAlignment;

pub use discriminant_locality_alignment::DiscriminantLocalityAlignmentConfig;

pub use distributed_discriminant::DistributedDiscriminantConfig;

pub use distributed_discriminant::DistributedLinearDiscriminantAnalysis;

pub use distributed_discriminant::DistributedQuadraticDiscriminantAnalysis;

pub use distributed_discriminant::MergeStrategy;

pub use ensemble_imbalanced::BaseClassifier;

pub use ensemble_imbalanced::EnsembleImbalancedConfig;

pub use ensemble_imbalanced::EnsembleImbalancedDiscriminantAnalysis;

pub use ensemble_imbalanced::EnsembleMethod;

pub use ensemble_imbalanced::SamplingStrategy;

pub use ensemble_imbalanced::TrainedEnsembleImbalancedDiscriminantAnalysis;

pub use ensemble_imbalanced::VotingMethod;

pub use error_correcting_output_codes::ErrorCorrectingOutputCodes;

pub use error_correcting_output_codes::ErrorCorrectingOutputCodesConfig;

pub use error_correcting_output_codes::TrainedErrorCorrectingOutputCodes;

pub use feature_ranking::DiscriminantFeatureRanking;

pub use feature_ranking::DiscriminantFeatureRankingConfig;

pub use feature_ranking::FeatureRank;

pub use heteroscedastic::HeteroscedasticDiscriminantAnalysis;

pub use heteroscedastic::HeteroscedasticDiscriminantAnalysisConfig;

pub use hierarchical::HierarchicalDiscriminantAnalysis;

pub use hierarchical::HierarchicalDiscriminantAnalysisConfig;

pub use hierarchical::HierarchyTree;

pub use hierarchical::TrainedHierarchicalDiscriminantAnalysis;

pub use information_theoretic::DiscretizationMethod;

pub use information_theoretic::InformationCriterion;

pub use information_theoretic::InformationTheoreticDiscriminantAnalysis;

pub use information_theoretic::InformationTheoreticDiscriminantAnalysisConfig;

pub use kernel_discriminant::KernelCVConfig;

pub use kernel_discriminant::KernelDiscriminantAnalysis;

pub use kernel_discriminant::KernelDiscriminantAnalysisConfig;

pub use kernel_discriminant::KernelOptimizationResults;

pub use kernel_discriminant::KernelParameterGrid;

pub use kernel_discriminant::KernelParameterOptimizer;

pub use kernel_discriminant::KernelType;

pub use kernel_discriminant::TrainedKernelDiscriminantAnalysis;

pub use lda::LinearDiscriminantAnalysis;

pub use lda::LinearDiscriminantAnalysisConfig;

pub use locality_preserving::LocalityPreservingDiscriminantAnalysis;

pub use locality_preserving::LocalityPreservingDiscriminantAnalysisConfig;

pub use locally_linear_discriminant::LocallyLinearDiscriminantAnalysis;

pub use locally_linear_discriminant::LocallyLinearDiscriminantAnalysisConfig;

pub use locally_linear_discriminant::TrainedLocallyLinearDiscriminantAnalysis;

pub use manifold_discriminant::ManifoldDiscriminantAnalysis;

pub use manifold_discriminant::ManifoldDiscriminantAnalysisConfig;

pub use manifold_discriminant::TrainedManifoldDiscriminantAnalysis;

pub use marginal_fisher::MarginalFisherAnalysis;

pub use marginal_fisher::MarginalFisherAnalysisConfig;

pub use minimum_volume_ellipsoid::MinimumVolumeEllipsoidConfig;

pub use minimum_volume_ellipsoid::MinimumVolumeEllipsoidDiscriminantAnalysis;

pub use minimum_volume_ellipsoid::TrainedMinimumVolumeEllipsoidDiscriminantAnalysis;

pub use mixture::MixtureDiscriminantAnalysis;

pub use mixture::MixtureDiscriminantAnalysisConfig;

pub use mixture_experts::ExpertType;

pub use mixture_experts::GatingNetworkType;

pub use mixture_experts::MixtureOfExpertsConfig;

pub use mixture_experts::MixtureOfExpertsDiscriminantAnalysis;

pub use mixture_experts::TrainedMixtureOfExpertsDiscriminantAnalysis;

pub use multi_task::MultiTaskDiscriminantLearning;

pub use multi_task::MultiTaskDiscriminantLearningConfig;

pub use multi_task::Task;

pub use multi_task::TaskClassifier;

pub use multi_task::TrainedMultiTaskDiscriminantLearning;

pub use multi_view_discriminant::FusionStrategy;

pub use multi_view_discriminant::MultiViewDiscriminantAnalysis;

pub use multi_view_discriminant::MultiViewDiscriminantAnalysisConfig;

pub use multi_view_discriminant::ViewInfo;

pub use nearest_shrunken_centroids::NearestShrunkenCentroids;

pub use nearest_shrunken_centroids::NearestShrunkenCentroidsConfig;

pub use nearest_shrunken_centroids::TrainedNearestShrunkenCentroids;

pub use neural_discriminant::ActivationFunction;

pub use neural_discriminant::NetworkArchitecture;

pub use neural_discriminant::NeuralDiscriminantAnalysis;

pub use neural_discriminant::NeuralDiscriminantAnalysisConfig;

pub use neural_discriminant::NeuralLayer;

pub use neural_discriminant::NeuralTrainingConfig;

pub use neural_discriminant::TrainedNeuralDiscriminantAnalysis;

pub use numerical_stability::ConditionMonitor;

pub use numerical_stability::ConditionStatistics;

pub use numerical_stability::MatrixAnalysis;

pub use numerical_stability::NumericalConfig;

pub use numerical_stability::NumericalStability;

pub use one_vs_one::OneVsOneDiscriminantAnalysis;

pub use one_vs_one::OneVsOneDiscriminantAnalysisConfig;

pub use one_vs_one::PairwiseClassifier;

pub use one_vs_rest::BinaryClassifier;

pub use one_vs_rest::OneVsRestDiscriminantAnalysis;

pub use one_vs_rest::OneVsRestDiscriminantAnalysisConfig;

pub use online_discriminant::OnlineDiscriminantAnalysis;

pub use online_discriminant::OnlineDiscriminantAnalysisConfig;

pub use online_discriminant::TrainedOnlineDiscriminantAnalysis;

pub use online_discriminant::UpdateStrategy;

pub use out_of_core::OutOfCoreConfig;

pub use out_of_core::OutOfCoreDataManager;

pub use out_of_core::OutOfCoreLDA;

pub use out_of_core::OutOfCoreQDA;

pub use out_of_core::StreamingDiscriminant;

pub use parallel_eigen::ParallelEigen;

pub use parallel_eigen::ParallelEigenConfig;

pub use parallel_eigen::ParallelEigenDecomposition;

pub use penalized_discriminant_analysis::PenalizedDiscriminantAnalysis;

pub use penalized_discriminant_analysis::PenalizedDiscriminantAnalysisConfig;

pub use penalized_discriminant_analysis::PenaltyType;

pub use penalized_discriminant_analysis::TrainedPenalizedDiscriminantAnalysis;

pub use qda::QuadraticDiscriminantAnalysis;

pub use qda::QuadraticDiscriminantAnalysisConfig;

pub use random_projection_discriminant_analysis::DiscriminantModel;

pub use random_projection_discriminant_analysis::LDAModel;

pub use random_projection_discriminant_analysis::ProjectionType;

pub use random_projection_discriminant_analysis::QDAModel;

pub use random_projection_discriminant_analysis::RDAModel;

pub use random_projection_discriminant_analysis::RandomProjectionDiscriminantAnalysis;

pub use random_projection_discriminant_analysis::RandomProjectionDiscriminantAnalysisConfig;

pub use random_projection_discriminant_analysis::TrainedRandomProjectionDiscriminantAnalysis;

pub use recursive_feature_elimination::EliminationStep;

pub use recursive_feature_elimination::RecursiveFeatureElimination;

pub use recursive_feature_elimination::RecursiveFeatureEliminationConfig;

pub use recursive_feature_elimination::TrainedRecursiveFeatureElimination;

pub use robust_adaptive::MEstimatorType;

pub use robust_adaptive::RobustDiscriminantAnalysis;

pub use robust_adaptive::RobustDiscriminantAnalysisConfig;

pub use robust_adaptive::TrainedRobustDiscriminantAnalysis;

pub use sequential_feature_selection::SelectionDirection;

pub use sequential_feature_selection::SelectionStep;

pub use sequential_feature_selection::SequentialFeatureSelection;

pub use sequential_feature_selection::SequentialFeatureSelectionConfig;

pub use sequential_feature_selection::TrainedSequentialFeatureSelection;

pub use simd_optimizations::AdvancedSimdOps;

pub use simd_optimizations::SimdArrayOps;

pub use simd_optimizations::SimdBenchmarkResults;

pub use simd_optimizations::SimdConfig;

pub use simd_optimizations::SimdMatrixOps;

pub use simd_optimizations::SimdSupport;

pub use stability_selection::FeatureStability;

pub use stability_selection::StabilitySelection;

pub use stability_selection::StabilitySelectionConfig;

pub use stability_selection::TrainedStabilitySelection;

pub use stochastic_discriminant::LearningRateSchedule;

pub use stochastic_discriminant::LossFunction;

pub use stochastic_discriminant::Optimizer;

pub use stochastic_discriminant::StochasticDiscriminantAnalysis;

pub use stochastic_discriminant::StochasticDiscriminantAnalysisConfig;

pub use stochastic_discriminant::TrainedStochasticDiscriminantAnalysis;

pub use sure_independence_screening::BaseDiscriminantModel;

pub use sure_independence_screening::SimpleLDA;

pub use sure_independence_screening::SureIndependenceScreening;

pub use sure_independence_screening::SureIndependenceScreeningConfig;

pub use sure_independence_screening::TrainedSureIndependenceScreening;

pub use temporal_discriminant::AggregationMethod;

pub use temporal_discriminant::TemporalDiscriminantAnalysis;

pub use temporal_discriminant::TemporalDiscriminantAnalysisConfig;

pub use temporal_discriminant::TemporalMethod;

pub use temporal_discriminant::TemporalPattern;

pub use temporal_discriminant::TrendMethod;

Modules

adaptive_discriminant

Adaptive Discriminant Learning

bayesian_discriminant

Bayesian Discriminant Analysis

canonical_discriminant

Canonical Discriminant Analysis

cost_sensitive_discriminant_analysis

Cost-sensitive Discriminant Analysis

cross_modal_discriminant

Cross-Modal Discriminant Learning

cross_validation

Cross-validation utilities for discriminant analysis parameter selection

deep_discriminant

Deep Discriminant Learning

diagonal_lda

Diagonal Linear Discriminant Analysis

discriminant_locality_alignment

Discriminant Locality Alignment implementation

distributed_discriminant

Distributed Discriminant Analysis

ensemble_imbalanced

Ensemble Methods for Imbalanced Data in Discriminant Analysis

error_correcting_output_codes

Error-Correcting Output Codes (ECOC) for Multi-Class Discriminant Analysis

feature_ranking

Discriminant Feature Ranking implementation

heteroscedastic

Heteroscedastic Discriminant Analysis implementation

hierarchical

Hierarchical Discriminant Analysis

information_theoretic

Information-Theoretic Discriminant Analysis implementation

kernel_discriminant

Kernel Discriminant Analysis

lda

Linear Discriminant Analysis (LDA) implementation

locality_preserving

Locality Preserving Discriminant Analysis implementation

locally_linear_discriminant

Locally Linear Discriminant Analysis

manifold_discriminant

Manifold-Based Discriminant Analysis

marginal_fisher

Marginal Fisher Analysis implementation

minimum_volume_ellipsoid

Minimum Volume Ellipsoid (MVE) Methods

mixture

Mixture Discriminant Analysis implementation

mixture_experts

Mixture of Experts Discriminant Analysis

multi_task

Multi-Task Discriminant Learning

multi_view_discriminant

Multi-View Discriminant Analysis

nearest_shrunken_centroids

Nearest Shrunken Centroids (NSC)

neural_discriminant

Neural Discriminant Analysis

numerical_stability

Numerical Stability Utilities

one_vs_one

One-vs-One Discriminant Analysis implementation

one_vs_rest

One-vs-Rest Discriminant Analysis implementation

online_discriminant

Online Discriminant Analysis

out_of_core

Out-of-Core Discriminant Analysis

parallel_eigen

Parallel Eigenvalue Decomposition

penalized_discriminant_analysis

Penalized Discriminant Analysis

qda

Quadratic Discriminant Analysis (QDA) implementation

random_projection_discriminant_analysis

Random Projection Discriminant Analysis

recursive_feature_elimination

Recursive Feature Elimination (RFE) for Discriminant Analysis

robust_adaptive

Robust and Adaptive Discriminant Analysis

sequential_feature_selection

Sequential Feature Selection (Forward and Backward) for Discriminant Analysis

simd_optimizations

SIMD Optimizations for Discriminant Analysis

stability_selection

Stability-Based Feature Selection

stochastic_discriminant

Stochastic Discriminant Analysis

sure_independence_screening

Sure Independence Screening for high-dimensional discriminant analysis

temporal_discriminant

Temporal Discriminant Analysis implementation