vexus 4.0.0

A neural network builder and trainer struct to make your own AI models.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use std::f32::consts::PI;

use vexus::{NeuralNetwork, Sigmoid};

fn normalize(x: f32, min: f32, max: f32) -> f32 {
    (x - min) / (max - min)
}

fn denormalize(x: f32, min: f32, max: f32) -> f32 {
    x * (max - min) + min
}

fn main() {
    let mut nn = NeuralNetwork::new(vec![1, 4, 4, 1], 0.01, Box::new(Sigmoid));
    // Create a neural network with 1 input, one hidden layer of 10 neurons, and 1 output

    // Generate training data: f(x) = x^2 for x in [-1, 1]
    let training_data: Vec<(Vec<f32>, Vec<f32>)> = (-100..=100)
        .map(|i| {
            let x = i as f32 / 100.0;
            let y = x * x;
            (vec![normalize(x, -1.0, 1.0)], vec![normalize(y, 0.0, 1.0)])
        })
        .collect();

    // Train the network
    println!("Training...");
    for epoch in 0..1000000 {
        let mut error = 0.0;
        for (input, expected) in &training_data {
            let _output = nn.forward(input);
            error = nn.errors(expected);
            nn.backpropagate(expected);
        }

        if epoch % 10000 == 0 {
            println!(
                "Epoch {}: MSE = {:.6}",
                epoch,
                error / training_data.len() as f32
            );
        }
    }

    // Test the network
    println!("\nTesting...");
    let test_points = vec![-1.0, -0.5, 0.0, 0.5, 1.0, 1.0 / PI];
    for x in test_points {
        let predicted = denormalize(nn.forward(&vec![normalize(x, -1.0, 1.0)])[0], 0.0, 1.0);
        println!(
            "x = {:.3}, x^2 = {:.3}, predicted = {:.3}, error = {:.3}",
            x,
            x * x,
            predicted,
            ((x * x) - predicted).abs()
        );
    }
}