Struct fast_neural_network::neural_network::Network

pub struct Network { /* private fields */ }

The main heap based neural network struct.

Implementations

impl Network

pub fn new( inputs: usize, outputs: usize, activation_func: ActivationType, alpha: f64 ) -> Self

Creates a new empty network with the given number of inputs and outputs.

Example

use fast_neural_network::{activation::*, neural_network::*};

let mut network = Network::new(3, 1, ActivationType::Relu, 0.005);

assert_eq!(network.dimensions().0, 3);
assert_eq!(network.dimensions().1, 1);
assert_eq!(network.hidden_layers_size(), 0);
assert_eq!(network.learning_rate(), 0.005);

pub fn new_with_layers( inputs: usize, outputs: usize, hidden_layers: Vec<Layer>, activation_func: ActivationType, alpha: f64 ) -> Self

Creates a new empty network with the given number of inputs and outputs and the given hidden layers.

Example

use fast_neural_network::{activation::*, neural_network::*};

let mut network = Network::new_with_layers(3, 1, vec![Layer::new(4), Layer::new(4)], ActivationType::Relu, 0.005);

assert_eq!(network.dimensions().0, 3);
assert_eq!(network.dimensions().1, 1);
assert_eq!(network.hidden_layers_size(), 2);
assert_eq!(network.learning_rate(), 0.005);

pub fn load(path: &str) -> Self

Loads a network from a json file.

Example

use fast_neural_network::neural_network::*;

let mut network = Network::load("network.json");

pub fn save(&self, path: &str)

Saves the network to a json file.

Example

use fast_neural_network::{activation::*, neural_network::*};

let mut network = Network::new(3, 1, ActivationType::Relu, 0.005);

network.save("network.json");

pub fn from_json(json: &str) -> Self

Creates a network from the given JSON string.

Panics

Panics if the JSON string is not valid.

pub fn add_hidden_layer(&mut self, layer: Layer)

Adds a hidden layer to the network.

pub fn add_hidden_layer_with_size(&mut self, size: usize)

Adds a hidden layer to the network with the given size.

Example

use fast_neural_network::{activation::*, neural_network::*};

let mut network = Network::new(3, 1, ActivationType::Relu, 0.005);

network.add_hidden_layer_with_size(4);

pub fn compile(&mut self)

Compiles the network. This is done automatically during training.

Compilations should be done after the hidden layers are set.

Example

use fast_neural_network::{activation::*, neural_network::*};

let mut network = Network::new(3, 1, ActivationType::Relu, 0.005);
network.add_hidden_layer_with_size(4);
network.add_hidden_layer_with_size(4);
network.compile();

Panics

Panics if any of the dimentions is 0 or if no hidden layers are present.

pub fn dimensions(&self) -> (usize, usize)

Returns a Tuple with the dimentions of the Neural Network (inputs, outputs)

pub fn set_activation(&mut self, activation: ActivationType)

Sets the activation function to be used by the network

pub fn activation(&self) -> ActivationType

Returns the activation function being used

pub fn set_layer_weights(&mut self, layer: usize, weights: Array2<f64>)

Sets the weights and biases of the given layer

pub fn layer_weights(&self, layer: usize) -> Array2<f64>

Returns the weights of the given layer

pub fn set_layer_biases(&mut self, layer: usize, biases: Array2<f64>)

Sets the biases of the given layer

pub fn layer_biases(&self, layer: usize) -> Array2<f64>

Returns the biases of the given layer

pub fn hidden_layers_size(&self) -> usize

Returns the number of hidden layers

pub fn set_learning_rate(&mut self, alpha: f64)

Sets the learning rate of the network

pub fn learning_rate(&self) -> f64

Returns the learning rate of the network

pub fn forward(&mut self, input: &Array1<f64>) -> Array2<f64>

Predicts the output of the network for the given input.

Example

// ... imports here
 
let mut network = Network::new(3, 1, ActivationType::Relu, 0.005);
 
// ... training done here
 
let prediction = network.forward(&array![2., 1., -1.]);

pub fn train( &mut self, training_set: &[(Array1<f64>, Array1<f64>)], epochs: usize, decay_time: usize )

Trains the network with the given training set for the given number of epochs.

Example

use fast_neural_network::{activation::*, neural_network::*};
use ndarray::*;

let mut network = Network::new(3, 1, ActivationType::Relu, 0.005);

network.add_hidden_layer_with_size(4);
network.add_hidden_layer_with_size(4);

network.compile();

network.train(&[(array![2., 1., -1.], array![9.])], 100, 100);

Trait Implementations

impl Clone for Network

fn clone(&self) -> Network

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Network

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Network

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Network

Formats the network to be printed

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

Formats the value using the given formatter.

impl Serialize for Network

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.