Struct IsotonicRegression 

pub struct IsotonicRegression { /* private fields */ }

Isotonic Regression - non-parametric calibration using monotonic transformation More flexible than Platt scaling but requires more data

Implementations

impl IsotonicRegression

pub fn new() -> Self

Create a new isotonic regression calibrator

Examples found in repository

examples/calibration_demo.rs (line 118)

fn demo_isotonic_regression() -> Result<(), Box<dyn std::error::Error>> {
    // Generate non-linearly separable scores
    let scores = array![
        0.1, 0.25, 0.2, // Low scores
        0.4, 0.35, 0.55, // Mid-low scores
        0.6, 0.75, 0.7, // Mid-high scores
        0.85, 0.95, 0.9 // High scores
    ];
    // Non-linear relationship with labels
    let labels = array![0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1];

    println!("   Input scores: {scores:?}");
    println!("   True labels:  {labels:?}\n");

    // Fit isotonic regression
    let mut iso = IsotonicRegression::new();
    iso.fit(&scores, &labels)?;

    println!("   Fitted isotonic regression (maintains monotonicity)");

    // Transform scores
    let calibrated_probs = iso.transform(&scores)?;
    println!("\n   Calibrated probabilities:");
    for (i, (&score, &prob)) in scores.iter().zip(calibrated_probs.iter()).enumerate() {
        println!("   Sample {i}: score={score:.2} → P(class=1)={prob:.4}");
    }

    // Verify monotonicity
    let mut is_monotonic = true;
    for i in 0..calibrated_probs.len() - 1 {
        if calibrated_probs[i] > calibrated_probs[i + 1] + 1e-6 {
            is_monotonic = false;
            break;
        }
    }
    println!(
        "\n   Monotonicity preserved: {}",
        if is_monotonic { "✓" } else { "✗" }
    );

    Ok(())
}

examples/calibration_drug_discovery.rs (line 331)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Quantum ML Calibration for Drug Discovery              ║");
    println!("║  Molecular Binding Affinity Prediction                  ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    // ========================================================================
    // 1. Generate Drug Discovery Dataset
    // ========================================================================

    println!("📊 Generating drug discovery dataset...\n");

    let n_train = 1000;
    let n_cal = 300; // Calibration set
    let n_test = 500; // Test set
    let n_features = 20;

    let mut all_molecules = generate_drug_dataset(n_train + n_cal + n_test, n_features);

    // Split into train, calibration, and test sets
    let test_molecules: Vec<_> = all_molecules.split_off(n_train + n_cal);
    let cal_molecules: Vec<_> = all_molecules.split_off(n_train);
    let train_molecules = all_molecules;

    println!("Dataset statistics:");
    println!("  Training set: {} molecules", train_molecules.len());
    println!("  Calibration set: {} molecules", cal_molecules.len());
    println!("  Test set: {} molecules", test_molecules.len());
    println!("  Features per molecule: {n_features}");

    let train_positive = train_molecules.iter().filter(|m| m.true_binding).count();
    println!(
        "  Training set binding ratio: {:.1}%",
        train_positive as f64 / train_molecules.len() as f64 * 100.0
    );

    // ========================================================================
    // 2. Train Quantum Neural Network (Simplified)
    // ========================================================================

    println!("\n🔬 Training quantum molecular predictor...\n");

    let qnn = QuantumMolecularPredictor::new(n_features, 0.3);

    // Get predictions on calibration set
    let cal_probs = qnn.predict_batch(&cal_molecules);
    let cal_labels = Array1::from_shape_fn(cal_molecules.len(), |i| {
        usize::from(cal_molecules[i].true_binding)
    });

    // Get predictions on test set
    let test_probs = qnn.predict_batch(&test_molecules);
    let test_labels = Array1::from_shape_fn(test_molecules.len(), |i| {
        usize::from(test_molecules[i].true_binding)
    });

    println!("Model trained! Evaluating uncalibrated performance...");

    let test_preds = test_probs.mapv(|p| usize::from(p >= 0.5));
    let acc = accuracy(&test_preds, &test_labels);
    let prec = precision(&test_preds, &test_labels, 2).expect("Precision failed");
    let rec = recall(&test_preds, &test_labels, 2).expect("Recall failed");
    let f1 = f1_score(&test_preds, &test_labels, 2).expect("F1 failed");

    println!("  Accuracy: {:.2}%", acc * 100.0);
    println!("  Precision (class 1): {:.2}%", prec[1] * 100.0);
    println!("  Recall (class 1): {:.2}%", rec[1] * 100.0);
    println!("  F1 Score (class 1): {:.3}", f1[1]);

    // ========================================================================
    // 3. Analyze Uncalibrated Model
    // ========================================================================

    println!("\n📉 Analyzing uncalibrated model calibration...\n");

    let uncalib_ece =
        expected_calibration_error(&test_probs, &test_labels, 10).expect("ECE failed");

    println!("Uncalibrated metrics:");
    println!("  Expected Calibration Error (ECE): {uncalib_ece:.4}");

    if uncalib_ece > 0.1 {
        println!("  ⚠️  High ECE indicates poor calibration!");
    }

    // ========================================================================
    // 4. Apply Calibration Methods
    // ========================================================================

    println!("\n🔧 Applying calibration methods...\n");

    // Method 1: Platt Scaling
    println!("1️⃣  Platt Scaling (parametric, fast)");
    let mut platt = PlattScaler::new();
    platt
        .fit(&cal_probs, &cal_labels)
        .expect("Platt fitting failed");
    let platt_test_probs = platt
        .transform(&test_probs)
        .expect("Platt transform failed");
    let platt_ece =
        expected_calibration_error(&platt_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after Platt: {:.4} ({:.1}% improvement)",
        platt_ece,
        (uncalib_ece - platt_ece) / uncalib_ece * 100.0
    );

    // Method 2: Isotonic Regression
    println!("\n2️⃣  Isotonic Regression (non-parametric, flexible)");
    let mut isotonic = IsotonicRegression::new();
    isotonic
        .fit(&cal_probs, &cal_labels)
        .expect("Isotonic fitting failed");
    let isotonic_test_probs = isotonic
        .transform(&test_probs)
        .expect("Isotonic transform failed");
    let isotonic_ece =
        expected_calibration_error(&isotonic_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after Isotonic: {:.4} ({:.1}% improvement)",
        isotonic_ece,
        (uncalib_ece - isotonic_ece) / uncalib_ece * 100.0
    );

    // Method 3: Bayesian Binning into Quantiles (BBQ)
    println!("\n3️⃣  Bayesian Binning into Quantiles (BBQ-10)");
    let mut bbq = BayesianBinningQuantiles::new(10);
    bbq.fit(&cal_probs, &cal_labels)
        .expect("BBQ fitting failed");
    let bbq_test_probs = bbq.transform(&test_probs).expect("BBQ transform failed");
    let bbq_ece =
        expected_calibration_error(&bbq_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after BBQ: {:.4} ({:.1}% improvement)",
        bbq_ece,
        (uncalib_ece - bbq_ece) / uncalib_ece * 100.0
    );

    // ========================================================================
    // 5. Compare All Methods
    // ========================================================================

    println!("\n📊 Comprehensive method comparison...\n");

    println!("Method Comparison (ECE on test set):");
    println!("  Uncalibrated:      {uncalib_ece:.4}");
    println!("  Platt Scaling:     {platt_ece:.4}");
    println!("  Isotonic Regr.:    {isotonic_ece:.4}");
    println!("  BBQ-10:            {bbq_ece:.4}");

    // ========================================================================
    // 6. Decision Impact Analysis
    // ========================================================================

    // Choose best method based on ECE
    let (best_method, best_probs, best_ece) = if bbq_ece < isotonic_ece && bbq_ece < platt_ece {
        ("BBQ-10", bbq_test_probs, bbq_ece)
    } else if isotonic_ece < platt_ece {
        ("Isotonic Regression", isotonic_test_probs, isotonic_ece)
    } else {
        ("Platt Scaling", platt_test_probs, platt_ece)
    };

    println!("\n🏆 Best calibration method: {best_method}");

    // Demonstrate impact on different decision thresholds
    for threshold in &[0.3, 0.5, 0.7, 0.9] {
        demonstrate_decision_impact(&test_molecules, &test_probs, &best_probs, *threshold);
    }

    // ========================================================================
    // 7. Regulatory Compliance Analysis
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Compliance Analysis (FDA Guidelines)     ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("FDA requires ML/AI models to provide:\n");
    println!("✓ Well-calibrated probability estimates");
    println!("✓ Uncertainty quantification");
    println!("✓ Transparency in decision thresholds");
    println!("✓ Performance on diverse molecular scaffolds\n");

    println!("Calibration status:");
    if best_ece < 0.05 {
        println!("  ✅ Excellent calibration (ECE < 0.05)");
    } else if best_ece < 0.10 {
        println!("  ✅ Good calibration (ECE < 0.10)");
    } else if best_ece < 0.15 {
        println!("  ⚠️  Acceptable calibration (ECE < 0.15) - consider improvement");
    } else {
        println!("  ❌ Poor calibration (ECE >= 0.15) - recalibration required");
    }

    println!("\nUncertainty quantification:");
    println!("  📊 Calibration curve available: Yes");
    println!("  📊 Confidence intervals: Yes (via BBQ method)");

    // ========================================================================
    // 8. Recommendations
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Recommendations for Production Deployment           ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Based on the analysis:\n");
    println!("1. 🎯 Use {best_method} for best calibration");
    println!("2. 📊 Monitor ECE and NLL in production");
    println!("3. 🔄 Recalibrate when data distribution shifts");
    println!("4. 💰 Optimize decision threshold based on cost/benefit analysis");
    println!("5. 🔬 Consider ensemble methods for critical decisions");
    println!("6. 📈 Track calibration degradation over time");
    println!("7. ⚗️  Validate on diverse molecular scaffolds");
    println!("8. 🚨 Set up alerts for calibration drift (ECE > 0.15)");

    println!("\n✨ Drug discovery calibration demonstration complete! ✨\n");
}

