Struct PatchEmbedding

pub struct PatchEmbedding<F: Float + Debug + ScalarOperand + Send + Sync> {
    pub image_size: (usize, usize),
    pub patch_size: (usize, usize),
    pub in_channels: usize,
    pub embedding_dim: usize,
    pub weight: Array<F, IxDyn>,
    pub bias: Option<Array<F, IxDyn>>,
    /* private fields */
}

Patch Embedding layer for vision transformers

This layer converts image patches into embeddings for vision transformers. It applies a convolution to extract patches and flatten them into embedding vectors.

Fields

image_size: (usize, usize)

Size of input images (height, width)

patch_size: (usize, usize)

Size of patches (height, width)

in_channels: usize

Number of input channels (e.g., 3 for RGB)

embedding_dim: usize

Dimension of each embedding vector

weight: Array<F, IxDyn>

Weight matrix for patch extraction

bias: Option<Array<F, IxDyn>>

Bias vector

Implementations

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

pub fn new( image_size: (usize, usize), patch_size: (usize, usize), in_channels: usize, embedding_dim: usize, use_bias: bool, ) -> Result<Self>

Create a new PatchEmbedding layer

Examples found in repository

examples/embedding_example.rs (line 66)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Running embedding examples...");

    // Example 1: Basic Embedding
    println!("\n--- Basic Embedding Example ---");
    let config = EmbeddingConfig {
        num_embeddings: 10,
        embedding_dim: 5,
        padding_idx: Some(0),
        max_norm: None,
        norm_type: 2.0,
        scale_grad_by_freq: false,
        sparse: false,
    };

    let embedding = Embedding::<f32>::new(config)?;

    // Create input indices
    let indices = Array::from_shape_vec(IxDyn(&[2, 3]), vec![1, 2, 0, 3, 0, 4])?;

    // Forward pass
    let output = embedding.forward(&indices.mapv(|x| x as f32))?;

    println!("Input indices shape: {:?}", indices.shape());
    println!("Output embeddings shape: {:?}", output.shape());
    println!(
        "First embedding vector: {:?}",
        output.slice(ndarray::s![0, 0, ..]).to_owned()
    );

    // Example 2: Positional Embedding
    println!("\n--- Positional Embedding Example ---");

    // Create fixed sinusoidal positional embeddings
    let pos_embedding = PositionalEmbedding::<f32>::new(10, 8, false)?;

    // Create dummy input (like token embeddings)
    let token_embeddings = Array::from_shape_fn(IxDyn(&[2, 5, 8]), |_| 1.0f32);

    // Add positional information
    let output = pos_embedding.forward(&token_embeddings)?;

    println!("Token embeddings shape: {:?}", token_embeddings.shape());
    println!(
        "Output with positional encoding shape: {:?}",
        output.shape()
    );
    println!(
        "First token before positional encoding: {:?}",
        token_embeddings.slice(ndarray::s![0, 0, ..]).to_owned()
    );
    println!(
        "First token after positional encoding: {:?}",
        output.slice(ndarray::s![0, 0, ..]).to_owned()
    );

    // Example 3: Patch Embedding (for Vision Transformers)
    println!("\n--- Patch Embedding Example ---");

    // Create patch embedding for a vision transformer
    let patch_embedding = PatchEmbedding::<f32>::new((32, 32), (8, 8), 3, 96, true)?;

    // Create random image input
    let image_input = Array::from_shape_fn(IxDyn(&[1, 3, 32, 32]), |_| rand::random::<f32>());

    // Extract patch embeddings
    let output = patch_embedding.forward(&image_input)?;

    println!("Input image shape: {:?}", image_input.shape());
    println!("Patch embeddings shape: {:?}", output.shape());
    println!("Number of patches: {}", patch_embedding.num_patches());
    println!("Embedding dimension: {}", patch_embedding.embedding_dim);

    // Print first patch embedding
    println!(
        "First patch embedding (first 5 values): {:?}",
        output.slice(ndarray::s![0, 0, ..5]).to_owned()
    );

    println!("\nAll embedding examples completed successfully!");

    Ok(())
}

pub fn num_patches(&self) -> usize

Calculate the number of patches

Examples found in repository

examples/embedding_example.rs (line 76)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Running embedding examples...");

    // Example 1: Basic Embedding
    println!("\n--- Basic Embedding Example ---");
    let config = EmbeddingConfig {
        num_embeddings: 10,
        embedding_dim: 5,
        padding_idx: Some(0),
        max_norm: None,
        norm_type: 2.0,
        scale_grad_by_freq: false,
        sparse: false,
    };

    let embedding = Embedding::<f32>::new(config)?;

    // Create input indices
    let indices = Array::from_shape_vec(IxDyn(&[2, 3]), vec![1, 2, 0, 3, 0, 4])?;

    // Forward pass
    let output = embedding.forward(&indices.mapv(|x| x as f32))?;

    println!("Input indices shape: {:?}", indices.shape());
    println!("Output embeddings shape: {:?}", output.shape());
    println!(
        "First embedding vector: {:?}",
        output.slice(ndarray::s![0, 0, ..]).to_owned()
    );

    // Example 2: Positional Embedding
    println!("\n--- Positional Embedding Example ---");

    // Create fixed sinusoidal positional embeddings
    let pos_embedding = PositionalEmbedding::<f32>::new(10, 8, false)?;

    // Create dummy input (like token embeddings)
    let token_embeddings = Array::from_shape_fn(IxDyn(&[2, 5, 8]), |_| 1.0f32);

    // Add positional information
    let output = pos_embedding.forward(&token_embeddings)?;

    println!("Token embeddings shape: {:?}", token_embeddings.shape());
    println!(
        "Output with positional encoding shape: {:?}",
        output.shape()
    );
    println!(
        "First token before positional encoding: {:?}",
        token_embeddings.slice(ndarray::s![0, 0, ..]).to_owned()
    );
    println!(
        "First token after positional encoding: {:?}",
        output.slice(ndarray::s![0, 0, ..]).to_owned()
    );

    // Example 3: Patch Embedding (for Vision Transformers)
    println!("\n--- Patch Embedding Example ---");

    // Create patch embedding for a vision transformer
    let patch_embedding = PatchEmbedding::<f32>::new((32, 32), (8, 8), 3, 96, true)?;

    // Create random image input
    let image_input = Array::from_shape_fn(IxDyn(&[1, 3, 32, 32]), |_| rand::random::<f32>());

    // Extract patch embeddings
    let output = patch_embedding.forward(&image_input)?;

    println!("Input image shape: {:?}", image_input.shape());
    println!("Patch embeddings shape: {:?}", output.shape());
    println!("Number of patches: {}", patch_embedding.num_patches());
    println!("Embedding dimension: {}", patch_embedding.embedding_dim);

    // Print first patch embedding
    println!(
        "First patch embedding (first 5 values): {:?}",
        output.slice(ndarray::s![0, 0, ..5]).to_owned()
    );

    println!("\nAll embedding examples completed successfully!");

    Ok(())
}

Trait Implementations

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

fn clone(&self) -> PatchEmbedding<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Float + Debug + ScalarOperand + Send + Sync> 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> 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 gradients

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 params(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer

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_params(&mut self, _params: &[Array<F, IxDyn>]) -> Result<()>

Set the parameters of the layer

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