Из чего состоят модели deep learning

Архитектура моделей Deep Learning

Модели глубокого обучения состоят из слоёв, которые обрабатывают входные данные и преобразуют их в предсказания. Это основные компоненты.

Основные типы слоёв (Layers)

1. Input Layer (Входной слой)

Принимает исходные данные:

import tensorflow as tf
from tensorflow import keras

# Определяю shape входа (batch_size, height, width, channels)
input_layer = keras.Input(shape=(224, 224, 3))  # RGB image

# Или в Sequential API
model = keras.Sequential([
    keras.layers.Input(shape=(224, 224, 3)),  # Input layer
    # ... остальные слои
])

2. Dense Layer (Полносвязный слой)

Каждый нейрон подключен к каждому нейрону предыдущего слоя:

# Dense layer с 128 нейронами и ReLU активацией
keras.layers.Dense(
    units=128,
    activation='relu',
    kernel_regularizer=keras.regularizers.l2(0.01)
)

# Это выполняет: output = activation(dot(input, weights) + bias)
# Почти все параметры модели в Dense слоях

3. Convolutional Layer (Свёрточный слой)

Для обработки изображений, сохраняет пространственные структуры:

# Conv layer с 32 фильтрами размера 3x3
keras.layers.Conv2D(
    filters=32,
    kernel_size=(3, 3),
    activation='relu',
    padding='same'  # Сохранять размер
)

# Conv layer обучает фильтры (kernels) которые детектируют паттерны
# Фильтр может детектировать: края, текстуры, shapes и т.д.

4. Recurrent Layer (Рекуррентный слой)

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

# LSTM cell (более продвинутый RNN)
keras.layers.LSTM(
    units=64,
    return_sequences=True  # Вернуть всю последовательность
)

# GRU (более простой, чем LSTM)
keras.layers.GRU(units=64)

# RNN запоминает предыдущие inputs (имеет "память")

5. Embedding Layer

Преобразует целые числа (ID слов) в плотные векторы:

# Для NLP
keras.layers.Embedding(
    input_dim=10000,  # Размер словаря
    output_dim=128,   # Размер embedding'а
)

# Превращает [1, 2, 3] (word IDs) в матрицу 128-мерных векторов

6. Dropout Layer

Предотвращает overfitting случайно отключая нейроны:

keras.layers.Dropout(rate=0.5)  # 50% нейронов отключены

# Во время training: случайно отключаешь 50% нейронов
# Во время inference: используешь всю сеть
# Это как ensemble of models

7. Batch Normalization

Нормализует inputs слоя для более быстрого обучения:

keras.layers.BatchNormalization()

# Нормализует каждый батч данных
# Помогает избежать internal covariate shift

8. Pooling Layer

Уменьшает пространственные размеры:

# Max pooling (берёт максимальное значение в окне)
keras.layers.MaxPooling2D(pool_size=(2, 2))

# Average pooling
keras.layers.AveragePooling2D(pool_size=(2, 2))

# Уменьшает размер и количество параметров

Примеры архитектур

1. Простая полносвязная сеть (для табулярных данных)

model = keras.Sequential([
    keras.layers.Input(shape=(10,)),        # 10 признаков
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(16, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')  # Бинарная классификация
])

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

2. CNN (Convolutional Neural Network) для изображений

model = keras.Sequential([
    keras.layers.Input(shape=(224, 224, 3)),
    
    # Block 1
    keras.layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
    keras.layers.BatchNormalization(),
    keras.layers.MaxPooling2D((2, 2)),
    keras.layers.Dropout(0.25),
    
    # Block 2
    keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    keras.layers.BatchNormalization(),
    keras.layers.MaxPooling2D((2, 2)),
    keras.layers.Dropout(0.25),
    
    # Flatten и Dense слои
    keras.layers.Flatten(),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dropout(0.5),
    keras.layers.Dense(10, activation='softmax')  # 10 классов
])

3. RNN (LSTM) для текста

model = keras.Sequential([
    keras.layers.Input(shape=(100,)),  # 100 tokens
    keras.layers.Embedding(input_dim=10000, output_dim=128),
    keras.layers.LSTM(64, return_sequences=True),
    keras.layers.Dropout(0.2),
    keras.layers.LSTM(32),
    keras.layers.Dense(16, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')  # Бинарная классификация
])

4. Transformer (для NLP)

# Simplified Transformer
model = keras.Sequential([
    keras.layers.Input(shape=(100,)),
    keras.layers.Embedding(10000, 256),
    
    # Multi-head attention (обычно 8 heads)
    keras.layers.MultiHeadAttention(
        num_heads=8,
        key_dim=32,
        value_dim=32
    ),
    keras.layers.LayerNormalization(),
    keras.layers.Dropout(0.1),
    
    # Feed-forward network
    keras.layers.Dense(512, activation='relu'),
    keras.layers.Dense(256),
    keras.layers.Dropout(0.1),
    
    # Итоговая классификация
    keras.layers.GlobalAveragePooling1D(),
    keras.layers.Dense(1, activation='sigmoid')
])

Компоненты обучения

1. Loss Function (Функция потерь)

Определяет, как далеко модель от правильного ответа:

# Бинарная классификация
loss = 'binary_crossentropy'
# y_true = 1, y_pred = 0.9 → loss = 0.105

# Многоклассовая классификация
loss = 'categorical_crossentropy'

# Регрессия
loss = 'mse'  # Mean Squared Error

# Пользовательская loss
def custom_loss(y_true, y_pred):
    return keras.backend.mean((y_true - y_pred) ** 2)

2. Optimizer (Оптимизатор)

Утало (algorithm) как обновлять weights:

# SGD (Stochastic Gradient Descent)
optimizer = keras.optimizers.SGD(learning_rate=0.01)

# Adam (самый популярный)
optimizer = keras.optimizers.Adam(
    learning_rate=0.001,
    beta_1=0.9,
    beta_2=0.999
)

# RMSprop
optimizer = keras.optimizers.RMSprop(learning_rate=0.001)

3. Metrics (Метрики оценки)

Вычисляются для мониторинга обучения:

metrics = [
    'accuracy',  # Для классификации
    keras.metrics.Precision(),
    keras.metrics.Recall(),
    keras.metrics.AUC(),
    keras.metrics.MeanSquaredError(),  # Для регрессии
]

Полный пример: обучение модели

import tensorflow as tf
from tensorflow import keras
import numpy as np

# Генерируем данные
X_train = np.random.random((1000, 10))
y_train = (X_train[:, 0] + X_train[:, 1] > 1).astype(int)  # Binary classification

# Создаём модель
model = keras.Sequential([
    keras.layers.Input(shape=(10,)),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.BatchNormalization(),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')
])

# Компилируем
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
    loss='binary_crossentropy',
    metrics=['accuracy', keras.metrics.AUC()]
)

# Обучаем
history = model.fit(
    X_train, y_train,
    batch_size=32,
    epochs=10,
    validation_split=0.2,
    verbose=1
)

# Предсказываем
predictions = model.predict(X_test)

Резюме: Из чего состоит модель DL

Input Layer → входные данные ↓ Hidden Layers → преобразования

• Dense (полносвязные)
• Conv2D (для изображений)
• LSTM/GRU (для последовательностей)
• Embedding (для текста)
• Dropout (регуляризация)
• BatchNorm (нормализация)
• Pooling (уменьшение размера) ↓ Output Layer → финальные предсказания ↓ Loss Function → ошибка модели ↓ Optimizer → обновление weights ↓ Metrics → оценка качества

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