pub fn plot(
name: &str,
x: Vec<f64>,
ys: Vec<Vec<f64>>,
label: Vec<String>,
path: Option<&str>,
) -> Result<(), Box<dyn Error>>Expand description
Plot the graph of the given data. ‘name’ is the name of the file. ‘x’ is the x-axis data. ‘ys’ is the y-axis data. ‘label’ is the label of the data. ‘path’ is the path to save the graph.
Examples found in repository?
examples/narma.rs (lines 69-75)
19fn main() {
20 let (train_input, train_expected_output) =
21 narma_n_data_gen(TRAIN_STEP, RANDOM_SEED, NARMA_STEP);
22 let (test_input, test_expected_output) =
23 narma_n_data_gen(TEST_STEP, TEST_RANDOM_SEED, NARMA_STEP);
24
25 let path = format!("{}/examples/graph", env!("CARGO_MANIFEST_DIR"));
26
27 let n_u = train_input.first().unwrap().len() as u64;
28 let n_y = train_expected_output.first().unwrap().len() as u64;
29
30 let mut model = EchoStateNetwork::new(
31 n_u,
32 n_y,
33 N_X,
34 0.1,
35 1.0,
36 0.9,
37 |x| x.tanh(),
38 None,
39 None,
40 1.0,
41 |x| x.clone_owned(),
42 |x| x.clone_owned(),
43 false,
44 BETA,
45 );
46
47 model.offline_train(&train_input, &train_expected_output);
48
49 let mut estimated_output = vec![];
50 for input in test_input.iter() {
51 estimated_output.push(model.estimate(input));
52 }
53
54 let (l2_error, l1_error) = get_error_rate(
55 estimated_output.clone(),
56 test_expected_output.clone(),
57 NARMA_STEP,
58 );
59 println!("Mean Squared Error: {}", l2_error);
60 println!("Mean Absolute Error: {}", l1_error);
61
62 let y_estimated = estimated_output.iter().map(|x| x[0]).collect::<Vec<f64>>();
63 let y_expected = test_expected_output
64 .clone()
65 .into_iter()
66 .flatten()
67 .collect::<Vec<f64>>();
68
69 plotter::plot(
70 "NARMA",
71 (0..TEST_STEP).map(|v| v as f64).collect::<Vec<f64>>(),
72 vec![y_expected, y_estimated],
73 vec!["Expected".to_string(), "Estimated".to_string()],
74 Some(&path),
75 )
76 .unwrap();
77}More examples
examples/xor.rs (lines 61-67)
12fn main() {
13 let (train_input, train_expected_output) = xor_data_gen(TRAIN_STEP, RANDOM_SEED);
14 let (test_input, test_expected_output) = xor_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 BETA,
36 );
37
38 model.offline_train(&train_input, &train_expected_output);
39
40 let mut estimated_output = vec![];
41 for input in test_input.iter() {
42 estimated_output.push(model.estimate(input));
43 }
44
45 let (bits_l2_error, bits_l1_error) =
46 get_bits_error_rate(estimated_output.clone(), test_expected_output.clone(), 2);
47 let (l2_error, l1_error) =
48 get_error_rate(estimated_output.clone(), test_expected_output.clone(), 2);
49 println!("Bits Mean Squared Error: {}", bits_l2_error);
50 println!("Bits Mean Absolute Error: {}", bits_l1_error);
51 println!("Mean Squared Error: {}", l2_error);
52 println!("Mean Absolute Error: {}", l1_error);
53
54 let y_estimated = estimated_output.iter().map(|x| x[0]).collect::<Vec<f64>>();
55 let y_expected = test_expected_output
56 .clone()
57 .into_iter()
58 .flatten()
59 .collect::<Vec<f64>>();
60
61 plotter::plot(
62 "XOR",
63 (0..TEST_STEP).map(|v| v as f64).collect::<Vec<f64>>(),
64 vec![y_expected, y_estimated],
65 vec!["Expected".to_string(), "Output".to_string()],
66 Some(&path),
67 )
68 .unwrap();
69
70 write_as_serde(
71 model,
72 &train_input,
73 &train_expected_output,
74 &test_input,
75 &test_expected_output,
76 estimated_output,
77 None,
78 );
79}