rust_metrics 0.1.7

Incremental evaluation metrics for various machine learning pipelines.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use crate::core::{Metric, MetricError};
use crate::utils::{MetricAggregator, Reduction, levenshtein_distance};

/// Streaming Levenshtein distance.
///
/// ```
/// use rust_metrics::{EditDistance, Metric};
///
/// let preds = ["rain"];
/// let targets = ["shine"];
/// let mut edit = EditDistance::default();
/// edit.update((&preds, &targets)).unwrap();
/// assert_eq!(edit.compute(), Some(3.0));
/// ```
#[derive(Debug, Clone)]
pub struct EditDistance {
    metric_aggregator: MetricAggregator,
}

impl Default for EditDistance {
    fn default() -> Self {
        Self::new(Reduction::Mean)
    }
}

impl EditDistance {
    pub fn new(reduction: Reduction) -> Self {
        Self {
            metric_aggregator: MetricAggregator::new(reduction),
        }
    }
}

impl Metric<(&[&str], &[&str])> for EditDistance {
    type Output = f64;

    fn update(&mut self, (predictions, targets): (&[&str], &[&str])) -> Result<(), MetricError> {
        if predictions.len() != targets.len() {
            return Err(MetricError::LengthMismatch {
                predictions: predictions.len(),
                targets: targets.len(),
            });
        }
        for (&prediction, &target) in predictions.iter().zip(targets.iter()) {
            let edit_distance = levenshtein_distance(prediction, target) as f64;
            self.metric_aggregator.update(edit_distance);
        }
        Ok(())
    }

    fn reset(&mut self) {
        self.metric_aggregator.reset();
    }

    fn compute(&self) -> Option<Self::Output> {
        self.metric_aggregator.compute()
    }
}

#[cfg(test)]
mod tests {
    use super::EditDistance;
    use crate::core::Metric;

    #[test]
    fn edit_over_batches() {
        let mut edit_distance = EditDistance::default();

        let preds = vec!["rain"];
        let targets = vec!["shine"];

        edit_distance.update((&preds, &targets)).unwrap();
        let score = edit_distance.compute().unwrap();
        assert_eq!(score, 3.0);

        edit_distance.reset();
        let score = edit_distance.compute();
        assert_eq!(score, None);

        let preds = vec!["the cat is on the bath"];
        let targets = vec!["the cat is on the mat"];
        edit_distance.update((&preds, &targets)).unwrap();
        let score = edit_distance.compute().unwrap();
        assert_eq!(score, 2.0);

        let preds = vec!["the cat is on the mat"];
        let targets = vec!["the cat is on the mat"];
        edit_distance.update((&preds, &targets)).unwrap();
        let score = edit_distance.compute().unwrap();
        assert_eq!(score, 1.0);
    }
}