Struct NabModel

pub struct NabModel { /* private fields */ }

Represents a model using the Functional API

Examples

use nabla_ml::nab_model::NabModel;
use nabla_ml::nab_layers::NabLayer;
 
// Create model architecture
let input = NabModel::input(vec![784]);
let dense1 = NabLayer::dense(784, 512, Some("relu"), Some("dense1"));
let x = input.apply(dense1);
let output_layer = NabLayer::dense(512, 10, Some("softmax"), Some("output"));
let output = x.apply(output_layer);
 
// Create and compile model
let mut model = NabModel::new_functional(vec![input], vec![output]);
model.compile(
    "sgd",
    0.1,
    "categorical_crossentropy",
    vec!["accuracy".to_string()]
);

Implementations

impl NabModel

pub fn input(shape: Vec<usize>) -> Input

Creates a new input layer with specified shape

Arguments

• shape - Shape of input excluding batch dimension

Examples

let input = NabModel::input(vec![784]); // For MNIST images

pub fn new() -> Self

Creates a new model

pub fn add(&mut self, layer: NabLayer) -> &mut Self

Adds a layer to the model

pub fn compile( &mut self, optimizer_type: &str, learning_rate: f64, loss_type: &str, metrics: Vec<String>, )

Compiles the model with training configuration

Arguments

• optimizer_type - Optimization algorithm (“sgd”, “adam”, etc)
• learning_rate - Learning rate for optimization
• loss_type - Loss function (“mse”, “categorical_crossentropy”)
• metrics - Metrics to track during training

pub fn new_functional(inputs: Vec<Input>, outputs: Vec<Output>) -> Self

Creates a new model from input and output nodes

pub fn fit( &mut self, x_train: &NDArray, y_train: &NDArray, batch_size: usize, epochs: usize, validation_data: Option<(&NDArray, &NDArray)>, ) -> HashMap<String, Vec<f64>>

Trains the model on input data

Arguments

• x_train - Training features
• y_train - Training labels
• batch_size - Mini-batch size
• epochs - Number of training epochs
• validation_data - Optional validation dataset

Returns

HashMap containing training history metrics

Examples

let history = model.fit(
    &x_train,
    &y_train, 
    64,    // batch_size
    5,     // epochs
    Some((&x_test, &y_test))
);

pub fn evaluate( &mut self, x_test: &NDArray, y_test: &NDArray, batch_size: usize, ) -> HashMap<String, f64>

Evaluates model performance on test data

Arguments

• x_test - Test features
• y_test - Test labels
• batch_size - Batch size for evaluation

Returns

HashMap containing evaluation metrics

pub fn predict(&mut self, x: &NDArray) -> NDArray

Makes predictions on input data

Arguments

• x - Input features to predict on

Returns

NDArray of model predictions

pub fn print_layers(&self)

Trait Implementations

impl Clone for NabModel

fn clone(&self) -> NabModel

Returns a copy of the value.

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

Performs copy-assignment from source.