mean_absolute_error

Function mean_absolute_error 

Source
pub fn mean_absolute_error(expected: &[f64], estimated: &[f64]) -> f64
Expand description

Get the mean absolute error between two vectors

Examples found in repository?
examples/narma.rs (lines 114-117)
102fn get_error_rate(
103    estimated_output: Vec<Vec<f64>>,
104    expected_output: Vec<Vec<f64>>,
105    ignore_bits: usize,
106) -> (f64, f64) {
107    let estimated_output = estimated_output.iter().map(|x| x[0]).collect::<Vec<f64>>();
108    let expected_output = expected_output.into_iter().flatten().collect::<Vec<f64>>();
109
110    let mse = mean_squared_error(
111        &expected_output[ignore_bits..],
112        &estimated_output[ignore_bits..],
113    );
114    let mae = mean_absolute_error(
115        &expected_output[ignore_bits..],
116        &estimated_output[ignore_bits..],
117    );
118
119    (mse, mae)
120}
More examples
Hide additional examples
examples/xor.rs (lines 119-122)
98fn get_bits_error_rate(
99    estimated_output: Vec<Vec<f64>>,
100    expected_output: Vec<Vec<f64>>,
101    ignore_bits: usize,
102) -> (f64, f64) {
103    let mut y_tested_binary = vec![0.0; estimated_output.len()];
104
105    for (n, estimated) in estimated_output.iter().enumerate() {
106        if estimated[0] > 0.5 {
107            y_tested_binary[n] = 1.0;
108        } else {
109            y_tested_binary[n] = 0.0;
110        }
111    }
112
113    let expected_output = expected_output.into_iter().flatten().collect::<Vec<f64>>();
114
115    let mse = mean_squared_error(
116        &expected_output[ignore_bits..],
117        &y_tested_binary[ignore_bits..],
118    );
119    let mae = mean_absolute_error(
120        &expected_output[ignore_bits..],
121        &y_tested_binary[ignore_bits..],
122    );
123
124    (mse, mae)
125}
126
127fn get_error_rate(
128    estimated_output: Vec<Vec<f64>>,
129    expected_output: Vec<Vec<f64>>,
130    ignore_bits: usize,
131) -> (f64, f64) {
132    let estimated_output = estimated_output.iter().map(|x| x[0]).collect::<Vec<f64>>();
133    let expected_output = expected_output.into_iter().flatten().collect::<Vec<f64>>();
134
135    let mse = mean_squared_error(
136        &expected_output[ignore_bits..],
137        &estimated_output[ignore_bits..],
138    );
139    let mae = mean_absolute_error(
140        &expected_output[ignore_bits..],
141        &estimated_output[ignore_bits..],
142    );
143
144    (mse, mae)
145}