Этот пример демонстрирует, как весовые коэффициенты нейронной сети настраиваются в процессе обучения, чтобы модель могла делать точные предсказания на основе входных данных.
Пример кода на Python с использованием библиотеки PyTorch для создания и обучения простой нейронной сети для классификации изображений рукописных цифр из набора данных MNIST:
```python
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
# Загрузка данных MNIST и предобработка
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
train_set = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
# Определение архитектуры нейронной сети
class SimpleNN(nn.Module):
def __init__(self):
super(SimpleNN, self).__init__()
self.fc1 = nn.Linear(28*28, 128)
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 10)
def forward(self, x):
x = torch.flatten(x, 1)
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = self.fc3(x)
return x
# Создание экземпляра модели
model = SimpleNN()
# Определение функции потерь и оптимизатора
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# Обучение модели
num_epochs = 5
for epoch in range(num_epochs):
running_loss = 0.0
for i, data in enumerate(train_loader, 0):
inputs, labels = data
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if (i+1) % 100 == 0:
print(f'Epoch {epoch+1}, Iteration {i+1}, Loss: {running_loss/100:.4f}')
running_loss = 0.0
print('Finished Training')
# Сохранение модели
torch.save(model.state_dict(), 'mnist_model.pth')
```
Этот код создает и обучает простую полносвязную нейронную сеть для классификации изображений MNIST. В ней используются три полносвязных слоя, функции активации ReLU и функция потерь CrossEntropyLoss. Модель обучается в течение нескольких эпох с использованием оптимизатора Adam. По завершении обучения модель сохраняется в файл ‘mnist_model.pth'.
Функции активации
Функции активации играют важную роль в работе нейронных сетей, добавляя нелинейность в модель и позволяя ей учить сложные зависимости в данных. Вот более подробное описание основных функций активации:
1. ReLU (Rectified Linear Unit): Это одна из самых популярных функций активации, которая заменяет все отрицательные значения на ноль, оставляя положительные значения без изменений. Это делает вычисления проще и ускоряет обучение модели. ReLU также помогает в предотвращении проблемы затухания градиента.
Пример использования ReLU в нейронной сети может быть следующим:
Допустим, у нас есть простая нейронная сеть для классификации изображений рукописных цифр. В этой сети мы можем использовать ReLU в качестве функции активации для скрытых слоев. Вот как это может выглядеть на практике:
```python
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as datasets
# Загрузка данных MNIST и предобработка
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
train_set = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
# Определение архитектуры нейронной сети с ReLU в скрытых слоях
class SimpleNN(nn.Module):
def __init__(self):
super(SimpleNN, self).__init__()
self.fc1 = nn.Linear(28*28, 128)
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 10)
self.relu = nn.ReLU()
def forward(self, x):
x = torch.flatten(x, 1)
x = self.relu(self.fc1(x))
x = self.relu(self.fc2(x))
x = self.fc3(x)
return x
# Создание экземпляра модели
model = SimpleNN()
# Обучение модели и применение ReLU в скрытых слоях
```
В этом примере мы создаем нейронную сеть с тремя полносвязными слоями. После каждого полносвязного слоя мы применяем ReLU в качестве функции активации, чтобы добавить нелинейность и ускорить обучение модели. В итоге, мы используем ReLU для предотвращения затухания градиента и улучшения производительности нашей нейронной сети.
2. Sigmoid: Sigmoid-функция сжимает выходные значения в диапазон от 0 до 1, что делает её полезной для задач бинарной классификации, где нужно получить вероятность принадлежности к одному из двух классов. Однако у неё есть проблема затухания градиента, особенно при глубоких сетях.
Пример использования Sigmoid в нейронной сети для задачи бинарной классификации может быть следующим:
Допустим, у нас есть набор данных, содержащий изображения лиц, и мы хотим определить, принадлежит ли каждое лицо к классу "улыбающееся" или "неулыбающееся". В этом случае мы можем использовать нейронную сеть с одним выходным нейроном и функцией активации Sigmoid для предсказания вероятности улыбки.
```python
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as datasets
# Загрузка и предобработка данных
transform = transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
train_set = datasets.ImageFolder(root='./data/train', transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
# Определение архитектуры нейронной сети с Sigmoid в выходном слое
class SimpleNN(nn.Module):
def __init__(self):
super(SimpleNN, self).__init__()
self.fc1 = nn.Linear(32*32*3, 128)
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
x = torch.flatten(x, 1)
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = self.fc3(x)
x = self.sigmoid(x)
return x
# Создание экземпляра модели
model = SimpleNN()
# Обучение модели и применение Sigmoid в выходном слое
```
В этом примере мы создаем нейронную сеть с тремя полносвязными слоями. После двух скрытых слоев мы применяем ReLU в качестве функции активации, а в выходном слое – Sigmoid. Это позволяет нам получить вероятность того, что каждое изображение принадлежит классу "улыбающееся" (значение близкое к 1) или "неулыбающееся" (значение близкое к 0). Однако важно помнить о проблеме затухания градиента при использовании Sigmoid, особенно в глубоких сетях, что может затруднить обучение модели.
3. Tanh (гиперболический тангенс): Тангенс гиперболический функция также сжимает выходные значения, но в диапазон от -1 до 1. Это помогает ускорить обучение по сравнению с сигмоидальной функцией, так как выходные значения более центрированы относительно нуля.
Пример использования Tanh (гиперболического тангенса) в нейронной сети для предсказания значения некоторого непрерывного признака:
```python
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as datasets
# Загрузка и предобработка данных
transform = transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
train_set = datasets.ImageFolder(root='./data/train', transform=transform)
