🥮 mooncakes.io

kernel-svm

Deterministic kernel SVM training and evaluation toolkit for MoonBit

svm
machine-learning
classification
kernel
smo
moon add Yuxiao-Bot/kernel-svm@0.1.0
Download zip
Version
0.1.0
License
Apache-2.0
Repository
Last updated
12 days ago
Downloads
3
README

#Yuxiao-Bot/kernel-svm

MoonBit deterministic kernel SVM classification, evaluation, diagnostics, and reporting toolkit.

See README.md for installation, examples, scope, and verification.

#
BinaryConfig

source
pub struct BinaryConfig {
  penalty_c : Double
  selected_kernel : Kernel
  iteration_limit : Int
  unchanged_pass_limit : Int
  kkt_tolerance : Double
  alpha_change_epsilon : Double
} derive(Eq, 
Debug)

Controls deterministic binary C-SVC optimization.

#
BinaryConfig::alpha_epsilon

source
fn BinaryConfig::alpha_epsilon(self : BinaryConfig) -> Double

#
BinaryConfig::c

source
fn BinaryConfig::c(self : BinaryConfig) -> Double

#
BinaryConfig::kernel

source
fn BinaryConfig::kernel(self : BinaryConfig) -> Kernel

#
BinaryConfig::max_iterations

source
fn BinaryConfig::max_iterations(self : BinaryConfig) -> Int

#
BinaryConfig::max_passes

source
fn BinaryConfig::max_passes(self : BinaryConfig) -> Int

#
BinaryConfig::tolerance

source
fn BinaryConfig::tolerance(self : BinaryConfig) -> Double

#
BinaryModel

source
pub struct BinaryModel {
  support_rows : Array[Array[Double]]
  support_class_labels : Array[Int]
  support_alpha_values : Array[Double]
  signed_coefficients : Array[Double]
  bias_value : Double
  input_columns : Int
  model_kernel : Kernel
  lower_class : Int
  upper_class : Int
  convergence_data : ConvergenceReport
} derive(Eq, 
Debug)

Stores the support-vector representation of a fitted binary C-SVC model.

#
BinaryModel::bias

source
fn BinaryModel::bias(self : BinaryModel) -> Double

#
BinaryModel::convergence

source
fn BinaryModel::convergence(self : BinaryModel) -> ConvergenceReport

#
BinaryModel::decision_value

source
fn BinaryModel::decision_value(self : BinaryModel, row : Array[Double]) -> Result[Double, SvmError]

Returns the signed decision value; positive values select the higher class.

#
BinaryModel::feature_count

source
fn BinaryModel::feature_count(self : BinaryModel) -> Int

#
BinaryModel::kernel

source
fn BinaryModel::kernel(self : BinaryModel) -> Kernel

#
BinaryModel::negative_class

source
fn BinaryModel::negative_class(self : BinaryModel) -> Int

#
BinaryModel::positive_class

source
fn BinaryModel::positive_class(self : BinaryModel) -> Int

#
BinaryModel::predict

source
fn BinaryModel::predict(self : BinaryModel, row : Array[Double]) -> Result[Int, SvmError]

#
BinaryModel::predict_batch

source
fn BinaryModel::predict_batch(self : BinaryModel, rows : Array[Array[Double]]) -> Result[Array[Int], SvmError]

#
BinaryModel::support_alphas

source
fn BinaryModel::support_alphas(self : BinaryModel) -> Array[Double]

#
BinaryModel::support_labels

source
fn BinaryModel::support_labels(self : BinaryModel) -> Array[Int]

#
BinaryModel::support_vector_count

source
fn BinaryModel::support_vector_count(self : BinaryModel) -> Int

#
BinaryModel::support_vectors

source
fn BinaryModel::support_vectors(self : BinaryModel) -> Array[Array[Double]]

#
BinaryModelDiagnostics

source
pub struct BinaryModelDiagnostics {
  retained_count : Int
  lower_class_count : Int
  upper_class_count : Int
  smallest_alpha : Double
  largest_alpha : Double
  average_alpha : Double
} derive(Eq, 
Debug)

Summarizes the retained support vectors of a binary model.

#
BinaryModelDiagnostics::maximum_alpha

source
fn BinaryModelDiagnostics::maximum_alpha(self : BinaryModelDiagnostics) -> Double

#
BinaryModelDiagnostics::mean_alpha

source
fn BinaryModelDiagnostics::mean_alpha(self : BinaryModelDiagnostics) -> Double

#
BinaryModelDiagnostics::minimum_alpha

source
fn BinaryModelDiagnostics::minimum_alpha(self : BinaryModelDiagnostics) -> Double

#
BinaryModelDiagnostics::negative_support_vectors

source
fn BinaryModelDiagnostics::negative_support_vectors(self : BinaryModelDiagnostics) -> Int

#
BinaryModelDiagnostics::positive_support_vectors

source
fn BinaryModelDiagnostics::positive_support_vectors(self : BinaryModelDiagnostics) -> Int

#
BinaryModelDiagnostics::support_vectors

source
fn BinaryModelDiagnostics::support_vectors(self : BinaryModelDiagnostics) -> Int

#
BinaryPredictionExplanation

source
pub struct BinaryPredictionExplanation {
  output_class : Int
  signed_decision_value : Double
  model_bias : Double
  ordered_contributions : Array[SupportContribution]
} derive(Eq, 
Debug)

Explains a binary decision as bias plus support-vector contributions.

#
BinaryPredictionExplanation::bias

source

#
BinaryPredictionExplanation::contributions

source

#
BinaryPredictionExplanation::decision_value

source
fn BinaryPredictionExplanation::decision_value(self : BinaryPredictionExplanation) -> Double

#
BinaryPredictionExplanation::predicted_class

source
fn BinaryPredictionExplanation::predicted_class(self : BinaryPredictionExplanation) -> Int

#
BinaryThresholdAnalysis

source
pub struct BinaryThresholdAnalysis {
  threshold_points : Array[ThresholdPoint]
  observed_positive_count : Int
  observed_negative_count : Int
  roc_area : Double
  average_precision_value : Double
} derive(Eq, 
Debug)

Stores deterministic ROC and precision-recall analysis.

#
BinaryThresholdAnalysis::average_precision

source
fn BinaryThresholdAnalysis::average_precision(self : BinaryThresholdAnalysis) -> Double

#
BinaryThresholdAnalysis::negative_count

source
fn BinaryThresholdAnalysis::negative_count(self : BinaryThresholdAnalysis) -> Int

