class

LazyConvTranspose2d

extendsConvTranspose2d

LazyConvTranspose2d(out_channels: int, kernel_size: _Size2d, stride: _Size2d = 1, padding: _Size2d = 0, output_padding: _Size2d = 0, groups: int = 1, bias: bool = True, dilation: _Size2d = 1, device: DeviceLike = None, dtype: DTypeLike = None)

source

A ConvTranspose2d that infers in_channels from the first input.

Lazy version of the 2D transposed convolution. Weight allocation is deferred until the first forward call, making it easy to compose upsampling decoder networks without manually tracking the channel dimension through each block.

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 (upsampling factor). Default: 1.

paddingint or tuple[int, int]= 0

dilation * (kernel_size - 1) - padding zero-padding applied on each side. String padding is not supported. Default: 0.

output_paddingint or tuple[int, int]= 0

Additional size added to one side of each output dimension. Default: 0.

groupsint= 1

Number of blocked connections. Default: 1.

biasbool= True

If True, a learnable bias is added after materialization. Default: True.

dilationint or tuple[int, int]= 1

Spacing between kernel elements. Default: 1.

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 (in_channels, out_channels // groups, K_H, K_W) afterwards.

biasParameter or None

None before materialization; (out_channels,) if bias=True.

in_channelsint or None

None before the first forward pass.

Notes

Input: $(N, C_{\text{in}}, H, W)$ — $C_{\text{in}}$ is inferred automatically. Output: $(N, C_{\text{out}}, H_{\text{out}}, W_{\text{out}})$ — same formula as ConvTranspose2d.

State-dict loading. A 4-D weight tensor (shape (in_channels, out_channels // groups, K_H, K_W)) triggers materialization before parameter copying.

Symmetric encoder–decoder pairs. Pair each LazyConv2d encoder stride with a LazyConvTranspose2d of matching kernel_size, stride, and padding to reconstruct exact spatial dimensions.

Examples

Lazy VAE decoder:
>>> import lucid
>>> import lucid.nn as nn
>>> decoder = nn.LazyConvTranspose2d(
...     out_channels=64, kernel_size=4, stride=2, padding=1
... )
>>> z = lucid.zeros(4, 128, 8, 8)   # in_channels=128 inferred
>>> y = decoder(z)
>>> y.shape
(4, 64, 16, 16)
Verify inference:
>>> import lucid
>>> import lucid.nn as nn
>>> lazy = nn.LazyConvTranspose2d(out_channels=32, kernel_size=3)
>>> _ = lazy(lucid.zeros(1, 64, 4, 4))
>>> print(lazy.in_channels)
64

Methods (3)

dunder

init

→None

__init__(out_channels: int, kernel_size: _Size2d, stride: _Size2d = 1, padding: _Size2d = 0, output_padding: _Size2d = 0, groups: int = 1, bias: bool = True, dilation: _Size2d = 1, device: DeviceLike = None, dtype: DTypeLike = None)

source

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

forward

→Tensor

forward(x: Tensor)

source

Apply the convolution to the input tensor.

Parameters

inputTensor

Input tensor of shape

(N, C_{\text{in}}, *)

Returns

Tensor

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

extra_repr

→str

extra_repr()

source

Return a string representation of the layer's configuration.