Нейросети: создание и оптимизация будущего. Джеймс Девис

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

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

      ```python

      import torch

      import torch.nn as nn

      import torch.optim as optim

      from torchvision import datasets, transforms

      import matplotlib.pyplot as plt

      # Простая модель: однослойная нейронная сеть

      class SimpleNN(nn.Module):

      def __init__(self):

      super(SimpleNN, self).__init__()

      self.fc = nn.Linear(28 * 28, 10)

      def forward(self, x):

      x = x.view(-1, 28 * 28) # Преобразуем изображение в вектор

      return self.fc(x)

      # Настройка данных (например, MNIST)

      transform = transforms.Compose([transforms.ToTensor()])

      train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)

      train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)

      # Инициализация модели и функции потерь

      model = SimpleNN()

      criterion = nn.CrossEntropyLoss()

      # Оптимизатор с моментом

      learning_rate = 0.1

      momentum = 0.9 # Значение момента

      optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)

      # Для сравнения: оптимизатор без момента

      optimizer_no_momentum = optim.SGD(model.parameters(), lr=learning_rate)

      # Процесс обучения

      def train_model(optimizer, num_epochs=10):

      model.train() # Переключение модели в режим обучения

      losses = []

      for epoch in range(num_epochs):

      running_loss = 0.0

      for inputs, labels in train_loader:

      optimizer.zero_grad() # Сброс градиентов

      outputs = model(inputs) # Прямой проход

      loss = criterion(outputs, labels) # Вычисление потерь

      loss.backward() # Обратное распространение

      optimizer.step() # Обновление весов

      running_loss += loss.item()

      avg_loss = running_loss / len(train_loader)

      losses.append(avg_loss)

      print(f"Epoch {epoch+1}/{num_epochs}, Loss: {avg_loss:.4f}")

      return losses

      # Обучение с моментом

      print("Training with Momentum")

      losses_momentum = train_model(optimizer)

      # Обучение без момента

      print("\nTraining without Momentum")

      losses_no_momentum = train_model(optimizer_no_momentum)

      # Сравнение потерь

      plt.plot(losses_momentum, label="With Momentum (μ=0.9)")

      plt.plot(losses_no_momentum, label="Without Momentum")

      plt.xlabel("Epoch")

      plt.ylabel("Loss")

      plt.title("Training Loss Comparison")

      plt.legend()

      plt.grid()

      plt.show()

      ```

      Объяснение кода

      1. Оптимизатор с моментом: Используется `SGD` с параметром `momentum=0.9`, что позволяет сглаживать траекторию обновления весов.

      2. Оптимизатор без момента: Для сравнения создаётся версия SGD без момента, чтобы показать влияние этой настройки на сходимость.

      3. Функция обучения: Реализована универсальная функция, которая принимает оптимизатор и выполняет процесс обучения модели. В конце каждой эпохи вычисляется средняя потеря для оценки прогресса.

      4. Сравнение потерь: После обучения потери, полученные с моментом и без него, визуализируются на графике. Обычно модель с моментом достигает более низких потерь быстрее и с меньшим количеством колебаний.

      Результат

      На графике можно будет увидеть, что модель с моментом ( mu = 0.9 ) быстрее достигает сходимости и демонстрирует более стабильное поведение функции потерь по сравнению с версией без момента.

      Тонкая