Yes, you can use Layer Normalization (LN) with CNNs, though it's less common than Batch Normalization. Layer Normalization normalizes across the feature dimension for each sample independently, making it batch-size agnostic.

How Layer Normalization Works

Layer Normalization computes statistics across all features for a single sample:

$$\mu = \frac{1}{H} \sum_{j=1}^{H} a_j \quad \sigma^2 = \frac{1}{H} \sum_{j=1}^{H} (a_j - \mu)^2$$

$$\hat{a}_j = \frac{a_j - \mu}{\sqrt{\sigma^2 + \epsilon}} \quad y_j = \gamma \hat{a}_j + \beta$$

Where $H$ is the number of features, $\gamma$ and $\beta$ are learnable scale and shift parameters.

Layer Norm vs Batch Norm in CNNs

When to Use Layer Normalization with CNNs

Layer Normalization works well when:

• Batch size is very small (e.g., 1-2 samples)
• You need consistent behavior between training and inference
• Working with variable-length sequences or sizes

Batch Normalization is typically better when:

• You have reasonably large batch sizes (32+)
• Training standard image classification CNNs
• You want the regularization effect of batch statistics

Implementation Example

1import torch
2import torch.nn as nn
3
4class CNNWithLayerNorm(nn.Module):
5    def __init__(self):
6        super().__init__()
7        self.conv1 = nn.Conv2d(3, 64, 3, padding=1)
8        self.ln1 = nn.LayerNorm([64, 32, 32])  # [C, H, W]
9        self.conv2 = nn.Conv2d(64, 128, 3, padding=1)
10        self.ln2 = nn.LayerNorm([128, 32, 32])
11        self.pool = nn.AdaptiveAvgPool2d(1)
12        self.fc = nn.Linear(128, 10)
13    
14    def forward(self, x):
15        x = torch.relu(self.ln1(self.conv1(x)))
16        x = torch.relu(self.ln2(self.conv2(x)))
17        x = self.pool(x).flatten(1)
18        return self.fc(x)

Note: LayerNorm in PyTorch requires specifying the normalized shape, which includes spatial dimensions for CNN feature maps.

Group Normalization: A Middle Ground

For CNNs, Group Normalization is often a better alternative to both:

# Divides channels into groups and normalizes within each group
self.gn = nn.GroupNorm(num_groups=8, num_channels=64)

Group Norm is batch-size independent like Layer Norm but preserves more spatial structure like Batch Norm.

Summary

• Yes, Layer Normalization works with CNNs
• Batch Normalization is usually preferred for standard CNN training with decent batch sizes
• Layer Normalization shines with small batches or when you need training/inference consistency
• Group Normalization is often the best compromise for CNNs when batch size is limited