Использование фреймворков для нейросетей в Data Science

Раздел: Data Science -> Scikit-learn

Для создания нейронных сетей на Python применяются два основных фреймворка: TensorFlow (с Keras) и PyTorch. Каждый из них предлагает различные способы построения архитектур. Рассмотрим основные подходы с примерами кода.

Создание нейронных сетей: TensorFlow и PyTorch

Как создать полносвязную сеть в TensorFlow?

Основное решение: Sequential API

Sequential API позволяет последовательно добавлять слои. Это самый простой способ для линейных архитектур.

import tensorflow as tf
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])

библиотеки для машинного обучения python (библиотеки для машинного обучения в python (scikit-learn, tensorflow, pytorch))

Данный код создает модель с одним скрытым слоем, dropout и выходным слоем. Проблема: если забыть указать input_shape, модель не будет знать размер входа. Решение: задать input_shape в первом слое или использовать model.build().

Вариант 1: Functional API

Functional API позволяет строить более сложные графы, например, с множественными входами и выходами. Подходит для нелинейных топологий.

inputs = tf.keras.Input(shape=(784,))
x = tf.keras.layers.Dense(128, activation='relu')(inputs)
x = tf.keras.layers.Dropout(0.2)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

Feature names python (имена признаков в python)

Частая ошибка:

неправильное соединение слоев (например, забыть передать тензор из предыдущего слоя). Решение: проверять, что каждый слой получает на вход тензор нужной формы.

Вариант 2: Subclassing (пользовательский класс)

Создание модели через наследование от tf.keras.Model дает полный контроль над проходом вперед. Используется для исследовательских задач.

class MyModel(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.dense1 = tf.keras.layers.Dense(128, activation='relu')
        self.dropout = tf.keras.layers.Dropout(0.2)
        self.dense2 = tf.keras.layers.Dense(10, activation='softmax')
    def call(self, inputs):
        x = self.dense1(inputs)
        x = self.dropout(x)
        return self.dense2(x)
model = MyModel()

искусственный интеллект на языке python (искусственный интеллект на python)

Ошибка:

забыть вызвать super().__init__(), что приводит к неправильной инициализации. Решение: всегда вызывать конструктор родительского класса.

Проблемы при работе с TensorFlow:

  • Несоответствие формы данных: часто возникает, когда размерность входа не совпадает с input_shape. Рекомендуется использовать model.summary() для проверки.
  • Выбор функции потерь: для многоклассовой классификации используется sparse_categorical_crossentropy при метках в виде индексов и categorical_crossentropy при one-hot.
  • Переобучение: помогает регуляризация (L1/L2) и Dropout.

Как создать полносвязную сеть в PyTorch?

Основное решение: nn.Sequential

PyTorch также предоставляет последовательный контейнер для линейных сетей.

import torch.nn as nn
model = nn.Sequential(
    nn.Linear(784, 128),
    nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(128, 10),
    nn.LogSoftmax(dim=1)
)

Python model (модели в python (машинное обучение))

Здесь каждый слой применяется последовательно. Внимание: в PyTorch часто используют nn.LogSoftmax вместе с nn.NLLLoss или nn.CrossEntropyLoss (которая включает softmax).

Вариант 1: Класс на основе nn.Module

Позволяет определить произвольные операции в методе forward, поддерживает динамические графы.

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.relu = nn.ReLU()
        self.drop = nn.Dropout(0.2)
        self.fc2 = nn.Linear(128, 10)
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.drop(x)
        x = self.fc2(x)
        return x
model = Net()

статистическая библиотека python (статистическая библиотека python (scipy, statsmodels))

Типичная ошибка:

неверное наследование (забыть super(Net, self).__init__()), что приводит к отсутствию параметров. Также важно правильно определить forward и вернуть тензор.

Вариант 2: Использование nn.ModuleList

Позволяет хранить несколько слоев в списке и применять их в цикле, удобно для глубоких сетей с повторяющимися блоками.

class DeepNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.ModuleList([
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 10)
        ])
    def forward(self, x):
        for layer in self.layers:
            x = layer(x)
        return x

Этот подход упрощает создание вариативных архитектур, но требует внимания к порядку слоев.

