Struct NeuralNet 

pub struct NeuralNet<'a, T, A>
where
    T: Criterion,
    A: OptimAlgorithm<BaseNeuralNet<'a, T>>,
{ /* private fields */ }

Neural Network Model

The Neural Network struct specifies a Criterion and a gradient descent algorithm.

Implementations

impl<'a> NeuralNet<'a, BCECriterion, StochasticGD>

pub fn default( layer_sizes: &[usize], ) -> NeuralNet<'_, BCECriterion, StochasticGD>

Creates a neural network with the specified layer sizes.

The layer sizes slice should include the input, hidden layers, and output layer sizes. The type of activation function must be specified.

Uses the default settings (stochastic gradient descent and sigmoid activation function).

Examples

use rusty_machine::learning::nnet::NeuralNet;

// Create a neural net with 4 layers, 3 neurons in each.
let layers = &[3; 4];
let mut net = NeuralNet::default(layers);

impl<'a, T, A> NeuralNet<'a, T, A>

where T: Criterion, A: OptimAlgorithm<BaseNeuralNet<'a, T>>,

pub fn new( layer_sizes: &'a [usize], criterion: T, alg: A, ) -> NeuralNet<'a, T, A>

Create a new neural network with the specified layer sizes.

The layer sizes slice should include the input, hidden layers, and output layer sizes. The type of activation function must be specified.

Currently defaults to simple batch Gradient Descent for optimization.

Examples

use rusty_machine::learning::nnet::BCECriterion;
use rusty_machine::learning::nnet::NeuralNet;
use rusty_machine::learning::optim::grad_desc::StochasticGD;

// Create a neural net with 4 layers, 3 neurons in each.
let layers = &[3; 4];
let mut net = NeuralNet::new(layers, BCECriterion::default(), StochasticGD::default());

Examples found in repository

examples/nnet-and_gate.rs (line 44)

fn main() {
    println!("AND gate learner sample:");

    const THRESHOLD: f64 = 0.7;

    const SAMPLES: usize = 10000;
    println!("Generating {} training data and labels...", SAMPLES as u32);

    let mut input_data = Vec::with_capacity(SAMPLES * 2);
    let mut label_data = Vec::with_capacity(SAMPLES);

    for _ in 0..SAMPLES {
        // The two inputs are "signals" between 0 and 1
        let Closed01(left) = random::<Closed01<f64>>();
        let Closed01(right) = random::<Closed01<f64>>();
        input_data.push(left);
        input_data.push(right);
        if left > THRESHOLD && right > THRESHOLD {
            label_data.push(1.0);
        } else {
            label_data.push(0.0)
        }
    }

    let inputs = Matrix::new(SAMPLES, 2, input_data);
    let targets = Matrix::new(SAMPLES, 1, label_data);

    let layers = &[2, 1];
    let criterion = BCECriterion::new(Regularization::L2(0.));
    let mut model = NeuralNet::new(layers, criterion, StochasticGD::default());

    println!("Training...");
    // Our train function returns a Result<(), E>
    model.train(&inputs, &targets).unwrap();

    let test_cases = vec![
        0.0, 0.0,
        0.0, 1.0,
        1.0, 1.0,
        1.0, 0.0,
        ];
    let expected = vec![
        0.0,
        0.0,
        1.0,
        0.0,
        ];
    let test_inputs = Matrix::new(test_cases.len() / 2, 2, test_cases);
    let res = model.predict(&test_inputs).unwrap();

    println!("Evaluation...");
    let mut hits = 0;
    let mut misses = 0;
    // Evaluation
    println!("Got\tExpected");
    for (idx, prediction) in res.into_vec().iter().enumerate() {
        println!("{:.2}\t{}", prediction, expected[idx]);
        if (prediction - 0.5) * (expected[idx] - 0.5) > 0. {
            hits += 1;
        } else {
            misses += 1;
        }
    }

    println!("Hits: {}, Misses: {}", hits, misses);
    let hits_f = hits as f64;
    let total = (hits + misses) as f64;
    println!("Accuracy: {}%", (hits_f / total) * 100.);
}

pub fn get_net_weights(&self, idx: usize) -> MatrixSlice<'_, f64>

Gets matrix of weights between specified layer and forward layer.

Examples

use rusty_machine::linalg::BaseMatrix;
use rusty_machine::learning::nnet::NeuralNet;

// Create a neural net with 4 layers, 3 neurons in each.
let layers = &[3; 4];
let mut net = NeuralNet::default(layers);

let w = &net.get_net_weights(2);

// We add a bias term to the weight matrix
assert_eq!(w.rows(), 4);
assert_eq!(w.cols(), 3);

Trait Implementations

impl<'a, T, A> Debug for NeuralNet<'a, T, A>

where T: Criterion + Debug, A: OptimAlgorithm<BaseNeuralNet<'a, T>> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T, A> SupModel<Matrix<f64>, Matrix<f64>> for NeuralNet<'a, T, A>

where T: Criterion, A: OptimAlgorithm<BaseNeuralNet<'a, T>>,

Supervised learning for the Neural Network.

The model is trained using back propagation.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Matrix<f64>>

Predict neural network output using forward propagation.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Matrix<f64>, ) -> LearningResult<()>

Train the model using gradient optimization and back propagation.