Struct TemperatureScaler 

pub struct TemperatureScaler { /* private fields */ }

Temperature Scaling - simple and effective multi-class calibration Scales logits by a single learned temperature parameter Particularly effective for neural network outputs

Implementations

impl TemperatureScaler

pub fn new() -> Self

Create a new temperature scaler

Examples found in repository

examples/calibration_demo.rs (line 171)

fn demo_temperature_scaling() -> Result<(), Box<dyn std::error::Error>> {
    // Generate multi-class logits (4 classes, 8 samples)
    let logits = array![
        [5.0, 1.0, 0.5, 0.0], // Overconfident for class 0
        [1.0, 5.0, 0.5, 0.0], // Overconfident for class 1
        [0.5, 1.0, 5.0, 0.0], // Overconfident for class 2
        [0.0, 0.5, 1.0, 5.0], // Overconfident for class 3
        [3.0, 2.0, 1.0, 0.5], // Moderately confident for class 0
        [1.0, 3.0, 2.0, 0.5], // Moderately confident for class 1
        [0.5, 1.0, 3.0, 2.0], // Moderately confident for class 2
        [0.5, 0.5, 1.0, 3.0], // Moderately confident for class 3
    ];
    let labels = array![0, 1, 2, 3, 0, 1, 2, 3];

    println!("   Input: 4-class classification with 8 samples");
    println!("   Logits shape: {}×{}\n", logits.nrows(), logits.ncols());

    // Compute uncalibrated softmax for comparison
    let mut uncalibrated_probs = Array2::zeros((logits.nrows(), logits.ncols()));
    for i in 0..logits.nrows() {
        let max_logit = logits
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        let exp_sum: f64 = logits.row(i).iter().map(|&x| (x - max_logit).exp()).sum();
        for j in 0..logits.ncols() {
            uncalibrated_probs[(i, j)] = ((logits[(i, j)] - max_logit).exp()) / exp_sum;
        }
    }

    // Fit temperature scaler
    let mut scaler = TemperatureScaler::new();
    scaler.fit(&logits, &labels)?;

    // Get fitted temperature
    if let Some(temp) = scaler.temperature() {
        println!("   Fitted temperature: T = {temp:.4}");
        println!(
            "   Interpretation: {}",
            if temp > 1.0 {
                "Model is overconfident (T > 1 reduces confidence)"
            } else if temp < 1.0 {
                "Model is underconfident (T < 1 increases confidence)"
            } else {
                "Model is well-calibrated (T ≈ 1)"
            }
        );
    }

    // Transform to calibrated probabilities
    let calibrated_probs = scaler.transform(&logits)?;

    println!("\n   Comparison (first 4 samples):");
    println!(
        "   {:<8} | {:<20} | {:<20}",
        "Sample", "Uncalibrated Max P", "Calibrated Max P"
    );
    println!("   {}", "-".repeat(60));

    for i in 0..4 {
        let uncal_max = uncalibrated_probs
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        let cal_max = calibrated_probs
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        println!("   Sample {i:<2}  | {uncal_max:.4}               | {cal_max:.4}");
    }

    // Compute predictions
    let mut correct = 0;
    for i in 0..calibrated_probs.nrows() {
        let pred = calibrated_probs
            .row(i)
            .iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(idx, _)| idx)
            .unwrap();
        if pred == labels[i] {
            correct += 1;
        }
    }

    let accuracy = correct as f64 / labels.len() as f64;
    println!("\n   Calibrated accuracy: {:.2}%", accuracy * 100.0);

    Ok(())
}

pub fn fit( &mut self, logits: &Array2<f64>, labels: &Array1<usize>, ) -> Result<()>

Fit the temperature scaler to logits and true labels Uses negative log-likelihood minimization

Examples found in repository

examples/calibration_demo.rs (line 172)