Проблемы в PyTorch:

  • Размерности: тензоры должны быть в формате (batch, features). Для изображений часто нужно использовать view или flatten.
  • Устройство: модель и данные должны находиться на одном устройстве (CPU/GPU). Используйте .to(device).
  • Функция потерь: CrossEntropyLoss ожидает logits, а не softmax. Поэтому в последнем слое обычно не ставят активацию, или используют LogSoftmax.
- задачи машинного обучения python (задачи машинного обучения на python)
- машинное обучение на данных python (машинное обучение на данных с помощью python)
- нейросеть python (нейросеть на python)

Расширенные примеры создания и обучения нейронных сетей

Пример 1: Полный цикл обучения в TensorFlow (Keras)

Рассмотрим полный процесс: подготовка данных, создание модели, компиляция, обучение и оценка. Используем датасет MNIST.

Пример 
import tensorflow as tf
from tensorflow.keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(-1, 784).astype('float32') / 255
x_test = x_test.reshape(-1, 784).astype('float32') / 255

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])

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

history = model.fit(x_train, y_train, epochs=5, batch_size=32, validation_split=0.2)

test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
print(f'Test accuracy: {test_acc:.4f}')
Epoch 1/5
1500/1500 [==============================] - 3s 2ms/step - loss: 0.2970 - accuracy: 0.9140 - val_loss: 0.1566 - val_accuracy: 0.9548
Epoch 2/5
1500/1500 [==============================] - 2s 2ms/step - loss: 0.1429 - accuracy: 0.9579 - val_loss: 0.1180 - val_accuracy: 0.9641
...
Test accuracy: 0.9770

Пояснение:

данные нормализованы, модель использует sparse_categorical_crossentropy так как метки целые. validation_split позволяет отслеживать переобучение.

Пример 2: Полный цикл обучения в PyTorch

Аналогичный процесс, но с ручным циклом обучения и DataLoader.

Пример 
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from torchvision import datasets, transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Lambda(lambda x: x.view(-1))
])

train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_data = datasets.MNIST(root='./data', train=False, transform=transform)

train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
test_loader = DataLoader(test_data, batch_size=32, shuffle=False)

model = nn.Sequential(
    nn.Linear(784, 128),
    nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(128, 10)
)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

for epoch in range(5):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
    print(f'Epoch {epoch+1}: loss={loss.item():.4f}')

model.eval()
correct = 0
total = 0
with torch.no_grad():
    for data, target in test_loader:
        output = model(data)
        _, predicted = torch.max(output, 1)
        total += target.size(0)
        correct += (predicted == target).sum().item()
print(f'Test accuracy: {100 * correct / total:.2f}%')
Epoch 1: loss=0.2895
Epoch 2: loss=0.1219
Epoch 3: loss=0.0932
Epoch 4: loss=0.0715
Epoch 5: loss=0.0612
Test accuracy: 97.15%

Пояснение:

используется CrossEntropyLoss, которая внутри применяет softmax, поэтому в последнем слое нет активации. Режимы model.train() и model.eval() важны для Dropout и BatchNorm.

Пример 3: Использование обратных вызовов (callbacks) в TensorFlow

Callbacks позволяют сохранять лучшую модель, останавливать обучение при отсутствии улучшений.

Пример 
import tensorflow as tf
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

# Предположим модель и данные готовы
model = ...  # та же Sequential модель
callbacks = [
    EarlyStopping(patience=3, restore_best_weights=True),
    ModelCheckpoint('best_model.h5', save_best_only=True)
]
history = model.fit(x_train, y_train, epochs=20, validation_data=(x_test, y_test), callbacks=callbacks)
# Лучшая модель будет загружена автоматически благодаря restore_best_weights
Epoch 1/20: loss=0.1800 - val_loss=0.1200
Epoch 2/20: loss=0.1000 - val_loss=0.1050
...
Early stopping at epoch 7: val_loss did not improve for 3 epochs.

Пример 4: Работа с GPU в PyTorch

Перенос модели и данных на GPU ускоряет обучение.

Пример 
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Net().to(device)  # Net - класс, определенный ранее
data, target = data.to(device), target.to(device)
# Далее обучение как обычно

Примечание:

необходимо убедиться, что все тензоры и модель находятся на одном устройстве, иначе возникнет ошибка.

Создание нейронных сетей на Python (TensorFlow, PyTorch) - comments

En
создание нейросетей на python (python)