Function loss 

pub fn loss(
    train: &Vec<f32>,
    validation: &Vec<f32>,
    accuracy: &Vec<f32>,
    title: &str,
    path: &str,
)

Plots a simple line plot of the given data.

Arguments

• train - The training loss.
• validation - The validation loss.
• accuracy - The validation accuracy.
• title - The title of the plot.
• path - The path to save the plot.

Examples found in repository

examples/bike/plain.rs (lines 80-86)

fn main() {
    // Load the ftir dataset
    let (x, y) = data("./examples/datasets/bike/hour.csv");

    let split = (x.len() as f32 * 0.8) as usize;
    let x = x.split_at(split);
    let y = y.split_at(split);

    let x_train: Vec<&tensor::Tensor> = x.0.iter().collect();
    let y_train: Vec<&tensor::Tensor> = y.0.iter().collect();
    let x_test: Vec<&tensor::Tensor> = x.1.iter().collect();
    let y_test: Vec<&tensor::Tensor> = y.1.iter().collect();

    // Create the network
    let mut network = network::Network::new(tensor::Shape::Single(12));

    network.dense(24, activation::Activation::ReLU, false, None);
    network.dense(24, activation::Activation::ReLU, false, None);
    network.dense(24, activation::Activation::ReLU, false, None);

    network.dense(1, activation::Activation::Linear, false, None);
    network.set_objective(objective::Objective::RMSE, None);

    network.set_optimizer(optimizer::Adam::create(0.01, 0.9, 0.999, 1e-4, None));

    println!("{}", network);

    // Train the network

    let (train_loss, val_loss, val_acc) = network.learn(
        &x_train,
        &y_train,
        Some((&x_test, &y_test, 25)),
        64,
        600,
        Some(100),
    );
    plot::loss(
        &train_loss,
        &val_loss,
        &val_acc,
        &"PLAIN : BIKE",
        &"./output/bike/plain.png",
    );

    // Use the network
    let prediction = network.predict(x_test.get(0).unwrap());
    println!(
        "Prediction. Target: {}. Output: {}.",
        y_test[0].data, prediction.data
    );
}

examples/bike/looping.rs (lines 83-89)

fn main() {
    // Load the ftir dataset
    let (x, y) = data("./examples/datasets/bike/hour.csv");

    let split = (x.len() as f32 * 0.8) as usize;
    let x = x.split_at(split);
    let y = y.split_at(split);

    let x_train: Vec<&tensor::Tensor> = x.0.iter().collect();
    let y_train: Vec<&tensor::Tensor> = y.0.iter().collect();
    let x_test: Vec<&tensor::Tensor> = x.1.iter().collect();
    let y_test: Vec<&tensor::Tensor> = y.1.iter().collect();

    // Create the network
    let mut network = network::Network::new(tensor::Shape::Single(12));

    network.dense(24, activation::Activation::ReLU, false, None);
    network.dense(24, activation::Activation::ReLU, false, None);
    network.dense(24, activation::Activation::ReLU, false, None);

    network.dense(1, activation::Activation::Linear, false, None);
    network.set_objective(objective::Objective::RMSE, None);

    network.loopback(2, 1, 2, Arc::new(|_loops| 1.0), false);

    network.set_optimizer(optimizer::Adam::create(0.01, 0.9, 0.999, 1e-4, None));

    println!("{}", network);

    // Train the network

    let (train_loss, val_loss, val_acc) = network.learn(
        &x_train,
        &y_train,
        Some((&x_test, &y_test, 25)),
        64,
        600,
        Some(100),
    );
    plot::loss(
        &train_loss,
        &val_loss,
        &val_acc,
        &"LOOP : BIKE",
        &"./output/bike/loop.png",
    );

    // Use the network
    let prediction = network.predict(x_test.get(0).unwrap());
    println!(
        "Prediction. Target: {}. Output: {}.",
        y_test[0].data, prediction.data
    );
}

examples/bike/feedback.rs (lines 88-94)