#
BinaryThresholdAnalysis::points

source

#
BinaryThresholdAnalysis::positive_count

source
fn BinaryThresholdAnalysis::positive_count(self : BinaryThresholdAnalysis) -> Int

#
BinaryThresholdAnalysis::roc_auc

source
fn BinaryThresholdAnalysis::roc_auc(self : BinaryThresholdAnalysis) -> Double

#
CandidateEvaluation

source
pub struct CandidateEvaluation {
  original_index : Int
  evaluated_name : String
  metric_score : Double
  validation_report : ValidationReport
} derive(Eq, 
Debug)

Stores one successfully evaluated candidate.

#
CandidateEvaluation::index

source
fn CandidateEvaluation::index(self : CandidateEvaluation) -> Int

#
CandidateEvaluation::name

source
fn CandidateEvaluation::name(self : CandidateEvaluation) -> String

#
CandidateEvaluation::score

source
fn CandidateEvaluation::score(self : CandidateEvaluation) -> Double

#
CandidateEvaluation::validation

source

#
CandidateFailure

source
pub struct CandidateFailure {
  original_index : Int
  failed_name : String
  failure_error : SvmError
} derive(Eq, 
Debug)

Stores one candidate's typed evaluation failure.

#
CandidateFailure::error

source

#
CandidateFailure::index

source
fn CandidateFailure::index(self : CandidateFailure) -> Int

#
CandidateFailure::name

source
fn CandidateFailure::name(self : CandidateFailure) -> String

#
ClassMetric

source
pub struct ClassMetric {
  class_label : Int
  true_positive_count : Int
  false_positive_count : Int
  false_negative_count : Int
  class_support : Int
  precision_value : Double
  recall_value : Double
  f1_value : Double
} derive(Eq, 
Debug)

Stores one class's confusion-derived rates.

#
ClassMetric::f1

source
fn ClassMetric::f1(self : ClassMetric) -> Double

#
ClassMetric::false_negatives

source
fn ClassMetric::false_negatives(self : ClassMetric) -> Int

#
ClassMetric::false_positives

source
fn ClassMetric::false_positives(self : ClassMetric) -> Int

#
ClassMetric::label

source
fn ClassMetric::label(self : ClassMetric) -> Int

#
ClassMetric::precision

source
fn ClassMetric::precision(self : ClassMetric) -> Double

#
ClassMetric::recall

source
fn ClassMetric::recall(self : ClassMetric) -> Double

#
ClassMetric::support

source
fn ClassMetric::support(self : ClassMetric) -> Int

#
ClassMetric::true_positives

source
fn ClassMetric::true_positives(self : ClassMetric) -> Int

#
ClassProfile

source
pub struct ClassProfile {
  class_label : Int
  observation_count : Int
  observation_proportion : Double
} derive(Eq, 
Debug)

Records one sorted class label's frequency.

#
ClassProfile::count

source
fn ClassProfile::count(self : ClassProfile) -> Int

#
ClassProfile::label

source
fn ClassProfile::label(self : ClassProfile) -> Int

#
ClassProfile::proportion

source
fn ClassProfile::proportion(self : ClassProfile) -> Double

#
ClassScoreProfile

source
pub struct ClassScoreProfile {
  profiled_class : Int
  positive_observations : Int
  negative_observations : Int
  positive_score_minimum : Double
  positive_score_maximum : Double
  positive_score_mean : Double
  negative_score_minimum : Double
  negative_score_maximum : Double
  negative_score_mean : Double
  mean_score_separation : Double
} derive(Eq, 
Debug)

Summarizes one OvR classifier's scores on positive and negative rows.

#
ClassScoreProfile::class_label

source
fn ClassScoreProfile::class_label(self : ClassScoreProfile) -> Int

#
ClassScoreProfile::maximum_negative_score

source
fn ClassScoreProfile::maximum_negative_score(self : ClassScoreProfile) -> Double

#
ClassScoreProfile::maximum_positive_score

source
fn ClassScoreProfile::maximum_positive_score(self : ClassScoreProfile) -> Double

#
ClassScoreProfile::minimum_negative_score

source
fn ClassScoreProfile::minimum_negative_score(self : ClassScoreProfile) -> Double

#
ClassScoreProfile::minimum_positive_score

source
fn ClassScoreProfile::minimum_positive_score(self : ClassScoreProfile) -> Double

#
ClassScoreProfile::negative_count

source
fn ClassScoreProfile::negative_count(self : ClassScoreProfile) -> Int

#
ClassScoreProfile::negative_mean_score

source
fn ClassScoreProfile::negative_mean_score(self : ClassScoreProfile) -> Double

#
ClassScoreProfile::positive_count

source
fn ClassScoreProfile::positive_count(self : ClassScoreProfile) -> Int

#
ClassScoreProfile::positive_mean_score

source
fn ClassScoreProfile::positive_mean_score(self : ClassScoreProfile) -> Double

#
ClassScoreProfile::score_separation

source
fn ClassScoreProfile::score_separation(self : ClassScoreProfile) -> Double

#
ClassWeight

source
pub struct ClassWeight {
  weighted_label : Int
  weight_value : Double
} derive(Eq, 
Debug)

Associates a positive multiplier with one integer class label.

#
ClassWeight::label

source
fn ClassWeight::label(self : ClassWeight) -> Int

#
ClassWeight::value

source
fn ClassWeight::value(self : ClassWeight) -> Double

#
ClassificationMetrics

source
pub struct ClassificationMetrics {
  ordered_classes : Array[Int]
  confusion_counts : Array[Array[Int]]
  class_metrics : Array[ClassMetric]
  total_observations : Int
  accuracy_value : Double
  error_rate_value : Double
  balanced_accuracy_value : Double
  macro_precision_value : Double
  macro_recall_value : Double
  macro_f1_value : Double
  micro_precision_value : Double
  micro_recall_value : Double
  micro_f1_value : Double
  weighted_precision_value : Double
  weighted_recall_value : Double
  weighted_f1_value : Double
} derive(Eq, 
Debug)

Stores deterministic multiclass classification metrics.

#
ClassificationMetrics::accuracy

