Struct Conv2d 

pub struct Conv2d<B>
where
    B: Backend,
{ /* private fields */ }

2D convolutional layer.

Applies a set of learnable filters to a 4D input [N, C_in, H, W], producing output of shape [N, C_out, H_out, W_out].

Examples

let conv = Conv2d::<CpuBackend>::new(1, 16, [3, 3], [1, 1], [1, 1], true, DType::F32, &dev)?;
let x = CpuTensor::rand((4, 1, 28, 28), DType::F32, &dev)?;
let y = conv.forward(&x)?; // [4, 16, 28, 28]

Implementations

impl<B> Conv2d<B>

where B: Backend,

pub fn new( in_channels: usize, out_channels: usize, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], use_bias: bool, dtype: DType, device: &<B as Backend>::Device, ) -> Result<Conv2d<B>, Error>

Create a new Conv2d layer with Kaiming uniform initialization.

Arguments

• in_channels: number of input channels (C_in)
• out_channels: number of output channels / filters (C_out)
• kernel_size: [kH, kW] spatial size of each filter
• stride: [sH, sW] stride of the convolution
• padding: [pH, pW] zero-padding added to both sides
• use_bias: whether to include an additive bias
• dtype: data type for parameters
• device: device to create parameters on

pub fn from_tensors( weight: Tensor<B>, bias: Option<Tensor<B>>, stride: [usize; 2], padding: [usize; 2], ) -> Result<Conv2d<B>, Error>

Create a Conv2d from existing weight and bias tensors (e.g. for loading).

pub fn in_channels(&self) -> usize

pub fn out_channels(&self) -> usize

pub fn kernel_size(&self) -> [usize; 2]

pub fn stride(&self) -> [usize; 2]

pub fn padding(&self) -> [usize; 2]

pub fn weight(&self) -> &Tensor<B>

pub fn bias(&self) -> Option<&Tensor<B>>

Trait Implementations

impl<B> Module<B> for Conv2d<B>

where B: Backend,

fn forward(&self, x: &Tensor<B>) -> Result<Tensor<B>, Error>

Forward pass: 2D convolution.

Input: [N, C_in, H, W] Output: [N, C_out, H_out, W_out]

fn parameters(&self) -> Vec<Tensor<B>>

Return all trainable parameters of this module. The optimizer uses these to update weights during training.

fn named_parameters(&self) -> Vec<(String, Tensor<B>)>

Return all trainable parameters with human-readable names.

fn set_training(&self, _training: bool)

Set training or evaluation mode.

fn is_training(&self) -> bool

Whether the module is in training mode (default: true).

fn train(&self)

Convenience: set training mode.

fn eval(&self)

Convenience: set evaluation mode.

fn num_parameters(&self) -> usize

Total number of scalar parameters in this module.

fn trainable_params_count(&self) -> usize

Number of trainable (variable) parameters.

fn frozen_parameters(&self) -> Vec<Tensor<B>>

Freeze all parameters: returns new parameter tensors with is_variable = false, preventing gradient accumulation.

fn state_dict(&self) -> Vec<(String, Tensor<B>)>

Returns a state_dict-style map of parameter name → tensor.