Struct SurfaceNetwork 

pub struct SurfaceNetwork<T = f32> { /* private fields */ }

A neural network capable of dynamic configuration. Essentially, each network is designed to materialize the surface of a 2-simplex (triad) using barycentric coordinates to define three critical points. These critical points define the minimum number of hidden layers within the network and serve as goalposts that guide the learning process. The remaining points continue this trend, simply mapping each extra hidden layer to another position within space. The verticies of the simplex are used to inform the input layer and in finding the centroid of the facet. The centroid defines the output layer of the facet, serving as the final piece in a pseudo sink-source dyanamic.

Implementations

impl<A> SurfaceNetwork<A>

where A: FromPrimitive + ScalarOperand,

pub fn add_critical_point(&mut self, kind: PointKind) -> &mut Self

where A: Float,

Add a new critical point to configure part of the network’s hidden layer

pub fn predict<X, Y>(&self, input: &X) -> Result<Y, NeuralError>

where SurfaceModel<A>: Predict<X, Output = Y>,

forward propogate the given input through the network

pub fn train<X, Y, Z>( &mut self, input: &X, expected: &Y, ) -> Result<Z, NeuralError>

where A: Float + FromPrimitive + NumAssign + ScalarOperand + FftNum, SurfaceModel<A>: Train<X, Y, Output = Z>,

perform a single backpropagation step on qualifing datasets

pub fn get_centroid(&self) -> Option<[A; 2]>

where A: Float + FromPrimitive,

get the position of the centroid w.r.t the headspace

pub fn get_position(&self, cp_index: usize) -> Option<[A; 3]>

where A: Copy + Num,

returns the position of a particular hidden layer w.r.t. the current headspace

pub fn init(self) -> Self

where SurfaceModel<A>: Init,

initialize the network

pub fn init_inplace(&mut self) -> &mut Self

where SurfaceModel<A>: InitInplace,

initialize the network in-place

pub fn predict_with_confidence<X, Y>( &self, input: &X, ) -> Result<(Y, <SurfaceModel<A> as PredictWithConfidence<X>>::Confidence), NeuralError>

where SurfaceModel<A>: PredictWithConfidence<X, Output = Y>,

returns the model’s prediction with a confidence value

pub fn reconfigure(&mut self, next: Triad)

where A: Float,

reconfigure the network with respect to the given triad; the method is typically called after applying a transformation to the headspace

pub fn transfer_knowledge_from(&mut self, other: &Self, adaptation_rate: A)

where A: Copy + PartialOrd + Num + Signed,

Transfer knowledge from another surface network

pub fn transform(&mut self, transform: LPR) -> SurfaceResult<()>

where A: Float,

applies the given LPR transformation to the headspace of the network before applying the neccessary adjusments to the architecture.

pub fn walk<I>(&mut self, iter: I) -> SurfaceResult<()>

where A: Float, I: IntoIterator<Item = LPR>,

Walk the network through a series of transformations

impl<T> SurfaceNetwork<T>

pub fn new(headspace: Triad) -> Self

where T: Float + FromPrimitive,

Create a new surface network for the given triad

pub const fn headspace(&self) -> Triad

returns an immutable reference to the network’s headspace

pub fn headspace_mut(&mut self) -> &mut Triad

returns a mutable reference to the network’s headspace

pub const fn model(&self) -> &SurfaceModel<T>

returns an immutable reference to the network’s surface

pub fn model_mut(&mut self) -> &mut SurfaceModel<T>

returns a mutable reference to the network’s surface

pub const fn points(&self) -> &Vec<Point<T>>

returns an immutable reference to the network’s critical points

pub fn points_mut(&mut self) -> &mut Vec<Point<T>>

returns a mutable reference to the network’s critical points

pub const fn input(&self) -> &Params<T>

returns an immutable reference to the network’s primary weights

pub fn input_mut(&mut self) -> &mut Params<T>

returns a mutable reference to the network’s primary weights

pub const fn input_bias(&self) -> &Array1<T>

returns an immutable reference to the model’s input layer bias

pub fn input_bias_mut(&mut self) -> &mut Array1<T>

returns a mutable reference to the model’s input layer bias

pub const fn input_weights(&self) -> &Array2<T>

returns an immutable reference to the model’s input layer weights

pub fn input_weights_mut(&mut self) -> &mut Array2<T>

returns a mutable reference to the model’s input layer weights

pub const fn hidden(&self) -> &Vec<Params<T>>

returns an immutable reference to the model’s hidden layers

pub fn hidden_mut(&mut self) -> &mut Vec<Params<T>>

returns a mutable reference to the model’s hidden layers

pub const fn output(&self) -> &Params<T>

returns an immutable reference to the network’s secondary weights

pub fn output_mut(&mut self) -> &mut Params<T>

returns a mutable reference to the network’s secondary weights

pub const fn output_bias(&self) -> &Array1<T>

returns an immutable reference to the model’s output layer bias

pub fn output_bias_mut(&mut self) -> &mut Array1<T>

returns a mutable reference to the model’s output layer bias

pub const fn output_weights(&self) -> &Array2<T>

returns an immutable reference to the model’s output layer weights

pub fn output_weights_mut(&mut self) -> &mut Array2<T>

returns a mutable reference to the model’s output layer weights

pub fn extend_surface<I>(&mut self, iter: I)

where I: IntoIterator<Item = Point<T>>,

pub fn set_points<I>(&mut self, iter: I)

where I: IntoIterator<Item = Point<T>>,

set the critical points of the network

pub fn with_attention(self) -> Self

where T: FromPrimitive,

enable the attention mechanism in the model

pub fn with_points<I>(self, iter: I) -> Self

where I: IntoIterator<Item = Point<T>>,

consumes the current instance and returns another with the given points

Trait Implementations

impl<T: Clone> Clone for SurfaceNetwork<T>

fn clone(&self) -> SurfaceNetwork<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SurfaceNetwork<T>

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

Formats the value using the given formatter.

impl<A, X, Y> Forward<X> for SurfaceNetwork<A>

where A: Float + FromPrimitive + NumAssign + ScalarOperand, SurfaceModel<A>: Forward<X, Output = Y>,

type Output = Y

fn forward(&self, input: &X) -> Result<Self::Output>

a single forward step

fn forward_then<F>(&self, input: &Rhs, then: F) -> Result<Self::Output, Error>

where F: FnOnce(Self::Output) -> Self::Output,

this method enables the forward pass to be generically activated using some closure. This is useful for isolating the logic of the forward pass from that of the activation function and is often used by layers and models.

impl<T> PartialEq for SurfaceNetwork<T>

where T: PartialEq, SurfaceModel<T>: PartialEq,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, X, Y, Z> Train<X, Y> for SurfaceNetwork<A>

where A: Float + FromPrimitive + NumAssign + ScalarOperand, SurfaceModel<A>: Train<X, Y, Output = Z>,

type Output = Z

fn train( &mut self, input: &X, expected: &Y, ) -> Result<Self::Output, NeuralError>

fn train_for( &mut self, input: &X, target: &Y, epochs: usize, ) -> Result<Self::Output, NeuralError>