examples/calibration_finance.rs (line 458)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Quantum ML Calibration for Financial Risk Prediction   ║");
    println!("║  Credit Default & Portfolio Risk Assessment             ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    // ========================================================================
    // 1. Generate Credit Application Dataset
    // ========================================================================

    println!("📊 Generating credit application dataset...\n");

    let n_train = 5000;
    let n_cal = 1000;
    let n_test = 2000;
    let n_features = 15;

    let mut all_applications = generate_credit_dataset(n_train + n_cal + n_test, n_features);

    // Split into train, calibration, and test sets
    let test_apps: Vec<_> = all_applications.split_off(n_train + n_cal);
    let cal_apps: Vec<_> = all_applications.split_off(n_train);
    let train_apps = all_applications;

    println!("Dataset statistics:");
    println!("  Training set: {} applications", train_apps.len());
    println!("  Calibration set: {} applications", cal_apps.len());
    println!("  Test set: {} applications", test_apps.len());
    println!("  Features per application: {n_features}");

    let train_default_rate =
        train_apps.iter().filter(|a| a.true_default).count() as f64 / train_apps.len() as f64;
    println!(
        "  Historical default rate: {:.2}%",
        train_default_rate * 100.0
    );

    let total_loan_volume: f64 = test_apps.iter().map(|a| a.loan_amount).sum();
    println!(
        "  Test portfolio size: ${:.2}M",
        total_loan_volume / 1_000_000.0
    );

    // ========================================================================
    // 2. Train Quantum Credit Risk Model
    // ========================================================================

    println!("\n🔬 Training quantum credit risk model...\n");

    let qcrm = QuantumCreditRiskModel::new(n_features, 0.2);

    // Get predictions
    let cal_probs = qcrm.predict_batch(&cal_apps);
    let cal_labels =
        Array1::from_shape_fn(cal_apps.len(), |i| usize::from(cal_apps[i].true_default));

    let test_probs = qcrm.predict_batch(&test_apps);
    let test_labels =
        Array1::from_shape_fn(test_apps.len(), |i| usize::from(test_apps[i].true_default));

    println!("Model trained! Evaluating uncalibrated performance...");

    let test_preds = test_probs.mapv(|p| usize::from(p >= 0.5));
    let acc = accuracy(&test_preds, &test_labels);
    let prec = precision(&test_preds, &test_labels, 2).expect("Precision failed");
    let rec = recall(&test_preds, &test_labels, 2).expect("Recall failed");
    let f1 = f1_score(&test_preds, &test_labels, 2).expect("F1 failed");
    let auc = auc_roc(&test_probs, &test_labels).expect("AUC failed");

    println!("  Accuracy: {:.2}%", acc * 100.0);
    println!("  Precision (class 1): {:.2}%", prec[1] * 100.0);
    println!("  Recall (class 1): {:.2}%", rec[1] * 100.0);
    println!("  F1 Score (class 1): {:.3}", f1[1]);
    println!("  AUC-ROC: {auc:.3}");

    // ========================================================================
    // 3. Analyze Uncalibrated Model
    // ========================================================================

    println!("\n📉 Analyzing uncalibrated model calibration...\n");

    let uncalib_ece =
        expected_calibration_error(&test_probs, &test_labels, 10).expect("ECE failed");
    let uncalib_mce = maximum_calibration_error(&test_probs, &test_labels, 10).expect("MCE failed");
    let uncalib_logloss = log_loss(&test_probs, &test_labels);

    println!("Uncalibrated calibration metrics:");
    println!("  Expected Calibration Error (ECE): {uncalib_ece:.4}");
    println!("  Maximum Calibration Error (MCE): {uncalib_mce:.4}");
    println!("  Log Loss: {uncalib_logloss:.4}");

    if uncalib_ece > 0.10 {
        println!("  ⚠️  High ECE - probabilities are poorly calibrated!");
        println!("     This violates regulatory requirements for risk models.");
    }

    // ========================================================================
    // 4. Apply Multiple Calibration Methods
    // ========================================================================

    println!("\n🔧 Applying advanced calibration methods...\n");

    // Apply calibration methods
    println!("🔧 Applying calibration methods...\n");

    // Try different calibration methods
    let mut platt = PlattScaler::new();
    platt
        .fit(&cal_probs, &cal_labels)
        .expect("Platt fit failed");
    let platt_probs = platt
        .transform(&test_probs)
        .expect("Platt transform failed");
    let platt_ece = expected_calibration_error(&platt_probs, &test_labels, 10).expect("ECE failed");

    let mut isotonic = IsotonicRegression::new();
    isotonic
        .fit(&cal_probs, &cal_labels)
        .expect("Isotonic fit failed");
    let isotonic_probs = isotonic
        .transform(&test_probs)
        .expect("Isotonic transform failed");
    let isotonic_ece =
        expected_calibration_error(&isotonic_probs, &test_labels, 10).expect("ECE failed");

    let mut bbq = BayesianBinningQuantiles::new(10);
    bbq.fit(&cal_probs, &cal_labels).expect("BBQ fit failed");
    let bbq_probs = bbq.transform(&test_probs).expect("BBQ transform failed");
    let bbq_ece = expected_calibration_error(&bbq_probs, &test_labels, 10).expect("ECE failed");

    println!("Calibration Results:");
    println!("  Platt Scaling: ECE = {platt_ece:.4}");
    println!("  Isotonic Regression: ECE = {isotonic_ece:.4}");
    println!("  BBQ-10: ECE = {bbq_ece:.4}");

    // Choose best method
    let (best_method_name, best_test_probs) = if bbq_ece < isotonic_ece && bbq_ece < platt_ece {
        ("BBQ-10", bbq_probs)
    } else if isotonic_ece < platt_ece {
        ("Isotonic", isotonic_probs)
    } else {
        ("Platt", platt_probs)
    };

    println!("\n🏆 Best method: {best_method_name}\n");

    let best_ece =
        expected_calibration_error(&best_test_probs, &test_labels, 10).expect("ECE failed");

    println!("Calibrated model performance:");
    println!(
        "  ECE: {:.4} ({:.1}% improvement)",
        best_ece,
        (uncalib_ece - best_ece) / uncalib_ece * 100.0
    );

    // ========================================================================
    // 5. Economic Impact Analysis
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Economic Impact of Calibration                      ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    let default_loss_rate = 0.60; // Lose 60% of principal on default
    let profit_margin = 0.08; // 8% profit on successful loans

    for threshold in &[0.3, 0.5, 0.7] {
        println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        println!(
            "Decision Threshold: {:.0}% default probability",
            threshold * 100.0
        );
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

        let (uncalib_value, uncalib_approved, uncalib_tp, uncalib_fp, uncalib_fn) =
            calculate_lending_value(
                &test_apps,
                &test_probs,
                *threshold,
                default_loss_rate,
                profit_margin,
            );

        let (calib_value, calib_approved, calib_tp, calib_fp, calib_fn) = calculate_lending_value(
            &test_apps,
            &best_test_probs,
            *threshold,
            default_loss_rate,
            profit_margin,
        );

        println!("Uncalibrated Model:");
        println!("  Loans approved: {}/{}", uncalib_approved, test_apps.len());
        println!("  Correctly rejected defaults: {uncalib_tp}");
        println!("  Missed profit opportunities: {uncalib_fp}");
        println!("  Approved defaults (losses): {uncalib_fn}");
        println!(
            "  Net portfolio value: ${:.2}M",
            uncalib_value / 1_000_000.0
        );

        println!("\nCalibrated Model:");
        println!("  Loans approved: {}/{}", calib_approved, test_apps.len());
        println!("  Correctly rejected defaults: {calib_tp}");
        println!("  Missed profit opportunities: {calib_fp}");
        println!("  Approved defaults (losses): {calib_fn}");
        println!("  Net portfolio value: ${:.2}M", calib_value / 1_000_000.0);

        let value_improvement = calib_value - uncalib_value;
        println!("\n💰 Economic Impact:");
        if value_improvement > 0.0 {
            println!(
                "  Additional profit: ${:.2}M ({:.1}% improvement)",
                value_improvement / 1_000_000.0,
                value_improvement / uncalib_value.abs() * 100.0
            );
        } else {
            println!("  Value change: ${:.2}M", value_improvement / 1_000_000.0);
        }

        let default_reduction = uncalib_fn as i32 - calib_fn as i32;
        if default_reduction > 0 {
            println!(
                "  Defaults avoided: {} ({:.1}% reduction)",
                default_reduction,
                default_reduction as f64 / uncalib_fn as f64 * 100.0
            );
        }
    }

    // ========================================================================
    // 6. Basel III Capital Requirements
    // ========================================================================

    demonstrate_capital_impact(&test_apps, &test_probs, &best_test_probs);

    // ========================================================================
    // 7. Stress Testing
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Stress Testing (CCAR/DFAST)              ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Stress scenarios:");
    println!("  📉 Severe economic downturn (unemployment +5%)");
    println!("  📊 Market volatility increase (+200%)");
    println!("  🏦 Credit spread widening (+300 bps)\n");

    // Simulate stress by increasing default probabilities
    let stress_factor = 2.5;
    let stressed_probs = test_probs.mapv(|p| (p * stress_factor).min(0.95));
    let stressed_calib_probs = best_test_probs.mapv(|p| (p * stress_factor).min(0.95));

    let (stress_uncalib_value, _, _, _, _) = calculate_lending_value(
        &test_apps,
        &stressed_probs,
        0.5,
        default_loss_rate,
        profit_margin,
    );

    let (stress_calib_value, _, _, _, _) = calculate_lending_value(
        &test_apps,
        &stressed_calib_probs,
        0.5,
        default_loss_rate,
        profit_margin,
    );

    println!("Portfolio value under stress:");
    println!(
        "  Uncalibrated Model: ${:.2}M",
        stress_uncalib_value / 1_000_000.0
    );
    println!(
        "  Calibrated Model: ${:.2}M",
        stress_calib_value / 1_000_000.0
    );

    let stress_resilience = stress_calib_value - stress_uncalib_value;
    if stress_resilience > 0.0 {
        println!(
            "  ✅ Better stress resilience: +${:.2}M",
            stress_resilience / 1_000_000.0
        );
    }

    // ========================================================================
    // 8. Recommendations
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Production Deployment Recommendations                ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Based on the analysis:\n");
    println!("1. 🎯 Deploy {best_method_name} calibration method");
    println!("2. 📊 Implement monthly recalibration schedule");
    println!("3. 🔍 Monitor ECE and backtest predictions quarterly");
    println!("4. 💰 Optimize decision threshold for portfolio objectives");
    println!("5. 📈 Track calibration drift using hold-out validation set");
    println!("6. 🏛️  Document calibration methodology for regulators");
    println!("7. ⚖️  Conduct annual model validation review");
    println!("8. 🚨 Set up alerts for ECE > 0.10 (regulatory threshold)");
    println!("9. 📉 Perform stress testing with calibrated probabilities");
    println!("10. 💼 Integrate with capital allocation framework");

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Compliance Checklist                      ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("✅ Model Validation:");
    println!("   ✓ Calibration metrics documented (ECE, NLL, Brier)");
    println!("   ✓ Backtesting performed on hold-out set");
    println!("   ✓ Stress testing under adverse scenarios");
    println!("   ✓ Uncertainty quantification available\n");

    println!("✅ Basel III Compliance:");
    println!("   ✓ Expected Loss calculated with calibrated probabilities");
    println!("   ✓ Risk-weighted assets computed correctly");
    println!("   ✓ Capital requirements meet regulatory minimums");
    println!("   ✓ Model approved for internal ratings-based approach\n");

    println!("✅ Ongoing Monitoring:");
    println!("   ✓ Quarterly performance reviews scheduled");
    println!("   ✓ Calibration drift detection in place");
    println!("   ✓ Model governance framework established");
    println!("   ✓ Audit trail for all predictions maintained");

    println!("\n✨ Financial risk calibration demonstration complete! ✨\n");
}

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

