xor/
xor.rs

1use echo_state_network::*;
2use rand::prelude::*;
3
4const TRAIN_STEP: usize = 5000;
5const TEST_STEP: usize = 100;
6const N_X: u64 = 100;
7const BETA: f64 = 0.0;
8
9const RANDOM_SEED: u64 = 41;
10const TEST_RANDOM_SEED: u64 = 91;
11
12fn main() {
13    let (train_input, train_expected_output) = data_gen(TRAIN_STEP, RANDOM_SEED);
14    let (test_input, test_expected_output) = data_gen(TEST_STEP, TEST_RANDOM_SEED);
15
16    let path = format!("{}/examples/graph", env!("CARGO_MANIFEST_DIR"));
17
18    let n_u = train_input.first().unwrap().len() as u64;
19    let n_y = train_expected_output.first().unwrap().len() as u64;
20
21    let mut model = EchoStateNetwork::new(
22        n_u,
23        n_y,
24        N_X,
25        0.1,
26        1.0,
27        0.9,
28        |x| x.tanh(),
29        None,
30        None,
31        1.0,
32        |x| x.clone_owned(),
33        |x| x.clone_owned(),
34        false,
35    );
36
37    let mut optimizer = Ridge::new(N_X, n_y, BETA);
38
39    model.train(&train_input, &train_expected_output, &mut optimizer);
40
41    let estimated_output = model.estimate(&test_input);
42
43    let (bits_l2_error, bits_l1_error) =
44        get_bits_error_rate(estimated_output.clone(), test_expected_output.clone());
45    let (l2_error, l1_error) =
46        get_error_rate(estimated_output.clone(), test_expected_output.clone());
47    println!("Bits Mean Squared Error: {}", bits_l2_error);
48    println!("Bits Mean Absolute Error: {}", bits_l1_error);
49    println!("Mean Squared Error: {}", l2_error);
50    println!("Mean Absolute Error: {}", l1_error);
51
52    let y_estimated = estimated_output.iter().map(|x| x[0]).collect::<Vec<f64>>();
53    let y_expected = test_expected_output
54        .clone()
55        .into_iter()
56        .flatten()
57        .collect::<Vec<f64>>();
58
59    plotter::plot(
60        "XOR",
61        (0..TEST_STEP).map(|v| v as f64).collect::<Vec<f64>>(),
62        vec![y_expected, y_estimated],
63        vec!["Expected".to_string(), "Output".to_string()],
64        Some(&path),
65    )
66    .unwrap();
67
68    write_as_serde(
69        model,
70        optimizer,
71        &train_input,
72        &train_expected_output,
73        &test_input,
74        &test_expected_output,
75        estimated_output,
76        None,
77    );
78}
79
80fn data_gen(step: usize, seed: u64) -> (Vec<Vec<f64>>, Vec<Vec<f64>>) {
81    let tau = 2;
82
83    let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
84
85    let train_input_vec = (0..step)
86        .map(|_| vec![rng.gen_range(0..2) as f64])
87        .collect::<Vec<Vec<f64>>>();
88
89    let mut expected_output_vec = vec![vec![0.0]; step];
90    for n in tau..step {
91        expected_output_vec[n][0] =
92            ((train_input_vec[n - 1][0] as u32) ^ (train_input_vec[n - 2][0] as u32)) as f64;
93    }
94
95    (train_input_vec, expected_output_vec)
96}
97
98fn get_bits_error_rate(
99    estimated_output: Vec<Vec<f64>>,
100    expected_output: Vec<Vec<f64>>,
101) -> (f64, f64) {
102    let mut y_tested_binary = vec![0.0; estimated_output.len()];
103
104    for (n, estimated) in estimated_output.iter().enumerate() {
105        if estimated[0] > 0.5 {
106            y_tested_binary[n] = 1.0;
107        } else {
108            y_tested_binary[n] = 0.0;
109        }
110    }
111
112    let expected_output = expected_output.into_iter().flatten().collect::<Vec<f64>>();
113
114    let mse = mean_squared_error(&expected_output, &y_tested_binary);
115    let mae = mean_absolute_error(&expected_output, &y_tested_binary);
116
117    (mse, mae)
118}
119
120fn get_error_rate(estimated_output: Vec<Vec<f64>>, expected_output: Vec<Vec<f64>>) -> (f64, f64) {
121    let estimated_output = estimated_output.iter().map(|x| x[0]).collect::<Vec<f64>>();
122    let expected_output = expected_output.into_iter().flatten().collect::<Vec<f64>>();
123
124    let mse = mean_squared_error(&expected_output, &estimated_output);
125    let mae = mean_absolute_error(&expected_output, &estimated_output);
126
127    (mse, mae)
128}
xor/xor.rs

xor/
xor.rs
