Struct Expr

pub struct Expr {
    pub result: f64,
    pub is_learnable: bool,
    pub name: String,
    /* private fields */
}

Expression representing a node in a calculation graph.

This struct represents a node in a calculation graph. It can be a leaf node, a unary operation or a binary operation.

A leaf node holds a value, which is the one that is used in the calculation.

A unary expression is the result of applying a unary operation to another expression. For example, the result of applying the tanh operation to a leaf node.

A binary expression is the result of applying a binary operation to two other expressions. For example, the result of adding two leaf nodes.

Fields

result: f64

The numeric result of the expression, as result of applying the operation to the operands.

is_learnable: bool

Whether the expression is learnable or not. Only learnable Expr will have their values updated during backpropagation (learning).

name: String

The name of the expression, used to identify it in the calculation graph.

Implementations

impl Expr

pub fn new_leaf(value: f64, name: &str) -> Expr

Creates a new leaf expression with the given value.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");

Examples found in repository

examples/operations.rs (line 11)

fn main() {
    let a = Expr::new_leaf(4.0, "a");
    let b = Expr::new_leaf(2.0, "b");

    let difference = a - b;

    let square_exponent = Expr::new_leaf(2.0, "square_exponent");
    let squared_diff = difference.pow(square_exponent, "squared_diff");

    println!("squared difference: {:.2}", squared_diff.result);
}

examples/neuron.rs (line 15)

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);
}

examples/layer.rs (line 15)

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);
}

examples/backpropagation.rs (line 17)

fn main() {
    // these are the initial values for the nodes of the graph
    let mut x1 = Expr::new_leaf(2.0, "x1");
    x1.is_learnable = false;

    let mut x2 = Expr::new_leaf(1.0, "x2");
    x2.is_learnable = false;

    let w1 = Expr::new_leaf(-3.0, "w1");
    let w2 = Expr::new_leaf(1.0, "w2");
    let b = Expr::new_leaf(6.5, "b");

    // here we compute the expression x1*w1 + x2*w2 + b
    let x1w1 = x1 * w1;
    let x2w2 = x2 * w2;
    let x1w1_x2w2 = x1w1 + x2w2;
    let n = x1w1_x2w2 + b;

    // we add a non-linear activation function: tanh(x1*w1 + x2*w2 + b)
    let o = n.tanh("o");

    println!("Initial output: {:.2}", o.result);

    // we set the target value
    let target_value = 0.2;
    let mut target = Expr::new_leaf(target_value, "target");
    target.is_learnable = false;

    // we compute the loss function
    let mut squared_exponent = Expr::new_leaf(2.0, "squared_exponent");
    squared_exponent.is_learnable = false;

    let mut loss = (o - target).pow(squared_exponent, "loss");
    loss.is_learnable = false;

    // we print the initial loss
    println!("Initial loss: {:.4}", loss.result);

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

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

        println!(
            "Iteration {:2}, loss: {:.4} / result: {:.2}",
            i, loss.result, target.result
        );
    }

    let w1 = loss.find("w1").expect("Node not found");
    let w2 = loss.find("w2").expect("Node not found");
    let b = loss.find("b").expect("Node not found");

    println!(
        "\nFinal values: w1: {:.2}, w2: {:.2}, b: {:.2}",
        w1.result, w2.result, b.result
    );

    let x1 = loss.find("x1").expect("Node not found");
    let x2 = loss.find("x2").expect("Node not found");

    let n = loss
        .find("(((x1 * w1) + (x2 * w2)) + b)") // auto-generated node name
        .expect("Node not found");
    let o = loss.find("o").expect("Node not found");

    println!(
        "Final formula: tanh({:.2}*{:.2} + {:.2}*{:.2} + {:.2}) = tanh({:.2}) = {:.2}",
        x1.result, w1.result, x2.result, w2.result, b.result, n.result, o.result
    )
}

examples/mlp.rs (line 17)

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 tanh(self, name: &str) -> Expr