source
fn ClassificationMetrics::accuracy(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::balanced_accuracy

source
fn ClassificationMetrics::balanced_accuracy(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::classes

source

#
ClassificationMetrics::confusion_matrix

source
fn ClassificationMetrics::confusion_matrix(self : ClassificationMetrics) -> Array[Array[Int]]

#
ClassificationMetrics::error_rate

source
fn ClassificationMetrics::error_rate(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::macro_f1

source
fn ClassificationMetrics::macro_f1(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::macro_precision

source
fn ClassificationMetrics::macro_precision(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::macro_recall

source
fn ClassificationMetrics::macro_recall(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::micro_f1

source
fn ClassificationMetrics::micro_f1(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::micro_precision

source
fn ClassificationMetrics::micro_precision(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::micro_recall

source
fn ClassificationMetrics::micro_recall(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::observation_count

source
fn ClassificationMetrics::observation_count(self : ClassificationMetrics) -> Int

#
ClassificationMetrics::per_class

source

#
ClassificationMetrics::weighted_f1

source
fn ClassificationMetrics::weighted_f1(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::weighted_precision

source
fn ClassificationMetrics::weighted_precision(self : ClassificationMetrics) -> Double

#
ClassificationMetrics::weighted_recall

source
fn ClassificationMetrics::weighted_recall(self : ClassificationMetrics) -> Double

#
ConvergenceReport

source
pub struct ConvergenceReport {
  completed_iterations : Int
  completed_pair_updates : Int
  retained_support_vectors : Int
  largest_kkt_violation : Double
  final_dual_objective : Double
  reached_stopping_condition : Bool
} derive(Eq, 
Debug)

Records directly computed optimization evidence for a fitted binary model.

#
ConvergenceReport::converged

source
fn ConvergenceReport::converged(self : ConvergenceReport) -> Bool

#
ConvergenceReport::dual_objective

source
fn ConvergenceReport::dual_objective(self : ConvergenceReport) -> Double

#
ConvergenceReport::iterations

source
fn ConvergenceReport::iterations(self : ConvergenceReport) -> Int

#
ConvergenceReport::max_kkt_violation

source
fn ConvergenceReport::max_kkt_violation(self : ConvergenceReport) -> Double

#
ConvergenceReport::pair_updates

source
fn ConvergenceReport::pair_updates(self : ConvergenceReport) -> Int

#
ConvergenceReport::support_vectors

source
fn ConvergenceReport::support_vectors(self : ConvergenceReport) -> Int

#
Dataset

source
pub struct Dataset {
  feature_rows : Array[Array[Double]]
  class_labels : Array[Int]
  dataset_name : String
  column_count : Int
  sorted_classes : Array[Int]
} derive(Eq, 
Debug)

Stores a validated dense numeric matrix and its integer class labels.

#
Dataset::class_count

source
fn Dataset::class_count(self : Dataset, label : Int) -> Int

#
Dataset::classes

source
fn Dataset::classes(self : Dataset) -> Array[Int]

#
Dataset::feature_count

source
fn Dataset::feature_count(self : Dataset) -> Int

#
Dataset::features

source
fn Dataset::features(self : Dataset) -> Array[Array[Double]]

#
Dataset::labels

source
fn Dataset::labels(self : Dataset) -> Array[Int]

#
Dataset::name

source
fn Dataset::name(self : Dataset) -> String

#
Dataset::row

source
fn Dataset::row(self : Dataset, index : Int) -> Result[Array[Double], SvmError]

#
Dataset::row_count

source
fn Dataset::row_count(self : Dataset) -> Int

#
Dataset::subset

source
fn Dataset::subset(self : Dataset, indices : Array[Int], name : String) -> Result[Dataset, SvmError]

Selects unique rows in caller-provided order and gives the result a new name.

#
DatasetProfile

source
pub struct DatasetProfile {
  source_name : String
  source_row_count : Int
  source_feature_count : Int
  source_class_count : Int
  feature_profiles : Array[FeatureProfile]
  class_profiles : Array[ClassProfile]
  feature_centroid : Array[Double]
  smallest_squared_row_norm : Double
  largest_squared_row_norm : Double
  average_squared_row_norm : Double
} derive(Eq, 
Debug)

Stores deterministic descriptive evidence for a validated dataset.

#
DatasetProfile::centroid

source
fn DatasetProfile::centroid(self : DatasetProfile) -> Array[Double]

#
DatasetProfile::class_count

source
fn DatasetProfile::class_count(self : DatasetProfile) -> Int

#
DatasetProfile::classes

source

#
DatasetProfile::feature_count

source
fn DatasetProfile::feature_count(self : DatasetProfile) -> Int

#
DatasetProfile::features

source

#
DatasetProfile::maximum_squared_norm

source
fn DatasetProfile::maximum_squared_norm(self : DatasetProfile) -> Double

#
DatasetProfile::mean_squared_norm

source
fn DatasetProfile::mean_squared_norm(self : DatasetProfile) -> Double

#
DatasetProfile::minimum_squared_norm

source
fn DatasetProfile::minimum_squared_norm(self : DatasetProfile) -> Double

#
DatasetProfile::name

source
fn DatasetProfile::name(self : DatasetProfile) -> String

#
DatasetProfile::row_count

source
fn DatasetProfile::row_count(self : DatasetProfile) -> Int

#
FeatureImportance

source
pub struct FeatureImportance {
  source_feature_index : Int
  unpermuted_accuracy : Double
  permuted_accuracy_value : Double
  measured_accuracy_drop : Double
} derive(Eq, 
Debug)

Records the accuracy change after deterministically permuting one feature.

#
FeatureImportance::accuracy_drop

source
fn FeatureImportance::accuracy_drop(self : FeatureImportance) -> Double

#
FeatureImportance::baseline_accuracy

source
fn FeatureImportance::baseline_accuracy(self : FeatureImportance) -> Double

#
FeatureImportance::feature_index

source
fn FeatureImportance::feature_index(self : FeatureImportance) -> Int

#
FeatureImportance::permuted_accuracy

source
fn FeatureImportance::permuted_accuracy(self : FeatureImportance) -> Double

#
FeatureProfile

source
pub struct FeatureProfile {
  source_column : Int
  minimum_value : Double
  maximum_value : Double
  arithmetic_mean : Double
  population_variance : Double
  population_standard_deviation : Double
  constant_column : Bool
} derive(Eq, 
Debug)

Summarizes one dense feature column using population variance.

#
FeatureProfile::feature_index

source
fn FeatureProfile::feature_index(self : FeatureProfile) -> Int

#
FeatureProfile::is_constant

source
fn FeatureProfile::is_constant(self : FeatureProfile) -> Bool

#
FeatureProfile::maximum

source
fn FeatureProfile::maximum(self : FeatureProfile) -> Double

#
FeatureProfile::mean

source
fn FeatureProfile::mean(self : FeatureProfile) -> Double

#
FeatureProfile::minimum

source
fn FeatureProfile::minimum(self : FeatureProfile) -> Double

#
FeatureProfile::standard_deviation

source
fn FeatureProfile::standard_deviation(self : FeatureProfile) -> Double

#
FeatureProfile::variance

source
fn FeatureProfile::variance(self : FeatureProfile) -> Double

#
FeatureScaler

source
pub struct FeatureScaler {
  scaler_kind : ScalerKind
  offset_values : Array[Double]
  scale_values : Array[Double]
  constant_columns : Array[Bool]
  input_columns : Int
} derive(Eq, 
Debug)

Stores immutable per-feature parameters for reversible scaling.

#
FeatureScaler::feature_count

source
fn FeatureScaler::feature_count(self : FeatureScaler) -> Int

#
FeatureScaler::inverse_row

source
fn FeatureScaler::inverse_row(self : FeatureScaler, row : Array[Double]) -> Result[Array[Double], SvmError]

#
FeatureScaler::kind

source

#
FeatureScaler::offsets

source
fn FeatureScaler::offsets(self : FeatureScaler) -> Array[Double]

#
FeatureScaler::scales

source
fn FeatureScaler::scales(self : FeatureScaler) -> Array[Double]

#
FeatureScaler::transform_dataset

source
fn FeatureScaler::transform_dataset(self : FeatureScaler, data : Dataset, name : String) -> Result[Dataset, SvmError]

Applies fitted parameters to every row while preserving class labels.

#
FeatureScaler::transform_row

source
fn FeatureScaler::transform_row(self : FeatureScaler, row : Array[Double]) -> Result[Array[Double], SvmError]

#
FoldEvaluation

source
pub struct FoldEvaluation {
  fold_number : Int
  training_rows : Array[Int]
  testing_rows : Array[Int]
  actual_labels : Array[Int]
  predicted_labels : Array[Int]
  fold_metrics : ClassificationMetrics
  fitted_scaler : FeatureScaler?
} derive(Eq, 
Debug)

Stores complete evidence for one held-out fold.

#
FoldEvaluation::actual

source
fn FoldEvaluation::actual(self : FoldEvaluation) -> Array[Int]

#
FoldEvaluation::index

source
fn FoldEvaluation::index(self : FoldEvaluation) -> Int

#
FoldEvaluation::metrics

source

#
FoldEvaluation::predicted

source
fn FoldEvaluation::predicted(self : FoldEvaluation) -> Array[Int]

#
FoldEvaluation::scaler

source

#
FoldEvaluation::test_indices

source
fn FoldEvaluation::test_indices(self : FoldEvaluation) -> Array[Int]

#
FoldEvaluation::train_indices

source
fn FoldEvaluation::train_indices(self : FoldEvaluation) -> Array[Int]

#
Kernel

source
pub(all) enum Kernel {
  Linear
  Rbf(Double)
  Polynomial(Double, Double, Int)
} derive(Eq, 
Debug)

Selects the similarity function used by SVM training and prediction.

#
Kernel::name

source
fn Kernel::name(self : Kernel) -> String

#
KernelDiagnostics

source
pub struct KernelDiagnostics {
  matrix_entry_count : Int
  smallest_entry : Double
  largest_entry : Double
  average_entry : Double
  average_diagonal : Double
  largest_symmetry_error : Double
} derive(Eq, 
Debug)

Summarizes the numeric range and symmetry of a kernel matrix.

#
KernelDiagnostics::diagonal_mean

source
fn KernelDiagnostics::diagonal_mean(self : KernelDiagnostics) -> Double

#
KernelDiagnostics::entry_count

source
fn KernelDiagnostics::entry_count(self : KernelDiagnostics) -> Int

#
KernelDiagnostics::maximum

source
fn KernelDiagnostics::maximum(self : KernelDiagnostics) -> Double

#
KernelDiagnostics::maximum_symmetry_error

source
fn KernelDiagnostics::maximum_symmetry_error(self : KernelDiagnostics) -> Double

#
KernelDiagnostics::mean

source
fn KernelDiagnostics::mean(self : KernelDiagnostics) -> Double

#
KernelDiagnostics::minimum

source
fn KernelDiagnostics::minimum(self : KernelDiagnostics) -> Double

#
MarginDiagnostics

source
pub struct MarginDiagnostics {
  fitted_observation_count : Int
  incorrect_count : Int
  violating_count : Int
  smallest_margin : Double
  largest_margin : Double
  average_margin : Double
} derive(Eq, 
Debug)

Summarizes signed training margins for a fitted binary model.

#
MarginDiagnostics::margin_violation_count

source
fn MarginDiagnostics::margin_violation_count(self : MarginDiagnostics) -> Int

#
MarginDiagnostics::maximum_margin

source
fn MarginDiagnostics::maximum_margin(self : MarginDiagnostics) -> Double

#
MarginDiagnostics::mean_margin

source
fn MarginDiagnostics::mean_margin(self : MarginDiagnostics) -> Double

#
MarginDiagnostics::minimum_margin

source
fn MarginDiagnostics::minimum_margin(self : MarginDiagnostics) -> Double

#
MarginDiagnostics::misclassified_count

source
fn MarginDiagnostics::misclassified_count(self : MarginDiagnostics) -> Int

#
MarginDiagnostics::observation_count

source
fn MarginDiagnostics::observation_count(self : MarginDiagnostics) -> Int

#
MulticlassModel

source
pub struct MulticlassModel {
  ordered_classes : Array[Int]
  class_models : Array[BinaryModel]
  input_columns : Int
} derive(Eq, 
Debug)

Stores one binary model per sorted class for one-vs-rest prediction.

#
MulticlassModel::binary_models

source
fn MulticlassModel::binary_models(self : MulticlassModel) -> Array[BinaryModel]

#
MulticlassModel::classes

source
fn MulticlassModel::classes(self : MulticlassModel) -> Array[Int]

#
MulticlassModel::decision_values

source
fn MulticlassModel::decision_values(self : MulticlassModel, row : Array[Double]) -> Result[Array[Double], SvmError]

#
MulticlassModel::feature_count

source
fn MulticlassModel::feature_count(self : MulticlassModel) -> Int

#
MulticlassModel::model_count

source
fn MulticlassModel::model_count(self : MulticlassModel) -> Int

#
MulticlassModel::predict

source
fn MulticlassModel::predict(self : MulticlassModel, row : Array[Double]) -> Result[Int, SvmError]

Chooses the largest one-vs-rest score; exact ties retain sorted class order.

#
MulticlassModel::predict_batch

source
fn MulticlassModel::predict_batch(self : MulticlassModel, rows : Array[Array[Double]]) -> Result[Array[Int], SvmError]

#
MulticlassModelDiagnostics

source
pub struct MulticlassModelDiagnostics {
  fitted_class_count : Int
  retained_support_counts : Array[Int]
  fitted_convergence_reports : Array[ConvergenceReport]
  retained_support_total : Int
  every_model_converged : Bool
} derive(Eq, 
Debug)

Aggregates support-vector and convergence evidence for an OvR model.

#
MulticlassModelDiagnostics::all_converged

source
fn MulticlassModelDiagnostics::all_converged(self : MulticlassModelDiagnostics) -> Bool

#
MulticlassModelDiagnostics::class_count

source

#
MulticlassModelDiagnostics::convergence_reports

source

#
MulticlassModelDiagnostics::support_counts

source

#
MulticlassModelDiagnostics::total_support_vectors

source
fn MulticlassModelDiagnostics::total_support_vectors(self : MulticlassModelDiagnostics) -> Int

#
MulticlassPredictionExplanation

source
pub struct MulticlassPredictionExplanation {
  output_class : Int
  ordered_classes : Array[Int]
  ordered_scores : Array[Double]
} derive(Eq, 
Debug)

Explains an OvR prediction with class-aligned binary decision scores.

#
MulticlassPredictionExplanation::classes

source

#
MulticlassPredictionExplanation::predicted_class

source

#
MulticlassPredictionExplanation::scores

source

#
PermutationImportance

source
pub struct PermutationImportance {
  original_accuracy : Double
  ordered_importances : Array[FeatureImportance]
} derive(Eq, 
Debug)

Stores feature importances ordered by descending accuracy drop.

#
PermutationImportance::baseline_accuracy

source
fn PermutationImportance::baseline_accuracy(self : PermutationImportance) -> Double

#
PermutationImportance::feature_count

source
fn PermutationImportance::feature_count(self : PermutationImportance) -> Int

#
PermutationImportance::ranked_features

source

#
PredictionAudit

source
pub struct PredictionAudit {
  audited_observations : Array[PredictionObservation]
  audited_class_profiles : Array[ClassScoreProfile]
  audit_metrics : ClassificationMetrics
  correct_prediction_count : Int
  incorrect_prediction_count : Int
  smallest_winning_margin : Double
  largest_winning_margin : Double
  average_winning_margin : Double
} derive(Eq, 
Debug)

Aggregates row-level prediction evidence and class-score separation.

#
PredictionAudit::accuracy

source
fn PredictionAudit::accuracy(self : PredictionAudit) -> Double

#
PredictionAudit::class_score_profiles

source
fn PredictionAudit::class_score_profiles(self : PredictionAudit) -> Array[ClassScoreProfile]

#
PredictionAudit::correct_count

source
fn PredictionAudit::correct_count(self : PredictionAudit) -> Int

#
PredictionAudit::incorrect_count

source
fn PredictionAudit::incorrect_count(self : PredictionAudit) -> Int

#
PredictionAudit::maximum_winning_margin

source
fn PredictionAudit::maximum_winning_margin(self : PredictionAudit) -> Double

#
PredictionAudit::mean_winning_margin

source
fn PredictionAudit::mean_winning_margin(self : PredictionAudit) -> Double

#
PredictionAudit::metrics

source

#
PredictionAudit::minimum_winning_margin

source
fn PredictionAudit::minimum_winning_margin(self : PredictionAudit) -> Double

#
PredictionAudit::misclassified_observations

source
fn PredictionAudit::misclassified_observations(self : PredictionAudit) -> Array[PredictionObservation]

#
PredictionAudit::observation_count

source
fn PredictionAudit::observation_count(self : PredictionAudit) -> Int

#
PredictionAudit::observations

source

#
PredictionObservation

source
pub struct PredictionObservation {
  source_row_index : Int
  observed_class : Int
  selected_class : Int
  selected_score : Double
  runner_up_class : Int
  runner_up_score : Double
  selected_margin : Double
  ordered_scores : Array[Double]
  prediction_correct : Bool
} derive(Eq, 
Debug)

Stores all evidence used for one multiclass prediction.

#
PredictionObservation::actual_class

source
fn PredictionObservation::actual_class(self : PredictionObservation) -> Int

#
PredictionObservation::is_correct

source
fn PredictionObservation::is_correct(self : PredictionObservation) -> Bool

#
PredictionObservation::predicted_class

source
fn PredictionObservation::predicted_class(self : PredictionObservation) -> Int

#
PredictionObservation::row_index

source
fn PredictionObservation::row_index(self : PredictionObservation) -> Int

#
PredictionObservation::scores

source
fn PredictionObservation::scores(self : PredictionObservation) -> Array[Double]

#
PredictionObservation::second_class

source
fn PredictionObservation::second_class(self : PredictionObservation) -> Int

#
PredictionObservation::second_score

source
fn PredictionObservation::second_score(self : PredictionObservation) -> Double

#
PredictionObservation::winning_margin

source
fn PredictionObservation::winning_margin(self : PredictionObservation) -> Double

#
PredictionObservation::winning_score

source
fn PredictionObservation::winning_score(self : PredictionObservation) -> Double

#
RepeatedValidationReport

source
pub struct RepeatedValidationReport {
  round_reports : Array[ValidationReport]
  folds_per_round : Int
  accuracy_mean : Double
  accuracy_minimum : Double
  accuracy_maximum : Double
  accuracy_deviation : Double
  macro_f1_mean : Double
  macro_f1_minimum : Double
  macro_f1_maximum : Double
  macro_f1_deviation : Double
} derive(Eq, 
Debug)

Aggregates reproducible metrics across several stratified CV rounds.

#
RepeatedValidationReport::accuracy_standard_deviation

source
fn RepeatedValidationReport::accuracy_standard_deviation(self : RepeatedValidationReport) -> Double

#
RepeatedValidationReport::fold_count

source

#
RepeatedValidationReport::macro_f1_standard_deviation

source
fn RepeatedValidationReport::macro_f1_standard_deviation(self : RepeatedValidationReport) -> Double

#
RepeatedValidationReport::maximum_accuracy

source
fn RepeatedValidationReport::maximum_accuracy(self : RepeatedValidationReport) -> Double

#
RepeatedValidationReport::maximum_macro_f1

source
fn RepeatedValidationReport::maximum_macro_f1(self : RepeatedValidationReport) -> Double

#
RepeatedValidationReport::mean_accuracy

source
fn RepeatedValidationReport::mean_accuracy(self : RepeatedValidationReport) -> Double

#
RepeatedValidationReport::mean_macro_f1

source
fn RepeatedValidationReport::mean_macro_f1(self : RepeatedValidationReport) -> Double

#
RepeatedValidationReport::minimum_accuracy

source
fn RepeatedValidationReport::minimum_accuracy(self : RepeatedValidationReport) -> Double

#
RepeatedValidationReport::minimum_macro_f1

source
fn RepeatedValidationReport::minimum_macro_f1(self : RepeatedValidationReport) -> Double

#
RepeatedValidationReport::repetition_count

source
fn RepeatedValidationReport::repetition_count(self : RepeatedValidationReport) -> Int

#
RepeatedValidationReport::reports

source

#
ScalerKind

source
pub(all) enum ScalerKind {
  StandardScale
  MinMaxScale(Double, Double)
} derive(Eq, 
Debug)

Selects feature preprocessing fitted only from training observations.

#
ScalingPlan

source
pub(all) enum ScalingPlan {
  NoScaling
  StandardScaling
  MinMaxScaling(Double, Double)
} derive(Eq, 
Debug)

Selects fold-local feature preprocessing for validation.

#
SearchResult

source
pub struct SearchResult {
  successful_candidates : Array[CandidateEvaluation]
  failed_candidates : Array[CandidateFailure]
  selected_original_index : Int
  selected_name : String
  selected_score : Double
  selected_metric : SelectionMetric
  selected_validation : ValidationReport
  selected_model : MulticlassModel
  selected_scaler : FeatureScaler?
} derive(Eq, 
Debug)

Stores candidate evidence and a full-data refit of the selected workflow.

#
SearchResult::best_index

source
fn SearchResult::best_index(self : SearchResult) -> Int

#
SearchResult::best_name

source
fn SearchResult::best_name(self : SearchResult) -> String

#
SearchResult::best_score

source
fn SearchResult::best_score(self : SearchResult) -> Double

#
SearchResult::candidates

source

#
SearchResult::failures

source

#
SearchResult::metric

source

#
SearchResult::model

source

#
SearchResult::predict

source
fn SearchResult::predict(self : SearchResult, row : Array[Double]) -> Result[Int, SvmError]

#
SearchResult::scaler

source
fn SearchResult::scaler(self : SearchResult) -> FeatureScaler?

#
SearchResult::validation

source
fn SearchResult::validation(self : SearchResult) -> ValidationReport

#
SelectionMetric

source
pub(all) enum SelectionMetric {
  SelectAccuracy
  SelectBalancedAccuracy
  SelectMacroF1
  SelectWeightedF1
} derive(Eq, 
Debug)

Selects the held-out metric maximized during candidate search.

#
StratifiedFold

source
pub struct StratifiedFold {
  fold_index : Int
  training_indices : Array[Int]
  testing_indices : Array[Int]
} derive(Eq, 
Debug)

Stores one deterministic train/test index partition.

#
StratifiedFold::index

source
fn StratifiedFold::index(self : StratifiedFold) -> Int

#
StratifiedFold::test_indices

source
fn StratifiedFold::test_indices(self : StratifiedFold) -> Array[Int]

#
StratifiedFold::train_indices

source
fn StratifiedFold::train_indices(self : StratifiedFold) -> Array[Int]

#
SupportContribution

source
pub struct SupportContribution {
  retained_index : Int
  retained_row : Array[Double]
  retained_label : Int
  retained_alpha : Double
  evaluated_kernel_value : Double
  signed_decision_contribution : Double
} derive(Eq, 
Debug)

Records one support vector's signed contribution to a decision value.

#
SupportContribution::alpha

source
fn SupportContribution::alpha(self : SupportContribution) -> Double

#
SupportContribution::class_label

source
fn SupportContribution::class_label(self : SupportContribution) -> Int

#
SupportContribution::contribution

source
fn SupportContribution::contribution(self : SupportContribution) -> Double

#
SupportContribution::kernel_value

source
fn SupportContribution::kernel_value(self : SupportContribution) -> Double

#
SupportContribution::support_index

source
fn SupportContribution::support_index(self : SupportContribution) -> Int

#
SupportContribution::support_vector

source
fn SupportContribution::support_vector(self : SupportContribution) -> Array[Double]

#
SvmCandidate

source
pub struct SvmCandidate {
  candidate_name : String
  binary_configuration : BinaryConfig
  candidate_scaling : ScalingPlan
} derive(Eq, 
Debug)

Names one explicit training and preprocessing candidate.

#
SvmCandidate::config

source
fn SvmCandidate::config(self : SvmCandidate) -> BinaryConfig

#
SvmCandidate::name

source
fn SvmCandidate::name(self : SvmCandidate) -> String

#
SvmCandidate::scaling

source
fn SvmCandidate::scaling(self : SvmCandidate) -> ScalingPlan

#
SvmError

source
pub(all) enum SvmError {
  EmptyDataset
  EmptyFeatureSet
  RaggedRow(Int, Int, Int)
  LabelLengthMismatch(Int, Int)
  NonFiniteFeature(Int, Int)
  SingleClassDataset
  InvalidSubsetIndex(Int, Int)
  DuplicateSubsetIndex(Int)
  InvalidKernelParameter(String, Double)
  KernelDimensionMismatch(Int, Int)
  InvalidConfiguration(String, Double)
  InvalidIterationCount(Int)
  InvalidWeight(Int, Double)
  WeightLengthMismatch(Int, Int)
  InvalidClassWeight(Int, Double)
  DuplicateClassWeight(Int)
  ZeroEffectiveWeight
  InvalidBinaryClassCount(Int)
  PredictionDimensionMismatch(Int, Int)
  TrainingDidNotConverge(Int)
  NumericFailure(String)
  InvalidFoldCount(Int)
  InsufficientClassSamples(Int, Int, Int)
  EmptyMetricInput
  MetricLengthMismatch(Int, Int)
  UnknownClassLabel(Int)
  InvalidCandidateCount(Int)
  NoValidCandidate
  NonFiniteReportValue(String)
} derive(Eq, 
Debug)

Describes rejected data, invalid configurations, and failed SVM operations.

#
ThresholdPoint

source
pub struct ThresholdPoint {
  score_threshold : Double
  accepted_true_positives : Int
  accepted_false_positives : Int
  rejected_true_negatives : Int
  rejected_false_negatives : Int
  true_positive_rate_value : Double
  false_positive_rate_value : Double
  precision_value : Double
  recall_value : Double
} derive(Eq, 
Debug)

Records binary confusion evidence after accepting scores at a threshold.

#
ThresholdPoint::false_negatives

source
fn ThresholdPoint::false_negatives(self : ThresholdPoint) -> Int

#
ThresholdPoint::false_positive_rate

source
fn ThresholdPoint::false_positive_rate(self : ThresholdPoint) -> Double

#
ThresholdPoint::false_positives

source
fn ThresholdPoint::false_positives(self : ThresholdPoint) -> Int

#
ThresholdPoint::precision

source
fn ThresholdPoint::precision(self : ThresholdPoint) -> Double

#
ThresholdPoint::recall

source
fn ThresholdPoint::recall(self : ThresholdPoint) -> Double

#
ThresholdPoint::threshold

source
fn ThresholdPoint::threshold(self : ThresholdPoint) -> Double

#
ThresholdPoint::true_negatives

source
fn ThresholdPoint::true_negatives(self : ThresholdPoint) -> Int

#
ThresholdPoint::true_positive_rate

source
fn ThresholdPoint::true_positive_rate(self : ThresholdPoint) -> Double

#
ThresholdPoint::true_positives

source
fn ThresholdPoint::true_positives(self : ThresholdPoint) -> Int

#
ValidationReport

source
pub struct ValidationReport {
  fold_evaluations : Array[FoldEvaluation]
  aggregate_metrics : ClassificationMetrics
  evaluated_observations : Int
  scaling_plan : ScalingPlan
} derive(Eq, 
Debug)

Stores all fold evidence and aggregate held-out metrics.

#
ValidationReport::fold_count

source
fn ValidationReport::fold_count(self : ValidationReport) -> Int

#
ValidationReport::folds

source

#
ValidationReport::metrics

source

#
ValidationReport::observation_count

source
fn ValidationReport::observation_count(self : ValidationReport) -> Int

#
ValidationReport::scaling

source

#
WeightProfile

source
pub struct WeightProfile {
  weight_count : Int
  minimum_weight : Double
  maximum_weight : Double
  total_weight : Double
  average_weight : Double
  effective_observation_count : Double
} derive(Eq, 
Debug)

Summarizes positive sample weights and their concentration.

#
WeightProfile::count

source
fn WeightProfile::count(self : WeightProfile) -> Int

#
WeightProfile::effective_sample_size

source
fn WeightProfile::effective_sample_size(self : WeightProfile) -> Double

#
WeightProfile::maximum

source
fn WeightProfile::maximum(self : WeightProfile) -> Double

#
WeightProfile::mean

source
fn WeightProfile::mean(self : WeightProfile) -> Double

#
WeightProfile::minimum

source
fn WeightProfile::minimum(self : WeightProfile) -> Double

#
WeightProfile::total

source
fn WeightProfile::total(self : WeightProfile) -> Double

#
binary_config

source
fn binary_config(c : Double, kernel : Kernel, max_iterations : Int, max_passes : Int, tolerance : Double, alpha_epsilon : Double) -> Result[BinaryConfig, SvmError]

Creates a fully explicit, validated binary SVM configuration.

#
binary_diagnostics_json

source
fn binary_diagnostics_json(diagnostics : BinaryModelDiagnostics, convergence : ConvergenceReport) -> String

Produces deterministic JSON for binary model diagnostics.

#
binary_diagnostics_text

source
fn binary_diagnostics_text(diagnostics : BinaryModelDiagnostics, convergence : ConvergenceReport) -> String

Produces stable binary support-vector and convergence evidence.

#
binary_model_diagnostics

source
fn binary_model_diagnostics(model : BinaryModel) -> BinaryModelDiagnostics

Summarizes alpha magnitudes and original-class support counts.

#
binary_permutation_importance

source
fn binary_permutation_importance(model : BinaryModel, data : Dataset) -> Result[PermutationImportance, SvmError]

Measures binary accuracy changes using a deterministic reverse permutation.

#
binary_threshold_analysis

source
fn binary_threshold_analysis(labels : Array[Int], scores : Array[Double], positive_class : Int) -> Result[BinaryThresholdAnalysis, SvmError]

Builds tied-threshold confusion evidence and deterministic curve areas.

#
class_weight

source
fn class_weight(label : Int, value : Double) -> Result[ClassWeight, SvmError]

#
classification_metrics

source
fn classification_metrics(actual : Array[Int], predicted : Array[Int]) -> Result[ClassificationMetrics, SvmError]

Computes a confusion matrix and common single-label classification metrics.

#
classification_metrics_json

source
fn classification_metrics_json(metrics : ClassificationMetrics) -> String

Produces deterministic JSON including confusion and per-class evidence.

#
classification_metrics_text

source
fn classification_metrics_text(metrics : ClassificationMetrics) -> String

Produces a stable human-readable classification report.

#
cross_validate

source
fn cross_validate(data : Dataset, config : BinaryConfig, fold_count : Int, scaling : ScalingPlan) -> Result[ValidationReport, SvmError]

Evaluates held-out predictions with preprocessing fitted inside each fold.

#
dataset

source
fn dataset(features : Array[Array[Double]], labels : Array[Int], name : String) -> Result[Dataset, SvmError]

Validates and defensively copies a dense numeric classification dataset.

#
dataset_profile

source
fn dataset_profile(data : Dataset) -> DatasetProfile

Computes reproducible descriptive statistics from validated dense data.

#
dataset_profile_json

source
fn dataset_profile_json(profile : DatasetProfile) -> String

Produces deterministic JSON for a dataset profile.

#
dataset_profile_text

source
fn dataset_profile_text(profile : DatasetProfile) -> String

Produces a stable line-oriented dataset audit report.

#
default_binary_config

source
fn default_binary_config(kernel : Kernel) -> Result[BinaryConfig, SvmError]

Returns C=1, 1000 iterations, 10 unchanged passes, and strict tolerances.

#
error_code

source
fn error_code(error : SvmError) -> String

Returns a stable machine-readable category for an error.

#
error_message

source
fn error_message(error : SvmError) -> String

Formats a concise explanation suitable for logs and command-line output.

#
explain_binary_prediction

source
fn explain_binary_prediction(model : BinaryModel, row : Array[Double]) -> Result[BinaryPredictionExplanation, SvmError]

Decomposes a checked binary prediction into support-vector contributions.

#
explain_multiclass_prediction

source
fn explain_multiclass_prediction(model : MulticlassModel, row : Array[Double]) -> Result[MulticlassPredictionExplanation, SvmError]

Returns class-aligned OvR scores and the deterministic winning class.

#
fit_scaler

source
fn fit_scaler(data : Dataset, kind : ScalerKind) -> Result[FeatureScaler, SvmError]

Fits preprocessing parameters from a validated training dataset.

#
kernel_diagnostics

source
fn kernel_diagnostics(data : Dataset, kernel : Kernel) -> Result[KernelDiagnostics, SvmError]

Computes finite summary statistics for the checked kernel matrix.

#
kernel_diagnostics_json

source
fn kernel_diagnostics_json(diagnostics : KernelDiagnostics) -> String

Produces deterministic JSON for kernel matrix diagnostics.

#
kernel_diagnostics_text

source
fn kernel_diagnostics_text(diagnostics : KernelDiagnostics) -> String

Produces stable range and symmetry evidence for a kernel matrix.

#
kernel_matrix

source
fn kernel_matrix(kernel : Kernel, data : Dataset) -> Result[Array[Array[Double]], SvmError]

Builds a symmetric kernel matrix for a validated dataset.

#
kernel_value

source
fn kernel_value(kernel : Kernel, left : Array[Double], right : Array[Double]) -> Result[Double, SvmError]

Evaluates a checked kernel on two finite vectors of equal length.

#
multiclass_diagnostics_json

source
fn multiclass_diagnostics_json(diagnostics : MulticlassModelDiagnostics) -> String

Produces deterministic JSON for every OvR convergence report.

#
multiclass_diagnostics_text

source
fn multiclass_diagnostics_text(diagnostics : MulticlassModelDiagnostics) -> String

Produces stable aggregate diagnostics for an OvR model.

#
multiclass_model_diagnostics

source
fn multiclass_model_diagnostics(model : MulticlassModel) -> MulticlassModelDiagnostics

Aggregates support counts and convergence reports in sorted class order.

#
multiclass_permutation_importance

source
fn multiclass_permutation_importance(model : MulticlassModel, data : Dataset) -> Result[PermutationImportance, SvmError]

Measures OvR accuracy changes using the same deterministic permutation.

#
multiclass_prediction_audit

source
fn multiclass_prediction_audit(model : MulticlassModel, data : Dataset) -> Result[PredictionAudit, SvmError]

Audits every OvR prediction and class score on a compatible dataset.

#
permutation_importance_json

source
fn permutation_importance_json(importance : PermutationImportance) -> String

Produces deterministic JSON for ranked feature importance.

#
permutation_importance_text

source
fn permutation_importance_text(importance : PermutationImportance) -> String

Produces a stable ranked permutation-importance report.

#
prediction_audit_json

source
fn prediction_audit_json(audit : PredictionAudit) -> String

Produces deterministic JSON for row-level prediction evidence.

#
prediction_audit_text

source
fn prediction_audit_text(audit : PredictionAudit) -> String

Produces a stable row-level prediction audit report.

#
repeated_cross_validate

source
fn repeated_cross_validate(data : Dataset, config : BinaryConfig, fold_count : Int, repetitions : Int, scaling : ScalingPlan) -> Result[RepeatedValidationReport, SvmError]

Repeats deterministic stratified CV with class-specific fold rotations.

#
repeated_validation_json

source
fn repeated_validation_json(report : RepeatedValidationReport) -> String

Produces deterministic JSON for repeated validation variability.

#
repeated_validation_text

source
fn repeated_validation_text(report : RepeatedValidationReport) -> String

Produces stable repeated-validation summary text.

#
select_svm

source
fn select_svm(data : Dataset, candidates : Array[SvmCandidate], fold_count : Int, metric : SelectionMetric) -> Result[SearchResult, SvmError]

Evaluates candidates in order and retains the earliest candidate on ties.

#
stratified_folds

source
fn stratified_folds(data : Dataset, fold_count : Int) -> Result[Array[StratifiedFold], SvmError]

Distributes each sorted class round-robin while retaining source row order.

#
svm_candidate

source
fn svm_candidate(name : String, config : BinaryConfig, scaling : ScalingPlan) -> SvmCandidate

#
threshold_analysis_json

source
fn threshold_analysis_json(analysis : BinaryThresholdAnalysis) -> String

Produces deterministic JSON for ROC and precision-recall points.

#
threshold_analysis_text

source
fn threshold_analysis_text(analysis : BinaryThresholdAnalysis) -> String

Produces a line-oriented threshold report with confusion evidence.

#
train_binary

source
fn train_binary(data : Dataset, config : BinaryConfig) -> Result[BinaryModel, SvmError]

Fits a deterministic, unweighted binary C-SVC model.

#
train_binary_weighted

source
fn train_binary_weighted(data : Dataset, sample_weights : Array[Double], class_weights : Array[ClassWeight], config : BinaryConfig) -> Result[BinaryModel, SvmError]

Fits binary C-SVC with positive sample and optional class multipliers.

#
train_multiclass

source
fn train_multiclass(data : Dataset, config : BinaryConfig) -> Result[MulticlassModel, SvmError]

Fits an unweighted deterministic one-vs-rest multiclass classifier.

#
train_multiclass_weighted

source
fn train_multiclass_weighted(data : Dataset, sample_weights : Array[Double], class_weights : Array[ClassWeight], config : BinaryConfig) -> Result[MulticlassModel, SvmError]

Fits one deterministic weighted binary classifier for each sorted class.

#
training_margin_diagnostics

source
fn training_margin_diagnostics(model : BinaryModel, data : Dataset) -> Result[MarginDiagnostics, SvmError]

Computes y*f(x) for observations belonging to the model's two classes.

#
validate_kernel

source
fn validate_kernel(kernel : Kernel) -> Result[Unit, SvmError]

Checks that all parameters define a finite, usable kernel.

#
weight_profile

source
fn weight_profile(weights : Array[Double]) -> Result[WeightProfile, SvmError]

Computes Kish's effective sample size for finite positive weights.

#
weight_profile_json

source
fn weight_profile_json(profile : WeightProfile) -> String

Produces deterministic JSON for positive sample-weight evidence.

#
weight_profile_text

source
fn weight_profile_text(profile : WeightProfile) -> String

Produces a stable summary of positive sample-weight concentration.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io