Crate sklears_svm 

Support Vector Machines for classification and regression

This module provides Support Vector Machine implementations including:

• SVC: Support Vector Classification
• SVR: Support Vector Regression
• LinearSVC: Linear Support Vector Classification (coordinate descent)
• LinearSVR: Linear Support Vector Regression (coordinate descent)
• SGDClassifier: Stochastic Gradient Descent SVM for large-scale learning
• NuSVC: Nu Support Vector Classification with automatic parameter selection
• NuSVR: Nu Support Vector Regression
• LSSVM: Least Squares Support Vector Machine for efficient training
• RobustSVM: Robust SVM with Huber and other robust loss functions
• OutlierResistantSVM: Outlier-resistant SVM with automatic outlier detection and handling
• FuzzySVM: Fuzzy SVM for handling noisy and uncertain data
• RankingSVM: Ranking SVM for learning-to-rank and structured output problems
• OrdinalRegressionSVM: Ordinal regression SVM for ordered categorical targets
• BinaryRelevanceSVM: Multi-label SVM using binary relevance strategy
• ClassifierChainsSVM: Multi-label SVM using classifier chains
• LabelPowersetSVM: Multi-label SVM using label powerset transformation
• StructuredSVM: Structured SVM for sequence labeling and structured prediction
• MetricLearningSVM: Metric learning SVM for learning optimal distance metrics
• TransductiveSVM: Transductive SVM for semi-supervised learning with unlabeled data
• SelfTrainingSVM: Self-training SVM for iterative semi-supervised learning
• CoTrainingSVM: Co-training SVM using multiple views for semi-supervised learning
• KernelPCA: Kernel Principal Component Analysis for dimensionality reduction
• OnlineSVM: Online learning for streaming data
• OutOfCoreSVM: Out-of-core training for datasets larger than memory
• DistributedSVM: Distributed training across multiple processes/machines
• AdaptiveSVM: Adaptive regularization with automatic parameter selection
• ADMMSVM: Alternating Direction Method of Multipliers for distributed optimization
• NewtonSVM: Newton methods for fast second-order optimization
• GridSearchCV: Grid search for hyperparameter optimization
• RandomSearchCV: Random search for hyperparameter optimization
• BayesianOptimizationCV: Bayesian optimization for efficient hyperparameter tuning
• Various kernel functions (Linear, RBF, Polynomial, Graph kernels, etc.)
• SMO algorithm for training

Re-exports

pub use errors::ErrorSeverity;

pub use errors::SVMError;

pub use errors::SVMResult;

pub use hyperparameter_optimization::BayesianOptimizationCV;

pub use hyperparameter_optimization::EvolutionaryOptimizationCV;

pub use hyperparameter_optimization::GridSearchCV;

pub use hyperparameter_optimization::OptimizationConfig;

pub use hyperparameter_optimization::OptimizationResult;

pub use hyperparameter_optimization::ParameterSet;

pub use hyperparameter_optimization::ParameterSpec;

pub use hyperparameter_optimization::RandomSearchCV;

pub use hyperparameter_optimization::ScoringMetric;

pub use hyperparameter_optimization::SearchSpace;

pub use adaptive_regularization::*;

pub use calibration::*;

pub use chunked_processing::*;

pub use compressed_kernels::*;

pub use computer_vision_kernels::*;

pub use crammer_singer::*;

pub use decomposition::*;

pub use distributed_svm::*;

pub use dual_coordinate_ascent::*;

pub use fuzzy_svm::*;

pub use gpu_kernels::*;

pub use graph_semi_supervised::*;

pub use group_lasso_svm::*;

pub use kernel_pca::*;

pub use kernels::*;

pub use linear_svc::*;

pub use linear_svr::*;

pub use ls_svm::*;

pub use memory_mapped_kernels::*;

pub use metric_learning_svm::*;

pub use multi_label_svm::*;

pub use multiclass::*;

pub use nusvc::*;

pub use nusvr::*;

pub use online_svm::*;

pub use ordinal_regression_svm::*;

pub use out_of_core_svm::*;

pub use outlier_resistant_svm::*;

pub use parallel_smo::*;

pub use primal_dual_methods::*;

pub use ranking_svm::*;

pub use regularization_path::*;

pub use robust_svm::*;

pub use sgd_svm::*;

pub use simd_kernels::*;

pub use smo::*;