Applies the hyperbolic tangent function to the expression and returns it as a new expression.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = expr.tanh("tanh");
 
println!("Result: {}", expr2.result); // 0.7615941559557649

Examples found in repository

examples/backpropagation.rs (line 34)

fn main() {
    // these are the initial values for the nodes of the graph
    let mut x1 = Expr::new_leaf(2.0, "x1");
    x1.is_learnable = false;

    let mut x2 = Expr::new_leaf(1.0, "x2");
    x2.is_learnable = false;

    let w1 = Expr::new_leaf(-3.0, "w1");
    let w2 = Expr::new_leaf(1.0, "w2");
    let b = Expr::new_leaf(6.5, "b");

    // here we compute the expression x1*w1 + x2*w2 + b
    let x1w1 = x1 * w1;
    let x2w2 = x2 * w2;
    let x1w1_x2w2 = x1w1 + x2w2;
    let n = x1w1_x2w2 + b;

    // we add a non-linear activation function: tanh(x1*w1 + x2*w2 + b)
    let o = n.tanh("o");

    println!("Initial output: {:.2}", o.result);

    // we set the target value
    let target_value = 0.2;
    let mut target = Expr::new_leaf(target_value, "target");
    target.is_learnable = false;

    // we compute the loss function
    let mut squared_exponent = Expr::new_leaf(2.0, "squared_exponent");
    squared_exponent.is_learnable = false;

    let mut loss = (o - target).pow(squared_exponent, "loss");
    loss.is_learnable = false;

    // we print the initial loss
    println!("Initial loss: {:.4}", loss.result);

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

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

        println!(
            "Iteration {:2}, loss: {:.4} / result: {:.2}",
            i, loss.result, target.result
        );
    }

    let w1 = loss.find("w1").expect("Node not found");
    let w2 = loss.find("w2").expect("Node not found");
    let b = loss.find("b").expect("Node not found");

    println!(
        "\nFinal values: w1: {:.2}, w2: {:.2}, b: {:.2}",
        w1.result, w2.result, b.result
    );

    let x1 = loss.find("x1").expect("Node not found");
    let x2 = loss.find("x2").expect("Node not found");

    let n = loss
        .find("(((x1 * w1) + (x2 * w2)) + b)") // auto-generated node name
        .expect("Node not found");
    let o = loss.find("o").expect("Node not found");

    println!(
        "Final formula: tanh({:.2}*{:.2} + {:.2}*{:.2} + {:.2}) = tanh({:.2}) = {:.2}",
        x1.result, w1.result, x2.result, w2.result, b.result, n.result, o.result
    )
}

pub fn relu(self, name: &str) -> Expr

Applies the rectified linear unit function to the expression and returns it as a new expression.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(-1.0, "x");
let expr2 = expr.relu("relu");
 
println!("Result: {}", expr2.result); // 0.0

pub fn exp(self, name: &str) -> Expr

Applies the exponential function (e^x) to the expression and returns it as a new expression.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = expr.exp("exp");
 
println!("Result: {}", expr2.result); // 2.718281828459045

pub fn pow(self, exponent: Expr, name: &str) -> Expr

Raises the expression to the power of the given exponent (expression) and returns it as a new expression.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(2.0, "x");
let exponent = Expr::new_leaf(3.0, "y");
let result = expr.pow(exponent, "x^y");
 
println!("Result: {}", result.result); // 8.0

Examples found in repository

examples/operations.rs (line 17)

fn main() {
    let a = Expr::new_leaf(4.0, "a");
    let b = Expr::new_leaf(2.0, "b");

    let difference = a - b;

    let square_exponent = Expr::new_leaf(2.0, "square_exponent");
    let squared_diff = difference.pow(square_exponent, "squared_diff");

    println!("squared difference: {:.2}", squared_diff.result);
}

examples/neuron.rs (line 38)

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);
}

examples/layer.rs (line 46)

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);
}

examples/backpropagation.rs (line 47)

