rustyml 0.15.0

A high-performance machine learning & deep learning library in pure Rust, offering ML algorithms and neural network 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
140
141
142

//! Weight containers for neural network layers
//!
//! Defines the [`LayerWeight`] enum and the per-layer weight structs it wraps. Each struct
//! holds its arrays as [`Cow`], so one type serves both directions. [`Layer::get_weights`]
//! borrows the live layer arrays (no clone) for inspection or saving, while loading
//! deserializes into owned arrays. The enum derives `Serialize`/`Deserialize`, so it is the
//! on-disk weight format
//!
//! [`Cow`]: std::borrow::Cow
//! [`Layer::get_weights`]: crate::neural_network::traits::Layer::get_weights
//! [`LayerWeight`]: crate::neural_network::layers::layer_weight::LayerWeight

use crate::{Deserialize, Serialize};

/// Per-layer weight container for the BatchNormalization layer
pub mod batch_normalization_weight;
/// Per-layer weight container for the Conv1DTranspose layer
pub mod conv_1d_transpose_weight;
/// Per-layer weight container for the Conv1D layer
pub mod conv_1d_weight;
/// Per-layer weight container for the Conv2DTranspose layer
pub mod conv_2d_transpose_weight;
/// Per-layer weight container for the Conv2D layer
pub mod conv_2d_weight;
/// Per-layer weight container for the Conv3DTranspose layer
pub mod conv_3d_transpose_weight;
/// Per-layer weight container for the Conv3D layer
pub mod conv_3d_weight;
/// Per-layer weight container for the Dense layer
pub mod dense_weight;
/// Per-layer weight container for the DepthwiseConv1D layer
pub mod depthwise_conv_1d_weight;
/// Per-layer weight container for the DepthwiseConv2D layer
pub mod depthwise_conv_2d_weight;
/// Per-layer weight container for the Embedding layer
pub mod embedding_weight;
/// Per-layer weight container for the GroupNormalization layer
pub mod group_normalization_weight;
/// Per-layer weight container for the GRU layer
pub mod gru_weight;
/// Per-layer weight container for the InstanceNormalization layer
pub mod instance_normalization_weight;
/// Per-layer weight container for the LayerNormalization layer
pub mod layer_normalization_weight;
/// Per-layer weight container for the LSTM layer
pub mod lstm_weight;
/// Per-layer weight container for the PReLU layer
pub mod p_relu_weight;
/// Per-layer weight container for the SeparableConv1D layer
pub mod separable_conv_1d_weight;
/// Per-layer weight container for the SeparableConv2D layer
pub mod separable_conv_2d_weight;
/// Per-layer weight container for the SimpleRNN layer
pub mod simple_rnn_weight;

pub use batch_normalization_weight::*;
pub use conv_1d_transpose_weight::*;
pub use conv_1d_weight::*;
pub use conv_2d_transpose_weight::*;
pub use conv_2d_weight::*;
pub use conv_3d_transpose_weight::*;
pub use conv_3d_weight::*;
pub use dense_weight::*;
pub use depthwise_conv_1d_weight::*;
pub use depthwise_conv_2d_weight::*;
pub use embedding_weight::*;
pub use group_normalization_weight::*;
pub use gru_weight::*;
pub use instance_normalization_weight::*;
pub use layer_normalization_weight::*;
pub use lstm_weight::*;
pub use p_relu_weight::*;
pub use separable_conv_1d_weight::*;
pub use separable_conv_2d_weight::*;
pub use simple_rnn_weight::*;

/// Polymorphic container for the weights of different neural network layer types
///
/// Each variant corresponds to a specific layer type and holds the matching weight struct. The
/// `'a` lifetime lets a variant borrow the live layer arrays when inspecting or saving (via
/// [`Cow`](std::borrow::Cow)). Loading deserializes into owned arrays, so the type is used as
/// `LayerWeight<'static>` on the load path. The enum uses serde's default, externally tagged
/// representation, which the non-self-describing postcard binary format requires
///
/// The variants differ in size (`BatchNormalization` carries 4 arrays, a convolution carries
/// 2), so every value is padded to the largest one. This is deliberate. Exactly 1 value of
/// this type exists per layer, built at save or load time, never in a hot path. Boxing the
/// wide variant would add an allocation to a type whose only purpose is to borrow the live
/// arrays without copying
///
/// **Append a new variant at the end.** postcard writes the variant index, so a variant inserted
/// in the middle renumbers every variant after it. An existing file would then decode a saved
/// layer as the wrong one. Appending keeps every earlier index, so a file written before the new
/// variant existed still loads, and
/// [`MODEL_FORMAT_VERSION`](crate::neural_network::layers::serialize_model::MODEL_FORMAT_VERSION)
/// needs no bump
#[allow(clippy::large_enum_variant)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum LayerWeight<'a> {
    /// Weights for dense (fully connected) layers
    Dense(DenseLayerWeight<'a>),
    /// Weights for simple recurrent neural network layers
    SimpleRNN(SimpleRNNLayerWeight<'a>),
    /// Weights for long short-term memory layers
    LSTM(LSTMLayerWeight<'a>),
    /// Weights for gated recurrent unit layers
    GRU(GRULayerWeight<'a>),
    /// Weights for 1D convolutional layers
    Conv1D(Conv1DLayerWeight<'a>),
    /// Weights for 2D convolutional layers
    Conv2D(Conv2DLayerWeight<'a>),
    /// Weights for 3D convolutional layers
    Conv3D(Conv3DLayerWeight<'a>),
    /// Weights for 2D separable convolutional layers
    SeparableConv2D(SeparableConv2DLayerWeight<'a>),
    /// Weights for 2D depthwise convolutional layers
    DepthwiseConv2D(DepthwiseConv2DLayerWeight<'a>),
    /// Weights for batch normalization layers
    BatchNormalization(BatchNormalizationLayerWeight<'a>),
    /// Weights for layer normalization layers
    LayerNormalization(LayerNormalizationLayerWeight<'a>),
    /// Weights for instance normalization layers
    InstanceNormalization(InstanceNormalizationLayerWeight<'a>),
    /// Weights for group normalization layers
    GroupNormalization(GroupNormalizationLayerWeight<'a>),
    /// Layer with no trainable parameters
    Empty,
    /// Weights for embedding layers
    Embedding(EmbeddingLayerWeight<'a>),
    /// Weights for 1D transposed convolutional layers
    Conv1DTranspose(Conv1DTransposeLayerWeight<'a>),
    /// Weights for 2D transposed convolutional layers
    Conv2DTranspose(Conv2DTransposeLayerWeight<'a>),
    /// Weights for 3D transposed convolutional layers
    Conv3DTranspose(Conv3DTransposeLayerWeight<'a>),
    /// Weights for PReLU layers
    PReLU(PReLULayerWeight<'a>),
    /// Weights for 1D depthwise convolutional layers
    DepthwiseConv1D(DepthwiseConv1DLayerWeight<'a>),
    /// Weights for 1D separable convolutional layers
    SeparableConv1D(SeparableConv1DLayerWeight<'a>),
}