pub use sparse_svm::*;

pub use structured_svm::*;

pub use svc::*;

pub use svr::*;

pub use text_classification::*;

pub use thread_safe_cache::*;

pub use time_series::*;

pub use topic_model_integration::*;

pub use visualization::*;

Modules

adaptive_regularization

Adaptive Regularization Methods for SVMs

array_views

Zero-copy array views utilities

calibration

Probability calibration methods for SVM classifiers

chunked_processing

Chunked processing for large-scale SVM training

compressed_kernels

Compressed kernel representations for memory-efficient SVM training

computer_vision_kernels

Computer Vision Kernels for SVM

crammer_singer

Crammer-Singer multi-class SVM implementation

dataset_ops

Dataset operations with zero-copy semantics

decomposition

Decomposition methods for large-scale SVM optimization

distributed_svm

Distributed Support Vector Machine Training

dual_coordinate_ascent

Dual Coordinate Ascent algorithm for large-scale SVM training

errors

Comprehensive Error Types for SVM Operations

fuzzy_svm

Fuzzy Support Vector Machines for handling noisy and uncertain data

gpu_kernels

GPU-accelerated kernel computations using WGPU

graph_semi_supervised

Graph-based Semi-supervised Support Vector Machines

group_lasso_svm

Group Lasso Support Vector Machine for feature selection

hyperparameter_optimization

Hyperparameter optimization for SVM algorithms

kernel_pca

Kernel Principal Component Analysis (Kernel PCA) for non-linear dimensionality reduction

kernels

Kernel functions for Support Vector Machines

linear_svc

Linear Support Vector Classification using coordinate descent

linear_svr

Linear Support Vector Regression using coordinate descent

ls_svm

Least Squares Support Vector Machines (LS-SVM)

memory_mapped_kernels

Memory-mapped kernel matrices for large-scale SVM training

metric_learning_svm

Metric Learning Support Vector Machines

multi_label_svm

Multi-Label Support Vector Machines

multiclass

Multi-class SVM classification using One-vs-Rest and One-vs-One strategies

nusvc

Nu Support Vector Classification

nusvr

Nu Support Vector Regression

online_svm

Online SVM algorithms for streaming data and incremental learning

ordinal_regression_svm

Ordinal Regression Support Vector Machines

out_of_core_svm

Out-of-Core Support Vector Machine Training

outlier_resistant_svm

Outlier-Resistant Support Vector Machines

parallel_smo

Parallel Sequential Minimal Optimization (SMO) algorithm for SVM training

primal_dual_methods

Primal-Dual Methods for SVM Optimization

ranking_svm

Ranking Support Vector Machines for Learning-to-Rank

regularization_path

Regularization Path Algorithms for SVM

robust_svm

Robust Support Vector Machines with robust loss functions

sgd_svm

Stochastic Gradient Descent SVM implementations for large-scale learning

simd_kernels

SIMD-optimized kernel functions for enhanced performance

smo

Sequential Minimal Optimization (SMO) algorithm for SVM training

sparse_svm

Sparse Support Vector Machine with L1 regularization

structured_svm

Structured Support Vector Machines

svc

Support Vector Classification (SVC) implementation

svr

Support Vector Regression (SVR) implementation

text_classification

Text classification specific kernels and utilities for SVM

thread_safe_cache

Thread-safe kernel caching for parallel SVM processing

time_series

Time series kernels and utilities for SVM

topic_model_integration

Topic Model Integration for Text Classification SVM

validation_ml

ML-specific validation functions

visualization

Support Vector Machine Visualization Tools

Macros

error_context

Macro for adding location context automatically

Structs

AccuracyComparison

Accuracy comparison between sklears and reference implementation

AdvancedParallelEnsemble

Advanced parallel ensemble trainer

AlertConfig

Alert configuration

AlgorithmBenchmark

Algorithm benchmark definition

AlgorithmicCriteria

Algorithmic correctness criteria

AnalysisResult

Result from a performance analyzer

ApiVersionInfo

Information about API versions and compatibility

ArrayPool

Memory pool for efficient array allocation

ArrayStats

Advanced array statistics with optimized implementations

AutocompleteTrie

AutomatedBenchmarkRunner

Benchmark runner for automated CI/CD integration

BaseEstimatorConfig

Configuration for base estimators

BenchmarkConfig

Configuration for benchmark execution