fn main() {
    // these are the initial values for the nodes of the graph
    let mut x1 = Expr::new_leaf(2.0, "x1");
    x1.is_learnable = false;

    let mut x2 = Expr::new_leaf(1.0, "x2");
    x2.is_learnable = false;

    let w1 = Expr::new_leaf(-3.0, "w1");
    let w2 = Expr::new_leaf(1.0, "w2");
    let b = Expr::new_leaf(6.5, "b");

    // here we compute the expression x1*w1 + x2*w2 + b
    let x1w1 = x1 * w1;
    let x2w2 = x2 * w2;
    let x1w1_x2w2 = x1w1 + x2w2;
    let n = x1w1_x2w2 + b;

    // we add a non-linear activation function: tanh(x1*w1 + x2*w2 + b)
    let o = n.tanh("o");

    println!("Initial output: {:.2}", o.result);

    // we set the target value
    let target_value = 0.2;
    let mut target = Expr::new_leaf(target_value, "target");
    target.is_learnable = false;

    // we compute the loss function
    let mut squared_exponent = Expr::new_leaf(2.0, "squared_exponent");
    squared_exponent.is_learnable = false;

    let mut loss = (o - target).pow(squared_exponent, "loss");
    loss.is_learnable = false;

    // we print the initial loss
    println!("Initial loss: {:.4}", loss.result);

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

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

        println!(
            "Iteration {:2}, loss: {:.4} / result: {:.2}",
            i, loss.result, target.result
        );
    }

    let w1 = loss.find("w1").expect("Node not found");
    let w2 = loss.find("w2").expect("Node not found");
    let b = loss.find("b").expect("Node not found");

    println!(
        "\nFinal values: w1: {:.2}, w2: {:.2}, b: {:.2}",
        w1.result, w2.result, b.result
    );

    let x1 = loss.find("x1").expect("Node not found");
    let x2 = loss.find("x2").expect("Node not found");

    let n = loss
        .find("(((x1 * w1) + (x2 * w2)) + b)") // auto-generated node name
        .expect("Node not found");
    let o = loss.find("o").expect("Node not found");

    println!(
        "Final formula: tanh({:.2}*{:.2} + {:.2}*{:.2} + {:.2}) = tanh({:.2}) = {:.2}",
        x1.result, w1.result, x2.result, w2.result, b.result, n.result, o.result
    )
}

pub fn log(self, name: &str) -> Expr

Applies the natural logarithm function to the expression and returns it as a new expression.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(2.0, "x");
let expr2 = expr.log("log");
 
println!("Result: {}", expr2.result); // 0.6931471805599453

pub fn neg(self, name: &str) -> Expr

Negates the expression and returns it as a new expression.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = expr.neg("neg");
 
println!("Result: {}", expr2.result); // -1.0

pub fn recalculate(&mut self)

Recalculates the value of the expression recursively, from new values of the operands.

Usually will be used after a call to Expr::learn, where the gradients have been calculated and the internal values of the expression tree have been updated.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let mut expr2 = expr.tanh("tanh(x)");
expr2.learn(1e-09);
expr2.recalculate();

Examples found in repository

examples/neuron.rs (line 50)

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);
}

examples/layer.rs (line 61)

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);
}

examples/backpropagation.rs (line 57)

