Struct NeuralNetwork

pub struct NeuralNetwork { /* private fields */ }

Neural network.

Implementations

impl NeuralNetwork

pub fn new() -> Self

Examples found in repository

examples/example.rs (line 4)

fn main() {
  let mut nn = NeuralNetwork::new();

  // Define a network with an input layer, a hidden layer, and an output layer
  nn.add_layer(3, ActivationFunction::None, 0.0); // Input layer with 3 neurons
  nn.add_layer(5, ActivationFunction::LeakyReLU, 0.1); // Hidden layer with 5 neurons
  nn.add_layer(2, ActivationFunction::Linear, 0.1); // Output layer with 2 neurons

  // Define 10 predictable input-target pairs
  // Targets are linear combinations of inputs:
  // output1 = (x1 + x2 + x3) / 3
  // output2 = (x1 - x2 + x3) / 3
  let training_data = [
    ([0.1, 0.2, 0.3], [0.2, 0.0667]),
    ([0.4, 0.5, 0.6], [0.5, 0.1333]),
    ([0.2, 0.1, 0.4], [0.2333, 0.1667]),
    ([0.9, 0.8, 0.7], [0.8, 0.2667]),
    ([0.3, 0.4, 0.5], [0.4, 0.1333]),
    ([0.6, 0.5, 0.4], [0.5, 0.1667]),
    ([0.4, 0.3, 0.2], [0.3, 0.1]),
    ([0.7, 0.8, 0.9], [0.8, 0.2667]),
    ([0.2, 0.3, 0.1], [0.2, 0.0]),
    ([0.8, 0.7, 0.6], [0.7, 0.2333]),
  ];

  let epochs = 1000;

  for epoch in 1..=epochs {
    let mut total_error = 0.0;
    for (inputs, targets) in &training_data {
      let error = nn.train(inputs, targets, 0.01);
      total_error += error;
    }
    let avg_error = total_error / training_data.len() as f32;
    if epoch % 100 == 0 {
      println!("Epoch {}: Average Error = {:.6}", epoch, avg_error);
    }
  }

  // Make predictions on the training data
  for (inputs, targets) in &training_data {
    let output = nn.predict(inputs);
    println!(
      "Input: {:?} | Predicted Output: {:?} | Target: {:?}",
      inputs, output, targets
    );
  }
}

pub fn add_layer( &mut self, width: usize, activation: ActivationFunction, bias: f32, )

Adds a layer to the neural network.

Examples found in repository

examples/example.rs (line 7)

fn main() {
  let mut nn = NeuralNetwork::new();

  // Define a network with an input layer, a hidden layer, and an output layer
  nn.add_layer(3, ActivationFunction::None, 0.0); // Input layer with 3 neurons
  nn.add_layer(5, ActivationFunction::LeakyReLU, 0.1); // Hidden layer with 5 neurons
  nn.add_layer(2, ActivationFunction::Linear, 0.1); // Output layer with 2 neurons

  // Define 10 predictable input-target pairs
  // Targets are linear combinations of inputs:
  // output1 = (x1 + x2 + x3) / 3
  // output2 = (x1 - x2 + x3) / 3
  let training_data = [
    ([0.1, 0.2, 0.3], [0.2, 0.0667]),
    ([0.4, 0.5, 0.6], [0.5, 0.1333]),
    ([0.2, 0.1, 0.4], [0.2333, 0.1667]),
    ([0.9, 0.8, 0.7], [0.8, 0.2667]),
    ([0.3, 0.4, 0.5], [0.4, 0.1333]),
    ([0.6, 0.5, 0.4], [0.5, 0.1667]),
    ([0.4, 0.3, 0.2], [0.3, 0.1]),
    ([0.7, 0.8, 0.9], [0.8, 0.2667]),
    ([0.2, 0.3, 0.1], [0.2, 0.0]),
    ([0.8, 0.7, 0.6], [0.7, 0.2333]),
  ];

  let epochs = 1000;

  for epoch in 1..=epochs {
    let mut total_error = 0.0;
    for (inputs, targets) in &training_data {
      let error = nn.train(inputs, targets, 0.01);
      total_error += error;
    }
    let avg_error = total_error / training_data.len() as f32;
    if epoch % 100 == 0 {
      println!("Epoch {}: Average Error = {:.6}", epoch, avg_error);
    }
  }

  // Make predictions on the training data
  for (inputs, targets) in &training_data {
    let output = nn.predict(inputs);
    println!(
      "Input: {:?} | Predicted Output: {:?} | Target: {:?}",
      inputs, output, targets
    );
  }
}

