Enum CalibrationMethod 

pub enum CalibrationMethod {
    Sigmoid,
    Isotonic,
    Temperature,
    HistogramBinning {
        n_bins: usize,
    },
    BBQ {
        min_bins: usize,
        max_bins: usize,
    },
    Beta,
    EnsembleTemperature {
        n_estimators: usize,
    },
    OneVsOne,
    MulticlassTemperature,
    MatrixScaling,
    Dirichlet {
        concentration: Float,
    },
    LocalKNN {
        k: usize,
    },
    LocalBinning {
        n_bins: usize,
    },
    KDE,
    AdaptiveKDE {
        adaptation_factor: Float,
    },
    GaussianProcess,
    VariationalGP {
        n_inducing: usize,
    },
    ConformalSplit {
        alpha: Float,
    },
    ConformalCross {
        alpha: Float,
        n_folds: usize,
    },
    ConformalJackknife {
        alpha: Float,
    },
    BayesianModelAveraging {
        n_models: usize,
    },
    VariationalInference {
        learning_rate: Float,
        n_samples: usize,
        max_iter: usize,
    },
    MCMC {
        n_samples: usize,
        burn_in: usize,
        step_size: Float,
    },
    HierarchicalBayesian,
    DirichletProcess {
        concentration: Float,
        max_clusters: usize,
    },
    NonParametricGP {
        kernel_type: String,
        n_inducing: usize,
    },
    TimeSeries {
        window_size: usize,
        temporal_decay: Float,
    },
    Regression {
        distributional: bool,
    },
    Ranking {
        ranking_weight: Float,
        listwise: bool,
    },
    Survival {
        time_points: Vec<Float>,
        handle_censoring: bool,
    },
    NeuralCalibration {
        hidden_dims: Vec<usize>,
        activation: String,
        learning_rate: Float,
        epochs: usize,
    },
    MixupCalibration {
        base_method: String,
        alpha: Float,
        num_mixup_samples: usize,
    },
    DropoutCalibration {
        hidden_dims: Vec<usize>,
        dropout_prob: Float,
        mc_samples: usize,
    },
    EnsembleNeuralCalibration {
        n_estimators: usize,
        hidden_dims: Vec<usize>,
    },
    StructuredPrediction {
        structure_type: String,
        use_mrf: bool,
        temperature: Float,
    },
    OnlineSigmoid {
        learning_rate: Float,
        use_momentum: bool,
        momentum: Float,
    },
    AdaptiveOnline {
        window_size: usize,
        retrain_frequency: usize,
        drift_threshold: Float,
    },
    IncrementalUpdate {
        update_frequency: usize,
        learning_rate: Float,
        use_smoothing: bool,
    },
    CalibrationAwareFocal {
        gamma: Float,
        temperature: Float,
        learning_rate: Float,
        max_epochs: usize,
    },
    CalibrationAwareCrossEntropy {
        lambda: Float,
        learning_rate: Float,
        max_epochs: usize,
    },
    CalibrationAwareBrier {
        learning_rate: Float,
        max_epochs: usize,
    },
    CalibrationAwareECE {
        n_bins: usize,
        learning_rate: Float,
        max_epochs: usize,
    },
    MultiModal {
        n_modalities: usize,
        fusion_strategy: String,
    },
    CrossModal {
        adaptation_weights: Vec<Float>,
    },
    HeterogeneousEnsemble {
        combination_strategy: String,
    },
    DomainAdaptation {
        adaptation_strength: Float,
    },
    TransferLearning {
        transfer_strategy: String,
        learning_rate: Float,
        finetune_iterations: usize,
    },
    TokenLevel {
        max_seq_length: usize,
        use_positional_encoding: bool,
    },
    SequenceLevel {
        aggregation_method: String,
    },
    VerbalizedConfidence {
        confidence_patterns: HashMap<String, Float>,
    },
    AttentionBased {
        aggregation_method: String,
    },
    DPPlattScaling {
        epsilon: Float,
        delta: Float,
        sensitivity: Float,
    },
    DPHistogramBinning {
        n_bins: usize,
        epsilon: Float,
        delta: Float,
    },
    DPTemperatureScaling {
        epsilon: Float,
        delta: Float,
    },
    ContinualLearning {
        base_method: String,
        replay_strategy: String,
        max_memory_size: usize,
        regularization_strength: Float,
    },
    DifferentiableECE {
        n_bins: usize,
        learning_rate: Float,
        max_iterations: usize,
        tolerance: Float,
        use_adaptive_bins: bool,
    },
}

Calibration methods

Variants

Sigmoid

Platt’s sigmoid method

Isotonic

Isotonic regression

Temperature

Temperature scaling

HistogramBinning

Histogram binning

Fields

n_bins: usize

BBQ

Bayesian binning into quantiles

Fields

min_bins: usize

max_bins: usize

Beta

Beta calibration

EnsembleTemperature

Ensemble temperature scaling

Fields

n_estimators: usize

OneVsOne

One-vs-one multiclass calibration

MulticlassTemperature

Multiclass temperature scaling

MatrixScaling

Matrix scaling for multiclass

Dirichlet

Dirichlet calibration for multiclass

Fields

concentration: Float

LocalKNN

Local k-NN calibration

Fields

k: usize

LocalBinning

Local binning calibration

Fields

n_bins: usize

KDE

Kernel density estimation calibration