fn main() {
    // these are the initial values for the nodes of the graph
    let mut x1 = Expr::new_leaf(2.0, "x1");
    x1.is_learnable = false;

    let mut x2 = Expr::new_leaf(1.0, "x2");
    x2.is_learnable = false;

    let w1 = Expr::new_leaf(-3.0, "w1");
    let w2 = Expr::new_leaf(1.0, "w2");
    let b = Expr::new_leaf(6.5, "b");

    // here we compute the expression x1*w1 + x2*w2 + b
    let x1w1 = x1 * w1;
    let x2w2 = x2 * w2;
    let x1w1_x2w2 = x1w1 + x2w2;
    let n = x1w1_x2w2 + b;

    // we add a non-linear activation function: tanh(x1*w1 + x2*w2 + b)
    let o = n.tanh("o");

    println!("Initial output: {:.2}", o.result);

    // we set the target value
    let target_value = 0.2;
    let mut target = Expr::new_leaf(target_value, "target");
    target.is_learnable = false;

    // we compute the loss function
    let mut squared_exponent = Expr::new_leaf(2.0, "squared_exponent");
    squared_exponent.is_learnable = false;

    let mut loss = (o - target).pow(squared_exponent, "loss");
    loss.is_learnable = false;

    // we print the initial loss
    println!("Initial loss: {:.4}", loss.result);

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

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

        println!(
            "Iteration {:2}, loss: {:.4} / result: {:.2}",
            i, loss.result, target.result
        );
    }

    let w1 = loss.find("w1").expect("Node not found");
    let w2 = loss.find("w2").expect("Node not found");
    let b = loss.find("b").expect("Node not found");

    println!(
        "\nFinal values: w1: {:.2}, w2: {:.2}, b: {:.2}",
        w1.result, w2.result, b.result
    );

    let x1 = loss.find("x1").expect("Node not found");
    let x2 = loss.find("x2").expect("Node not found");

    let n = loss
        .find("(((x1 * w1) + (x2 * w2)) + b)") // auto-generated node name
        .expect("Node not found");
    let o = loss.find("o").expect("Node not found");

    println!(
        "Final formula: tanh({:.2}*{:.2} + {:.2}*{:.2} + {:.2}) = tanh({:.2}) = {:.2}",
        x1.result, w1.result, x2.result, w2.result, b.result, n.result, o.result
    )
}

examples/mlp.rs (line 97)

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 learn(&mut self, learning_rate: f64)

Applies backpropagation to the expression, updating the values of the gradients and the expression itself.

This method will change the gradients based on the gradient of the last expression in the calculation graph.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let mut expr2 = expr.tanh("tanh(x)");
expr2.learn(1e-09);

After adjusting the gradients, the method will update the values of the individual expression tree nodes to minimize the loss function.

In order to get a new calculation of the expression tree, you’ll need to call Expr::recalculate after calling Expr::learn.

Examples found in repository

examples/neuron.rs (line 49)

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);
}

examples/layer.rs (line 60)

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);
}

examples/backpropagation.rs (line 56)

fn main() {
    // these are the initial values for the nodes of the graph
    let mut x1 = Expr::new_leaf(2.0, "x1");
    x1.is_learnable = false;

    let mut x2 = Expr::new_leaf(1.0, "x2");
    x2.is_learnable = false;

    let w1 = Expr::new_leaf(-3.0, "w1");
    let w2 = Expr::new_leaf(1.0, "w2");
    let b = Expr::new_leaf(6.5, "b");

    // here we compute the expression x1*w1 + x2*w2 + b
    let x1w1 = x1 * w1;
    let x2w2 = x2 * w2;
    let x1w1_x2w2 = x1w1 + x2w2;
    let n = x1w1_x2w2 + b;

    // we add a non-linear activation function: tanh(x1*w1 + x2*w2 + b)
    let o = n.tanh("o");

    println!("Initial output: {:.2}", o.result);

    // we set the target value
    let target_value = 0.2;
    let mut target = Expr::new_leaf(target_value, "target");
    target.is_learnable = false;

    // we compute the loss function
    let mut squared_exponent = Expr::new_leaf(2.0, "squared_exponent");
    squared_exponent.is_learnable = false;

    let mut loss = (o - target).pow(squared_exponent, "loss");
    loss.is_learnable = false;

    // we print the initial loss
    println!("Initial loss: {:.4}", loss.result);

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

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

        println!(
            "Iteration {:2}, loss: {:.4} / result: {:.2}",
            i, loss.result, target.result
        );
    }

    let w1 = loss.find("w1").expect("Node not found");
    let w2 = loss.find("w2").expect("Node not found");
    let b = loss.find("b").expect("Node not found");

    println!(
        "\nFinal values: w1: {:.2}, w2: {:.2}, b: {:.2}",
        w1.result, w2.result, b.result
    );

    let x1 = loss.find("x1").expect("Node not found");
    let x2 = loss.find("x2").expect("Node not found");

    let n = loss
        .find("(((x1 * w1) + (x2 * w2)) + b)") // auto-generated node name
        .expect("Node not found");
    let o = loss.find("o").expect("Node not found");

    println!(
        "Final formula: tanh({:.2}*{:.2} + {:.2}*{:.2} + {:.2}) = tanh({:.2}) = {:.2}",
        x1.result, w1.result, x2.result, w2.result, b.result, n.result, o.result
    )
}

