Struct Sequential

pub struct Sequential { /* private fields */ }

Implementation of the neural network / sequential models of layers

Implementations

impl Sequential

pub fn new(num_inputs: usize) -> Sequential

Create a new instance of a sequential model num_inputs = the number of inputs to the model

pub fn get_num_inputs(&self) -> usize

Returns the requested input dimension

pub fn get_layers(&self) -> &Vec<Layer>

Get the layers (as ref)

pub fn get_layers_mut(&mut self) -> &mut Vec<Layer>

Get the layers (as mut)

pub fn get_params(&self) -> Vec<Float>

Return the flat parameters of the layers (including LReLU factors). Used for evolution-strategies

pub fn set_params(&mut self, params: &[Float]) -> &mut Self

Set the layers’ parameters (including LReLU factors) by a flat input. Used for evolution-strategies. Panics if params’ size does not fit the layers

pub fn add_layer(&mut self, layer: Layer) -> &mut Self

Add a layer to the sequential model. Be sure to have appropriate parameters inside the layer, they are not checked! You can use specific add_layer_ methods to get simple, correct creation of layers with parameters.

pub fn add_layer_lrelu(&mut self, factor: Float) -> &mut Self

Add a LReLU layer: factor = factor to apply to x < 0

pub fn add_layer_prelu(&mut self, factor: Float) -> &mut Self

Add a PReLU layer: factor = factor to apply to x < 0

pub fn add_layer_pelu(&mut self, a: Float, b: Float) -> &mut Self

Add a PELU layer: a and b are the specific factors

pub fn add_layer_dropout(&mut self, d: Float) -> &mut Self

Add a Dropout layer: d = fraction of nodes to drop

pub fn add_layer_dense( &mut self, neurons: usize, init: Initializer, ) -> &mut Self

Add a Dense layer: neurons = number of neurons/units in the layer init = initializer to use (use He for ReLU, Glorot for Tanh)

pub fn run(&self, input: &[Float]) -> Vec<Float>

Do a forward pass through the model

pub fn predict(&self, inputs: &[Vec<Float>]) -> Vec<Vec<Float>>

Predict values (forward pass) for a vector of input data (Vec):

pub fn to_json(&self) -> String

Encodes the model as a JSON string.

pub fn from_json(encoded: &str) -> Sequential

Builds a new model from a JSON string.

pub fn from_reader<R: Read>(encoded: R) -> Sequential

Builds a new model from a JSON reader (e.g. file).

pub fn save(&self, file: &str) -> Result<(), Error>

Saves the model to a file

pub fn load(file: &str) -> Result<Sequential, Error>

Creates a model from a previously saved file

pub fn calc_mse(&self, target: &[(Vec<Float>, Vec<Float>)]) -> Float

Calculate the error to a target set (Vec<(x, y)>): Mean squared error (for regression) Potentially ignores different vector lenghts!

pub fn calc_rmse(&self, target: &[(Vec<Float>, Vec<Float>)]) -> Float

Calculate the error to a target set (Vec<(x, y)>): Root mean squared error (for regression) Potentially ignores different vector lenghts!

pub fn calc_mae(&self, target: &[(Vec<Float>, Vec<Float>)]) -> Float

Calculate the error to a target set (Vec<(x, y)>): Mean absolute error (for regression) Potentially ignores different vector lenghts!

pub fn calc_mape(&self, target: &[(Vec<Float>, Vec<Float>)]) -> Float

Calculate the error to a target set (Vec<(x, y)>): Mean absolute percentage error (better don’t use if target has 0 values) (for regression) Potentially ignores different vector lenghts!

pub fn calc_logcosh(&self, target: &[(Vec<Float>, Vec<Float>)]) -> Float

Calculate the error to a target set (Vec<(x, y)>): logcosh (for regression) Potentially ignores different vector lenghts!

pub fn calc_binary_crossentropy( &self, target: &[(Vec<Float>, Vec<Float>)], ) -> Float

Calculate the error to a target set (Vec<(x, y)>): binary cross-entropy (be sure to use 0, 1 classifiers+labels) (for classification) Potentially ignores different vector lenghts!

pub fn calc_categorical_crossentropy( &self, target: &[(Vec<Float>, Vec<Float>)], ) -> Float

Calculate the error to a target set (Vec<(x, y)>): categorical cross-entropy (be sure to use 0, 1 classifiers+labels) (for classification) Potentially ignores different vector lenghts!

pub fn calc_hingeloss(&self, target: &[(Vec<Float>, Vec<Float>)]) -> Float

Calculate the error to a target set (Vec<(x, y)>): hinge loss (be sure to use 1, -1 classifiers+labels) (for classification) Potentially ignores different vector lenghts!

Trait Implementations

impl Clone for Sequential

fn clone(&self) -> Sequential

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sequential

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Sequential

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Sequential

fn eq(&self, other: &Sequential) -> 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 Serialize for Sequential

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Sequential