Какие знаешь архитектуры энкодера?

Архитектуры энкодеров в Deep Learning

Энкодеры - это ключевой компонент современных нейронных сетей для извлечения признаков из данных. Рассмотрю основные архитектуры и их применение.

1. CNN (Convolutional Neural Networks)

Классический энкодер для изображений на основе свёрток:

import torch
import torch.nn as nn

class CNNEncoder(nn.Module):
    def __init__(self, output_dim=256):
        super(CNNEncoder, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc = nn.Linear(128 * 28 * 28, output_dim)
    
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = self.pool(torch.relu(self.conv3(x)))
        x = x.view(x.size(0), -1)
        return self.fc(x)

Преимущества: Локальная связанность, параметрическая эффективность Применение: Классификация и детекция на изображениях

2. RNN/LSTM (Recurrent Neural Networks)

Для последовательностей данных (текст, временные ряды):

class LSTMEncoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers=2):
        super(LSTMEncoder, self).__init__()
        self.embedding = nn.Embedding(input_dim, 128)
        self.lstm = nn.LSTM(128, hidden_dim, num_layers, batch_first=True)
    
    def forward(self, x):
        embedded = self.embedding(x)
        output, (hidden, cell) = self.lstm(embedded)
        return output, hidden, cell

Преимущества: Обработка последовательностей, сохранение контекста Применение: NLP, временные ряды, машинный перевод

3. Transformer (Self-Attention)

Современная архитектура на основе внимания, доминирующая в NLP:

class TransformerEncoder(nn.Module):
    def __init__(self, vocab_size, d_model=512, num_heads=8, num_layers=6):
        super(TransformerEncoder, self).__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=d_model, nhead=num_heads, dim_feedforward=2048, batch_first=True
        )
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
    
    def forward(self, x):
        embedded = self.embedding(x)
        output = self.transformer_encoder(embedded)
        return output

Преимущества: Параллелизм, глобальная контекст, масштабируемость Применение: BERT, GPT, классификация текстов

4. Vision Transformer (ViT)

Применение трансформеров к изображениям:

from torchvision.models import vit_b_16

encoder = vit_b_16(pretrained=True)
features = encoder(images)  # (batch, 768)

Преимущества: Глобальная контекст для всего изображения Применение: Классификация и обнаружение на изображениях

5. Graph Neural Networks (GNN)

Для структурированных данных в виде графов:

from torch_geometric.nn import GCNConv

class GNNEncoder(torch.nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(GNNEncoder, self).__init__()
        self.conv1 = GCNConv(input_dim, hidden_dim)
        self.conv2 = GCNConv(hidden_dim, output_dim)
    
    def forward(self, x, edge_index):
        x = torch.relu(self.conv1(x, edge_index))
        x = self.conv2(x, edge_index)
        return x

Преимущества: Работа с графовыми структурами, сохранение связности Применение: Рекомендации, молекулярный анализ

6. Autoencoder

Для неконтролируемого обучения и уменьшения размерности:

class Autoencoder(nn.Module):
    def __init__(self, input_dim, bottleneck_dim):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, bottleneck_dim)
        )
        self.decoder = nn.Sequential(
            nn.Linear(bottleneck_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, input_dim)
        )
    
    def forward(self, x):
        latent = self.encoder(x)
        reconstructed = self.decoder(latent)
        return reconstructed, latent

Преимущества: Неконтролируемое обучение, сжатие данных Применение: Уменьшение размерности, детекция аномалий

7. ResNet и его варианты

Остаточные сети с skip connections:

from torchvision.models import resnet50

encoder = resnet50(pretrained=True)
encoder = torch.nn.Sequential(*list(encoder.children())[:-1])

Преимущества: Глубокие сети без затухания градиента Применение: Transfer learning для изображений

Сравнение архитектур

Выбор архитектуры

Выбор энкодера зависит от:

• Типа данных: изображения (CNN/ViT), текст (RNN/Transformer), графы (GNN)
• Объема данных: Transformer требует больше данных, CNN эффективнее на малых
• Вычислительных ресурсов: RNN медленнее, Transformer можно параллелизировать
• Интерпретируемости: CNN более интерпретируемы, Transformer менее

Модерные подходы часто используют pretrained энкодеры (BERT, ResNet-50) и fine-tune их под конкретную задачу.