examples/mlp.rs (line 96)

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 find(&self, name: &str) -> Option<&Expr>

Finds a node in the expression tree by its name.

This method will search the expression tree for a node with the given name. If the node is not found, it will return None.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = expr.tanh("tanh(x)");
let original = expr2.find("x");
 
assert_eq!(original.expect("Could not find x").result, 1.0);

Examples found in repository

examples/neuron.rs (line 40)

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);
}

examples/layer.rs (line 48)

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);
}

examples/backpropagation.rs (line 59)

fn main() {
    // these are the initial values for the nodes of the graph
    let mut x1 = Expr::new_leaf(2.0, "x1");
    x1.is_learnable = false;

    let mut x2 = Expr::new_leaf(1.0, "x2");
    x2.is_learnable = false;

    let w1 = Expr::new_leaf(-3.0, "w1");
    let w2 = Expr::new_leaf(1.0, "w2");
    let b = Expr::new_leaf(6.5, "b");

    // here we compute the expression x1*w1 + x2*w2 + b
    let x1w1 = x1 * w1;
    let x2w2 = x2 * w2;
    let x1w1_x2w2 = x1w1 + x2w2;
    let n = x1w1_x2w2 + b;

    // we add a non-linear activation function: tanh(x1*w1 + x2*w2 + b)
    let o = n.tanh("o");

    println!("Initial output: {:.2}", o.result);

    // we set the target value
    let target_value = 0.2;
    let mut target = Expr::new_leaf(target_value, "target");
    target.is_learnable = false;

    // we compute the loss function
    let mut squared_exponent = Expr::new_leaf(2.0, "squared_exponent");
    squared_exponent.is_learnable = false;

    let mut loss = (o - target).pow(squared_exponent, "loss");
    loss.is_learnable = false;

    // we print the initial loss
    println!("Initial loss: {:.4}", loss.result);

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

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

        println!(
            "Iteration {:2}, loss: {:.4} / result: {:.2}",
            i, loss.result, target.result
        );
    }

    let w1 = loss.find("w1").expect("Node not found");
    let w2 = loss.find("w2").expect("Node not found");
    let b = loss.find("b").expect("Node not found");

    println!(
        "\nFinal values: w1: {:.2}, w2: {:.2}, b: {:.2}",
        w1.result, w2.result, b.result
    );

    let x1 = loss.find("x1").expect("Node not found");
    let x2 = loss.find("x2").expect("Node not found");

    let n = loss
        .find("(((x1 * w1) + (x2 * w2)) + b)") // auto-generated node name
        .expect("Node not found");
    let o = loss.find("o").expect("Node not found");

    println!(
        "Final formula: tanh({:.2}*{:.2} + {:.2}*{:.2} + {:.2}) = tanh({:.2}) = {:.2}",
        x1.result, w1.result, x2.result, w2.result, b.result, n.result, o.result
    )
}

examples/mlp.rs (line 84)

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 Add<Expr> for f64

Implements the Add trait for the f64 type, when the right operand is an Expr.

This implementation allows the addition of a f64 value and an Expr object.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let result = 2.0 + expr;
 
println!("Result: {}", result.result); // 3.0

type Output = Expr

The resulting type after applying the + operator.

fn add(self, other: Expr) -> Expr