fn main() {
    // Load the ftir dataset
    let (x, y) = data("./examples/datasets/bike/hour.csv");

    let split = (x.len() as f32 * 0.8) as usize;
    let x = x.split_at(split);
    let y = y.split_at(split);

    let x_train: Vec<&tensor::Tensor> = x.0.iter().collect();
    let y_train: Vec<&tensor::Tensor> = y.0.iter().collect();
    let x_test: Vec<&tensor::Tensor> = x.1.iter().collect();
    let y_test: Vec<&tensor::Tensor> = y.1.iter().collect();

    // Create the network
    let mut network = network::Network::new(tensor::Shape::Single(12));

    network.dense(24, activation::Activation::ReLU, false, None);
    network.feedback(
        vec![
            feedback::Layer::Dense(24, activation::Activation::ReLU, false, None),
            feedback::Layer::Dense(24, activation::Activation::ReLU, false, None),
        ],
        3,
        true,
        true,
        feedback::Accumulation::Mean,
    );

    network.dense(1, activation::Activation::Linear, false, None);
    network.set_objective(objective::Objective::RMSE, None);

    network.set_optimizer(optimizer::Adam::create(0.01, 0.9, 0.999, 1e-4, None));

    println!("{}", network);

    // Train the network

    let (train_loss, val_loss, val_acc) = network.learn(
        &x_train,
        &y_train,
        Some((&x_test, &y_test, 25)),
        64,
        600,
        Some(100),
    );
    plot::loss(
        &train_loss,
        &val_loss,
        &val_acc,
        &"FEEDBACK : BIKE",
        &"./output/bike/feedback.png",
    );

    // Use the network
    let prediction = network.predict(x_test.get(0).unwrap());
    println!(
        "Prediction. Target: {}. Output: {}.",
        y_test[0].data, prediction.data
    );
}

examples/mnist-fashion/skip.rs (lines 126-132)

fn main() {
    let x_train = load_mnist("./examples/datasets/mnist-fashion/train-images-idx3-ubyte").unwrap();
    let y_train = load_labels(
        "./examples/datasets/mnist-fashion/train-labels-idx1-ubyte",
        10,
    )
    .unwrap();
    let x_test = load_mnist("./examples/datasets/mnist-fashion/t10k-images-idx3-ubyte").unwrap();
    let y_test = load_labels(
        "./examples/datasets/mnist-fashion/t10k-labels-idx1-ubyte",
        10,
    )
    .unwrap();
    println!(
        "Train: {} images, Test: {} images",
        x_train.len(),
        x_test.len()
    );

    let x_train: Vec<&tensor::Tensor> = x_train.iter().collect();
    let y_train: Vec<&tensor::Tensor> = y_train.iter().collect();
    let x_test: Vec<&tensor::Tensor> = x_test.iter().collect();
    let y_test: Vec<&tensor::Tensor> = y_test.iter().collect();

    let mut network = network::Network::new(tensor::Shape::Triple(1, 14, 14));

    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.maxpool((2, 2), (2, 2));
    network.dense(10, activation::Activation::Softmax, true, None);

    network.connect(0, 2);

    network.set_optimizer(optimizer::Adam::create(0.001, 0.9, 0.999, 1e-8, None));
    network.set_objective(objective::Objective::CrossEntropy, None);

    println!("{}", network);

    // Train the network
    let (train_loss, val_loss, val_acc) = network.learn(
        &x_train,
        &y_train,
        Some((&x_test, &y_test, 10)),
        32,
        25,
        Some(5),
    );
    plot::loss(
        &train_loss,
        &val_loss,
        &val_acc,
        "SKIP : Fashion-MNIST",
        "./output/mnist-fashion/skip.png",
    );

    // Validate the network
    let (val_loss, val_acc) = network.validate(&x_test, &y_test, 1e-6);
    println!(
        "Final validation accuracy: {:.2} % and loss: {:.5}",
        val_acc * 100.0,
        val_loss
    );

    // Use the network
    let prediction = network.predict(x_test.get(0).unwrap());
    println!(
        "Prediction on input: Target: {}. Output: {}.",
        y_test[0].argmax(),
        prediction.argmax()
    );

    // let x = x_test.get(5).unwrap();
    // let y = y_test.get(5).unwrap();
    // Plot the pre- and post-activation heatmaps for each (image) layer.
    // let (pre, post, _) = network.forward(x);
    // for (i, (i_pre, i_post)) in pre.iter().zip(post.iter()).enumerate() {
    //     let pre_title = format!("layer_{}_pre", i);
    //     let post_title = format!("layer_{}_post", i);
    //     let pre_file = format!("layer_{}_pre.png", i);
    //     let post_file = format!("layer_{}_post.png", i);
    //     plot::heatmap(&i_pre, &pre_title, &pre_file);
    //     plot::heatmap(&i_post, &post_title, &post_file);
    // }
}

