Struct BasicTrainer

pub struct BasicTrainer<const N: usize, const O: usize> { /* private fields */ }

A simple struct for Training Neural Networks

Implementations

impl<const N: usize, const O: usize> BasicTrainer<N, O>

pub fn new(data: DataSet<N, O>) -> Self

Examples found in repository

examples/training.rs (line 16)

fn main() {
    // create a neural network
    let mut net = NeuralNetwork::new().add_layer(1, ActivationFunction::Linear);

    // create training data
    let mut inputs = vec![];
    let mut outputs = vec![];
    for i in -50..50 {
        inputs.push([i as f32]);
        outputs.push([i as f32 * 3.0]);
    }
    let data = DataSet { inputs, outputs };

    let trainer = BasicTrainer::new(data);

    // train the model
    for _ in 0..10 {
        trainer.train(&mut net, 10);
        // lower is better
        println!("{}", trainer.get_total_error(&net))
    }

    // show that this actually works!
    println!("########");
    for i in -5..5 {
        println!("{}", &net.run(&[i as f32 + 0.5])[0]);
    }
}

examples/circle.rs (line 30)

fn main() {
    // this network is completely overkill, but it does the job
    let mut net: NeuralNetwork<2, 1> = NeuralNetwork::new()
        .add_layer(3, ActivationFunction::ReLU)
        .add_layer(3, ActivationFunction::ReLU)
        // this layer reduced everything to one input!
        .add_layer(1, ActivationFunction::Linear);

    let mut inputs = vec![];
    let mut output = vec![];
    for x in 0..=100 {
        for y in 0..=100 {
            inputs.push([x as f32, y as f32]);
            // we want this to be a classifier, so we ask it for a result greater zero or smaller zero
            output.push(if (x as f32).abs() + (y as f32).abs() < 30.0 {
                [1.0]
            } else {
                [-1.0]
            })
        }
    }

    let data = DataSet {
        inputs,
        outputs: output,
    };

    let trainer = BasicTrainer::new(data);
    for _ in 0..50 {
        trainer.train(&mut net, 10);
        println!("{}", trainer.get_total_error(&net))
    }
}

pub fn train(&self, net: &mut NeuralNetwork<N, O>, iterations: usize)

Examples found in repository

examples/training.rs (line 20)

fn main() {
    // create a neural network
    let mut net = NeuralNetwork::new().add_layer(1, ActivationFunction::Linear);

    // create training data
    let mut inputs = vec![];
    let mut outputs = vec![];
    for i in -50..50 {
        inputs.push([i as f32]);
        outputs.push([i as f32 * 3.0]);
    }
    let data = DataSet { inputs, outputs };

    let trainer = BasicTrainer::new(data);

    // train the model
    for _ in 0..10 {
        trainer.train(&mut net, 10);
        // lower is better
        println!("{}", trainer.get_total_error(&net))
    }

    // show that this actually works!
    println!("########");
    for i in -5..5 {
        println!("{}", &net.run(&[i as f32 + 0.5])[0]);
    }
}

examples/circle.rs (line 32)

fn main() {
    // this network is completely overkill, but it does the job
    let mut net: NeuralNetwork<2, 1> = NeuralNetwork::new()
        .add_layer(3, ActivationFunction::ReLU)
        .add_layer(3, ActivationFunction::ReLU)
        // this layer reduced everything to one input!
        .add_layer(1, ActivationFunction::Linear);

    let mut inputs = vec![];
    let mut output = vec![];
    for x in 0..=100 {
        for y in 0..=100 {
            inputs.push([x as f32, y as f32]);
            // we want this to be a classifier, so we ask it for a result greater zero or smaller zero
            output.push(if (x as f32).abs() + (y as f32).abs() < 30.0 {
                [1.0]
            } else {
                [-1.0]
            })
        }
    }

    let data = DataSet {
        inputs,
        outputs: output,
    };

    let trainer = BasicTrainer::new(data);
    for _ in 0..50 {
        trainer.train(&mut net, 10);
        println!("{}", trainer.get_total_error(&net))
    }
}

pub fn get_total_error(&self, net: &NeuralNetwork<N, O>) -> f32

Examples found in repository

examples/training.rs (line 22)

fn main() {
    // create a neural network
    let mut net = NeuralNetwork::new().add_layer(1, ActivationFunction::Linear);

    // create training data
    let mut inputs = vec![];
    let mut outputs = vec![];
    for i in -50..50 {
        inputs.push([i as f32]);
        outputs.push([i as f32 * 3.0]);
    }
    let data = DataSet { inputs, outputs };

    let trainer = BasicTrainer::new(data);

    // train the model
    for _ in 0..10 {
        trainer.train(&mut net, 10);
        // lower is better
        println!("{}", trainer.get_total_error(&net))
    }

    // show that this actually works!
    println!("########");
    for i in -5..5 {
        println!("{}", &net.run(&[i as f32 + 0.5])[0]);
    }
}

examples/circle.rs (line 33)

fn main() {
    // this network is completely overkill, but it does the job
    let mut net: NeuralNetwork<2, 1> = NeuralNetwork::new()
        .add_layer(3, ActivationFunction::ReLU)
        .add_layer(3, ActivationFunction::ReLU)
        // this layer reduced everything to one input!
        .add_layer(1, ActivationFunction::Linear);

    let mut inputs = vec![];
    let mut output = vec![];
    for x in 0..=100 {
        for y in 0..=100 {
            inputs.push([x as f32, y as f32]);
            // we want this to be a classifier, so we ask it for a result greater zero or smaller zero
            output.push(if (x as f32).abs() + (y as f32).abs() < 30.0 {
                [1.0]
            } else {
                [-1.0]
            })
        }
    }

    let data = DataSet {
        inputs,
        outputs: output,
    };

    let trainer = BasicTrainer::new(data);
    for _ in 0..50 {
        trainer.train(&mut net, 10);
        println!("{}", trainer.get_total_error(&net))
    }
}