Struct Matrix 

pub struct Matrix {
    pub data: Vec<f64>,
    pub width: usize,
    pub height: usize,
    pub transposed: bool,
}

Fields

data: Vec<f64>

width: usize

height: usize

transposed: bool

Implementations

impl Matrix

pub fn init_zero(height: usize, width: usize) -> Matrix

pub fn init(height: usize, width: usize, data: Vec<f64>) -> Matrix

pub fn init_rand(height: usize, width: usize) -> Matrix

pub fn get(&self, row: usize, column: usize) -> f64

Examples found in repository

examples/mnist.rs (line 62)

fn _print_a_number(labels: Matrix, images: Matrix, v: usize) {
    println!("{}", labels.get(0, v));

    for i in 0..28 * 28 {
        if images.get(v, i) > 0.5 && images.get(v, i) < 1.0 {
            if i % 28 == 0 {
                print!("\n");
            }

            if images.get(v, i) > 0.5 && images.get(v, i) < 0.75 {
                print!("-");
            } else {
                print!("*");
            }
        } else {
            if i % 28 == 0 {
                print!("\n");
            }
            print!("_");
        }
    }
}

pub fn get_1d(&self, index: usize) -> f64

pub fn get_row(&self, row: usize) -> Vec<f64>

pub fn set(&mut self, value: f64, row: usize, column: usize)

pub fn set_1d(&mut self, value: f64, index: usize)

pub fn set_row(&mut self, new_row: &Vec<f64>, row: usize)

pub fn dot(&self, m: &Matrix) -> Matrix

pub fn add_1d_matrix_to_all_rows(&self, m: &Matrix) -> Matrix

pub fn max(&self) -> f64

pub fn min(&self) -> f64

pub fn normalize(&mut self)

Examples found in repository

examples/mnist.rs (line 20)

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

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

    println!("loading pre-trained model...");
    let mut model: Model = load_model("mnist_128x128".to_string()).unwrap();

    println!("evaluating...");
    let score = model.evaluate(&images, false);
    let acc = model.accuracy(&score, &labels);

    println!("acc : {}", acc);
}

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);
}

pub fn transpose_inplace(&mut self)

pub fn t(&self) -> Matrix

pub fn is_equal(&self, m: &Matrix, precision: i32) -> bool

pub fn exp_inplace(&mut self)

pub fn sqrt_inplace(&mut self)

pub fn exp(&self) -> Matrix

pub fn pow_inplace(&mut self, a: i32)

pub fn pow(&self, a: i32) -> Matrix

pub fn sum(&self) -> f64

pub fn sum_rows(&self) -> Matrix

pub fn add_inplace(&mut self, a: f64)

pub fn div_inplace(&mut self, a: f64)

pub fn div(&self, a: f64) -> Matrix

pub fn mult_inplace(&mut self, a: f64)

pub fn mult(&self, a: f64) -> Matrix

pub fn add_two_matrices(&self, m: &Matrix) -> Matrix

pub fn add_two_matrices_inplace(&mut self, m: &Matrix)

pub fn div_two_matrices_inplace(&mut self, m: &Matrix)

pub fn pop_last_row(&mut self)

pub fn compute_d_relu_inplace(&mut self, z_minus_1: &Matrix)

pub fn display(&self)

pub fn convert_to_csv(&self) -> String

Trait Implementations

impl Clone for Matrix

fn clone(&self) -> Matrix

Returns a duplicate of the value.

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

Performs copy-assignment from source.