examples/mnist/plain.rs (lines 119-125)

fn main() {
    let x_train = load_mnist("./examples/datasets/mnist/train-images-idx3-ubyte").unwrap();
    let y_train = load_labels("./examples/datasets/mnist/train-labels-idx1-ubyte", 10).unwrap();
    let x_test = load_mnist("./examples/datasets/mnist/t10k-images-idx3-ubyte").unwrap();
    let y_test = load_labels("./examples/datasets/mnist/t10k-labels-idx1-ubyte", 10).unwrap();
    println!(
        "Train: {} images, Test: {} images",
        x_train.len(),
        x_test.len()
    );

    let x_train: Vec<&tensor::Tensor> = x_train.iter().collect();
    let y_train: Vec<&tensor::Tensor> = y_train.iter().collect();
    let x_test: Vec<&tensor::Tensor> = x_test.iter().collect();
    let y_test: Vec<&tensor::Tensor> = y_test.iter().collect();

    let mut network = network::Network::new(tensor::Shape::Triple(1, 14, 14));

    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.maxpool((2, 2), (2, 2));
    network.dense(10, activation::Activation::Softmax, true, None);

    network.set_optimizer(optimizer::Adam::create(0.001, 0.9, 0.999, 1e-8, None));
    network.set_objective(
        objective::Objective::CrossEntropy, // Objective function
        None,                               // Gradient clipping
    );

    println!("{}", network);

    // Train the network
    let (train_loss, val_loss, val_acc) = network.learn(
        &x_train,
        &y_train,
        Some((&x_test, &y_test, 10)),
        32,
        25,
        Some(5),
    );
    plot::loss(
        &train_loss,
        &val_loss,
        &val_acc,
        "PLAIN : MNIST",
        "./output/mnist/plain.png",
    );

    // Validate the network
    let (val_loss, val_acc) = network.validate(&x_test, &y_test, 1e-6);
    println!(
        "Final validation accuracy: {:.2} % and loss: {:.5}",
        val_acc * 100.0,
        val_loss
    );

    // Use the network
    let prediction = network.predict(x_test.get(0).unwrap());
    println!(
        "Prediction on input: Target: {}. Output: {}.",
        y_test[0].argmax(),
        prediction.argmax()
    );

    // let x = x_test.get(5).unwrap();
    // let y = y_test.get(5).unwrap();
    // plot::heatmap(
    //     &x,
    //     &format!("Target: {}", y.argmax()),
    //     "./output/mnist/input.png",
    // );

    // Plot the pre- and post-activation heatmaps for each (image) layer.
    // let (pre, post, _) = network.forward(x);
    // for (i, (i_pre, i_post)) in pre.iter().zip(post.iter()).enumerate() {
    //     let pre_title = format!("layer_{}_pre", i);
    //     let post_title = format!("layer_{}_post", i);
    //     let pre_file = format!("layer_{}_pre.png", i);
    //     let post_file = format!("layer_{}_post.png", i);
    //     plot::heatmap(&i_pre, &pre_title, &pre_file);
    //     plot::heatmap(&i_post, &post_title, &post_file);
    // }
}

examples/mnist/skip.rs (lines 121-127)