Performs the + operation.

impl Add<f64> for Expr

Implements the Add trait for the Expr struct, when the right operand is a f64.

This implementation allows the addition of an Expr object and a f64 value.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let result = expr + 2.0;
 
println!("Result: {}", result.result); // 3.0

type Output = Expr

The resulting type after applying the + operator.

fn add(self, other: f64) -> Expr

Performs the + operation.

impl Add for Expr

Implements the Add trait for the Expr struct.

This implementation allows the addition of two Expr objects.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = Expr::new_leaf(2.0, "y");
 
let result = expr + expr2;
 
println!("Result: {}", result.result); // 3.0

type Output = Expr

The resulting type after applying the + operator.

fn add(self, other: Expr) -> Expr

Performs the + operation.

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Div<f64> for Expr

Implements the Div trait for the Expr struct, when the right operand is a f64.

This implementation allows the division of an Expr object and a f64 value.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let result = expr / 2.0;
 
println!("Result: {}", result.result); // 0.5

type Output = Expr

The resulting type after applying the / operator.

fn div(self, other: f64) -> Expr

Performs the / operation.

impl Div for Expr

Implements the Div trait for the Expr struct.

This implementation allows the division of two Expr objects.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = Expr::new_leaf(2.0, "y");
 
let result = expr / expr2;
 
println!("Result: {}", result.result); // 0.5

type Output = Expr

The resulting type after applying the / operator.

fn div(self, other: Expr) -> Expr

Performs the / operation.

impl Mul<Expr> for f64

Implements the Mul trait for the f64 type, when the right operand is an Expr.

This implementation allows the multiplication of a f64 value and an Expr object.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let result = 2.0 * expr;
 
println!("Result: {}", result.result); // 2.0

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, other: Expr) -> Expr

Performs the * operation.

impl Mul<f64> for Expr

Implements the Mul trait for the Expr struct, when the right operand is a f64.

This implementation allows the multiplication of an Expr object and a f64 value.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let result = expr * 2.0;
 
println!("Result: {}", result.result); // 2.0

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Expr

Performs the * operation.

impl Mul for Expr

Implements the Mul trait for the Expr struct.

This implementation allows the multiplication of two Expr objects.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = Expr::new_leaf(2.0, "y");
 
let result = expr * expr2;
 
println!("Result: {}", result.result); // 2.0

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, other: Expr) -> Expr

Performs the * operation.

impl Sub<Expr> for f64

Implements the Sub trait for the f64 type, when the right operand is an Expr.

This implementation allows the subtraction of a f64 value and an Expr object.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let result = 2.0 - expr;
 
println!("Result: {}", result.result); // 1.0

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, other: Expr) -> Expr

Performs the - operation.

impl Sub<f64> for Expr

Implements the Sub trait for the Expr struct, when the right operand is a f64.

This implementation allows the subtraction of an Expr object and a f64 value.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let result = expr - 2.0;
 
println!("Result: {}", result.result); // -1.0

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, other: f64) -> Expr

Performs the - operation.

impl Sub for Expr

Implements the Sub trait for the Expr struct.

This implementation allows the subtraction of two Expr objects.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = Expr::new_leaf(2.0, "y");
 
let result = expr - expr2;
 
println!("Result: {}", result.result); // -1.0

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, other: Expr) -> Expr

Performs the - operation.

impl Sum for Expr

Implements the Sum trait for the Expr struct.

Note that this implementation will generate temporary Expr objects, which may not be the most efficient way to sum a collection of Expr objects. However, it is provided as a convenience method for users that want to use sum over an Iterator<Expr>.

Example:

use alpha_micrograd_rust::value::Expr;
 
let expr = Expr::new_leaf(1.0, "x");
let expr2 = Expr::new_leaf(2.0, "y");
let expr3 = Expr::new_leaf(3.0, "z");
 
let sum = vec![expr, expr2, expr3].into_iter().sum::<Expr>();
 
println!("Result: {}", sum.result); // 6.0

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.