Что такое сверточный слой?

Question

claude-haiku-4.5 · Accepted Answer

## Сверточный слой (Convolutional Layer)

**Сверточный слой** — это основной строительный блок свёрточных нейронных сетей (CNN), который применяет операцию **свёртки** к входным данным. Эта операция позволяет сети обнаруживать локальные паттерны и признаки (edges, текстуры, формы) в данных, особенно в изображениях.

### Как работает свёртка

Операция свёртки работает следующим образом:

```
1. Берём небольшую матрицу (фильтр/kernel), например 3x3 пикселя
2. Скользим эту матрицу по входному изображению
3. На каждой позиции перемножаем элементы фильтра на элементы изображения
4. Суммируем результаты (это скалярное произведение)
5. Результат — один элемент в выходной карте признаков
```

### Пример вручную

```
Входное изображение (4x4):     Фильтр (3x3):
1 2 3 4                          1 0 -1
5 6 7 8                          2 0 -2
9 10 11 12                       1 0 -1
13 14 15 16

Шаг 1: применяем фильтр к левому верхнему углу:
(1*1 + 2*0 + 3*-1) + (5*2 + 6*0 + 7*-2) + (9*1 + 10*0 + 11*-1) = -12

Шаг 2: сдвигаем фильтр на 1 пиксель (stride=1) и повторяем

Результат (2x2):
-12  -8
 -8  -8
```

### Реализация на Python (с NumPy)

```python
import numpy as np
from scipy import signal

def convolution_2d(image, kernel):
    """Применяет свёртку к изображению."""
    output = signal.convolve2d(image, kernel, mode='valid')
    return output

# Входное изображение (5x5)
image = np.array([
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15],
    [16, 17, 18, 19, 20],
    [21, 22, 23, 24, 25]
])

# Фильтр edge detection Sobel (3x3)
kernel = np.array([
    [1, 0, -1],
    [2, 0, -2],
    [1, 0, -1]
])

output = convolution_2d(image, kernel)
print(output)
# Выходная карта будет 3x3 (так как mode='valid')
```

### Использование в TensorFlow/Keras

```python
import tensorflow as tf
from tensorflow import keras

# Конструирование CNN
model = keras.Sequential([
    # Conv2D(filters, kernel_size, activation, padding, strides)
    keras.layers.Conv2D(32, (3, 3), activation='relu', padding='same', 
                       input_shape=(28, 28, 1)),
    keras.layers.MaxPooling2D((2, 2)),
    
    keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    keras.layers.MaxPooling2D((2, 2)),
    
    keras.layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
    keras.layers.Flatten(),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

model.summary()
```

### Параметры сверточного слоя

#### 1. **Filters (количество фильтров)**

Каждый фильтр обучается обнаруживать разные признаки:

```python
keras.layers.Conv2D(32, ...)  # 32 фильтра
# Каждый фильтр имеет размер (kernel_size, kernel_size, input_channels)
# Для первого слоя с RGB: (3, 3, 3) = 27 параметров + 1 bias = 28 параметров на фильтр
```

#### 2. **Kernel size (размер фильтра)**

Обычно нечётные значения (3x3, 5x5, 7x7):

```python
# 3x3 — самый популярный (обнаруживает мелкие детали)
keras.layers.Conv2D(32, (3, 3))

# 5x5 — видит более широкий контекст
keras.layers.Conv2D(32, (5, 5))

# 1x1 — изменяет количество каналов, не меняя пространственный размер
keras.layers.Conv2D(32, (1, 1))
```

#### 3. **Stride (шаг сдвига)**

На сколько пикселей сдвигать фильтр:

```python
# stride=1 (дефолт): каждый пиксель
keras.layers.Conv2D(32, (3, 3), strides=1)

# stride=2: через пиксель (уменьшает размер вывода в 2 раза)
keras.layers.Conv2D(32, (3, 3), strides=2)
```

Расчёт размера вывода:
```
output_size = (input_size - kernel_size + 2*padding) / stride + 1
```

#### 4. **Padding (добавление границ нулей)**

```python
# 'valid': без padding (меньше выход)
keras.layers.Conv2D(32, (3, 3), padding='valid')
# Если вход 28x28, выход 26x26

# 'same': padding чтобы выход = вход
keras.layers.Conv2D(32, (3, 3), padding='same')
# Если вход 28x28, выход 28x28
```

#### 5. **Activation (функция активации)**

```python
# ReLU: самая популярная
keras.layers.Conv2D(32, (3, 3), activation='relu')

# Эквивалент с отдельным слоем:
keras.layers.Conv2D(32, (3, 3))
keras.layers.Activation('relu')
```

### Что обучается в сверточном слое?

Слой обучает **веса фильтров** и **bias** (смещение):

```
Входные параметры для Conv2D(32, (3,3), input_channels=3):
- Веса: 32 * 3 * 3 * 3 = 864 параметра
- Bias: 32 параметра
- Всего: 896 параметров

Все эти параметры обновляются во время обучения (backpropagation)!
```

### Иерархия признаков в CNN

```
Входное изображение (пиксели)
        ↓
Первый Conv слой
→ Обнаруживает простые признаки (edges, texture)
        ↓
Второй Conv слой
→ Комбинирует простые признаки (углы, patterns)
        ↓
Третий Conv слой
→ Обнаруживает высокоуровневые признаки (части лица, объекты)
        ↓
Полносвязный слой
→ Принимает решение (классификация)
```

### Практический пример: классификация MNIST

```python
from tensorflow.keras import datasets, layers, models

# Загружаем данные
(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()

# Нормализуем
train_images = train_images.reshape((60000, 28, 28, 1)) / 255.0
test_images = test_images.reshape((10000, 28, 28, 1)) / 255.0

# CNN модель
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    
    layers.Conv2D(64, (3, 3), activation='relu'),
    
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
             loss='sparse_categorical_crossentropy',
             metrics=['accuracy'])

model.fit(train_images, train_labels, epochs=10, batch_size=128,
         validation_split=0.1)

test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'Точность: {test_acc:.4f}')  # ~99% для MNIST
```

### Типы свёрток

**1D свёртка** — для последовательностей (текст, временные ряды):
```python
keras.layers.Conv1D(32, kernel_size=5)
```

**2D свёртка** — для изображений:
```python
keras.layers.Conv2D(32, kernel_size=(3, 3))
```

**3D свёртка** — для видео (4D тензор: batch, depth, height, width):
```python
keras.layers.Conv3D(32, kernel_size=(3, 3, 3))
```

### Практические советы

- **Начни с 3x3 фильтров** — они самые универсальные
- **Удваивай количество фильтров** на каждом слое (32 → 64 → 128)
- **Используй padding='same'** чтобы не терять информацию
- **Чередуй Conv + ReLU + MaxPooling** — классический паттерн
- **Регуляризируй** (Dropout, L2) чтобы избежать переобучения

Сверточные слои — сердце компьютерного зрения и обработки данных с пространственной структурой.

Что такое сверточный слой?

Комментарии (1)

Сверточный слой (Convolutional Layer)

Как работает свёртка

Пример вручную

Реализация на Python (с NumPy)

Использование в TensorFlow/Keras

Параметры сверточного слоя

1. Filters (количество фильтров)

2. Kernel size (размер фильтра)

3. Stride (шаг сдвига)

4. Padding (добавление границ нулей)

5. Activation (функция активации)

Что обучается в сверточном слое?

Иерархия признаков в CNN

Практический пример: классификация MNIST

Типы свёрток

Практические советы