use alloc::vec;
use alloc::vec::Vec;
pub trait Metric: Send + Sync {
fn reset(&mut self);
fn value(&self) -> f64;
}
#[derive(Debug, Clone, Default)]
pub struct Accuracy {
correct: usize,
total: usize,
}
impl Accuracy {
pub fn new() -> Self {
Self {
correct: 0,
total: 0,
}
}
pub fn update(&mut self, preds: &[usize], targets: &[usize]) {
let count = preds.len().min(targets.len());
for i in 0..count {
if preds[i] == targets[i] {
self.correct += 1;
}
}
self.total += count;
}
}
impl Metric for Accuracy {
fn reset(&mut self) {
self.correct = 0;
self.total = 0;
}
fn value(&self) -> f64 {
if self.total == 0 {
0.0
} else {
self.correct as f64 / self.total as f64
}
}
}
#[derive(Debug, Clone, Default)]
pub struct Precision {
tp: usize,
fp: usize,
positive_class: usize,
}
impl Precision {
pub fn new(positive_class: usize) -> Self {
Self {
tp: 0,
fp: 0,
positive_class,
}
}
pub fn update(&mut self, preds: &[usize], targets: &[usize]) {
let count = preds.len().min(targets.len());
for i in 0..count {
if preds[i] == self.positive_class {
if targets[i] == self.positive_class {
self.tp += 1;
} else {
self.fp += 1;
}
}
}
}
}
impl Metric for Precision {
fn reset(&mut self) {
self.tp = 0;
self.fp = 0;
}
fn value(&self) -> f64 {
if self.tp + self.fp == 0 {
0.0
} else {
self.tp as f64 / (self.tp + self.fp) as f64
}
}
}
#[derive(Debug, Clone, Default)]
pub struct Recall {
tp: usize,
fn_count: usize,
positive_class: usize,
}
impl Recall {
pub fn new(positive_class: usize) -> Self {
Self {
tp: 0,
fn_count: 0,
positive_class,
}
}
pub fn update(&mut self, preds: &[usize], targets: &[usize]) {
let count = preds.len().min(targets.len());
for i in 0..count {
if targets[i] == self.positive_class {
if preds[i] == self.positive_class {
self.tp += 1;
} else {
self.fn_count += 1;
}
}
}
}
}
impl Metric for Recall {
fn reset(&mut self) {
self.tp = 0;
self.fn_count = 0;
}
fn value(&self) -> f64 {
if self.tp + self.fn_count == 0 {
0.0
} else {
self.tp as f64 / (self.tp + self.fn_count) as f64
}
}
}
#[derive(Debug, Clone, Default)]
pub struct F1Score {
precision: Precision,
recall: Recall,
}
impl F1Score {
pub fn new(positive_class: usize) -> Self {
Self {
precision: Precision::new(positive_class),
recall: Recall::new(positive_class),
}
}
pub fn update(&mut self, preds: &[usize], targets: &[usize]) {
self.precision.update(preds, targets);
self.recall.update(preds, targets);
}
}
impl Metric for F1Score {
fn reset(&mut self) {
self.precision.reset();
self.recall.reset();
}
fn value(&self) -> f64 {
let p = self.precision.value();
let r = self.recall.value();
if p + r == 0.0 {
0.0
} else {
2.0 * p * r / (p + r)
}
}
}
#[derive(Debug, Clone, Default)]
pub struct MSE {
sum_sq_err: f64,
count: usize,
}
impl MSE {
pub fn new() -> Self {
Self {
sum_sq_err: 0.0,
count: 0,
}
}
pub fn update(&mut self, preds: &[f32], targets: &[f32]) {
let len = preds.len().min(targets.len());
for i in 0..len {
let diff = (preds[i] - targets[i]) as f64;
self.sum_sq_err += diff * diff;
}
self.count += len;
}
}
impl Metric for MSE {
fn reset(&mut self) {
self.sum_sq_err = 0.0;
self.count = 0;
}
fn value(&self) -> f64 {
if self.count == 0 {
0.0
} else {
self.sum_sq_err / self.count as f64
}
}
}
#[derive(Debug, Clone)]
pub struct ConfusionMatrix {
num_classes: usize,
matrix: Vec<Vec<usize>>,
}
impl ConfusionMatrix {
pub fn new(num_classes: usize) -> Self {
Self {
num_classes,
matrix: vec![vec![0; num_classes]; num_classes],
}
}
pub fn update(&mut self, preds: &[usize], targets: &[usize]) {
let count = preds.len().min(targets.len());
for i in 0..count {
let t = targets[i];
let p = preds[i];
if t < self.num_classes && p < self.num_classes {
self.matrix[t][p] += 1;
}
}
}
pub fn matrix(&self) -> &[Vec<usize>] {
&self.matrix
}
pub fn reset(&mut self) {
for row in &mut self.matrix {
for val in row {
*val = 0;
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_accuracy() {
let mut acc = Accuracy::new();
acc.update(&[0, 1, 2, 3], &[0, 1, 2, 0]);
assert_eq!(acc.value(), 0.75); acc.reset();
assert_eq!(acc.value(), 0.0);
}
#[test]
fn test_precision_recall_f1() {
let mut f1 = F1Score::new(1); f1.update(&[1, 1, 0, 0], &[1, 0, 1, 0]);
assert_eq!(f1.precision.value(), 0.5);
assert_eq!(f1.recall.value(), 0.5);
assert_eq!(f1.value(), 0.5);
}
#[test]
fn test_mse() {
let mut mse = MSE::new();
mse.update(&[1.0, 2.0, 3.0], &[1.0, 4.0, 3.0]);
assert!((mse.value() - (4.0 / 3.0)).abs() < 1e-6);
}
}