fn main() {
    let x_train = load_mnist("./examples/datasets/mnist/train-images-idx3-ubyte").unwrap();
    let y_train = load_labels("./examples/datasets/mnist/train-labels-idx1-ubyte", 10).unwrap();
    let x_test = load_mnist("./examples/datasets/mnist/t10k-images-idx3-ubyte").unwrap();
    let y_test = load_labels("./examples/datasets/mnist/t10k-labels-idx1-ubyte", 10).unwrap();
    println!(
        "Train: {} images, Test: {} images",
        x_train.len(),
        x_test.len()
    );

    let x_train: Vec<&tensor::Tensor> = x_train.iter().collect();
    let y_train: Vec<&tensor::Tensor> = y_train.iter().collect();
    let x_test: Vec<&tensor::Tensor> = x_test.iter().collect();
    let y_test: Vec<&tensor::Tensor> = y_test.iter().collect();

    let mut network = network::Network::new(tensor::Shape::Triple(1, 14, 14));

    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.convolution(
        1,
        (3, 3),
        (1, 1),
        (1, 1),
        (1, 1),
        activation::Activation::ReLU,
        None,
    );
    network.maxpool((2, 2), (2, 2));
    network.dense(10, activation::Activation::Softmax, true, None);

    network.connect(0, 3);

    network.set_optimizer(optimizer::Adam::create(0.001, 0.9, 0.999, 1e-8, None));
    network.set_objective(
        objective::Objective::CrossEntropy, // Objective function
        None,                               // Gradient clipping
    );

    println!("{}", network);

    // Train the network
    let (train_loss, val_loss, val_acc) = network.learn(
        &x_train,
        &y_train,
        Some((&x_test, &y_test, 10)),
        32,
        25,
        Some(5),
    );
    plot::loss(
        &train_loss,
        &val_loss,
        &val_acc,
        "SKIP : MNIST",
        "./output/mnist/skip.png",
    );

    // Validate the network
    let (val_loss, val_acc) = network.validate(&x_test, &y_test, 1e-6);
    println!(
        "Final validation accuracy: {:.2} % and loss: {:.5}",
        val_acc * 100.0,
        val_loss
    );

    // Use the network
    let prediction = network.predict(x_test.get(0).unwrap());
    println!(
        "Prediction on input: Target: {}. Output: {}.",
        y_test[0].argmax(),
        prediction.argmax()
    );

    // let x = x_test.get(5).unwrap();
    // let y = y_test.get(5).unwrap();
    // plot::heatmap(
    //     &x,
    //     &format!("Target: {}", y.argmax()),
    //     "./output/mnist/input.png",
    // );

    // Plot the pre- and post-activation heatmaps for each (image) layer.
    // let (pre, post, _) = network.forward(x);
    // for (i, (i_pre, i_post)) in pre.iter().zip(post.iter()).enumerate() {
    //     let pre_title = format!("layer_{}_pre", i);
    //     let post_title = format!("layer_{}_post", i);
    //     let pre_file = format!("layer_{}_pre.png", i);
    //     let post_file = format!("layer_{}_post.png", i);
    //     plot::heatmap(&i_pre, &pre_title, &pre_file);
    //     plot::heatmap(&i_post, &post_title, &post_file);
    // }
}

Additional examples can be found in:

• examples/mnist/deconvolution.rs
• examples/mnist-fashion/feedback.rs
• examples/mnist-fashion/plain.rs
• examples/mnist/feedback.rs
• examples/cifar10/plain.rs
• examples/mnist-fashion/looping.rs
• examples/cifar10/looping.rs
• examples/mnist/looping.rs
• examples/ftir/mlp/plain.rs
• examples/cifar10/feedback.rs
• examples/ftir/cnn/plain.rs
• examples/ftir/mlp/skip.rs
• examples/ftir/mlp/looping.rs
• examples/ftir/cnn/skip.rs
• examples/ftir/cnn/looping.rs
• examples/ftir/cnn/feedback.rs
• examples/ftir/mlp/feedback.rs