fn demo_temperature_scaling() -> Result<(), Box<dyn std::error::Error>> {
    // Generate multi-class logits (4 classes, 8 samples)
    let logits = array![
        [5.0, 1.0, 0.5, 0.0], // Overconfident for class 0
        [1.0, 5.0, 0.5, 0.0], // Overconfident for class 1
        [0.5, 1.0, 5.0, 0.0], // Overconfident for class 2
        [0.0, 0.5, 1.0, 5.0], // Overconfident for class 3
        [3.0, 2.0, 1.0, 0.5], // Moderately confident for class 0
        [1.0, 3.0, 2.0, 0.5], // Moderately confident for class 1
        [0.5, 1.0, 3.0, 2.0], // Moderately confident for class 2
        [0.5, 0.5, 1.0, 3.0], // Moderately confident for class 3
    ];
    let labels = array![0, 1, 2, 3, 0, 1, 2, 3];

    println!("   Input: 4-class classification with 8 samples");
    println!("   Logits shape: {}×{}\n", logits.nrows(), logits.ncols());

    // Compute uncalibrated softmax for comparison
    let mut uncalibrated_probs = Array2::zeros((logits.nrows(), logits.ncols()));
    for i in 0..logits.nrows() {
        let max_logit = logits
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        let exp_sum: f64 = logits.row(i).iter().map(|&x| (x - max_logit).exp()).sum();
        for j in 0..logits.ncols() {
            uncalibrated_probs[(i, j)] = ((logits[(i, j)] - max_logit).exp()) / exp_sum;
        }
    }

    // Fit temperature scaler
    let mut scaler = TemperatureScaler::new();
    scaler.fit(&logits, &labels)?;

    // Get fitted temperature
    if let Some(temp) = scaler.temperature() {
        println!("   Fitted temperature: T = {temp:.4}");
        println!(
            "   Interpretation: {}",
            if temp > 1.0 {
                "Model is overconfident (T > 1 reduces confidence)"
            } else if temp < 1.0 {
                "Model is underconfident (T < 1 increases confidence)"
            } else {
                "Model is well-calibrated (T ≈ 1)"
            }
        );
    }

    // Transform to calibrated probabilities
    let calibrated_probs = scaler.transform(&logits)?;

    println!("\n   Comparison (first 4 samples):");
    println!(
        "   {:<8} | {:<20} | {:<20}",
        "Sample", "Uncalibrated Max P", "Calibrated Max P"
    );
    println!("   {}", "-".repeat(60));

    for i in 0..4 {
        let uncal_max = uncalibrated_probs
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        let cal_max = calibrated_probs
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        println!("   Sample {i:<2}  | {uncal_max:.4}               | {cal_max:.4}");
    }

    // Compute predictions
    let mut correct = 0;
    for i in 0..calibrated_probs.nrows() {
        let pred = calibrated_probs
            .row(i)
            .iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(idx, _)| idx)
            .unwrap();
        if pred == labels[i] {
            correct += 1;
        }
    }

    let accuracy = correct as f64 / labels.len() as f64;
    println!("\n   Calibrated accuracy: {:.2}%", accuracy * 100.0);

    Ok(())
}

pub fn transform(&self, logits: &Array2<f64>) -> Result<Array2<f64>>

Transform logits to calibrated probabilities using temperature scaling

Examples found in repository

examples/calibration_demo.rs (line 190)

fn demo_temperature_scaling() -> Result<(), Box<dyn std::error::Error>> {
    // Generate multi-class logits (4 classes, 8 samples)
    let logits = array![
        [5.0, 1.0, 0.5, 0.0], // Overconfident for class 0
        [1.0, 5.0, 0.5, 0.0], // Overconfident for class 1
        [0.5, 1.0, 5.0, 0.0], // Overconfident for class 2
        [0.0, 0.5, 1.0, 5.0], // Overconfident for class 3
        [3.0, 2.0, 1.0, 0.5], // Moderately confident for class 0
        [1.0, 3.0, 2.0, 0.5], // Moderately confident for class 1
        [0.5, 1.0, 3.0, 2.0], // Moderately confident for class 2
        [0.5, 0.5, 1.0, 3.0], // Moderately confident for class 3
    ];
    let labels = array![0, 1, 2, 3, 0, 1, 2, 3];

    println!("   Input: 4-class classification with 8 samples");
    println!("   Logits shape: {}×{}\n", logits.nrows(), logits.ncols());

    // Compute uncalibrated softmax for comparison
    let mut uncalibrated_probs = Array2::zeros((logits.nrows(), logits.ncols()));
    for i in 0..logits.nrows() {
        let max_logit = logits
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        let exp_sum: f64 = logits.row(i).iter().map(|&x| (x - max_logit).exp()).sum();
        for j in 0..logits.ncols() {
            uncalibrated_probs[(i, j)] = ((logits[(i, j)] - max_logit).exp()) / exp_sum;
        }
    }

    // Fit temperature scaler
    let mut scaler = TemperatureScaler::new();
    scaler.fit(&logits, &labels)?;

    // Get fitted temperature
    if let Some(temp) = scaler.temperature() {
        println!("   Fitted temperature: T = {temp:.4}");
        println!(
            "   Interpretation: {}",
            if temp > 1.0 {
                "Model is overconfident (T > 1 reduces confidence)"
            } else if temp < 1.0 {
                "Model is underconfident (T < 1 increases confidence)"
            } else {
                "Model is well-calibrated (T ≈ 1)"
            }
        );
    }

    // Transform to calibrated probabilities
    let calibrated_probs = scaler.transform(&logits)?;

    println!("\n   Comparison (first 4 samples):");
    println!(
        "   {:<8} | {:<20} | {:<20}",
        "Sample", "Uncalibrated Max P", "Calibrated Max P"
    );
    println!("   {}", "-".repeat(60));

    for i in 0..4 {
        let uncal_max = uncalibrated_probs
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        let cal_max = calibrated_probs
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        println!("   Sample {i:<2}  | {uncal_max:.4}               | {cal_max:.4}");
    }

    // Compute predictions
    let mut correct = 0;
    for i in 0..calibrated_probs.nrows() {
        let pred = calibrated_probs
            .row(i)
            .iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(idx, _)| idx)
            .unwrap();
        if pred == labels[i] {
            correct += 1;
        }
    }

    let accuracy = correct as f64 / labels.len() as f64;
    println!("\n   Calibrated accuracy: {:.2}%", accuracy * 100.0);

    Ok(())
}

