Что такое операция свертки? Какие у неё свойства?

Операция свертки (Convolution Operation)

Свертка — это математическая операция, которая применяет фильтр (kernel) к входным данным для извлечения локальных признаков. Основа CNN (Convolutional Neural Networks).

Математическое определение

(f * g)(x) = ∫ f(t) × g(x - t) dt    (интегральная свертка)

Для дискретных данных (изображения):
Output(i,j) = Σ Σ Input(i+m, j+n) × Kernel(m, n)

Пример: 2D свертка

Входное изображение (5×5):        Kernel (3×3):
[1 2 3 4 5]                         [1 0 -1]
[2 3 4 5 6]                         [2 0 -2]
[3 4 5 6 7]                         [1 0 -1]
[4 5 6 7 8]                         (Sobel edge detector)
[5 6 7 8 9]

Процесс:
1. Поместить kernel в позицию (0,0)
2. Перемножить элементы и просуммировать
3. Результат → output пиксель
4. Сдвинуть kernel на шаг (stride) и повторить

Реализация в PyTorch

import torch
import torch.nn.functional as F

# Входные данные: (batch_size, channels, height, width)
X = torch.randn(1, 3, 224, 224)  # одно RGB изображение

# Kernel (filter): (out_channels, in_channels, kernel_h, kernel_w)
kernel = torch.randn(32, 3, 3, 3)  # 32 фильтра 3×3

# Свертка
output = F.conv2d(X, kernel, stride=1, padding=1)
print(output.shape)  # (1, 32, 224, 224)

# Или через слой
conv_layer = torch.nn.Conv2d(
    in_channels=3,
    out_channels=32,
    kernel_size=3,
    stride=1,
    padding=1
)
output = conv_layer(X)

Свойства свертки

1. Локальность (Locality)

Каждый выходной пиксель зависит только от локальной области входа

Преимущество:
- Экономит память (не нужно обрабатывать весь экран одновременно)
- Находит локальные признаки (edges, textures)

2. Перестановочность (Commutativity)

f * g = g * f  (в математике)

Но в глубоком обучении:
- Kernel(фильтр) НЕ коммутативен с Input
- Conv2d(image, kernel) ≠ Conv2d(kernel, image)

3. Трансляционная инвариантность (Translation Invariance)

Если подвинуть объект на одно место на изображении,
свертка найдет его в любой позиции

Примерно: у кота в левом углу и правом углу одинаковые признаки

4. Параметризация (Parameter Sharing)

Один kernel используется для всего изображения
- Уменьшает количество параметров
- Ускоряет обучение

Сравнение:
Полносвязный слой (FC): 224×224×3 входа × 32 выхода = 4.8M параметров
Swertka: 3×3×3 kernel × 32 = 864 параметров (5000x меньше!)

Гиперпараметры свертки

conv = nn.Conv2d(
    in_channels=3,
    out_channels=32,
    kernel_size=3,      # размер фильтра (3×3)
    stride=1,           # шаг смещения (на сколько пиксель сдвигаем)
    padding=1,          # добавляем нули по краям
    dilation=1,         # расстояние между элементами kernel
    groups=1            # групповая свертка (1 = обычная)
)

# Формула выходного размера:
output_size = (input_size - kernel_size + 2×padding) / stride + 1

# Пример:
input_size = 224
kernel_size = 3
padding = 1
stride = 1

output_size = (224 - 3 + 2×1) / 1 + 1 = 224  (same size!)

Примеры ядер (Kernels)

import numpy as np

# Edge detection (Sobel X)
sobel_x = np.array([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1]
])

# Blur (Gaussian)
blur = np.array([
    [1, 2, 1],
    [2, 4, 2],
    [1, 2, 1]
]) / 16

# Sharpen
sharpen = np.array([
    [0, -1, 0],
    [-1, 5, -1],
    [0, -1, 0]
])

# В CNN: kernel учится автоматически!

Типы сверток

1. Standard Convolution

conv = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3)

2. Dilated Convolution (расширенная)

conv_dilated = nn.Conv2d(
    in_channels=64,
    out_channels=128,
    kernel_size=3,
    dilation=2  # пропускаем каждый второй пиксель
)
# Receptive field больше, параметров меньше

3. Depthwise Separable Convolution

# Разделяем на две операции: глубинная + точечная
# в 9x раз меньше параметров

4. Transposed Convolution (Upsampling)

deconv = nn.ConvTranspose2d(
    in_channels=128,
    out_channels=64,
    kernel_size=3
)  # увеличивает размер (для segmentation, style transfer)

Применение в архитектурах

from torchvision import models

# ResNet
resnet = models.resnet50()  # много Conv2d слоев

# VGG
vgg = models.vgg16()  # 13 conv слоев + pooling

# MobileNet (эффективная архитектура)
mobilenet = models.mobilenet_v2()  # depthwise separable convolutions

Рецептивное поле (Receptive Field)

Какую область входа "видит" один выходной пиксель?

Один Conv2d слой: RF = kernel_size
Два Conv2d слоя: RF растёт
Много слоёв: RF охватывает всё изображение

Пример:
- Conv(k=3) + Conv(k=3) → RF = 5×5
- Conv(k=3) + Conv(k=3) + Conv(k=3) → RF = 7×7

Преимущества свертки для изображений

✓ Локальность: находит локальные признаки
✓ Общий параметры: меньше параметров, быстрее обучение
✓ Трансляционная инвариантность: находит объекты везде
✓ Иерархия: ранние слои = простые признаки
           последние слои = сложные объекты

Резюме

Свертка (Convolution):

• Применяет фильтр к входным данным
• Основа CNN
• Параметры: kernel_size, stride, padding, dilation
• Свойства: локальность, параметризация, трансляционная инвариантность
• Типы: standard, dilated, depthwise separable, transposed
• Создает иерархию признаков (edges → shapes → objects)