Какие виды сверток знаете, плюсы и минусы каждой?

Какие виды сверток знаете, плюсы и минусы каждой?

Свёртка (Convolution) — фундаментальная операция в нейронных сетях для обработки изображений и последовательностей. Существует множество вариантов, каждый с особенностями.

1. Standard Convolution (Обычная свёртка)

Описание: Классическая операция, где фильтр скользит по входу, вычисляя скалярное произведение.

import torch
import torch.nn as nn

# Standard Conv2d
conv = nn.Conv2d(
    in_channels=3,      # RGB
    out_channels=64,    # Количество фильтров
    kernel_size=3,      # 3×3 фильтр
    stride=1,
    padding=1
)

x = torch.randn(1, 3, 224, 224)  # Batch, Channels, Height, Width
output = conv(x)  # (1, 64, 224, 224)

# Параметры: (3 × 3 × 3 + 1) × 64 = 1856 параметров
print(f"Параметров: {sum(p.numel() for p in conv.parameters())}")

Плюсы:

• Полностью свёртывает всё пространство входа
• Быстро вычисляется на GPU
• Хорошо работает для большинства задач

Минусы:

• Много параметров (O(k² × in × out))
• Медленно для больших фильтров (k > 5)
• Одинаковый расход памяти на все слои

2. Depthwise Separable Convolution

Описание: Разделяет свёртку на две части: depthwise (k×k за раз для каждого канала) + pointwise (1×1 для объединения).

class DepthwiseSeparableConv(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3):
        super().__init__()
        # Depthwise: k×k для каждого канала отдельно
        self.depthwise = nn.Conv2d(
            in_channels,
            in_channels,
            kernel_size,
            padding=1,
            groups=in_channels  # groups=in_channels → depthwise!
        )
        # Pointwise: 1×1 для объединения
        self.pointwise = nn.Conv2d(in_channels, out_channels, 1)
    
    def forward(self, x):
        x = self.depthwise(x)
        x = self.pointwise(x)
        return x

# Сравнение параметров
standard_params = 3 * 3 * 64 * 128 + 128  # 73856

# Depthwise separable
depthwise_params = (3*3*64) + (64*128) + 128  # 8448
print(f"Standard Conv: {standard_params}")
print(f"Depthwise Separable: {depthwise_params}")
print(f"Экономия: {standard_params / depthwise_params:.1f}x")

Плюсы:

• Минимум параметров (O(k² × in + in × out))
• Быстрее: ~10x меньше вычислений
• Память эффективнее (MobileNet, EfficientNet)

Минусы:

• Немного хуже качество (каналы обрабатываются независимо)
• Требует две операции вместо одной
• Менее универсален

3. Grouped Convolution

Описание: Входные и выходные каналы разбиваются на группы, свёртка выполняется независимо для каждой группы.

# Grouped convolution
conv_grouped = nn.Conv2d(
    in_channels=64,
    out_channels=128,
    kernel_size=3,
    groups=32  # 64/32 входных + 128/32 выходных на группу
)

# Параметры для группы:
# (64/32) × 3 × 3 × (128/32) = 2 × 3 × 3 × 4 = 72 параметров
# Всего: 72 × 32 = 2304 параметров

print(f"Параметров (grouped): {sum(p.numel() for p in conv_grouped.parameters())}")

# Сравнение со standard
conv_standard = nn.Conv2d(64, 128, 3)
print(f"Параметров (standard): {sum(p.numel() for p in conv_standard.parameters())}")

Плюсы:

• Меньше параметров: O(k² × (in/g) × (out/g) × g)
• Быстрее вычисляется
• Улучшает обобщаемость (меньше переобучения)

Минусы:

• Группы не взаимодействуют (информация не смешивается)
• Нужен 1×1 conv для соединения информации
• Менее универсален

4. Dilated (Atrous) Convolution

Описание: Добавляет промежутки между элементами фильтра, увеличивая receptive field без снижения разрешения.

# Standard 3×3: receptive field = 3
conv_standard = nn.Conv2d(64, 128, kernel_size=3)

# Dilated 3×3 с dilation=2: receptive field = 5
conv_dilated = nn.Conv2d(64, 128, kernel_size=3, dilation=2)

# Dilated 3×3 с dilation=4: receptive field = 7
conv_dilated_4 = nn.Conv2d(64, 128, kernel_size=3, dilation=4)