pub fn fit_transform( &mut self, logits: &Array2<f64>, labels: &Array1<usize>, ) -> Result<Array2<f64>>

Fit and transform in one step

pub fn temperature(&self) -> Option<f64>

Get the fitted temperature parameter

Examples found in repository

examples/calibration_demo.rs (line 175)

fn demo_temperature_scaling() -> Result<(), Box<dyn std::error::Error>> {
    // Generate multi-class logits (4 classes, 8 samples)
    let logits = array![
        [5.0, 1.0, 0.5, 0.0], // Overconfident for class 0
        [1.0, 5.0, 0.5, 0.0], // Overconfident for class 1
        [0.5, 1.0, 5.0, 0.0], // Overconfident for class 2
        [0.0, 0.5, 1.0, 5.0], // Overconfident for class 3
        [3.0, 2.0, 1.0, 0.5], // Moderately confident for class 0
        [1.0, 3.0, 2.0, 0.5], // Moderately confident for class 1
        [0.5, 1.0, 3.0, 2.0], // Moderately confident for class 2
        [0.5, 0.5, 1.0, 3.0], // Moderately confident for class 3
    ];
    let labels = array![0, 1, 2, 3, 0, 1, 2, 3];

    println!("   Input: 4-class classification with 8 samples");
    println!("   Logits shape: {}×{}\n", logits.nrows(), logits.ncols());

    // Compute uncalibrated softmax for comparison
    let mut uncalibrated_probs = Array2::zeros((logits.nrows(), logits.ncols()));
    for i in 0..logits.nrows() {
        let max_logit = logits
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        let exp_sum: f64 = logits.row(i).iter().map(|&x| (x - max_logit).exp()).sum();
        for j in 0..logits.ncols() {
            uncalibrated_probs[(i, j)] = ((logits[(i, j)] - max_logit).exp()) / exp_sum;
        }
    }

    // Fit temperature scaler
    let mut scaler = TemperatureScaler::new();
    scaler.fit(&logits, &labels)?;

    // Get fitted temperature
    if let Some(temp) = scaler.temperature() {
        println!("   Fitted temperature: T = {temp:.4}");
        println!(
            "   Interpretation: {}",
            if temp > 1.0 {
                "Model is overconfident (T > 1 reduces confidence)"
            } else if temp < 1.0 {
                "Model is underconfident (T < 1 increases confidence)"
            } else {
                "Model is well-calibrated (T ≈ 1)"
            }
        );
    }

    // Transform to calibrated probabilities
    let calibrated_probs = scaler.transform(&logits)?;

    println!("\n   Comparison (first 4 samples):");
    println!(
        "   {:<8} | {:<20} | {:<20}",
        "Sample", "Uncalibrated Max P", "Calibrated Max P"
    );
    println!("   {}", "-".repeat(60));

    for i in 0..4 {
        let uncal_max = uncalibrated_probs
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        let cal_max = calibrated_probs
            .row(i)
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        println!("   Sample {i:<2}  | {uncal_max:.4}               | {cal_max:.4}");
    }

    // Compute predictions
    let mut correct = 0;
    for i in 0..calibrated_probs.nrows() {
        let pred = calibrated_probs
            .row(i)
            .iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(idx, _)| idx)
            .unwrap();
        if pred == labels[i] {
            correct += 1;
        }
    }

    let accuracy = correct as f64 / labels.len() as f64;
    println!("\n   Calibrated accuracy: {:.2}%", accuracy * 100.0);

    Ok(())
}

Trait Implementations

impl Clone for TemperatureScaler

fn clone(&self) -> TemperatureScaler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TemperatureScaler

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

Formats the value using the given formatter.

impl Default for TemperatureScaler

fn default() -> Self

Returns the “default value” for a type.