Struct peroxide::statistics::stat::ConfusionMatrix

pub struct ConfusionMatrix {
    pub TP: usize,
    pub TN: usize,
    pub FP: usize,
    pub FN: usize,
}

Confusion Matrix

• TP : True Positive
• TN : True Negative
• FP : False Positive
• FN : False Negative

Examples

use peroxide::fuga::*;

fn main() {
    let y           = vec![1usize, 1, 1, 0, 0, 0];
    let y_hat       = vec![1usize, 0, 1, 0, 0, 1];
    let true_val    = 1usize;

    // Create Confusion Matrix
    let cm = ConfusionMatrix::new(&y, &y_hat, true_val);

    // Print
    cm.print();
    //        c[0]  c[1]
    // r[0]  2.0000  1.0000
    // r[1]  1.0000  2.0000

    // To Matrix
    let cm_mat = cm.to_matrix();

    // Calculate Accuracy
    let acc = cm.ACC();

    // Calculate for some metrics
    let metrics = cm.calc_metrics(&[ACC, TPR, FPR, F1]);

    // Print summary for some metrics
    cm.summary(&[ACC, TPR, FPR, F1]);
}

Fields

TP: usize

TN: usize

FP: usize

FN: usize

Implementations

impl ConfusionMatrix

pub fn new<T: PartialEq + Clone + Copy>( y: &Vec<T>, y_hat: &Vec<T>, true_val: T, ) -> Self

Create Confusion Matrix

Examples

use peroxide::fuga::*;

fn main() {
    let y           = vec![1usize, 1, 1, 0, 0, 0];
    let y_hat       = vec![1usize, 0, 1, 0, 0, 1];
    let true_val    = 1usize;

    let true_val = 1usize;
    let cm = ConfusionMatrix::new(&y, &y_hat, true_val);
    cm.print();
    //        c[0]  c[1]
    // r[0]  2.0000  1.0000
    // r[1]  1.0000  2.0000
}

pub fn P(&self) -> usize

Condition Positive

pub fn N(&self) -> usize

Condition Negative

pub fn TPR(&self) -> f64

True Positive Rate (Sensitivity, Recall, Hit-rate)

pub fn TNR(&self) -> f64

True Negative Rate (Specificity, Selectivity)

pub fn PPV(&self) -> f64

Positive Predictive Value (Precision)

pub fn NPV(&self) -> f64

Negative Predictive Value

pub fn FNR(&self) -> f64

False Negative Rate (Miss-rate)

pub fn FPR(&self) -> f64

False Positive Rate (Fall-out)

pub fn FDR(&self) -> f64

False Discovery Rate

pub fn FOR(&self) -> f64

False Omission Rate

pub fn LR_plus(&self) -> f64

Positive Likelihood Ratio

pub fn LR_minus(&self) -> f64

Negative Likelihood Ratio

pub fn PT(&self) -> f64

Prevalence Threshold

pub fn TS(&self) -> f64

Threat Score (Critical Success Index)

pub fn prevalence(&self) -> f64

Prevalence

pub fn ACC(&self) -> f64

Accuracy

pub fn BA(&self) -> f64

Balanced Accuracy

pub fn F1(&self) -> f64

F1 Score

pub fn MCC(&self) -> f64

Matthews Correlation Coefficient (Phi Coefficient)

pub fn FM(&self) -> f64

Fowlkes-Mallows Index

pub fn BM(&self) -> f64

Bookmaker Informedness (Informedness)

pub fn MK(&self) -> f64

Markedness (deltaP)

pub fn DOR(&self) -> f64

Diagnostic Odds Ratio

pub fn to_matrix(&self) -> Matrix

To Matrix

pub fn calc_metric(&self, metric: Metric) -> f64

Calculate a specific metric

pub fn calc_metrics(&self, metrics: &[Metric]) -> Vec<f64>

Calculate for some metrics

pub fn summary(&self, metrics: &[Metric])

Summarize some metrics

Trait Implementations

impl Clone for ConfusionMatrix

fn clone(&self) -> ConfusionMatrix

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ConfusionMatrix

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

Formats the value using the given formatter.

impl PartialEq for ConfusionMatrix

fn eq(&self, other: &ConfusionMatrix) -> 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 Printable for ConfusionMatrix

fn print(&self)

impl StructuralPartialEq for ConfusionMatrix