Что такое полносвязанная нейронная сеть?

Что такое полносвязанная нейронная сеть?

Полносвязанная нейронная сеть (Fully Connected Neural Network, Dense Neural Network, MLP — Multi-Layer Perceptron) — это архитектура искусственной нейронной сети, в которой каждый нейрон в одном слое связан со всеми нейронами в соседних слоях. Это самая простая и базовая архитектура глубокого обучения.

Структура полносвязанной сети

Входной слой (Input Layer)      Скрытые слои (Hidden Layers)    Выходной слой (Output Layer)
x₁ ━━━━━━━━━━━━━━━━━━━━━━━━━━┓
                               ├─→ h₁ ━━━━┓
x₂ ━━━━━━━━━━━━━━━━━━━━━━━━━━┤            ├─→ y₁
                               ├─→ h₂ ━━━━┤
x₃ ━━━━━━━━━━━━━━━━━━━━━━━━━━┛            ├─→ y₂
                               ┌─→ h₃ ━━━━┛
                               │
                               └─→ h₄

Каждый нейрон в слое l вычисляет:

z = Σ(w·x) + b
a = activation(z)

Математическая формула

Входной слой: a⁰ = X (размер: n₀ × m)
Скрытый слой 1: z¹ = W¹·a⁰ + b¹, a¹ = σ(z¹) (размер: n₁ × m)
Скрытый слой 2: z² = W²·a¹ + b², a² = σ(z²) (размер: n₂ × m)
Выходной слой: ŷ = W³·a² + b³ (размер: n_output × m)

где:
- W — матрица весов
- b — смещение (bias)
- σ — функция активации
- m — количество примеров

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

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Загрузить данные
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Стандартизировать
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Определить модель
class FullyConnectedNN(nn.Module):
    def __init__(self, input_size, hidden_sizes, output_size):
        super(FullyConnectedNN, self).__init__()
        layers = []
        prev_size = input_size
        
        # Скрытые слои
        for hidden_size in hidden_sizes:
            layers.append(nn.Linear(prev_size, hidden_size))
            layers.append(nn.ReLU())  # Функция активации
            layers.append(nn.Dropout(0.2))  # Регуляризация
            prev_size = hidden_size
        
        # Выходной слой
        layers.append(nn.Linear(prev_size, output_size))
        
        self.network = nn.Sequential(*layers)
    
    def forward(self, x):
        return self.network(x)

# Создать модель
model = FullyConnectedNN(
    input_size=4,
    hidden_sizes=[64, 32, 16],
    output_size=3
)

# Функция потерь и оптимизатор
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# Обучение
X_train_tensor = torch.FloatTensor(X_train)
y_train_tensor = torch.LongTensor(y_train)

train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

num_epochs = 100
for epoch in range(num_epochs):
    for X_batch, y_batch in train_loader:
        # Forward pass
        outputs = model(X_batch)
        loss = criterion(outputs, y_batch)
        
        # Backward pass
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    if (epoch + 1) % 20 == 0:
        print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item():.4f}')

# Оценка
X_test_tensor = torch.FloatTensor(X_test)
y_test_tensor = torch.LongTensor(y_test)

with torch.no_grad():
    predictions = model(X_test_tensor)
    accuracy = (predictions.argmax(1) == y_test_tensor).float().mean()
    print(f'Accuracy: {accuracy:.4f}')

Реализация на TensorFlow/Keras

import tensorflow as tf
from tensorflow.keras import layers, models

# Модель
model = models.Sequential([
    layers.Input(shape=(4,)),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(32, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(16, activation='relu'),
    layers.Dense(3, activation='softmax')  # Выходной слой
])

# Компилировать
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Обучить
model.fit(X_train, y_train, epochs=100, batch_size=32, validation_split=0.2)

# Предсказать
y_pred = model.predict(X_test)

Функции активации

# ReLU (Rectified Linear Unit) — самая популярная
# Вывод: max(0, x)

# Sigmoid — для вероятностей
# Вывод: 1 / (1 + e^(-x)) → [0, 1]

# Tanh — улучшенный Sigmoid
# Вывод: (e^x - e^(-x)) / (e^x + e^(-x)) → [-1, 1]

# Softmax — для многоклассовой классификации
# Вывод: вероятности каждого класса, сумма = 1

Плюсы и минусы

Плюсы:

• Просто реализовать и понять
• Универсальные (могут аппроксимировать любую функцию)
• Работают хорошо для табличных данных
• Быстрое обучение на малых данных

Минусы:

• Неэффективны для изображений (используй CNN вместо этого)
• Не учитывают последовательность (используй RNN/Transformers для текста)
• Много параметров → переобучение
• Медленно для больших входов (28×28 = 784 нейрона)

Когда использовать полносвязанные сети

• Табличные данные (структурированные признаки)
• Классификация и регрессия
• Рекомендательные системы
• Прогнозирование временных рядов (с правильной подготовкой данных)