Struct Neuron

pub struct Neuron { /* private fields */ }

A neuron in a neural network.

A neuron has a collection of weights and a bias. It calculates the weighted sum of the inputs and applies an activation function to the result.

Implementations

impl Neuron

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

Create a new Neuron with n_inputs inputs.

The weights and bias are initialized randomly from a uniform distribution between -1 and 1.

The weights are named w_i where i is the index of the weight (starting from 1). The bias is named b.

Examples found in repository

examples/neuron.rs (line 18)

fn main() {
    let mut target = Expr::new_leaf(50.0, "target");
    target.is_learnable = false;

    let neuron = Neuron::new(3, Activation::None);
    println!("Initial values: {:}", neuron);

    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 = neuron.forward(inputs);
    y.name = "y".to_string();

    let difference = y - target;
    let mut square_exponent = Expr::new_leaf(2.0, "square_exponent");
    square_exponent.is_learnable = false;

    let mut loss = difference.pow(square_exponent, "loss");

    let target = loss.find("target").unwrap();
    let y = loss.find("y").unwrap();
    println!("Initial target: {:.2}", target.result);
    println!("Predicted: {:.2}", y.result);
    println!("Initial loss: {:.2}", loss.result);

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

        let y = loss.find("y").expect("Node not found");
        let target = loss.find("target").expect("Node not found");

        println!(
            "Iteration {:3}, loss: {:9.4} / predicted: {:.2} (target: {:.2})",
            i, loss.result, y.result, target.result
        );
    }

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

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

Calculate the output of the neuron for the given inputs.

The output of the neuron is the weighted sum of the inputs and the bias. The activation function is applied to the result.

Examples found in repository

examples/neuron.rs (line 31)

fn main() {
    let mut target = Expr::new_leaf(50.0, "target");
    target.is_learnable = false;

    let neuron = Neuron::new(3, Activation::None);
    println!("Initial values: {:}", neuron);

    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 = neuron.forward(inputs);
    y.name = "y".to_string();

    let difference = y - target;
    let mut square_exponent = Expr::new_leaf(2.0, "square_exponent");
    square_exponent.is_learnable = false;

    let mut loss = difference.pow(square_exponent, "loss");

    let target = loss.find("target").unwrap();
    let y = loss.find("y").unwrap();
    println!("Initial target: {:.2}", target.result);
    println!("Predicted: {:.2}", y.result);
    println!("Initial loss: {:.2}", loss.result);

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

        let y = loss.find("y").expect("Node not found");
        let target = loss.find("target").expect("Node not found");

        println!(
            "Iteration {:3}, loss: {:9.4} / predicted: {:.2} (target: {:.2})",
            i, loss.result, y.result, target.result
        );
    }

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

Trait Implementations

impl Display for Neuron

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

Formats the value using the given formatter.