nnl 0.1.6

A high-performance neural network library for Rust with CPU and GPU support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! # NNL - Neural Network Library
//!
//! A high-performance neural network library for Rust with comprehensive GPU and CPU support.
//!
//! ## Features
//!
//! - **Multi-backend Support**: Vulkan, and optimized CPU execution
//! - **Automatic Hardware Detection**: Seamlessly selects the best available compute backend
//! - **Multiple Training Methods**: Backpropagation, Newton's method, and advanced optimizers
//! - **Flexible Architecture**: Support for both linear and convolutional networks
//! - **Model Persistence**: Import/export trained models to disk
//! - **Production Ready**: Zero-copy operations, SIMD optimizations, and batched processing
//!
//! ## Quick Start
//!
//! ```rust
//! use nnl::prelude::*;
//!
//! // Create a simple network
//! let mut network = NetworkBuilder::new()
//!     .add_layer(LayerConfig::Dense {
//!         input_size: 2,
//!         output_size: 4,
//!         activation: Activation::ReLU,
//!     })
//!     .add_layer(LayerConfig::Dense {
//!         input_size: 4,
//!         output_size: 1,
//!         activation: Activation::Sigmoid,
//!     })
//!     .loss(LossFunction::MeanSquaredError)
//!     .optimizer(OptimizerConfig::Adam { learning_rate: 0.001 })
//!     .build()?;
//!
//! // Train the network
//! let inputs = Tensor::from_slice(&[0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0], &[4, 2])?;
//! let targets = Tensor::from_slice(&[0.0, 1.0, 1.0, 0.0], &[4, 1])?;
//!
//! network.train(&inputs, &targets, 1000)?;
//!
//! // Make predictions
//! let prediction = network.forward(&Tensor::from_slice(&[1.0, 0.0], &[1, 2])?)?;
//! println!("Prediction: {}", prediction);
//! ```

#![warn(missing_docs)]
#![cfg_attr(docsrs, feature(doc_cfg))]

// Core modules
pub mod activations;
pub mod device;
pub mod io;
pub mod layers;
pub mod losses;
pub mod network;
pub mod optimizers;
pub mod tensor;

// Utilities and error handling
pub mod error;
pub mod utils;

// Re-exports for convenience
pub use error::{NnlError, Result};

/// Prelude module for convenient imports
pub mod prelude {
    pub use crate::activations::Activation;
    pub use crate::device::{Backend, Device, DeviceType};
    pub use crate::error::{NnlError, Result};
    pub use crate::io::{
        DatasetInfo, ModelFormat, ModelMetadata, TrainingInfo, load_model, load_network,
        load_network_auto, save_model,
    };
    pub use crate::layers::{Layer, LayerConfig, WeightInit};
    pub use crate::losses::LossFunction;
    pub use crate::network::{
        LearningRateSchedule, Network, NetworkBuilder, TrainingConfig, TrainingHistory,
        TrainingMetrics,
    };
    pub use crate::optimizers::{Optimizer, OptimizerConfig};
    pub use crate::tensor::{Shape, Tensor, TensorView};
    pub use crate::utils;

    // External dependencies commonly used
    pub use anyhow::Result as AnyhowResult;
    pub use chrono;
    pub use env_logger;
    pub use std::collections::HashMap;
}

#[cfg(test)]
mod tests {
    use super::prelude::*;

    #[test]
    fn test_device_detection() {
        let device = Device::auto_select();
        assert!(device.is_ok());

        let device = device.unwrap();
        println!("Auto-selected device: {:?}", device.device_type());
    }

    #[test]
    fn test_tensor_creation() {
        let tensor = Tensor::zeros(&[2, 3]);
        assert!(tensor.is_ok());

        let tensor = tensor.unwrap();
        assert_eq!(tensor.shape(), &[2, 3]);
    }

    #[test]
    fn test_simple_network() -> Result<()> {
        let mut network = NetworkBuilder::new()
            .add_layer(LayerConfig::Dense {
                input_size: 2,
                output_size: 1,
                activation: Activation::Sigmoid,
                use_bias: true,
                weight_init: crate::layers::WeightInit::Xavier,
            })
            .loss(LossFunction::MeanSquaredError)
            .optimizer(OptimizerConfig::SGD {
                learning_rate: 0.1,
                momentum: None,
                weight_decay: None,
                nesterov: false,
            })
            .build()?;

        let inputs = Tensor::from_slice(&[1.0, 0.0], &[1, 2])?;
        let output = network.forward(&inputs)?;

        assert_eq!(output.shape(), &[1, 1]);
        Ok(())
    }
}