pub fn train(&mut self, inputs: &[f32], targets: &[f32], rate: f32) -> f32

Trains the neural network with the given inputs and targets.

Examples found in repository

examples/example.rs (line 33)

fn main() {
  let mut nn = NeuralNetwork::new();

  // Define a network with an input layer, a hidden layer, and an output layer
  nn.add_layer(3, ActivationFunction::None, 0.0); // Input layer with 3 neurons
  nn.add_layer(5, ActivationFunction::LeakyReLU, 0.1); // Hidden layer with 5 neurons
  nn.add_layer(2, ActivationFunction::Linear, 0.1); // Output layer with 2 neurons

  // Define 10 predictable input-target pairs
  // Targets are linear combinations of inputs:
  // output1 = (x1 + x2 + x3) / 3
  // output2 = (x1 - x2 + x3) / 3
  let training_data = [
    ([0.1, 0.2, 0.3], [0.2, 0.0667]),
    ([0.4, 0.5, 0.6], [0.5, 0.1333]),
    ([0.2, 0.1, 0.4], [0.2333, 0.1667]),
    ([0.9, 0.8, 0.7], [0.8, 0.2667]),
    ([0.3, 0.4, 0.5], [0.4, 0.1333]),
    ([0.6, 0.5, 0.4], [0.5, 0.1667]),
    ([0.4, 0.3, 0.2], [0.3, 0.1]),
    ([0.7, 0.8, 0.9], [0.8, 0.2667]),
    ([0.2, 0.3, 0.1], [0.2, 0.0]),
    ([0.8, 0.7, 0.6], [0.7, 0.2333]),
  ];

  let epochs = 1000;

  for epoch in 1..=epochs {
    let mut total_error = 0.0;
    for (inputs, targets) in &training_data {
      let error = nn.train(inputs, targets, 0.01);
      total_error += error;
    }
    let avg_error = total_error / training_data.len() as f32;
    if epoch % 100 == 0 {
      println!("Epoch {}: Average Error = {:.6}", epoch, avg_error);
    }
  }

  // Make predictions on the training data
  for (inputs, targets) in &training_data {
    let output = nn.predict(inputs);
    println!(
      "Input: {:?} | Predicted Output: {:?} | Target: {:?}",
      inputs, output, targets
    );
  }
}

pub fn predict(&mut self, inputs: &[f32]) -> &[f32]

Predicts the output for the given inputs.

Examples found in repository

examples/example.rs (line 44)

fn main() {
  let mut nn = NeuralNetwork::new();

  // Define a network with an input layer, a hidden layer, and an output layer
  nn.add_layer(3, ActivationFunction::None, 0.0); // Input layer with 3 neurons
  nn.add_layer(5, ActivationFunction::LeakyReLU, 0.1); // Hidden layer with 5 neurons
  nn.add_layer(2, ActivationFunction::Linear, 0.1); // Output layer with 2 neurons

  // Define 10 predictable input-target pairs
  // Targets are linear combinations of inputs:
  // output1 = (x1 + x2 + x3) / 3
  // output2 = (x1 - x2 + x3) / 3
  let training_data = [
    ([0.1, 0.2, 0.3], [0.2, 0.0667]),
    ([0.4, 0.5, 0.6], [0.5, 0.1333]),
    ([0.2, 0.1, 0.4], [0.2333, 0.1667]),
    ([0.9, 0.8, 0.7], [0.8, 0.2667]),
    ([0.3, 0.4, 0.5], [0.4, 0.1333]),
    ([0.6, 0.5, 0.4], [0.5, 0.1667]),
    ([0.4, 0.3, 0.2], [0.3, 0.1]),
    ([0.7, 0.8, 0.9], [0.8, 0.2667]),
    ([0.2, 0.3, 0.1], [0.2, 0.0]),
    ([0.8, 0.7, 0.6], [0.7, 0.2333]),
  ];

  let epochs = 1000;

  for epoch in 1..=epochs {
    let mut total_error = 0.0;
    for (inputs, targets) in &training_data {
      let error = nn.train(inputs, targets, 0.01);
      total_error += error;
    }
    let avg_error = total_error / training_data.len() as f32;
    if epoch % 100 == 0 {
      println!("Epoch {}: Average Error = {:.6}", epoch, avg_error);
    }
  }

  // Make predictions on the training data
  for (inputs, targets) in &training_data {
    let output = nn.predict(inputs);
    println!(
      "Input: {:?} | Predicted Output: {:?} | Target: {:?}",
      inputs, output, targets
    );
  }
}