BenchmarkResults

Results from running all benchmarks

BenchmarkRunResult

Result from a single benchmark run

BenchmarkSuite

Benchmark suite for running multiple algorithm comparisons

CICoverageResult

CI/CD coverage check result

CIDConfig

Configuration for CI/CD coverage checks

CodeFormatter

Main formatter for checking code quality

CodeQualityCriteria

Code quality criteria

CompilationImpact

ContributionChecker

Main contribution checker and validator

ContributionConfig

Configuration for contribution checking

ContributionResult

Result of contribution check

ContributionWorkflow

Contribution workflow helper

CoverageCI

CI/CD specific coverage functionality

CoverageCollector

Main code coverage collector and analyzer

CoverageConfig

Configuration for coverage collection and analysis

CoverageReport

Comprehensive coverage analysis report

CowDataset

Zero-copy features and target pair

CrossPlatformModel

Cross-platform model exchange format

CsvOptions

CSV-specific options

DataFrame

Pandas-compatible DataFrame structure

Dataset

A simple dataset structure for machine learning operations

DependencyAnalysis

DependencyAnalyzer

DependencyAudit

Main dependency audit system

DependencyInfo

Information about a dependency

DependencyRecommendation

Recommendation for dependency optimization

DependencyReport

Comprehensive dependency audit report

DistributedEnsemble

Distributed ensemble training (placeholder for future implementation)

DocumentFormatter

Document formatter for converting API references to various output formats

DocumentationCriteria

Documentation criteria

EnsembleConfig

Configuration for ensemble methods

EnsembleParallelConfig

Parallel training configuration

ErrorChain

Chain multiple errors together for better debugging

ExampleGenerator

ExampleValidator

Example validator for checking and validating code examples

ExplorerConfig

Configuration for the trait explorer with comprehensive options

FeatureCount

Type-safe feature count

FittedScikitLearnModel

Fitted scikit-learn compatible model

FormatDetector

Format detection utilities

FormatOptions

Format-specific options container

FormatReader

Generic format reader interface

FormatWriter

Generic format writer interface

FormattingConfig

Configuration for code formatting checks

FormattingConfigBuilder

Builder for creating formatting configurations

FormattingIssue

Individual formatting issue

FormattingReport

Result of formatting checks

GateResult

Result of individual quality gate

Hdf5Options

HDF5-specific options

InputSanitizer

Input sanitizer with configurable policies

JsonOptions

JSON-specific options

LearningPath

LinearRegressionConfig

Example validated configuration for linear regression

LinearRegressionConfigBuilder

Builder for LinearRegressionConfig with compile-time validation

LiveCodeRunner

Live code execution engine for interactive examples

MLFormattingRules

ML-specific formatting rules

MatrixOps

Advanced matrix operations with optimizations

MemoryFootprint

MemoryOps

Memory-efficient operations for large arrays

MemoryPoolStats

Statistics for memory pool usage

MemorySafety

Memory safety documentation and validation utilities

MemorySafetyGuarantee

Memory safety guarantee documentation

MemoryStatistics

Memory usage statistics

MockConfig

Configuration for mock estimator behavior

MockEnsemble

Mock ensemble for testing ensemble methods

MockEstimator

Mock estimator with configurable behavior for testing

MockEstimatorBuilder

Builder for configuring mock estimators

MockStateSnapshot

Snapshot of mock state for testing

MockTransformConfig

Configuration for mock transformer

MockTransformer

Mock transformer for testing transformation pipelines

MockTransformerBuilder

Builder for mock transformers

ModularApiReference

Complete API reference for a crate

ModularApiReferenceGenerator

Main API reference generator with comprehensive formatting capabilities

ModularCodeExample

Code example extracted from documentation

ModularCrossReferenceBuilder

Cross-reference builder for linking API elements

ModularGeneratorConfig

Configuration for the API reference generator

ModularTraitAnalyzer

Trait analyzer for extracting trait information from Rust code

ModularTraitInfo

Information about a trait

ModularTypeExtractor

Type extractor for analyzing type definitions from Rust code

ModularTypeInfo

Information about a type

NumpyArray

NumPy-compatible array wrapper

NumpyOptions

NumPy-specific options

ParallelConfig

Configuration for parallel operations

ParallelCrossValidator

Cross-validation utilities with parallel execution

ParallelEnsembleOps