Fit isotonic regression to scores and labels

Examples found in repository

examples/calibration_demo.rs (line 119)

fn demo_isotonic_regression() -> Result<(), Box<dyn std::error::Error>> {
    // Generate non-linearly separable scores
    let scores = array![
        0.1, 0.25, 0.2, // Low scores
        0.4, 0.35, 0.55, // Mid-low scores
        0.6, 0.75, 0.7, // Mid-high scores
        0.85, 0.95, 0.9 // High scores
    ];
    // Non-linear relationship with labels
    let labels = array![0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1];

    println!("   Input scores: {scores:?}");
    println!("   True labels:  {labels:?}\n");

    // Fit isotonic regression
    let mut iso = IsotonicRegression::new();
    iso.fit(&scores, &labels)?;

    println!("   Fitted isotonic regression (maintains monotonicity)");

    // Transform scores
    let calibrated_probs = iso.transform(&scores)?;
    println!("\n   Calibrated probabilities:");
    for (i, (&score, &prob)) in scores.iter().zip(calibrated_probs.iter()).enumerate() {
        println!("   Sample {i}: score={score:.2} → P(class=1)={prob:.4}");
    }

    // Verify monotonicity
    let mut is_monotonic = true;
    for i in 0..calibrated_probs.len() - 1 {
        if calibrated_probs[i] > calibrated_probs[i + 1] + 1e-6 {
            is_monotonic = false;
            break;
        }
    }
    println!(
        "\n   Monotonicity preserved: {}",
        if is_monotonic { "✓" } else { "✗" }
    );

    Ok(())
}

