Struct cogent::core::NeuralNetwork

pub struct NeuralNetwork { /* fields omitted */ }

Neural network.

Methods

impl NeuralNetwork

pub fn new(inputs: usize, layers: &[Layer], cost: Option<Cost>) -> NeuralNetwork

Constructs network of given layers.

Returns constructed network.

use cogent::core::{NeuralNetwork,Layer,Activation};
 
let mut net = NeuralNetwork::new(2,&[
    Layer::new(3,Activation::Sigmoid),
    Layer::new(2,Activation::Softmax)
],None);

pub fn activation(&mut self, index: usize, activation: Activation)

Sets activation of layer specified by index (excluding input layer).

use cogent::core::{NeuralNetwork,Layer,Activation};
 
let mut net = NeuralNetwork::new(2,&[
    Layer::new(3,Activation::Sigmoid),
    Layer::new(2,Activation::Sigmoid)
],None);
net.activation(1,Activation::Softmax); // Changes activation of output layer.

pub fn run(&self, inputs: &Array2<f32>) -> Array2<f32>

Runs batch of examples through network.

Returns outputs from batch of examples.

use cogent::core::{NeuralNetwork,Layer,Activation};
use ndarray::{Array2,array};
 
let mut net = NeuralNetwork::new(2,&[
    Layer::new(3,Activation::Sigmoid),
    Layer::new(2,Activation::Softmax)
],None);
let input:Array2<f32> = array![
    [0f32,0f32],
    [1f32,0f32],
    [0f32,1f32],
    [1f32,1f32]
];
let output:Array2<f32> = net.run(&input);

pub fn train(
    &mut self,
    training_data: &Vec<(Vec<f32>, usize)>,
    k: usize
) -> Trainer

Begins setting hyperparameters for training.

Returns Trainer struct used to specify hyperparameters

Training a network to learn an XOR gate:

use cogent::core::{NeuralNetwork,Layer,Activation,EvaluationData};
 
// Sets network
let mut neural_network = NeuralNetwork::new(2,&[
    Layer::new(3,Activation::Sigmoid),
    Layer::new(2,Activation::Softmax)
],None);
// Sets data
// For output 0=false and 1=true.
let data = vec![
    (vec![0f32,0f32],0),
    (vec![1f32,0f32],1),
    (vec![0f32,1f32],1),
    (vec![1f32,1f32],0)
];
// Trains network
neural_network.train(&data,2)
    .learning_rate(2f32)
    .evaluation_data(EvaluationData::Actual(&data)) // Use testing data as evaluation data.
    .lambda(0f32)
.go();

pub fn evaluate(&self, test_data: &[(Vec<f32>, usize)], k: usize) -> (f32, u32)

Returns tuple: (Average cost across batch, Number of examples correctly classified).

pub fn evaluate_outputs(
    &self,
    test_data: &[(Vec<f32>, usize)],
    k: usize
) -> (Array1<f32>, Array2<f32>)

Requires ordered test_data.

Returns tuple of: (List of correctly classified percentage for each class. Confusion matrix of percentages).

pub fn print(&self) -> String

Returns pretty string of wieghts (self.connections) and biases (self.biases).

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

Exports neural network to path.

pub fn import(path: &str) -> NeuralNetwork

Imports neural network from path.

Trait Implementations

impl Clone for NeuralNetwork

fn clone(&self) -> NeuralNetwork

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for NeuralNetwork

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

Deserialize this value from the given Serde deserializer.

impl Serialize for NeuralNetwork

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

Serialize this value into the given Serde serializer.