Parallel ensemble operations

ParallelMatrixOps

Parallel matrix operations

ParquetOptions

Parquet-specific options

PerformanceAnalysis

PerformanceCriteria

Performance criteria

PerformanceReport

Complete performance report

PerformanceReporter

Main performance reporting and analysis system

PositiveValidator

Positive number validator

Probability

Type-safe probability value constrained to [0, 1]

ProbabilityValidator

Probability validator (0.0 to 1.0)

ProgressTracker

PublicApiConfig

Configuration for public APIs

PublicApiConfigBuilder

Builder for public API configuration

QualityGate

Quality gate definition

QualityGatesResult

Quality gates evaluation result

RangeValidator

Compile-time range validator

ReportConfig

Configuration for performance reporting

ReviewCriteria

Review criteria for contributions

RuntimeOverhead

SafeMemoryPool

Safe memory pool for efficient allocation with automatic cleanup

SafePooledBuffer

Safe pooled buffer with automatic return to pool on drop

SafePtr

Safe pointer wrapper that prevents raw pointer dereference

SafeSharedModel

Thread-safe reference counting for shared machine learning models

SafetyRecommendation

Safety improvement recommendation

SampleCount

Type-safe sample count

SanitizationConfig

Configuration for input sanitization

ScikitLearnModel

Generic scikit-learn compatible model wrapper

SearchQuery

SearchResult

SemanticSearchEngine

SimilarTrait

StreamingReader

Streaming reader for large datasets

TensorMetadata

PyTorch-compatible tensor metadata

TestingCriteria

Testing criteria

TimingStatistics

Timing statistics for benchmark runs

TrainedMockEstimator

Trained mock estimator

TrainedParallelEnsemble

Trained parallel ensemble

TrainingState

Training state tracking

TraitExplorationResult

Result of trait exploration analysis

TraitExplorer

Main trait explorer for analyzing trait relationships and usage

TraitGraph

TraitGraphEdge

TraitGraphGenerator

TraitGraphMetadata

TraitGraphNode

TraitPerformanceAnalyzer

TraitRegistry

Registry for managing trait information and relationships.

Tutorial

TutorialBuilder

TutorialSystem

UIComponentBuilder

UI component builder for interactive elements

UnsafeAuditConfig

Configuration for unsafe code auditing

UnsafeAuditReport

Result of unsafe code audit

UnsafeAuditor

Main unsafe code auditor

UnsafeFinding

Individual unsafe code finding

UnsafePattern

Pattern for safe unsafe code usage

UnsafeValidationResult

Result of unsafe code validation

UsageExample

ValidatedConfig

Configuration wrapper that tracks validation state at compile time

ValidationConfig

Validation configuration for code examples

ValidationContext

Validation context for providing better error messages

ValidationRules

Container for multiple validation rules

WasmPlaygroundManager

WebAssembly playground manager for browser-based code execution

WorkflowStep

Individual workflow step

ZeroCopyDataset

Zero-copy features and target pair

Enums

AggregationMethod

Methods for aggregating predictions

AlgorithmType

Types of machine learning algorithms

AnalysisType

Different types of performance analysis

ApiStability

API stability classification

BaseEstimatorType

Types of base estimators

BenchmarkDataset

Dataset for benchmarking

BinarySizeImpact

Relative impact on binary size

ClippyLevel

Clippy compliance levels

CompileTimeImpact

Relative impact on compile time

CoverageTool

Supported coverage tools

DataFormat

Supported data formats for reading and writing

DataValue

Value types supported in DataFrame

DependencyCategory

Classification of dependency importance and usage

EdgeType

EnsembleType

Types of ensemble methods

ExampleCategory

ExampleDifficulty

GraphExportFormat

Export formats for graph visualizations

HealthStatus

Overall health status

IssueSeverity

Severity level of formatting issues

MockBehavior

Different mock behavior patterns

MockErrorType

Types of errors that can be simulated

MockTransformType

Types of transformations to simulate

ModelFormat

Model format types

ModularOutputFormat

Supported output formats for API documentation

NodeRole

Node roles in distributed training

OutputFormat

Output format options for reports

ParamValue

Parameter value type for scikit-learn compatibility

QualityGateType

Types of quality gates

RecommendationAction

Types of recommendations

RecommendationPriority

Recommendation priority levels

RegressionThreshold