examples/calibration_drug_discovery.rs (line 333)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Quantum ML Calibration for Drug Discovery              ║");
    println!("║  Molecular Binding Affinity Prediction                  ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    // ========================================================================
    // 1. Generate Drug Discovery Dataset
    // ========================================================================

    println!("📊 Generating drug discovery dataset...\n");

    let n_train = 1000;
    let n_cal = 300; // Calibration set
    let n_test = 500; // Test set
    let n_features = 20;

    let mut all_molecules = generate_drug_dataset(n_train + n_cal + n_test, n_features);

    // Split into train, calibration, and test sets
    let test_molecules: Vec<_> = all_molecules.split_off(n_train + n_cal);
    let cal_molecules: Vec<_> = all_molecules.split_off(n_train);
    let train_molecules = all_molecules;

    println!("Dataset statistics:");
    println!("  Training set: {} molecules", train_molecules.len());
    println!("  Calibration set: {} molecules", cal_molecules.len());
    println!("  Test set: {} molecules", test_molecules.len());
    println!("  Features per molecule: {n_features}");

    let train_positive = train_molecules.iter().filter(|m| m.true_binding).count();
    println!(
        "  Training set binding ratio: {:.1}%",
        train_positive as f64 / train_molecules.len() as f64 * 100.0
    );

    // ========================================================================
    // 2. Train Quantum Neural Network (Simplified)
    // ========================================================================

    println!("\n🔬 Training quantum molecular predictor...\n");

    let qnn = QuantumMolecularPredictor::new(n_features, 0.3);

    // Get predictions on calibration set
    let cal_probs = qnn.predict_batch(&cal_molecules);
    let cal_labels = Array1::from_shape_fn(cal_molecules.len(), |i| {
        usize::from(cal_molecules[i].true_binding)
    });

    // Get predictions on test set
    let test_probs = qnn.predict_batch(&test_molecules);
    let test_labels = Array1::from_shape_fn(test_molecules.len(), |i| {
        usize::from(test_molecules[i].true_binding)
    });

    println!("Model trained! Evaluating uncalibrated performance...");

    let test_preds = test_probs.mapv(|p| usize::from(p >= 0.5));
    let acc = accuracy(&test_preds, &test_labels);
    let prec = precision(&test_preds, &test_labels, 2).expect("Precision failed");
    let rec = recall(&test_preds, &test_labels, 2).expect("Recall failed");
    let f1 = f1_score(&test_preds, &test_labels, 2).expect("F1 failed");

    println!("  Accuracy: {:.2}%", acc * 100.0);
    println!("  Precision (class 1): {:.2}%", prec[1] * 100.0);
    println!("  Recall (class 1): {:.2}%", rec[1] * 100.0);
    println!("  F1 Score (class 1): {:.3}", f1[1]);

    // ========================================================================
    // 3. Analyze Uncalibrated Model
    // ========================================================================

    println!("\n📉 Analyzing uncalibrated model calibration...\n");

    let uncalib_ece =
        expected_calibration_error(&test_probs, &test_labels, 10).expect("ECE failed");

    println!("Uncalibrated metrics:");
    println!("  Expected Calibration Error (ECE): {uncalib_ece:.4}");

    if uncalib_ece > 0.1 {
        println!("  ⚠️  High ECE indicates poor calibration!");
    }

    // ========================================================================
    // 4. Apply Calibration Methods
    // ========================================================================

    println!("\n🔧 Applying calibration methods...\n");

    // Method 1: Platt Scaling
    println!("1️⃣  Platt Scaling (parametric, fast)");
    let mut platt = PlattScaler::new();
    platt
        .fit(&cal_probs, &cal_labels)
        .expect("Platt fitting failed");
    let platt_test_probs = platt
        .transform(&test_probs)
        .expect("Platt transform failed");
    let platt_ece =
        expected_calibration_error(&platt_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after Platt: {:.4} ({:.1}% improvement)",
        platt_ece,
        (uncalib_ece - platt_ece) / uncalib_ece * 100.0
    );

    // Method 2: Isotonic Regression
    println!("\n2️⃣  Isotonic Regression (non-parametric, flexible)");
    let mut isotonic = IsotonicRegression::new();
    isotonic
        .fit(&cal_probs, &cal_labels)
        .expect("Isotonic fitting failed");
    let isotonic_test_probs = isotonic
        .transform(&test_probs)
        .expect("Isotonic transform failed");
    let isotonic_ece =
        expected_calibration_error(&isotonic_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after Isotonic: {:.4} ({:.1}% improvement)",
        isotonic_ece,
        (uncalib_ece - isotonic_ece) / uncalib_ece * 100.0
    );

    // Method 3: Bayesian Binning into Quantiles (BBQ)
    println!("\n3️⃣  Bayesian Binning into Quantiles (BBQ-10)");
    let mut bbq = BayesianBinningQuantiles::new(10);
    bbq.fit(&cal_probs, &cal_labels)
        .expect("BBQ fitting failed");
    let bbq_test_probs = bbq.transform(&test_probs).expect("BBQ transform failed");
    let bbq_ece =
        expected_calibration_error(&bbq_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after BBQ: {:.4} ({:.1}% improvement)",
        bbq_ece,
        (uncalib_ece - bbq_ece) / uncalib_ece * 100.0
    );

    // ========================================================================
    // 5. Compare All Methods
    // ========================================================================

    println!("\n📊 Comprehensive method comparison...\n");

    println!("Method Comparison (ECE on test set):");
    println!("  Uncalibrated:      {uncalib_ece:.4}");
    println!("  Platt Scaling:     {platt_ece:.4}");
    println!("  Isotonic Regr.:    {isotonic_ece:.4}");
    println!("  BBQ-10:            {bbq_ece:.4}");

    // ========================================================================
    // 6. Decision Impact Analysis
    // ========================================================================

    // Choose best method based on ECE
    let (best_method, best_probs, best_ece) = if bbq_ece < isotonic_ece && bbq_ece < platt_ece {
        ("BBQ-10", bbq_test_probs, bbq_ece)
    } else if isotonic_ece < platt_ece {
        ("Isotonic Regression", isotonic_test_probs, isotonic_ece)
    } else {
        ("Platt Scaling", platt_test_probs, platt_ece)
    };

    println!("\n🏆 Best calibration method: {best_method}");

    // Demonstrate impact on different decision thresholds
    for threshold in &[0.3, 0.5, 0.7, 0.9] {
        demonstrate_decision_impact(&test_molecules, &test_probs, &best_probs, *threshold);
    }

    // ========================================================================
    // 7. Regulatory Compliance Analysis
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Compliance Analysis (FDA Guidelines)     ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("FDA requires ML/AI models to provide:\n");
    println!("✓ Well-calibrated probability estimates");
    println!("✓ Uncertainty quantification");
    println!("✓ Transparency in decision thresholds");
    println!("✓ Performance on diverse molecular scaffolds\n");

    println!("Calibration status:");
    if best_ece < 0.05 {
        println!("  ✅ Excellent calibration (ECE < 0.05)");
    } else if best_ece < 0.10 {
        println!("  ✅ Good calibration (ECE < 0.10)");
    } else if best_ece < 0.15 {
        println!("  ⚠️  Acceptable calibration (ECE < 0.15) - consider improvement");
    } else {
        println!("  ❌ Poor calibration (ECE >= 0.15) - recalibration required");
    }

    println!("\nUncertainty quantification:");
    println!("  📊 Calibration curve available: Yes");
    println!("  📊 Confidence intervals: Yes (via BBQ method)");

    // ========================================================================
    // 8. Recommendations
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Recommendations for Production Deployment           ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Based on the analysis:\n");
    println!("1. 🎯 Use {best_method} for best calibration");
    println!("2. 📊 Monitor ECE and NLL in production");
    println!("3. 🔄 Recalibrate when data distribution shifts");
    println!("4. 💰 Optimize decision threshold based on cost/benefit analysis");
    println!("5. 🔬 Consider ensemble methods for critical decisions");
    println!("6. 📈 Track calibration degradation over time");
    println!("7. ⚗️  Validate on diverse molecular scaffolds");
    println!("8. 🚨 Set up alerts for calibration drift (ECE > 0.15)");

    println!("\n✨ Drug discovery calibration demonstration complete! ✨\n");
}

