Lucid3.0
class

LazyConv2d

extendsConv2d
LazyConv2d(out_channels: int, kernel_size: _Size2d, stride: _Size2d = 1, padding: _Size2d | str = 0, dilation: _Size2d = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device: DeviceLike = None, dtype: DTypeLike = None)
source

A Conv2d that infers in_channels from the first input.

Lazy initialization allows building 2D convolutional networks without knowing the input channel count in advance. The module registers weight and bias as None parameters and allocates them on the first forward call, reading C_in from x.shape[1].

Parameters

out_channelsint
Number of output channels.
kernel_sizeint or tuple[int, int]
Size of the 2D convolving kernel.
strideint or tuple[int, int]= 1
Stride of the convolution. Default: 1.
paddingint, tuple[int, int], or str= 0
Zero-padding or "same" / "valid" string specifier. Default: 0.
dilationint or tuple[int, int]= 1
Spacing between kernel elements. Default: 1.
groupsint= 1
Number of blocked connections. Default: 1.
biasbool= True
If True, a learnable bias is added after materialization. Default: True.
padding_modestr= 'zeros'
"zeros", "reflect", "replicate", or "circular". Default: "zeros".
deviceDeviceLike= None
Device used when allocating weights. Default: None.
dtypeDTypeLike= None
Data type used when allocating weights. Default: None.

Attributes

weightParameter or None
None before materialization; shape (out_channels, in_channels // groups, K_H, K_W) afterwards.
biasParameter or None
None before materialization; shape (out_channels,) if bias=True, else remains None.
in_channelsint or None
None before the first forward pass; inferred channel count afterwards.

Notes

Input: (N,Cin,H,W)(N, C_{\text{in}}, H, W) — CinC_{\text{in}} is inferred automatically. Output: (N,Cout,Hout,Wout)(N, C_{\text{out}}, H_{\text{out}}, W_{\text{out}}) — same formula as Conv2d.

State-dict materialization. Loading a state_dict with a 4-D weight tensor triggers materialization before parameter copying, enabling round-trip checkpoint compatibility.

Examples

Dynamic channel inference in a feature extractor:
>>> import lucid
>>> import lucid.nn as nn
>>> model = nn.Sequential(
...     nn.LazyConv2d(out_channels=64, kernel_size=3, padding=1),
...     nn.ReLU(),
...     nn.LazyConv2d(out_channels=128, kernel_size=3, padding=1),
... )
>>> x = lucid.zeros(2, 3, 32, 32)   # in_channels=3 inferred here
>>> y = model(x)
>>> y.shape
(2, 128, 32, 32)
Verify inferred in_channels after forward:
>>> import lucid
>>> import lucid.nn as nn
>>> lazy = nn.LazyConv2d(out_channels=16, kernel_size=3, padding=1)
>>> _ = lazy(lucid.zeros(1, 8, 16, 16))
>>> print(lazy.in_channels)
8

Methods (3)

dunder

__init__

→None
__init__(out_channels: int, kernel_size: _Size2d, stride: _Size2d = 1, padding: _Size2d | str = 0, dilation: _Size2d = 1, groups: int = 1, bias: bool = True, padding_mode: str = 'zeros', device: DeviceLike = None, dtype: DTypeLike = None)
source

Initialise the LazyConv2d module. See the class docstring for parameter semantics.

fn

forward

→Tensor
forward(x: Tensor)
source

Apply the convolution to the input tensor.

Parameters

inputTensor
Input tensor of shape (N,Cin,∗)(N, C_{\text{in}}, *).

Returns

Tensor

Output tensor of shape (N,Cout,∗)(N, C_{\text{out}}, *) with spatial dimensions determined by stride, padding, dilation, and kernel size.

fn

extra_repr

→str
extra_repr()
source

Return a string representation of the layer's configuration.