print("Receptive fields:")
print(f"  Standard (kernel=3): {3}")
print(f"  Dilated (kernel=3, dilation=2): {5}")
print(f"  Dilated (kernel=3, dilation=4): {7}")
print(f"  vs Standard (kernel=7): {7} (но 49 параметров vs 27)")

# Параметры одинаковые, но receptive field больше!

Плюсы:

• Увеличивает receptive field без потери разрешения
• Хорошо для semantic segmentation
• Параметры как у обычной свёртки
• Нет потери информации (как при max pooling)

Минусы:

• Сложнее реализовать
• Grid artifacts при некорректном использовании
• Медленнее стандартной свёртки

5. Transposed Convolution (Deconvolution)

Описание: Обратная операция обычной свёртки, увеличивает разрешение входа.

# Обычная свёртка: (224, 224) → (112, 112)
conv_down = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)

# Transposed свёртка: (112, 112) → (224, 224)
conv_up = nn.ConvTranspose2d(
    128, 64,
    kernel_size=3,
    stride=2,
    padding=1,
    output_padding=1
)

x = torch.randn(1, 64, 224, 224)
x_down = conv_down(x)  # (1, 128, 112, 112)
x_up = conv_up(x_down)  # (1, 64, 224, 224)

print(f"Input: {x.shape}")
print(f"After standard conv: {x_down.shape}")
print(f"After transposed conv: {x_up.shape}")

Плюсы:

• Увеличивает разрешение (для segmentation, GAN)
• Параметризуемая (можно обучать)
• Хорошо работает на практике

Минусы:

• Может создавать артефакты (checkerboard)
• Потери информации необратимы
• Медленнее интерполяции

Альтернатива: Upsampling + обычная свёртка лучше!

6. 1×1 Convolution (Pointwise)

Описание: Минимальная свёртка, преобразует только каналы без пространственного взаимодействия.

# 1×1 свёртка
conv_1x1 = nn.Conv2d(64, 128, kernel_size=1)

x = torch.randn(1, 64, 224, 224)
output = conv_1x1(x)  # (1, 128, 224, 224)

# Параметры: 64 × 128 + 128 = 8320
print(f"Параметров: {sum(p.numel() for p in conv_1x1.parameters())}")

# Эквивалентно слою Dense на каждой пространственной позиции
# Используется в Bottleneck слоях ResNet

Плюсы:

• Очень быстро
• Совсем мало параметров
• Объединяет информацию между каналами

Минусы:

• Нет пространственного взаимодействия
• Должен комбинироваться с другими сверткам

7. Spatial Separable Convolution

Описание: Разбивает свёртку на горизонтальную (1×k) и вертикальную (k×1) операции.

class SpatialSeparableConv(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3):
        super().__init__()
        padding = kernel_size // 2
        
        # Горизонтальная
        self.horizontal = nn.Conv2d(
            in_channels, out_channels,
            kernel_size=(1, kernel_size),
            padding=(0, padding)
        )
        # Вертикальная
        self.vertical = nn.Conv2d(
            in_channels, out_channels,
            kernel_size=(kernel_size, 1),
            padding=(padding, 0)
        )
    
    def forward(self, x):
        x_h = self.horizontal(x)
        x_v = self.vertical(x)
        return x_h + x_v  # Или конкатенация

# Параметры: k × out × in × 2 (вместо k² × out × in)

Плюсы:

• Экономия параметров: O(k × in × out × 2)
• Быстро для больших kernel size

Минусы:

• Может упустить диагональные паттерны
• Менее универсален

Сравнительная таблица

Рекомендации по использованию

Для классификации:

• Standard conv в больших сетях
• Depthwise separable в MobileNet-like
• Dilated для расширения receptive field

Для segmentation:

• Dilated convolution (сохраняет разрешение)
• 1×1 conv для объединения признаков
• Transposed conv для upsampling

Для GAN:

• Transposed conv (или Upsampling + Conv)
• Depthwise separable для экономии

Для edge devices (мобильные):

• Depthwise separable convolution
• Grouped convolution
• Минимум параметров

Вывод: Выбирайте свёртку на основе задачи, памяти и скорости. Standard convolution — это основа, остальные оптимизируют под специфические условия!