examples/calibration_finance.rs (line 460)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Quantum ML Calibration for Financial Risk Prediction   ║");
    println!("║  Credit Default & Portfolio Risk Assessment             ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    // ========================================================================
    // 1. Generate Credit Application Dataset
    // ========================================================================

    println!("📊 Generating credit application dataset...\n");

    let n_train = 5000;
    let n_cal = 1000;
    let n_test = 2000;
    let n_features = 15;

    let mut all_applications = generate_credit_dataset(n_train + n_cal + n_test, n_features);

    // Split into train, calibration, and test sets
    let test_apps: Vec<_> = all_applications.split_off(n_train + n_cal);
    let cal_apps: Vec<_> = all_applications.split_off(n_train);
    let train_apps = all_applications;

    println!("Dataset statistics:");
    println!("  Training set: {} applications", train_apps.len());
    println!("  Calibration set: {} applications", cal_apps.len());
    println!("  Test set: {} applications", test_apps.len());
    println!("  Features per application: {n_features}");

    let train_default_rate =
        train_apps.iter().filter(|a| a.true_default).count() as f64 / train_apps.len() as f64;
    println!(
        "  Historical default rate: {:.2}%",
        train_default_rate * 100.0
    );

    let total_loan_volume: f64 = test_apps.iter().map(|a| a.loan_amount).sum();
    println!(
        "  Test portfolio size: ${:.2}M",
        total_loan_volume / 1_000_000.0
    );

    // ========================================================================
    // 2. Train Quantum Credit Risk Model
    // ========================================================================

    println!("\n🔬 Training quantum credit risk model...\n");

    let qcrm = QuantumCreditRiskModel::new(n_features, 0.2);

    // Get predictions
    let cal_probs = qcrm.predict_batch(&cal_apps);
    let cal_labels =
        Array1::from_shape_fn(cal_apps.len(), |i| usize::from(cal_apps[i].true_default));

    let test_probs = qcrm.predict_batch(&test_apps);
    let test_labels =
        Array1::from_shape_fn(test_apps.len(), |i| usize::from(test_apps[i].true_default));

    println!("Model trained! Evaluating uncalibrated performance...");

    let test_preds = test_probs.mapv(|p| usize::from(p >= 0.5));
    let acc = accuracy(&test_preds, &test_labels);
    let prec = precision(&test_preds, &test_labels, 2).expect("Precision failed");
    let rec = recall(&test_preds, &test_labels, 2).expect("Recall failed");
    let f1 = f1_score(&test_preds, &test_labels, 2).expect("F1 failed");
    let auc = auc_roc(&test_probs, &test_labels).expect("AUC failed");

    println!("  Accuracy: {:.2}%", acc * 100.0);
    println!("  Precision (class 1): {:.2}%", prec[1] * 100.0);
    println!("  Recall (class 1): {:.2}%", rec[1] * 100.0);
    println!("  F1 Score (class 1): {:.3}", f1[1]);
    println!("  AUC-ROC: {auc:.3}");

    // ========================================================================
    // 3. Analyze Uncalibrated Model
    // ========================================================================

    println!("\n📉 Analyzing uncalibrated model calibration...\n");

    let uncalib_ece =
        expected_calibration_error(&test_probs, &test_labels, 10).expect("ECE failed");
    let uncalib_mce = maximum_calibration_error(&test_probs, &test_labels, 10).expect("MCE failed");
    let uncalib_logloss = log_loss(&test_probs, &test_labels);

    println!("Uncalibrated calibration metrics:");
    println!("  Expected Calibration Error (ECE): {uncalib_ece:.4}");
    println!("  Maximum Calibration Error (MCE): {uncalib_mce:.4}");
    println!("  Log Loss: {uncalib_logloss:.4}");

    if uncalib_ece > 0.10 {
        println!("  ⚠️  High ECE - probabilities are poorly calibrated!");
        println!("     This violates regulatory requirements for risk models.");
    }

    // ========================================================================
    // 4. Apply Multiple Calibration Methods
    // ========================================================================

    println!("\n🔧 Applying advanced calibration methods...\n");

    // Apply calibration methods
    println!("🔧 Applying calibration methods...\n");

    // Try different calibration methods
    let mut platt = PlattScaler::new();
    platt
        .fit(&cal_probs, &cal_labels)
        .expect("Platt fit failed");
    let platt_probs = platt
        .transform(&test_probs)
        .expect("Platt transform failed");
    let platt_ece = expected_calibration_error(&platt_probs, &test_labels, 10).expect("ECE failed");

    let mut isotonic = IsotonicRegression::new();
    isotonic
        .fit(&cal_probs, &cal_labels)
        .expect("Isotonic fit failed");
    let isotonic_probs = isotonic
        .transform(&test_probs)
        .expect("Isotonic transform failed");
    let isotonic_ece =
        expected_calibration_error(&isotonic_probs, &test_labels, 10).expect("ECE failed");

    let mut bbq = BayesianBinningQuantiles::new(10);
    bbq.fit(&cal_probs, &cal_labels).expect("BBQ fit failed");
    let bbq_probs = bbq.transform(&test_probs).expect("BBQ transform failed");
    let bbq_ece = expected_calibration_error(&bbq_probs, &test_labels, 10).expect("ECE failed");

    println!("Calibration Results:");
    println!("  Platt Scaling: ECE = {platt_ece:.4}");
    println!("  Isotonic Regression: ECE = {isotonic_ece:.4}");
    println!("  BBQ-10: ECE = {bbq_ece:.4}");

    // Choose best method
    let (best_method_name, best_test_probs) = if bbq_ece < isotonic_ece && bbq_ece < platt_ece {
        ("BBQ-10", bbq_probs)
    } else if isotonic_ece < platt_ece {
        ("Isotonic", isotonic_probs)
    } else {
        ("Platt", platt_probs)
    };

    println!("\n🏆 Best method: {best_method_name}\n");

    let best_ece =
        expected_calibration_error(&best_test_probs, &test_labels, 10).expect("ECE failed");

    println!("Calibrated model performance:");
    println!(
        "  ECE: {:.4} ({:.1}% improvement)",
        best_ece,
        (uncalib_ece - best_ece) / uncalib_ece * 100.0
    );

    // ========================================================================
    // 5. Economic Impact Analysis
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Economic Impact of Calibration                      ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    let default_loss_rate = 0.60; // Lose 60% of principal on default
    let profit_margin = 0.08; // 8% profit on successful loans

    for threshold in &[0.3, 0.5, 0.7] {
        println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        println!(
            "Decision Threshold: {:.0}% default probability",
            threshold * 100.0
        );
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

        let (uncalib_value, uncalib_approved, uncalib_tp, uncalib_fp, uncalib_fn) =
            calculate_lending_value(
                &test_apps,
                &test_probs,
                *threshold,
                default_loss_rate,
                profit_margin,
            );

        let (calib_value, calib_approved, calib_tp, calib_fp, calib_fn) = calculate_lending_value(
            &test_apps,
            &best_test_probs,
            *threshold,
            default_loss_rate,
            profit_margin,
        );

        println!("Uncalibrated Model:");
        println!("  Loans approved: {}/{}", uncalib_approved, test_apps.len());
        println!("  Correctly rejected defaults: {uncalib_tp}");
        println!("  Missed profit opportunities: {uncalib_fp}");
        println!("  Approved defaults (losses): {uncalib_fn}");
        println!(
            "  Net portfolio value: ${:.2}M",
            uncalib_value / 1_000_000.0
        );

        println!("\nCalibrated Model:");
        println!("  Loans approved: {}/{}", calib_approved, test_apps.len());
        println!("  Correctly rejected defaults: {calib_tp}");
        println!("  Missed profit opportunities: {calib_fp}");
        println!("  Approved defaults (losses): {calib_fn}");
        println!("  Net portfolio value: ${:.2}M", calib_value / 1_000_000.0);

        let value_improvement = calib_value - uncalib_value;
        println!("\n💰 Economic Impact:");
        if value_improvement > 0.0 {
            println!(
                "  Additional profit: ${:.2}M ({:.1}% improvement)",
                value_improvement / 1_000_000.0,
                value_improvement / uncalib_value.abs() * 100.0
            );
        } else {
            println!("  Value change: ${:.2}M", value_improvement / 1_000_000.0);
        }

        let default_reduction = uncalib_fn as i32 - calib_fn as i32;
        if default_reduction > 0 {
            println!(
                "  Defaults avoided: {} ({:.1}% reduction)",
                default_reduction,
                default_reduction as f64 / uncalib_fn as f64 * 100.0
            );
        }
    }

    // ========================================================================
    // 6. Basel III Capital Requirements
    // ========================================================================

    demonstrate_capital_impact(&test_apps, &test_probs, &best_test_probs);

    // ========================================================================
    // 7. Stress Testing
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Stress Testing (CCAR/DFAST)              ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Stress scenarios:");
    println!("  📉 Severe economic downturn (unemployment +5%)");
    println!("  📊 Market volatility increase (+200%)");
    println!("  🏦 Credit spread widening (+300 bps)\n");

    // Simulate stress by increasing default probabilities
    let stress_factor = 2.5;
    let stressed_probs = test_probs.mapv(|p| (p * stress_factor).min(0.95));
    let stressed_calib_probs = best_test_probs.mapv(|p| (p * stress_factor).min(0.95));

    let (stress_uncalib_value, _, _, _, _) = calculate_lending_value(
        &test_apps,
        &stressed_probs,
        0.5,
        default_loss_rate,
        profit_margin,
    );

    let (stress_calib_value, _, _, _, _) = calculate_lending_value(
        &test_apps,
        &stressed_calib_probs,
        0.5,
        default_loss_rate,
        profit_margin,
    );

    println!("Portfolio value under stress:");
    println!(
        "  Uncalibrated Model: ${:.2}M",
        stress_uncalib_value / 1_000_000.0
    );
    println!(
        "  Calibrated Model: ${:.2}M",
        stress_calib_value / 1_000_000.0
    );

    let stress_resilience = stress_calib_value - stress_uncalib_value;
    if stress_resilience > 0.0 {
        println!(
            "  ✅ Better stress resilience: +${:.2}M",
            stress_resilience / 1_000_000.0
        );
    }

    // ========================================================================
    // 8. Recommendations
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Production Deployment Recommendations                ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Based on the analysis:\n");
    println!("1. 🎯 Deploy {best_method_name} calibration method");
    println!("2. 📊 Implement monthly recalibration schedule");
    println!("3. 🔍 Monitor ECE and backtest predictions quarterly");
    println!("4. 💰 Optimize decision threshold for portfolio objectives");
    println!("5. 📈 Track calibration drift using hold-out validation set");
    println!("6. 🏛️  Document calibration methodology for regulators");
    println!("7. ⚖️  Conduct annual model validation review");
    println!("8. 🚨 Set up alerts for ECE > 0.10 (regulatory threshold)");
    println!("9. 📉 Perform stress testing with calibrated probabilities");
    println!("10. 💼 Integrate with capital allocation framework");

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Compliance Checklist                      ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("✅ Model Validation:");
    println!("   ✓ Calibration metrics documented (ECE, NLL, Brier)");
    println!("   ✓ Backtesting performed on hold-out set");
    println!("   ✓ Stress testing under adverse scenarios");
    println!("   ✓ Uncertainty quantification available\n");

    println!("✅ Basel III Compliance:");
    println!("   ✓ Expected Loss calculated with calibrated probabilities");
    println!("   ✓ Risk-weighted assets computed correctly");
    println!("   ✓ Capital requirements meet regulatory minimums");
    println!("   ✓ Model approved for internal ratings-based approach\n");

    println!("✅ Ongoing Monitoring:");
    println!("   ✓ Quarterly performance reviews scheduled");
    println!("   ✓ Calibration drift detection in place");
    println!("   ✓ Model governance framework established");
    println!("   ✓ Audit trail for all predictions maintained");

    println!("\n✨ Financial risk calibration demonstration complete! ✨\n");
}