AdaptiveKDE

Adaptive KDE calibration

Fields

adaptation_factor: Float

GaussianProcess

Gaussian process calibration

VariationalGP

Variational Gaussian process calibration

Fields

n_inducing: usize

ConformalSplit

Split conformal prediction

Fields

alpha: Float

ConformalCross

Cross-conformal prediction with K-fold CV

Fields

alpha: Float

n_folds: usize

ConformalJackknife

Jackknife+ conformal prediction

Fields

alpha: Float

BayesianModelAveraging

Bayesian model averaging calibration

Fields

n_models: usize

VariationalInference

Variational inference calibration

Fields

learning_rate: Float

n_samples: usize

max_iter: usize

MCMC

MCMC-based calibration

Fields

n_samples: usize

burn_in: usize

step_size: Float

HierarchicalBayesian

Hierarchical Bayesian calibration

DirichletProcess

Dirichlet Process non-parametric calibration

Fields

concentration: Float

max_clusters: usize

NonParametricGP

Non-parametric Gaussian Process calibration

Fields

kernel_type: String

n_inducing: usize

TimeSeries

Time series calibration with temporal dependencies

Fields

window_size: usize

temporal_decay: Float

Regression

Regression calibration for continuous outputs

Fields

distributional: bool

Ranking

Ranking calibration preserving order relationships

Fields

ranking_weight: Float

listwise: bool

Survival

Survival analysis calibration for time-to-event data

Fields

time_points: Vec<Float>

handle_censoring: bool

NeuralCalibration

Neural network calibration layer

Fields

hidden_dims: Vec<usize>

activation: String

learning_rate: Float

epochs: usize

MixupCalibration

Mixup calibration with data augmentation

Fields

base_method: String

alpha: Float

num_mixup_samples: usize

DropoutCalibration

Dropout-based uncertainty calibration

Fields

hidden_dims: Vec<usize>

dropout_prob: Float

mc_samples: usize

EnsembleNeuralCalibration

Ensemble neural calibration

Fields

n_estimators: usize

hidden_dims: Vec<usize>

StructuredPrediction

Structured prediction calibration for sequences, trees, graphs, and grids

Fields

structure_type: String

use_mrf: bool

temperature: Float

OnlineSigmoid

Online sigmoid calibration for streaming data

Fields

learning_rate: Float

use_momentum: bool

momentum: Float

AdaptiveOnline

Adaptive online calibration with concept drift detection

Fields

window_size: usize

retrain_frequency: usize

drift_threshold: Float

IncrementalUpdate

Incremental calibration updates without full retraining

Fields

update_frequency: usize

learning_rate: Float

use_smoothing: bool

CalibrationAwareFocal

Calibration-aware training with focal loss and temperature scaling

Fields

gamma: Float

temperature: Float

learning_rate: Float

max_epochs: usize

CalibrationAwareCrossEntropy

Calibration-aware training with cross-entropy and calibration regularization

Fields

lambda: Float

learning_rate: Float

max_epochs: usize

CalibrationAwareBrier

Calibration-aware training with Brier score minimization

Fields

learning_rate: Float

max_epochs: usize

CalibrationAwareECE

Calibration-aware training with ECE minimization

Fields

n_bins: usize

learning_rate: Float

max_epochs: usize

MultiModal

Multi-modal calibration for predictions from multiple modalities

Fields

n_modalities: usize

fusion_strategy: String

CrossModal

Cross-modal calibration for knowledge transfer between modalities

Fields

adaptation_weights: Vec<Float>

HeterogeneousEnsemble

Heterogeneous ensemble calibration combining different algorithmic families

Fields

combination_strategy: String

DomainAdaptation

Domain adaptation calibration for transferring from source to target domain

Fields

adaptation_strength: Float

TransferLearning

Transfer learning calibration using pre-trained models

Fields

transfer_strategy: String

learning_rate: Float

finetune_iterations: usize

TokenLevel

Token-level calibration for language models with position-aware calibration

Fields

max_seq_length: usize

use_positional_encoding: bool

SequenceLevel

Sequence-level calibration for entire generated sequences

Fields

aggregation_method: String

VerbalizedConfidence

Verbalized confidence extraction from model outputs

Fields

confidence_patterns: HashMap<String, Float>

AttentionBased

Attention-based calibration using attention weights as confidence indicators

Fields

aggregation_method: String

DPPlattScaling

Differentially private Platt scaling with formal privacy guarantees

Fields

epsilon: Float

delta: Float

sensitivity: Float

DPHistogramBinning

Differentially private histogram binning with Laplace mechanism

Fields

n_bins: usize

epsilon: Float

delta: Float

DPTemperatureScaling

Differentially private temperature scaling with exponential mechanism

Fields

epsilon: Float

delta: Float

ContinualLearning

Continual learning calibration for sequential task learning

Fields

base_method: String

replay_strategy: String

max_memory_size: usize

regularization_strength: Float

DifferentiableECE

Differentiable ECE Meta-Calibration (Bohdal et al. 2023)

Fields

n_bins: usize

learning_rate: Float

max_iterations: usize

tolerance: Float

use_adaptive_bins: bool

Trait Implementations

impl Clone for CalibrationMethod

fn clone(&self) -> CalibrationMethod

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CalibrationMethod

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CalibrationMethod

fn eq(&self, other: &CalibrationMethod) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CalibrationMethod