Struct Layer

pub struct Layer { /* private fields */ }

A layer in a neural network.

A layer is a collection of Neurons. It calculates the output of each neuron in the layer. The output of the layer is the collection of the outputs of the neurons.

Implementations

impl Layer

pub fn new(n_inputs: u32, n_outputs: u32, activation: Activation) -> Layer

Create a new Layer with n_inputs to the neurons and n_outputs neurons.

The layer is a collection of neurons. The number of neurons is n_outputs. Each neuron has n_inputs inputs.

Examples found in repository

examples/layer.rs (line 19)

fn main() {
    let mut target = vec![Expr::new_leaf(15.0, "t1"), Expr::new_leaf(85.0, "t2")];
    target[0].is_learnable = false;
    target[1].is_learnable = false;

    let layer = Layer::new(3, 2, Activation::None);
    println!("Initial values: {:}", layer);

    let mut inputs = vec![
        Expr::new_leaf(1.0, "x_1"),
        Expr::new_leaf(2.0, "x_2"),
        Expr::new_leaf(3.0, "x_3"),
    ];

    inputs.iter_mut().for_each(|input| {
        input.is_learnable = false;
    });

    let mut y = layer.forward(inputs);
    let mut y1 = y.remove(0);
    y1.name = "y1".to_string();
    let mut y2 = y.remove(0);
    y2.name = "y2".to_string();

    let d1 = y1 - target[0].clone();
    let mut sqr1 = Expr::new_leaf(2.0, "square_exponent1");
    sqr1.is_learnable = false;

    let d2 = y2 - target[1].clone();
    let mut sqr2 = Expr::new_leaf(2.0, "square_exponent2");
    sqr2.is_learnable = false;

    let mut loss = d1.pow(sqr1, "diff1") + d2.pow(sqr2, "diff2");

    let t1 = loss.find("t1").unwrap();
    let t2 = loss.find("t2").unwrap();
    let y1 = loss.find("y1").unwrap();
    let y2 = loss.find("y2").unwrap();

    println!("Initial targets: {:.2}, {:.2}", t1.result, t2.result);
    println!("Predicted: {:.2}, {:.2}", y1.result, y2.result);
    println!("Initial loss: {:.2}", loss.result);

    println!("\nTraining:");
    let learning_rate = 0.004;
    for i in 1..=100 {
        loss.learn(learning_rate);
        loss.recalculate();

        let t1 = loss.find("t1").unwrap();
        let t2 = loss.find("t2").unwrap();
        let y1 = loss.find("y1").unwrap();
        let y2 = loss.find("y2").unwrap();

        println!(
            "Iteration {:3}, loss: {:9.4} / predicted: {:5.2}, {:5.2} (targets: {:5.2}, {:5.2})",
            i, loss.result, y1.result, y2.result, t1.result, t2.result
        );
    }

    println!("Final values: {:}", layer);
}

pub fn forward(&self, x: Vec<Expr>) -> Vec<Expr>

Calculate the output of the layer for the given inputs.

The output of the layer is the collection of the outputs of the neurons.

Examples found in repository

examples/layer.rs (line 32)

fn main() {
    let mut target = vec![Expr::new_leaf(15.0, "t1"), Expr::new_leaf(85.0, "t2")];
    target[0].is_learnable = false;
    target[1].is_learnable = false;

    let layer = Layer::new(3, 2, Activation::None);
    println!("Initial values: {:}", layer);

    let mut inputs = vec![
        Expr::new_leaf(1.0, "x_1"),
        Expr::new_leaf(2.0, "x_2"),
        Expr::new_leaf(3.0, "x_3"),
    ];

    inputs.iter_mut().for_each(|input| {
        input.is_learnable = false;
    });

    let mut y = layer.forward(inputs);
    let mut y1 = y.remove(0);
    y1.name = "y1".to_string();
    let mut y2 = y.remove(0);
    y2.name = "y2".to_string();

    let d1 = y1 - target[0].clone();
    let mut sqr1 = Expr::new_leaf(2.0, "square_exponent1");
    sqr1.is_learnable = false;

    let d2 = y2 - target[1].clone();
    let mut sqr2 = Expr::new_leaf(2.0, "square_exponent2");
    sqr2.is_learnable = false;

    let mut loss = d1.pow(sqr1, "diff1") + d2.pow(sqr2, "diff2");

    let t1 = loss.find("t1").unwrap();
    let t2 = loss.find("t2").unwrap();
    let y1 = loss.find("y1").unwrap();
    let y2 = loss.find("y2").unwrap();

    println!("Initial targets: {:.2}, {:.2}", t1.result, t2.result);
    println!("Predicted: {:.2}, {:.2}", y1.result, y2.result);
    println!("Initial loss: {:.2}", loss.result);

    println!("\nTraining:");
    let learning_rate = 0.004;
    for i in 1..=100 {
        loss.learn(learning_rate);
        loss.recalculate();

        let t1 = loss.find("t1").unwrap();
        let t2 = loss.find("t2").unwrap();
        let y1 = loss.find("y1").unwrap();
        let y2 = loss.find("y2").unwrap();

        println!(
            "Iteration {:3}, loss: {:9.4} / predicted: {:5.2}, {:5.2} (targets: {:5.2}, {:5.2})",
            i, loss.result, y1.result, y2.result, t1.result, t2.result
        );
    }

    println!("Final values: {:}", layer);
}

Trait Implementations

impl Display for Layer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.