Struct NeuralNetwork

pub struct NeuralNetwork<const I: usize, const O: usize> { /* private fields */ }

A simple Neural Network

Implementations

impl<const I: usize, const O: usize> NeuralNetwork<I, O>

pub fn new() -> Self

Examples found in repository

examples/bench.rs (line 5)

fn main() {
    // let's check how fast this thing gets
    let mut net: NeuralNetwork<1, 1> = NeuralNetwork::new()
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(1, ActivationFunction::Linear);

    let mut sum = 0.0;
    for i in 0..10_000_000 {
        sum += net.run(&[i as f32])[0];
    }

    println!("{sum}");
}

examples/training.rs (line 5)

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 5)

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 add_layer(self, n: usize, func: ActivationFunction) -> Self

adds a layer with n neurons and the specified activation function

Examples found in repository

examples/bench.rs (line 6)

fn main() {
    // let's check how fast this thing gets
    let mut net: NeuralNetwork<1, 1> = NeuralNetwork::new()
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(1, ActivationFunction::Linear);

    let mut sum = 0.0;
    for i in 0..10_000_000 {
        sum += net.run(&[i as f32])[0];
    }

    println!("{sum}");
}

examples/training.rs (line 5)

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 6)

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 random_layer(self, n: usize, func: ActivationFunction) -> Self

adds a layer with n neurons and randomized weights/bias to the model

pub fn random_edit(&mut self)

randomly edits some neuron

pub fn reverse_edit(&mut self)

Reverses the last random edit

pub fn with_weights(self, weights: Vec<Vec<f32>>) -> Self

Adds custom weights to the last layer of the model

pub fn with_bias(self, biases: Vec<f32>) -> Self

adds custom biases to the last layer of the model

pub fn run(&mut self, input: &[f32; I]) -> [f32; O]

runs the model on the given input.

Examples found in repository

examples/bench.rs (line 16)

fn main() {
    // let's check how fast this thing gets
    let mut net: NeuralNetwork<1, 1> = NeuralNetwork::new()
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(5, ActivationFunction::ReLU)
        .add_layer(1, ActivationFunction::Linear);

    let mut sum = 0.0;
    for i in 0..10_000_000 {
        sum += net.run(&[i as f32])[0];
    }

    println!("{sum}");
}

examples/training.rs (line 28)

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

pub fn unbuffered_run(&self, input: &[f32; I]) -> [f32; O]

runs the model on the given input. This does not buffer some things, and thus is slower as ist does extra allocations work.

pub fn par_run(&self, inputs: &Vec<[f32; I]>) -> Vec<[f32; O]>

runs the model on a large set of data. Uses rayon for faster computation

Trait Implementations

impl<const I: usize, const O: usize> Default for NeuralNetwork<I, O>

fn default() -> Self

Returns the “default value” for a type.