Struct ModelBuilder 

pub struct ModelBuilder { /* private fields */ }

Implementations

impl ModelBuilder

pub fn new() -> ModelBuilder

Examples found in repository

examples/mnist.rs (line 44)

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 21)

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 add_layer(self, layer: Layer) -> ModelBuilder

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 optimizer(self, optimizer: Optimizer) -> ModelBuilder

Examples found in repository

examples/mnist.rs (lines 48-52)

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 (lines 25-27)

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 l2_reg(self, lambda: f64) -> ModelBuilder

Examples found in repository

examples/mnist.rs (line 53)

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 28)

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 checkpoint(self, checkpoint: Checkpoint) -> ModelBuilder

Examples found in repository

examples/mnist.rs (lines 54-56)

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 verbose(self, print_frequency: usize, silent_mode: bool) -> ModelBuilder

Examples found in repository

examples/mnist.rs (line 57)

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 debug(self, debug: bool) -> ModelBuilder

pub fn build(self) -> Model

pub fn build_and_train( self, data: &Matrix, labels: &Matrix, batch_size: u32, epochs: u32, validation_dataset_size: usize, )

Examples found in repository

examples/mnist.rs (line 58)

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 29)

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

Trait Implementations

impl Clone for ModelBuilder

fn clone(&self) -> ModelBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.