Struct Conv2d 

pub struct Conv2d<D: Dtype, IT, OT, const RANK: usize> {
    pub in_channels: usize,
    pub out_channels: usize,
    pub kernel_h: usize,
    pub kernel_w: usize,
    pub stride_h: usize,
    pub stride_w: usize,
    pub padding_h: usize,
    pub padding_w: usize,
    pub groups: usize,
    pub has_bias: bool,
    /* private fields */
}

2-D convolution layer: output = conv2d(input, weight) [+ b]

Input shape: [N, C_in, H_in, W_in ] Output shape: [N, C_out, H_out, W_out]

where: H_out = (H_in + 2*padding_h - kernel_h) / stride_h + 1 W_out = (W_in + 2*padding_w - kernel_w) / stride_w + 1

Type parameters:

• D — element dtype
• IT — input tensor type (rank 4: [N, C_in, H, W])
• OT — output tensor type (rank 4: [N, C_out, H, W])
• RANK — tensor rank; must be 4 for a valid 2-D convolution

Tensor bounds are on impls, not the struct, so SymTensor can have its own Layer impl without a coherence conflict.

Fields

in_channels: usize

Number of input channels.

out_channels: usize

Number of output channels.

kernel_h: usize

Convolution kernel height.

kernel_w: usize

Convolution kernel width.

stride_h: usize

Vertical stride.

stride_w: usize

Horizontal stride.

padding_h: usize

Vertical zero-padding.

padding_w: usize

Horizontal zero-padding.

groups: usize

Number of blocked/grouped connections (1 = standard convolution).

has_bias: bool

Whether to add a learned bias.

Implementations

impl<D: Dtype, IT, OT, const RANK: usize> Conv2d<D, IT, OT, RANK>

pub fn new( in_channels: usize, out_channels: usize, kernel_size: (usize, usize), stride: (usize, usize), padding: (usize, usize), has_bias: bool, ) -> Self

Create a new Conv2d layer.

• kernel_size — (height, width) of the convolution kernel
• stride — (height, width) step between kernel applications
• padding — (height, width) zero-padding added to each spatial side

pub fn new_grouped( in_channels: usize, out_channels: usize, kernel_size: (usize, usize), stride: (usize, usize), padding: (usize, usize), has_bias: bool, groups: usize, ) -> Self

Creates a new grouped Conv2d layer (see Conv2d::groups).

Trait Implementations

impl<D: Dtype, IT: Tensor<D, RANK> + EagerTensor, OT: Tensor<D, RANK>, const RANK: usize> Layer<IT> for Conv2d<D, IT, OT, RANK>

type Output = OT

This layer’s output type.

fn call(&self, _input: IT) -> Self::Output

Applies this layer to input.

impl<D: Dtype, const RANK: usize> Layer<SymTensor> for Conv2d<D, SymTensor, SymTensor, RANK>

type Output = SymTensor

This layer’s output type.

fn call(&self, input: SymTensor) -> SymTensor

Applies this layer to input.