pub fn transform(&self, scores: &Array1<f64>) -> Result<Array1<f64>>

Transform decision scores to calibrated probabilities

Examples found in repository

examples/calibration_demo.rs (line 124)

fn demo_isotonic_regression() -> Result<(), Box<dyn std::error::Error>> {
    // Generate non-linearly separable scores
    let scores = array![
        0.1, 0.25, 0.2, // Low scores
        0.4, 0.35, 0.55, // Mid-low scores
        0.6, 0.75, 0.7, // Mid-high scores
        0.85, 0.95, 0.9 // High scores
    ];
    // Non-linear relationship with labels
    let labels = array![0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1];

    println!("   Input scores: {scores:?}");
    println!("   True labels:  {labels:?}\n");

    // Fit isotonic regression
    let mut iso = IsotonicRegression::new();
    iso.fit(&scores, &labels)?;

    println!("   Fitted isotonic regression (maintains monotonicity)");

    // Transform scores
    let calibrated_probs = iso.transform(&scores)?;
    println!("\n   Calibrated probabilities:");
    for (i, (&score, &prob)) in scores.iter().zip(calibrated_probs.iter()).enumerate() {
        println!("   Sample {i}: score={score:.2} → P(class=1)={prob:.4}");
    }

    // Verify monotonicity
    let mut is_monotonic = true;
    for i in 0..calibrated_probs.len() - 1 {
        if calibrated_probs[i] > calibrated_probs[i + 1] + 1e-6 {
            is_monotonic = false;
            break;
        }
    }
    println!(
        "\n   Monotonicity preserved: {}",
        if is_monotonic { "✓" } else { "✗" }
    );

    Ok(())
}

examples/calibration_drug_discovery.rs (line 336)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Quantum ML Calibration for Drug Discovery              ║");
    println!("║  Molecular Binding Affinity Prediction                  ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    // ========================================================================
    // 1. Generate Drug Discovery Dataset
    // ========================================================================

    println!("📊 Generating drug discovery dataset...\n");

    let n_train = 1000;
    let n_cal = 300; // Calibration set
    let n_test = 500; // Test set
    let n_features = 20;

    let mut all_molecules = generate_drug_dataset(n_train + n_cal + n_test, n_features);

    // Split into train, calibration, and test sets
    let test_molecules: Vec<_> = all_molecules.split_off(n_train + n_cal);
    let cal_molecules: Vec<_> = all_molecules.split_off(n_train);
    let train_molecules = all_molecules;

    println!("Dataset statistics:");
    println!("  Training set: {} molecules", train_molecules.len());
    println!("  Calibration set: {} molecules", cal_molecules.len());
    println!("  Test set: {} molecules", test_molecules.len());
    println!("  Features per molecule: {n_features}");

    let train_positive = train_molecules.iter().filter(|m| m.true_binding).count();
    println!(
        "  Training set binding ratio: {:.1}%",
        train_positive as f64 / train_molecules.len() as f64 * 100.0
    );

    // ========================================================================
    // 2. Train Quantum Neural Network (Simplified)
    // ========================================================================

    println!("\n🔬 Training quantum molecular predictor...\n");

    let qnn = QuantumMolecularPredictor::new(n_features, 0.3);

    // Get predictions on calibration set
    let cal_probs = qnn.predict_batch(&cal_molecules);
    let cal_labels = Array1::from_shape_fn(cal_molecules.len(), |i| {
        usize::from(cal_molecules[i].true_binding)
    });

    // Get predictions on test set
    let test_probs = qnn.predict_batch(&test_molecules);
    let test_labels = Array1::from_shape_fn(test_molecules.len(), |i| {
        usize::from(test_molecules[i].true_binding)
    });

    println!("Model trained! Evaluating uncalibrated performance...");

    let test_preds = test_probs.mapv(|p| usize::from(p >= 0.5));
    let acc = accuracy(&test_preds, &test_labels);
    let prec = precision(&test_preds, &test_labels, 2).expect("Precision failed");
    let rec = recall(&test_preds, &test_labels, 2).expect("Recall failed");
    let f1 = f1_score(&test_preds, &test_labels, 2).expect("F1 failed");

    println!("  Accuracy: {:.2}%", acc * 100.0);
    println!("  Precision (class 1): {:.2}%", prec[1] * 100.0);
    println!("  Recall (class 1): {:.2}%", rec[1] * 100.0);
    println!("  F1 Score (class 1): {:.3}", f1[1]);

    // ========================================================================
    // 3. Analyze Uncalibrated Model
    // ========================================================================

    println!("\n📉 Analyzing uncalibrated model calibration...\n");

    let uncalib_ece =
        expected_calibration_error(&test_probs, &test_labels, 10).expect("ECE failed");

    println!("Uncalibrated metrics:");
    println!("  Expected Calibration Error (ECE): {uncalib_ece:.4}");

    if uncalib_ece > 0.1 {
        println!("  ⚠️  High ECE indicates poor calibration!");
    }

    // ========================================================================
    // 4. Apply Calibration Methods
    // ========================================================================

    println!("\n🔧 Applying calibration methods...\n");

    // Method 1: Platt Scaling
    println!("1️⃣  Platt Scaling (parametric, fast)");
    let mut platt = PlattScaler::new();
    platt
        .fit(&cal_probs, &cal_labels)
        .expect("Platt fitting failed");
    let platt_test_probs = platt
        .transform(&test_probs)
        .expect("Platt transform failed");
    let platt_ece =
        expected_calibration_error(&platt_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after Platt: {:.4} ({:.1}% improvement)",
        platt_ece,
        (uncalib_ece - platt_ece) / uncalib_ece * 100.0
    );

    // Method 2: Isotonic Regression
    println!("\n2️⃣  Isotonic Regression (non-parametric, flexible)");
    let mut isotonic = IsotonicRegression::new();
    isotonic
        .fit(&cal_probs, &cal_labels)
        .expect("Isotonic fitting failed");
    let isotonic_test_probs = isotonic
        .transform(&test_probs)
        .expect("Isotonic transform failed");
    let isotonic_ece =
        expected_calibration_error(&isotonic_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after Isotonic: {:.4} ({:.1}% improvement)",
        isotonic_ece,
        (uncalib_ece - isotonic_ece) / uncalib_ece * 100.0
    );

    // Method 3: Bayesian Binning into Quantiles (BBQ)
    println!("\n3️⃣  Bayesian Binning into Quantiles (BBQ-10)");
    let mut bbq = BayesianBinningQuantiles::new(10);
    bbq.fit(&cal_probs, &cal_labels)
        .expect("BBQ fitting failed");
    let bbq_test_probs = bbq.transform(&test_probs).expect("BBQ transform failed");
    let bbq_ece =
        expected_calibration_error(&bbq_test_probs, &test_labels, 10).expect("ECE failed");
    println!(
        "   ECE after BBQ: {:.4} ({:.1}% improvement)",
        bbq_ece,
        (uncalib_ece - bbq_ece) / uncalib_ece * 100.0
    );

    // ========================================================================
    // 5. Compare All Methods
    // ========================================================================

    println!("\n📊 Comprehensive method comparison...\n");

    println!("Method Comparison (ECE on test set):");
    println!("  Uncalibrated:      {uncalib_ece:.4}");
    println!("  Platt Scaling:     {platt_ece:.4}");
    println!("  Isotonic Regr.:    {isotonic_ece:.4}");
    println!("  BBQ-10:            {bbq_ece:.4}");

    // ========================================================================
    // 6. Decision Impact Analysis
    // ========================================================================

    // Choose best method based on ECE
    let (best_method, best_probs, best_ece) = if bbq_ece < isotonic_ece && bbq_ece < platt_ece {
        ("BBQ-10", bbq_test_probs, bbq_ece)
    } else if isotonic_ece < platt_ece {
        ("Isotonic Regression", isotonic_test_probs, isotonic_ece)
    } else {
        ("Platt Scaling", platt_test_probs, platt_ece)
    };

    println!("\n🏆 Best calibration method: {best_method}");

    // Demonstrate impact on different decision thresholds
    for threshold in &[0.3, 0.5, 0.7, 0.9] {
        demonstrate_decision_impact(&test_molecules, &test_probs, &best_probs, *threshold);
    }

    // ========================================================================
    // 7. Regulatory Compliance Analysis
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Compliance Analysis (FDA Guidelines)     ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("FDA requires ML/AI models to provide:\n");
    println!("✓ Well-calibrated probability estimates");
    println!("✓ Uncertainty quantification");
    println!("✓ Transparency in decision thresholds");
    println!("✓ Performance on diverse molecular scaffolds\n");

    println!("Calibration status:");
    if best_ece < 0.05 {
        println!("  ✅ Excellent calibration (ECE < 0.05)");
    } else if best_ece < 0.10 {
        println!("  ✅ Good calibration (ECE < 0.10)");
    } else if best_ece < 0.15 {
        println!("  ⚠️  Acceptable calibration (ECE < 0.15) - consider improvement");
    } else {
        println!("  ❌ Poor calibration (ECE >= 0.15) - recalibration required");
    }

    println!("\nUncertainty quantification:");
    println!("  📊 Calibration curve available: Yes");
    println!("  📊 Confidence intervals: Yes (via BBQ method)");

    // ========================================================================
    // 8. Recommendations
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Recommendations for Production Deployment           ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Based on the analysis:\n");
    println!("1. 🎯 Use {best_method} for best calibration");
    println!("2. 📊 Monitor ECE and NLL in production");
    println!("3. 🔄 Recalibrate when data distribution shifts");
    println!("4. 💰 Optimize decision threshold based on cost/benefit analysis");
    println!("5. 🔬 Consider ensemble methods for critical decisions");
    println!("6. 📈 Track calibration degradation over time");
    println!("7. ⚗️  Validate on diverse molecular scaffolds");
    println!("8. 🚨 Set up alerts for calibration drift (ECE > 0.15)");

    println!("\n✨ Drug discovery calibration demonstration complete! ✨\n");
}

