Struct MLP

pub struct MLP { /* private fields */ }

A multilayer perceptron.

A multilayer perceptron is a collection of Layers. It calculates the output of each layer and passes it to the next layer. The output of the MLP is the output of the last layer.

Implementations

impl MLP

pub fn new( n_inputs: u32, input_activation: Activation, n_hidden: Vec<u32>, hidden_activation: Activation, n_outputs: u32, output_activation: Activation, ) -> MLP

Create a new multilayer perceptron (MLP) with the given number of inputs, hidden layers, and outputs.

The MLP is a collection of Layers. The total number of layers is n_hidden.len() + 2. The first layer has n_inputs inputs and n_hidden[0] neurons. The hidden layer i has n_hidden[i] neurons. There are n_hidden.len() hidden layers. The last layer has n_hidden[n_hidden.len() - 1] inputs and n_outputs neurons. The activation functions for the input, hidden, and output layers are input_activation, hidden_activation, and output_activation, respectively.

Examples found in repository

examples/mlp.rs (lines 25-32)

fn main() {
    let mut targets = vec![
        Expr::new_leaf(150.0, "t1"),
        Expr::new_leaf(250.0, "t2"),
        Expr::new_leaf(350.0, "t3"),
    ];
    targets.iter_mut().for_each(|target| {
        target.is_learnable = false;
    });

    let mlp = MLP::new(
        3,
        Activation::Tanh,
        vec![2, 2],
        Activation::Tanh,
        1,
        Activation::None,
    );
    println!("Initial values: {:}", mlp);

    let mut inputs = vec![
        vec![
            Expr::new_leaf(1.0, "x_1,1"),
            Expr::new_leaf(2.0, "x_1,2"),
            Expr::new_leaf(3.0, "x_1,3"),
        ],
        vec![
            Expr::new_leaf(4.0, "x_2,1"),
            Expr::new_leaf(5.0, "x_2,2"),
            Expr::new_leaf(6.0, "x_2,3"),
        ],
        vec![
            Expr::new_leaf(7.0, "x_3,1"),
            Expr::new_leaf(8.0, "x_3,2"),
            Expr::new_leaf(9.0, "x_3,3"),
        ],
    ];

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

    let predictions = inputs
        // for each example, make a prediction
        .iter()
        .map(|example| mlp.forward(example.clone()))
        // name these predictions y1, y2, y3
        .enumerate()
        .map(|(i, mut y)| {
            // the result is a vector but it's a single value because we specified 1 output neuron
            let mut result = y.remove(0);
            result.name = format!("y{:}", i + 1).to_string();
            result
        })
        // collect them into a single vector
        .collect::<Vec<_>>();

    let differences = predictions
        .iter()
        .zip(targets.iter())
        .map(|(y, t)| y.clone() - t.clone())
        .collect::<Vec<_>>();
    let mut loss = differences
        .iter()
        .map(|d| d.clone() * d.clone())
        .sum::<Expr>();

    let y1 = loss.find("y1").unwrap();
    let y2 = loss.find("y2").unwrap();
    let y3 = loss.find("y3").unwrap();
    println!("Initial loss: {:.2}", loss.result);
    println!(
        "Initial predictions: {:5.2} {:5.2} {:5.2}",
        y1.result, y2.result, y3.result
    );

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

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

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

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

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

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

Calculate the output of the MLP for the given inputs.

The output of the MLP is the output of the last layer.

Examples found in repository

examples/mlp.rs (line 62)

fn main() {
    let mut targets = vec![
        Expr::new_leaf(150.0, "t1"),
        Expr::new_leaf(250.0, "t2"),
        Expr::new_leaf(350.0, "t3"),
    ];
    targets.iter_mut().for_each(|target| {
        target.is_learnable = false;
    });

    let mlp = MLP::new(
        3,
        Activation::Tanh,
        vec![2, 2],
        Activation::Tanh,
        1,
        Activation::None,
    );
    println!("Initial values: {:}", mlp);

    let mut inputs = vec![
        vec![
            Expr::new_leaf(1.0, "x_1,1"),
            Expr::new_leaf(2.0, "x_1,2"),
            Expr::new_leaf(3.0, "x_1,3"),
        ],
        vec![
            Expr::new_leaf(4.0, "x_2,1"),
            Expr::new_leaf(5.0, "x_2,2"),
            Expr::new_leaf(6.0, "x_2,3"),
        ],
        vec![
            Expr::new_leaf(7.0, "x_3,1"),
            Expr::new_leaf(8.0, "x_3,2"),
            Expr::new_leaf(9.0, "x_3,3"),
        ],
    ];

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

    let predictions = inputs
        // for each example, make a prediction
        .iter()
        .map(|example| mlp.forward(example.clone()))
        // name these predictions y1, y2, y3
        .enumerate()
        .map(|(i, mut y)| {
            // the result is a vector but it's a single value because we specified 1 output neuron
            let mut result = y.remove(0);
            result.name = format!("y{:}", i + 1).to_string();
            result
        })
        // collect them into a single vector
        .collect::<Vec<_>>();

    let differences = predictions
        .iter()
        .zip(targets.iter())
        .map(|(y, t)| y.clone() - t.clone())
        .collect::<Vec<_>>();
    let mut loss = differences
        .iter()
        .map(|d| d.clone() * d.clone())
        .sum::<Expr>();

    let y1 = loss.find("y1").unwrap();
    let y2 = loss.find("y2").unwrap();
    let y3 = loss.find("y3").unwrap();
    println!("Initial loss: {:.2}", loss.result);
    println!(
        "Initial predictions: {:5.2} {:5.2} {:5.2}",
        y1.result, y2.result, y3.result
    );

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

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

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

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

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

Trait Implementations

impl Display for MLP

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

Formats the value using the given formatter.