anomaly_detection 0.4.0

Time series anomaly detection for Rust
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

use super::detect_anoms::detect_anoms;
use super::result::AnomalyDetectionResult;
use super::Error;

/// The direction to detect anomalies.
#[derive(Clone, Debug)]
pub enum Direction {
    /// Positive direction.
    Positive,
    /// Negative direction.
    Negative,
    /// Both directions.
    Both,
}

/// A set of anomaly detection parameters.
#[derive(Clone, Debug)]
pub struct AnomalyDetectionParams {
    alpha: f32,
    max_anoms: f32,
    direction: Direction,
    verbose: bool,
}

impl AnomalyDetectionParams {
    /// Creates a new set of parameters.
    pub fn new() -> Self {
        Self {
            alpha: 0.05,
            max_anoms: 0.1,
            direction: Direction::Both,
            verbose: false,
        }
    }

    /// Sets the level of statistical significance.
    pub fn alpha(&mut self, value: f32) -> &mut Self {
        self.alpha = value;
        self
    }

    /// Sets the maximum number of anomalies as percent of data.
    pub fn max_anoms(&mut self, value: f32) -> &mut Self {
        self.max_anoms = value;
        self
    }

    /// Sets the direction.
    pub fn direction(&mut self, value: Direction) -> &mut Self {
        self.direction = value;
        self
    }

    /// Sets whether to show progress.
    pub fn verbose(&mut self, value: bool) -> &mut Self {
        self.verbose = value;
        self
    }

    /// Detects anomalies in a time series.
    pub fn fit(&self, series: &[f32], period: usize) -> Result<AnomalyDetectionResult, Error> {
        let (one_tail, upper_tail) = match self.direction {
            Direction::Positive => (true, true),
            Direction::Negative => (true, false),
            Direction::Both => (false, true),
        };

        Ok(AnomalyDetectionResult {
            anomalies: detect_anoms(
                series,
                period,
                self.max_anoms,
                self.alpha,
                one_tail,
                upper_tail,
                self.verbose,
            )?,
        })
    }
}

impl Default for AnomalyDetectionParams {
    fn default() -> Self {
        Self::new()
    }
}