Struct PatchEmbedding 

pub struct PatchEmbedding<F: Float + Debug + ScalarOperand + Send + Sync + NumAssign> { /* private fields */ }

Patch Embedding layer.

Divides an image into fixed-size patches and projects each patch to an embedding vector via a learned linear projection (optionally including a bias term).

Shape

• Input: [batch_size, in_channels, image_height, image_width]
• Output: [batch_size, num_patches, embed_dim] where num_patches = (image_height / patch_size) * (image_width / patch_size)

Parameters

• weight: shape [embed_dim, in_channels * patch_h * patch_w] — the projection matrix
• bias (optional): shape [embed_dim] — per-embedding bias

Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync + NumAssign + 'static> PatchEmbedding<F>

pub fn new<R: Rng>( image_size: (usize, usize), patch_size: (usize, usize), in_channels: usize, embed_dim: usize, use_bias: bool, rng: &mut R, ) -> Result<Self>

Create a new PatchEmbedding layer.

Arguments

• image_size — expected input image dimensions (height, width)
• patch_size — patch dimensions (height, width) — must divide image_size evenly
• in_channels — number of input image channels
• embed_dim — output embedding dimension
• use_bias — whether to include a learnable bias term
• rng — random number generator for weight initialisation

pub fn num_patches(&self) -> usize

Total number of patches produced from one image

pub fn patch_dim(&self) -> usize

Flat patch vector dimension: in_channels * patch_h * patch_w

Trait Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync + NumAssign + 'static> Clone for PatchEmbedding<F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Float + Debug + ScalarOperand + Send + Sync + NumAssign + 'static> Debug for PatchEmbedding<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Float + Debug + ScalarOperand + Send + Sync + NumAssign + 'static> Layer<F> for PatchEmbedding<F>

fn forward(&self, input: &Array<F, IxDyn>) -> Result<Array<F, IxDyn>>

Forward pass of the layer

fn backward( &self, _input: &Array<F, IxDyn>, grad_output: &Array<F, IxDyn>, ) -> Result<Array<F, IxDyn>>

Backward pass of the layer to compute gradients

fn update(&mut self, learning_rate: F) -> Result<()>

Update the layer parameters with the given learning rate

fn as_any(&self) -> &dyn Any

Get the layer as a dyn Any for downcasting

fn as_any_mut(&mut self) -> &mut dyn Any

Get the layer as a mutable dyn Any for downcasting

fn layer_type(&self) -> &str

Get the type of the layer (e.g., “Dense”, “Conv2D”)

fn parameter_count(&self) -> usize

Get the number of trainable parameters in this layer

fn layer_description(&self) -> String

Get a detailed description of this layer

fn params(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer

fn set_params(&mut self, params: &[Array<F, IxDyn>]) -> Result<()>

Set the parameters of the layer

fn inputshape(&self) -> Option<Vec<usize>>

Get the input shape if known

fn outputshape(&self) -> Option<Vec<usize>>

Get the output shape if known

fn gradients(&self) -> Vec<Array<F, IxDyn>>

Get the gradients of the layer parameters

fn set_gradients(&mut self, _gradients: &[Array<F, IxDyn>]) -> Result<()>

Set the gradients of the layer parameters

fn set_training(&mut self, _training: bool)

Set the layer to training mode (true) or evaluation mode (false)

fn is_training(&self) -> bool

Get the current training mode

fn name(&self) -> Option<&str>

Get the name of the layer if set

impl<F: Float + Debug + ScalarOperand + Send + Sync + NumAssign + 'static> ParamLayer<F> for PatchEmbedding<F>

fn get_parameters(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer as a vector of arrays

fn get_gradients(&self) -> Vec<Array<F, IxDyn>>

Get the gradients of the parameters

fn set_parameters(&mut self, params: Vec<Array<F, IxDyn>>) -> Result<()>

Set the parameters

impl<F: Float + Debug + ScalarOperand + Send + Sync + NumAssign> Send for PatchEmbedding<F>

impl<F: Float + Debug + ScalarOperand + Send + Sync + NumAssign> Sync for PatchEmbedding<F>