Работал ли MLP моделями

MLP (Multi-Layer Perceptron) модели в моей практике

Да, я работал с MLP моделями в различных проектах, от простых классификаторов до глубоких нейросетей. Расскажу о моем опыте и применениях.

1. Что такое MLP?

MLP (многослойный перцептрон) — это базовая архитектура нейросети, состоящая из:

import numpy as np
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation
from tensorflow.keras.optimizers import Adam

# Простая архитектура MLP:
# Input Layer (784 нейронов для MNIST)
#     ↓
# Hidden Layer 1 (128 нейронов)
#     ↓
# Hidden Layer 2 (64 нейрона)
#     ↓
# Output Layer (10 нейронов для 10 классов)

model = Sequential([
    Dense(128, input_dim=784, activation='relu'),
    Dropout(0.2),
    Dense(64, activation='relu'),
    Dropout(0.2),
    Dense(10, activation='softmax')
])

model.compile(
    optimizer=Adam(learning_rate=0.001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# Архитектура:
# - Input: 784
# - Dense(128): 784 * 128 + 128 = 100,480 параметров
# - Dense(64): 128 * 64 + 64 = 8,256 параметров
# - Dense(10): 64 * 10 + 10 = 650 параметров
# Всего: ~109,000 параметров

2. Проект: классификация цифр MNIST

Мой первый серьезный проект с MLP — классификация рукописных цифр:

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# Загрузить данные
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Нормализация (пиксели от 0-255 к 0-1)
X_train = X_train.reshape(-1, 28*28).astype('float32') / 255
X_test = X_test.reshape(-1, 28*28).astype('float32') / 255

# One-hot encoding для labels
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# Обучение
history = model.fit(
    X_train, y_train,
    batch_size=128,
    epochs=20,
    validation_split=0.1,
    verbose=1
)

# Оценка
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print(f'Test Accuracy: {test_accuracy:.4f}')  # ~0.98 (98%)

# Предсказание на новых данных
predictions = model.predict(X_test[:10])
predicted_digits = np.argmax(predictions, axis=1)
print(predicted_digits)  # [7, 2, 1, 0, 4, 1, 4, 9, 5, 9]

3. Проект: регрессия (предсказание цен)

MLP подходит не только для классификации, но и для регрессии:

# Задача: предсказать цену дома по параметрам
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Загрузить данные
data = fetch_california_housing()
X, y = data.data, data.target

# Нормализация (очень важна для нейросетей!)
scaler = StandardScaler()
X = scaler.fit_transform(X)

# Разделение на train/test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# MLP для регрессии
regression_model = Sequential([
    Dense(64, input_dim=X_train.shape[1], activation='relu'),
    Dropout(0.2),
    Dense(32, activation='relu'),
    Dropout(0.2),
    Dense(1)  # Output: одно значение (цена)
])

regression_model.compile(
    optimizer=Adam(learning_rate=0.001),
    loss='mse',  # Mean Squared Error для регрессии
    metrics=['mae']  # Mean Absolute Error
)

# Обучение
history = regression_model.fit(
    X_train, y_train,
    batch_size=32,
    epochs=100,
    validation_split=0.1,
    verbose=0
)

# Предсказание
predictions = regression_model.predict(X_test[:5])
print(predictions)  # Предсказанные цены домов

# Оценка
mse = regression_model.evaluate(X_test, y_test)
print(f'MSE: {mse:.4f}')

4. Проект: текстовая классификация

MLP используется для анализа тональности и других NLP задач:

from sklearn.feature_extraction.text import TfidfVectorizer

# Данные: отзывы о продуктах
reviews = [
    'Great product, highly recommended!',
    'Poor quality, wasted money',
    'Amazing! Love it!',
    'Terrible, broke after one day',
    # ... ещё 1000 отзывов ...
]
labels = [1, 0, 1, 0]  # 1=positive, 0=negative

# Преобразование текста в числа (TF-IDF)
vectorizer = TfidfVectorizer(max_features=1000)
X = vectorizer.fit_transform(reviews).toarray()

# MLP для классификации
text_model = Sequential([
    Dense(256, input_dim=X.shape[1], activation='relu'),
    Dropout(0.3),
    Dense(128, activation='relu'),
    Dropout(0.3),
    Dense(64, activation='relu'),
    Dense(1, activation='sigmoid')  # Binary classification
])

text_model.compile(
    optimizer=Adam(learning_rate=0.001),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# Обучение
text_model.fit(X, labels, batch_size=32, epochs=10, validation_split=0.2)

# Предсказание тональности
new_review = 'This product is excellent!'
new_review_vec = vectorizer.transform([new_review]).toarray()
sentiment = text_model.predict(new_review_vec)
print(f'Positive probability: {sentiment[0][0]:.2%}')  # ~95%

5. Гиперпараметры, которые я использовал

# Размер hidden layers
# Правило: 10-100x размер input
def choose_hidden_size(input_size):
    return max(input_size * 10, 64)

# Learning rate (очень важен!)
learning_rates = [0.001, 0.0001, 0.01]  # Adam обычно: 0.001

# Dropout (защита от overfitting)
dropout_rates = [0.2, 0.3, 0.5]

# Batch size
batch_sizes = [32, 64, 128]

# Optimizer
# - Adam: лучший выбор по умолчанию
# - SGD: старый, но иногда работает лучше
# - RMSprop: когда Adam переобучается

# Activation functions
# - relu: для hidden layers (стандартный)
# - sigmoid: для binary classification output
# - softmax: для multi-class classification
# - tanh: иногда помогает при проблемах с gradients

# Loss function
# - categorical_crossentropy: multi-class classification
# - binary_crossentropy: binary classification
# - mse: регрессия

6. Валидация и оценка

from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
import matplotlib.pyplot as plt

# Валидация во время обучения
history = model.fit(X_train, y_train, validation_split=0.2, epochs=20)

# График loss
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.legend()
plt.show()

# После обучения
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)

# Метрики
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred_classes))

