Struct EchoStateNetwork 

pub struct EchoStateNetwork { /* private fields */ }

Implementations

impl EchoStateNetwork

pub fn new( n_u: u64, n_y: u64, n_x: u64, density: f64, input_scale: f64, rho: f64, activation: fn(f64) -> f64, feedback_scale: Option<f64>, noise_level: Option<f64>, leaking_rate: f64, output_function: fn(&DVector<f64>) -> DVector<f64>, inverse_output_function: fn(&DVector<f64>) -> DVector<f64>, is_classification: bool, ridge_beta: f64, ) -> Self

Examples found in repository

examples/narma.rs (lines 30-45)

fn main() {
    let (train_input, train_expected_output) =
        narma_n_data_gen(TRAIN_STEP, RANDOM_SEED, NARMA_STEP);
    let (test_input, test_expected_output) =
        narma_n_data_gen(TEST_STEP, TEST_RANDOM_SEED, NARMA_STEP);

    let path = format!("{}/examples/graph", env!("CARGO_MANIFEST_DIR"));

    let n_u = train_input.first().unwrap().len() as u64;
    let n_y = train_expected_output.first().unwrap().len() as u64;

    let mut model = EchoStateNetwork::new(
        n_u,
        n_y,
        N_X,
        0.1,
        1.0,
        0.9,
        |x| x.tanh(),
        None,
        None,
        1.0,
        |x| x.clone_owned(),
        |x| x.clone_owned(),
        false,
        BETA,
    );

    model.offline_train(&train_input, &train_expected_output);

    let mut estimated_output = vec![];
    for input in test_input.iter() {
        estimated_output.push(model.estimate(input));
    }

    let (l2_error, l1_error) = get_error_rate(
        estimated_output.clone(),
        test_expected_output.clone(),
        NARMA_STEP,
    );
    println!("Mean Squared Error: {}", l2_error);
    println!("Mean Absolute Error: {}", l1_error);

    let y_estimated = estimated_output.iter().map(|x| x[0]).collect::<Vec<f64>>();
    let y_expected = test_expected_output
        .clone()
        .into_iter()
        .flatten()
        .collect::<Vec<f64>>();

    plotter::plot(
        "NARMA",
        (0..TEST_STEP).map(|v| v as f64).collect::<Vec<f64>>(),
        vec![y_expected, y_estimated],
        vec!["Expected".to_string(), "Estimated".to_string()],
        Some(&path),
    )
    .unwrap();
}

examples/xor.rs (lines 21-36)

fn main() {
    let (train_input, train_expected_output) = xor_data_gen(TRAIN_STEP, RANDOM_SEED);
    let (test_input, test_expected_output) = xor_data_gen(TEST_STEP, TEST_RANDOM_SEED);

    let path = format!("{}/examples/graph", env!("CARGO_MANIFEST_DIR"));

    let n_u = train_input.first().unwrap().len() as u64;
    let n_y = train_expected_output.first().unwrap().len() as u64;

    let mut model = EchoStateNetwork::new(
        n_u,
        n_y,
        N_X,
        0.1,
        1.0,
        0.9,
        |x| x.tanh(),
        None,
        None,
        1.0,
        |x| x.clone_owned(),
        |x| x.clone_owned(),
        false,
        BETA,
    );

    model.offline_train(&train_input, &train_expected_output);

    let mut estimated_output = vec![];
    for input in test_input.iter() {
        estimated_output.push(model.estimate(input));
    }

    let (bits_l2_error, bits_l1_error) =
        get_bits_error_rate(estimated_output.clone(), test_expected_output.clone(), 2);
    let (l2_error, l1_error) =
        get_error_rate(estimated_output.clone(), test_expected_output.clone(), 2);
    println!("Bits Mean Squared Error: {}", bits_l2_error);
    println!("Bits Mean Absolute Error: {}", bits_l1_error);
    println!("Mean Squared Error: {}", l2_error);
    println!("Mean Absolute Error: {}", l1_error);

    let y_estimated = estimated_output.iter().map(|x| x[0]).collect::<Vec<f64>>();
    let y_expected = test_expected_output
        .clone()
        .into_iter()
        .flatten()
        .collect::<Vec<f64>>();

    plotter::plot(
        "XOR",
        (0..TEST_STEP).map(|v| v as f64).collect::<Vec<f64>>(),
        vec![y_expected, y_estimated],
        vec!["Expected".to_string(), "Output".to_string()],
        Some(&path),
    )
    .unwrap();

    write_as_serde(
        model,
        &train_input,
        &train_expected_output,
        &test_input,
        &test_expected_output,
        estimated_output,
        None,
    );
}

pub fn serde_json(&self) -> Result<String>

Trait Implementations

impl ReservoirComputing for EchoStateNetwork

fn train(&mut self, teaching_input: &[f64], teaching_output: &[f64])

Online training method.

fn offline_train( &mut self, teaching_input: &[Vec<f64>], teaching_output: &[Vec<f64>], )

Offline training method.

fn estimate(&mut self, input: &[f64]) -> Vec<f64>

Estimate method.