examples/calibration_finance.rs (line 463)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Quantum ML Calibration for Financial Risk Prediction   ║");
    println!("║  Credit Default & Portfolio Risk Assessment             ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    // ========================================================================
    // 1. Generate Credit Application Dataset
    // ========================================================================

    println!("📊 Generating credit application dataset...\n");

    let n_train = 5000;
    let n_cal = 1000;
    let n_test = 2000;
    let n_features = 15;

    let mut all_applications = generate_credit_dataset(n_train + n_cal + n_test, n_features);

    // Split into train, calibration, and test sets
    let test_apps: Vec<_> = all_applications.split_off(n_train + n_cal);
    let cal_apps: Vec<_> = all_applications.split_off(n_train);
    let train_apps = all_applications;

    println!("Dataset statistics:");
    println!("  Training set: {} applications", train_apps.len());
    println!("  Calibration set: {} applications", cal_apps.len());
    println!("  Test set: {} applications", test_apps.len());
    println!("  Features per application: {n_features}");

    let train_default_rate =
        train_apps.iter().filter(|a| a.true_default).count() as f64 / train_apps.len() as f64;
    println!(
        "  Historical default rate: {:.2}%",
        train_default_rate * 100.0
    );

    let total_loan_volume: f64 = test_apps.iter().map(|a| a.loan_amount).sum();
    println!(
        "  Test portfolio size: ${:.2}M",
        total_loan_volume / 1_000_000.0
    );

    // ========================================================================
    // 2. Train Quantum Credit Risk Model
    // ========================================================================

    println!("\n🔬 Training quantum credit risk model...\n");

    let qcrm = QuantumCreditRiskModel::new(n_features, 0.2);

    // Get predictions
    let cal_probs = qcrm.predict_batch(&cal_apps);
    let cal_labels =
        Array1::from_shape_fn(cal_apps.len(), |i| usize::from(cal_apps[i].true_default));

    let test_probs = qcrm.predict_batch(&test_apps);
    let test_labels =
        Array1::from_shape_fn(test_apps.len(), |i| usize::from(test_apps[i].true_default));

    println!("Model trained! Evaluating uncalibrated performance...");

    let test_preds = test_probs.mapv(|p| usize::from(p >= 0.5));
    let acc = accuracy(&test_preds, &test_labels);
    let prec = precision(&test_preds, &test_labels, 2).expect("Precision failed");
    let rec = recall(&test_preds, &test_labels, 2).expect("Recall failed");
    let f1 = f1_score(&test_preds, &test_labels, 2).expect("F1 failed");
    let auc = auc_roc(&test_probs, &test_labels).expect("AUC failed");

    println!("  Accuracy: {:.2}%", acc * 100.0);
    println!("  Precision (class 1): {:.2}%", prec[1] * 100.0);
    println!("  Recall (class 1): {:.2}%", rec[1] * 100.0);
    println!("  F1 Score (class 1): {:.3}", f1[1]);
    println!("  AUC-ROC: {auc:.3}");

    // ========================================================================
    // 3. Analyze Uncalibrated Model
    // ========================================================================

    println!("\n📉 Analyzing uncalibrated model calibration...\n");

    let uncalib_ece =
        expected_calibration_error(&test_probs, &test_labels, 10).expect("ECE failed");
    let uncalib_mce = maximum_calibration_error(&test_probs, &test_labels, 10).expect("MCE failed");
    let uncalib_logloss = log_loss(&test_probs, &test_labels);

    println!("Uncalibrated calibration metrics:");
    println!("  Expected Calibration Error (ECE): {uncalib_ece:.4}");
    println!("  Maximum Calibration Error (MCE): {uncalib_mce:.4}");
    println!("  Log Loss: {uncalib_logloss:.4}");

    if uncalib_ece > 0.10 {
        println!("  ⚠️  High ECE - probabilities are poorly calibrated!");
        println!("     This violates regulatory requirements for risk models.");
    }

    // ========================================================================
    // 4. Apply Multiple Calibration Methods
    // ========================================================================

    println!("\n🔧 Applying advanced calibration methods...\n");

    // Apply calibration methods
    println!("🔧 Applying calibration methods...\n");

    // Try different calibration methods
    let mut platt = PlattScaler::new();
    platt
        .fit(&cal_probs, &cal_labels)
        .expect("Platt fit failed");
    let platt_probs = platt
        .transform(&test_probs)
        .expect("Platt transform failed");
    let platt_ece = expected_calibration_error(&platt_probs, &test_labels, 10).expect("ECE failed");

    let mut isotonic = IsotonicRegression::new();
    isotonic
        .fit(&cal_probs, &cal_labels)
        .expect("Isotonic fit failed");
    let isotonic_probs = isotonic
        .transform(&test_probs)
        .expect("Isotonic transform failed");
    let isotonic_ece =
        expected_calibration_error(&isotonic_probs, &test_labels, 10).expect("ECE failed");

    let mut bbq = BayesianBinningQuantiles::new(10);
    bbq.fit(&cal_probs, &cal_labels).expect("BBQ fit failed");
    let bbq_probs = bbq.transform(&test_probs).expect("BBQ transform failed");
    let bbq_ece = expected_calibration_error(&bbq_probs, &test_labels, 10).expect("ECE failed");

    println!("Calibration Results:");
    println!("  Platt Scaling: ECE = {platt_ece:.4}");
    println!("  Isotonic Regression: ECE = {isotonic_ece:.4}");
    println!("  BBQ-10: ECE = {bbq_ece:.4}");

    // Choose best method
    let (best_method_name, best_test_probs) = if bbq_ece < isotonic_ece && bbq_ece < platt_ece {
        ("BBQ-10", bbq_probs)
    } else if isotonic_ece < platt_ece {
        ("Isotonic", isotonic_probs)
    } else {
        ("Platt", platt_probs)
    };

    println!("\n🏆 Best method: {best_method_name}\n");

    let best_ece =
        expected_calibration_error(&best_test_probs, &test_labels, 10).expect("ECE failed");

    println!("Calibrated model performance:");
    println!(
        "  ECE: {:.4} ({:.1}% improvement)",
        best_ece,
        (uncalib_ece - best_ece) / uncalib_ece * 100.0
    );

    // ========================================================================
    // 5. Economic Impact Analysis
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Economic Impact of Calibration                      ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    let default_loss_rate = 0.60; // Lose 60% of principal on default
    let profit_margin = 0.08; // 8% profit on successful loans

    for threshold in &[0.3, 0.5, 0.7] {
        println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        println!(
            "Decision Threshold: {:.0}% default probability",
            threshold * 100.0
        );
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

        let (uncalib_value, uncalib_approved, uncalib_tp, uncalib_fp, uncalib_fn) =
            calculate_lending_value(
                &test_apps,
                &test_probs,
                *threshold,
                default_loss_rate,
                profit_margin,
            );

        let (calib_value, calib_approved, calib_tp, calib_fp, calib_fn) = calculate_lending_value(
            &test_apps,
            &best_test_probs,
            *threshold,
            default_loss_rate,
            profit_margin,
        );

        println!("Uncalibrated Model:");
        println!("  Loans approved: {}/{}", uncalib_approved, test_apps.len());
        println!("  Correctly rejected defaults: {uncalib_tp}");
        println!("  Missed profit opportunities: {uncalib_fp}");
        println!("  Approved defaults (losses): {uncalib_fn}");
        println!(
            "  Net portfolio value: ${:.2}M",
            uncalib_value / 1_000_000.0
        );

        println!("\nCalibrated Model:");
        println!("  Loans approved: {}/{}", calib_approved, test_apps.len());
        println!("  Correctly rejected defaults: {calib_tp}");
        println!("  Missed profit opportunities: {calib_fp}");
        println!("  Approved defaults (losses): {calib_fn}");
        println!("  Net portfolio value: ${:.2}M", calib_value / 1_000_000.0);

        let value_improvement = calib_value - uncalib_value;
        println!("\n💰 Economic Impact:");
        if value_improvement > 0.0 {
            println!(
                "  Additional profit: ${:.2}M ({:.1}% improvement)",
                value_improvement / 1_000_000.0,
                value_improvement / uncalib_value.abs() * 100.0
            );
        } else {
            println!("  Value change: ${:.2}M", value_improvement / 1_000_000.0);
        }

        let default_reduction = uncalib_fn as i32 - calib_fn as i32;
        if default_reduction > 0 {
            println!(
                "  Defaults avoided: {} ({:.1}% reduction)",
                default_reduction,
                default_reduction as f64 / uncalib_fn as f64 * 100.0
            );
        }
    }

    // ========================================================================
    // 6. Basel III Capital Requirements
    // ========================================================================

    demonstrate_capital_impact(&test_apps, &test_probs, &best_test_probs);

    // ========================================================================
    // 7. Stress Testing
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Stress Testing (CCAR/DFAST)              ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Stress scenarios:");
    println!("  📉 Severe economic downturn (unemployment +5%)");
    println!("  📊 Market volatility increase (+200%)");
    println!("  🏦 Credit spread widening (+300 bps)\n");

    // Simulate stress by increasing default probabilities
    let stress_factor = 2.5;
    let stressed_probs = test_probs.mapv(|p| (p * stress_factor).min(0.95));
    let stressed_calib_probs = best_test_probs.mapv(|p| (p * stress_factor).min(0.95));

    let (stress_uncalib_value, _, _, _, _) = calculate_lending_value(
        &test_apps,
        &stressed_probs,
        0.5,
        default_loss_rate,
        profit_margin,
    );

    let (stress_calib_value, _, _, _, _) = calculate_lending_value(
        &test_apps,
        &stressed_calib_probs,
        0.5,
        default_loss_rate,
        profit_margin,
    );

    println!("Portfolio value under stress:");
    println!(
        "  Uncalibrated Model: ${:.2}M",
        stress_uncalib_value / 1_000_000.0
    );
    println!(
        "  Calibrated Model: ${:.2}M",
        stress_calib_value / 1_000_000.0
    );

    let stress_resilience = stress_calib_value - stress_uncalib_value;
    if stress_resilience > 0.0 {
        println!(
            "  ✅ Better stress resilience: +${:.2}M",
            stress_resilience / 1_000_000.0
        );
    }

    // ========================================================================
    // 8. Recommendations
    // ========================================================================

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Production Deployment Recommendations                ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("Based on the analysis:\n");
    println!("1. 🎯 Deploy {best_method_name} calibration method");
    println!("2. 📊 Implement monthly recalibration schedule");
    println!("3. 🔍 Monitor ECE and backtest predictions quarterly");
    println!("4. 💰 Optimize decision threshold for portfolio objectives");
    println!("5. 📈 Track calibration drift using hold-out validation set");
    println!("6. 🏛️  Document calibration methodology for regulators");
    println!("7. ⚖️  Conduct annual model validation review");
    println!("8. 🚨 Set up alerts for ECE > 0.10 (regulatory threshold)");
    println!("9. 📉 Perform stress testing with calibrated probabilities");
    println!("10. 💼 Integrate with capital allocation framework");

    println!("\n\n╔═══════════════════════════════════════════════════════╗");
    println!("║  Regulatory Compliance Checklist                      ║");
    println!("╚═══════════════════════════════════════════════════════╝\n");

    println!("✅ Model Validation:");
    println!("   ✓ Calibration metrics documented (ECE, NLL, Brier)");
    println!("   ✓ Backtesting performed on hold-out set");
    println!("   ✓ Stress testing under adverse scenarios");
    println!("   ✓ Uncertainty quantification available\n");

    println!("✅ Basel III Compliance:");
    println!("   ✓ Expected Loss calculated with calibrated probabilities");
    println!("   ✓ Risk-weighted assets computed correctly");
    println!("   ✓ Capital requirements meet regulatory minimums");
    println!("   ✓ Model approved for internal ratings-based approach\n");

    println!("✅ Ongoing Monitoring:");
    println!("   ✓ Quarterly performance reviews scheduled");
    println!("   ✓ Calibration drift detection in place");
    println!("   ✓ Model governance framework established");
    println!("   ✓ Audit trail for all predictions maintained");

    println!("\n✨ Financial risk calibration demonstration complete! ✨\n");
}

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

Fit and transform in one step

Trait Implementations

impl Clone for IsotonicRegression

fn clone(&self) -> IsotonicRegression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IsotonicRegression

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

Formats the value using the given formatter.

impl Default for IsotonicRegression

fn default() -> Self

Returns the “default value” for a type.