Thresholds for detecting performance regressions

SafetyIssue

Types of safety issues that can be found in input data

SafetySeverity

Severity of safety concerns

SamplingStrategy

Sampling strategies for training data

SklearsError

Main error type for sklears

TimeRange

Time range for historical analysis

TraitNodeType

TrendDirection

Performance trend direction

UnsafeType

Type of unsafe operation

ValidationRule

Validation attributes for ML parameter constraints

VotingStrategy

Voting strategies for mock ensemble

ZeroCopyArray

Zero-copy array wrapper that can hold either owned or borrowed data

Traits

BaseEstimator

Trait for base estimators in ensembles

CompileTimeValidated

Trait for algorithms that support compile-time configuration validation

ConfigValidation

Configuration validation for complete ML algorithms

DimensionValidator

Trait for dimension validation at compile time

ErrorContext

Enhanced error context trait for better error propagation

Estimator

Base trait for all estimators with enhanced type safety

ExperimentalApi

Marker trait for experimental APIs

Fit

Enhanced trait for models that can be fitted to data

FitPredict

Trait for models that can be fitted and used for prediction in one step

FitTransform

Trait for transformers that can be fitted and transform in one step

FloatBounds

Floating point trait bounds for machine learning operations with enhanced constraints

IntBounds

Integer trait bounds for machine learning operations

ModelSerialization

Generic model serialization interface

Numeric

Core numeric trait bounds for machine learning operations with SIMD support

ParallelCrossValidation

Trait for parallel cross-validation

ParallelEnsemble

Trait for parallel ensemble operations

ParallelFit

Trait for parallel fitting operations

ParallelPredict

Trait for parallel prediction operations

ParallelTransform

Trait for parallel transformation operations

ParameterValidator

Trait for compile-time parameter validation

PartialFit

Trait for models that support incremental/online learning

PerformanceAnalyzer

Generic trait for performance analyzers

Predict

Enhanced trait for models that can make predictions

SafeArrayOps

Safe array operations trait

Sanitize

Trait for sanitizing input data

SklearnCompatible

Trait for scikit-learn API compatibility

SolverCompatibility

Trait for solver compatibility validation

StableApi

Marker trait for stable APIs

TrainedBaseModel

Trait for trained base models

Transform

Trait for models that can transform data

Validate

Core validation trait that can be derived for automatic parameter validation

ZeroCopy

Trait for zero-copy conversion

Functions

api_version_info

Get current API version information

calculate_metrics

Calculate dependency tree metrics

generate_dependency_graph

Generate dependency visualization (simplified DOT format)

is_api_experimental

Check if an API is experimental

is_api_stable

Check if an API is stable

is_ml_data_safe

Quick safety check for ML data

load_iris

Load the classic Iris dataset (subset for testing)

make_blobs

Generate synthetic classification dataset with Gaussian clusters

make_regression

Generate synthetic regression dataset

ndarray_to_pytorch_tensor

Convert ndarray to PyTorch tensor format

sanitize_ml_data

Convenience functions for quick sanitization Sanitize machine learning input data

Type Aliases

Array1

1-dimensional array type alias

Array2

2-dimensional array type alias

ArrayView1

1-dimensional array view type alias

ArrayView2

2-dimensional array view type alias

ArrayViewMut1

1-dimensional mutable array view type alias

ArrayViewMut2

2-dimensional mutable array view type alias

CowFeatures

Copy-on-write (Cow) variants for efficient memory usage Copy-on-write features matrix

CowLabels

Copy-on-write labels vector

CowPredictions

Copy-on-write predictions vector

CowProbabilities

Copy-on-write probabilities matrix

CowSampleWeight

Copy-on-write sample weights vector

CowTarget

Copy-on-write target vector

Distances

Distance matrix type (n_samples x n_samples)

Features

Domain-specific type aliases for machine learning Feature matrix type (n_samples x n_features)

Float

Default floating point type for the library

Int

Default integer type for the library

Labels

Labels vector type (n_samples,)

Predictions

Predictions vector type (n_samples,)

Probabilities

Probability matrix type (n_samples x n_classes)

Result

Result type alias for sklears operations

SampleWeight

Sample weights type (n_samples,)

Similarities

Similarity matrix type (n_samples x n_samples)

Target

Target vector type (n_samples,)

ZeroCopyFeatures

ZeroCopyTarget