Struct 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 prepares the random inital values of the network. Can be re-run as much as needed, if needed. This is done automatically during training if it was not compiled before hand.

Compilation should be done after the hidden layers are set, but before setting any custom layer values.

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: Array1<f64>)

Sets the biases of the given layer

pub fn layer_biases(&self, layer: usize) -> Array1<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 set_ui_update_interval(&mut self, interval: usize)

Sets the UI progress update interval 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.

It will compile the network if it was not compiled at least once

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.