Struct Layer 

pub struct Layer {
    pub weights_t: Matrix,
    pub biases: Matrix,
    pub relu: bool,
    pub output: Matrix,
    pub first_moment_weight: Option<Matrix>,
    pub first_moment_biase: Option<Matrix>,
    pub second_moment_weight: Option<Matrix>,
    pub second_moment_biase: Option<Matrix>,
}

Fields

weights_t: Matrix

biases: Matrix

relu: bool

output: Matrix

first_moment_weight: Option<Matrix>

first_moment_biase: Option<Matrix>

second_moment_weight: Option<Matrix>

second_moment_biase: Option<Matrix>

Implementations

impl Layer

pub fn init(input_size: u32, size: u32, relu: bool) -> Layer

Examples found in repository

examples/mnist.rs (line 45)

pub fn training() {
    println!("extracting mnist data...");
    let labels: Matrix = extract_labels("train-labels.idx1-ubyte");
    let mut images: Matrix = extract_images("train-images.idx3-ubyte");
    println!("extraction done");

    images.normalize();
    println!("number of images {}", images.height);
    println!("number of pixels in each image {}", images.width);

    ModelBuilder::new()
        .add_layer(Layer::init(28 * 28, 128, true))
        .add_layer(Layer::init(128, 128, true))
        .add_layer(Layer::init(128, 10, false))
        .optimizer(Optimizer::Adam {
            learning_step: 0.001,
            beta1: 0.9,
            beta2: 0.999,
        })
        .l2_reg(0.001)
        .checkpoint(Checkpoint::ValAcc {
            save_path: "mnist_128x128".to_string(),
        })
        .verbose(10, false)
        .build_and_train(&images, &labels, 128, 10, 2000);
}

examples/spiral.rs (line 22)

pub fn main() {
    // generating the spiral dataset points
    // 3000 points, spread into three classes (here a class = one spiral)
    let (data, labels) = generate_spiral_dataset(3000, 3);

    // Layer::init(number_of_inputs: u32, number_of_neurons_for_the_layer: u32, reLu: bool)
    // if the last arg is true, applies ReLu as the activation function
    // by default softmax is applied to the last layer

    // One point of the spiral dataset consists of a X and a Y
    // So the first layer has 2 inputs
    // The last layer has 3 neurons because we have 3 classes, and therefore we want 3 outputs

    // build and train
    // (data: &matrix, labels: &matrix, batch_size: u32, number_of_epochs: u32, size_of_the_validation_dataset, usize)
    let _ = ModelBuilder::new()
        .add_layer(Layer::init(2, 10, true))
        .add_layer(Layer::init(10, 10, true))
        .add_layer(Layer::init(10, 3, false))
        .optimizer(Optimizer::SGD {
            learning_step: 0.001,
        })
        .l2_reg(0.0001)
        .build_and_train(&data, &labels, 128, 10, 500);
}

pub fn init_with_data(weights_t: Matrix, biases: Matrix, relu: bool) -> Layer

pub fn init_test(size: u32, relu: bool, weights_t: Matrix) -> Layer

pub fn forward(&mut self, input: &Matrix, predict: bool) -> Matrix

pub fn backprop( &mut self, d_z: &Matrix, z_minus_1: &Matrix, previous_layer_relu: bool, lambda: f64, optimizer: &Optimizer, iteration: i32, is_input_layer: bool, debug: bool, debug_array_d_weights: &mut Option<Vec<Matrix>>, debug_array_d_biaises: &mut Option<Vec<Matrix>>, debug_array_d_outputs: &mut Option<Vec<Matrix>>, ) -> Matrix

pub fn update_weigths( &mut self, input: Matrix, optimizer: &Optimizer, iteration: i32, )

pub fn update_biases( &mut self, input: Matrix, optimizer: &Optimizer, iteration: i32, )

Trait Implementations

impl Clone for Layer

fn clone(&self) -> Layer

Returns a duplicate of the value.

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

Performs copy-assignment from source.