# Confusion matrix
cm = confusion_matrix(y_test, y_pred_classes)
print(cm)

7. Проблемы, которые я встречал, и решения

Проблема: Overfitting (переобучение)

# Симптомы: training loss падает, validation loss растёт

# Решения:
# 1. Добавить Dropout
model = Sequential([
    Dense(128, activation='relu'),
    Dropout(0.3),  # 30% нейронов отключаются
    Dense(64, activation='relu'),
    Dropout(0.3),
])

# 2. Добавить L1/L2 regularization
from tensorflow.keras.regularizers import l2
model = Sequential([
    Dense(128, activation='relu', kernel_regularizer=l2(0.001)),
    Dense(64, activation='relu', kernel_regularizer=l2(0.001)),
])

# 3. Early stopping
from tensorflow.keras.callbacks import EarlyStopping
early_stop = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
model.fit(X_train, y_train, callbacks=[early_stop], validation_split=0.2)

Проблема: Vanishing Gradient

# Симптомы: нейросеть перестаёт учиться после первых эпох

# Решения:
# 1. Использовать ReLU вместо sigmoid/tanh
# 2. Нормализовать данные (BatchNormalization)
from tensorflow.keras.layers import BatchNormalization

model = Sequential([
    Dense(128, activation='relu'),
    BatchNormalization(),
    Dense(64, activation='relu'),
    BatchNormalization(),
])

8. Когда использовать MLP vs другие архитектуры?

# MLP хороша для:
# ✅ Табличных данных (CSV, SQL)
# ✅ Простых классификаций
# ✅ Регрессии
# ✅ Когда данных мало (<10k примеров)
# ✅ Когда скорость inference важна

# CNN лучше для:
# ✅ Изображений (есть пространственная структура)
# ✅ Когда нужна translation invariance

# RNN/Transformer лучше для:
# ✅ Последовательностей (текст, звук, временной ряд)
# ✅ Когда контекст важен

9. Советы из опыта

# 1. Всегда нормализуй данные
X_train = (X_train - X_train.mean()) / X_train.std()

# 2. Начни с простой архитектуры
# Лучше недоучить, чем переучить

# 3. Используй validation set во время обучения
# Это предотвращает переобучение

# 4. Сохраняй лучшую модель
from tensorflow.keras.callbacks import ModelCheckpoint
checkpoint = ModelCheckpoint('best_model.h5', monitor='val_loss', save_best_only=True)
model.fit(X_train, y_train, callbacks=[checkpoint])

# 5. Не забывай про baseline
# Сравни с простой моделью (логистическая регрессия, decision tree)
from sklearn.linear_model import LogisticRegression
baseline = LogisticRegression()
baseline.fit(X_train, y_train)
print(f'Baseline accuracy: {baseline.score(X_test, y_test)}')

# 6. Документируй эксперименты
# Какие гиперпараметры использовал? Какой accuracy? Почему именно эта архитектура?

Вывод

Я активно работал с MLP моделями:

• ✅ Классификация (MNIST, текстовая тональность)
• ✅ Регрессия (предсказание цен)
• ✅ Гиперпараметр-тюнинг
• ✅ Борьба с переобучением
• ✅ Валидация и оценка моделей

MLP — это базовый блок глубокого обучения:

• Просто понять и реализовать
• Хорошо подходит для табличных данных
• Основа для более сложных архитектур (CNN, RNN)

Я комфортен как с теорией (backpropagation, градиенты), так и с практикой (TensorFlow, PyTorch, scikit-learn).