Что такое сверточная нейронная сеть?

Question

claude-haiku-4.5 · Accepted Answer

## Сверточная нейронная сеть (Convolutional Neural Network, CNN)

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

### Основной принцип

CNN использует три ключевых компонента:

**1. Свёртка (Convolution):**
Применяет фильтр (ядро) размером K×K к входному изображению, скользя его по всему изображению и вычисляя поточечное произведение.

```
Output(i,j) = Σ(Filter[a,b] * Input[i+a, j+b]) + bias
```

**2. Pooling (Субдискретизация):**
Уменьшает пространственные размеры, сохраняя важную информацию.

**3. Нелинейность (ReLU):**
Добавляет способность сети обучаться нелинейным функциям.

### Архитектура

```python
import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        
        # Сверточные слои: извлечение признаков
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        # 3 входных канала (RGB)
        # 32 фильтра
        # размер фильтра 3x3
        
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        
        # Pooling слои
        self.pool = nn.MaxPool2d(2, 2)
        
        # Полносвязные слои: классификация
        self.fc1 = nn.Linear(128 * 4 * 4, 256)  # Размер зависит от входа
        self.fc2 = nn.Linear(256, 10)  # 10 классов (например, CIFAR-10)
        
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)
        
    def forward(self, x):
        # Блок 1: Conv -> ReLU -> Pool
        x = self.relu(self.conv1(x))
        x = self.pool(x)  # 32x32 -> 16x16
        
        # Блок 2: Conv -> ReLU -> Pool
        x = self.relu(self.conv2(x))
        x = self.pool(x)  # 16x16 -> 8x8
        
        # Блок 3: Conv -> ReLU -> Pool
        x = self.relu(self.conv3(x))
        x = self.pool(x)  # 8x8 -> 4x4
        
        # Flatten: преобразование в одномерный вектор
        x = x.view(x.size(0), -1)  # (batch_size, 128*4*4)
        
        # Классификация
        x = self.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        
        return x

# Инициализация и тренировка
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
```

### Преимущества CNN

**1. Локальная связь (Local Connectivity):**
```python
# Каждый нейрон связан только с небольшой областью входа
# Соседние пиксели часто коррелируют
conv_layer = nn.Conv2d(3, 64, kernel_size=3, padding=1)
# Фильтр размером 3x3 обрабатывает соседства пикселей
```

**2. Разделение весов (Weight Sharing):**
```python
# Одни и те же веса применяются ко всему изображению
# Это позволяет:
# - Уменьшить количество параметров
# - Детектировать признаки независимо от их позиции (инвариантность)

# Например, фильтр обнаружения краёв работает везде
# Это очень эффективно для изображений
```

**3. Инвариантность к трансляции (Translation Invariance):**
```python
# Если объект сдвинуть на несколько пикселей
# CNN всё равно его распознает благодаря разделению весов
```

**4. Иерархическое извлечение признаков:**
```
Уровень 1: Простые признаки (линии, углы)
      ↓
Уровень 2: Геометрические формы (окружности, треугольники)
      ↓
Уровень 3: Части объектов (лапы, уши, морда)
      ↓
Уровень 4: Высокоуровневые понятия (собака, кот)
```

### Размеры после каждого слоя

```python
# Input: (1, 3, 32, 32) - batch_size=1, channels=3, height=32, width=32

# Conv2d(3, 32, kernel_size=3, padding=1)
# Output: (1, 32, 32, 32) - высота и ширина сохраняются из-за padding=1

# MaxPool2d(2, 2)
# Output: (1, 32, 16, 16) - высота и ширина уменьшаются в 2 раза

# Conv2d(32, 64, kernel_size=3, padding=1)
# Output: (1, 64, 16, 16)

# MaxPool2d(2, 2)
# Output: (1, 64, 8, 8)

# Flatten
# Output: (1, 64*8*8) = (1, 4096)

# Linear(4096, 256)
# Output: (1, 256)
```

### Популярные архитектуры CNN

**1. LeNet (1998):**
```python
# Первая успешная CNN, использовалась для распознавания цифр
# Простая: 2 сверточных слоя + полносвязные слои
```

**2. AlexNet (2012):**
```python
# Революция в компьютерном зрении
# Глубже, больше параметров, использует GPU
# Выиграла ImageNet competition
```

**3. VGG (2014):**
```python
# Систематическое увеличение глубины
# 16-19 слоёв
# Показала, что глубина важна
```

**4. ResNet (2015):**
```python
from torchvision import models

# Skip connections решают проблему затухания градиентов
# Позволяет обучать очень глубокие сети (152+ слоёв)
resnet = models.resnet50(pretrained=True)

# Используется для transfer learning
# В среднем точнее и быстрее, чем VGG
```

**5. MobileNet:**
```python
# Оптимизирована для мобильных устройств
# Меньше параметров, быстрее инференция
# Хороший баланс между точностью и скоростью
```

### Transfer Learning с CNN

```python
import torch
from torchvision import models, transforms
from torch import nn

# Загружаем предобученную ResNet50 на ImageNet
model = models.resnet50(pretrained=True)

# Заморозим все слои кроме последнего
for param in model.parameters():
    param.requires_grad = False

# Заменим последний слой для нашей задачи (10 классов вместо 1000)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)

# Обучаем только новый слой
optimizer = torch.optim.Adam(model.fc.parameters(), lr=0.001)

# Или fine-tune последние несколько слоёв
for param in model.layer4.parameters():
    param.requires_grad = True
```

### CNN для разных типов данных

```python
# 1D CNN для времянных рядов, текста
conv1d = nn.Conv1d(in_channels=100, out_channels=32, kernel_size=3)

# 2D CNN для изображений (наиболее распространена)
conv2d = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3)

# 3D CNN для видео, медицинских объёмов
conv3d = nn.Conv3d(in_channels=3, out_channels=32, kernel_size=3)
```

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

Что такое сверточная нейронная сеть?

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

Сверточная нейронная сеть (Convolutional Neural Network, CNN)

Основной принцип

Архитектура

Преимущества CNN

Размеры после каждого слоя

Популярные архитектуры CNN

Transfer Learning с CNN

CNN для разных типов данных