AI & GPU
Как легко понять ResNet в PyTorch

Как легко понять ResNet в PyTorch

Введение в ResNet

Что такое ResNet?

ResNet, сокращение от Residual Neural Network (Нейронная сеть с остаточными связями), является архитектурой глубокого обучения, которая была представлена в 2015 году исследователями из Microsoft. Она была разработана для решения проблемы возникновения/истощения градиента, общей проблемы при обучении очень глубоких нейронных сетей.

  1. Residual Neural Network: ResNet является типом нейронной сети, которая использует "сквозные связи" или "остаточные связи" для обучения намного более глубоких моделей. Эти сквозные связи позволяют сети обходить определенные слои, создавая "переход", который помогает устранить проблему истощения градиента.

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

Преимущества ResNet

  1. Улучшение производительности глубоких нейронных сетей: Остаточные связи ResNet позволяют обучать гораздо более глубокие нейронные сети, что может привести к значительному улучшению производительности на различных задачах, таких как классификация изображений, обнаружение объектов и семантическая сегментация.

  2. Быстрая сходимость во время обучения: Сквозные связи в ResNet также могут помочь сети быстрее сошлась в процессе обучения, так как они позволяют градиентам свободнее протекать через сеть.

Реализация ResNet в PyTorch

Создание среды

  1. Установка PyTorch: Чтобы начать реализацию ResNet в PyTorch, вам сначала нужно установить библиотеку PyTorch. Вы можете скачать и установить PyTorch с официального веб-сайта (https://pytorch.org/ (opens in a new tab)) в зависимости от вашей операционной системы и версии Python.

  2. Импорт необходимых библиотек: После установки PyTorch вам потребуется импортировать необходимые библиотеки для вашего проекта. Обычно это включает PyTorch, NumPy и любые другие библиотеки, которые вам могут понадобиться для предварительной обработки данных, визуализации или других задач.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt

Определение архитектуры ResNet

Понимание основных строительных блоков

  1. Сверточные слои: ResNet, как и множество других моделей глубокого обучения, использует сверточные слои в качестве основных строительных блоков для извлечения признаков.

  2. Нормализация по пакетам: ResNet также использует слои нормализации по пакетам для стабилизации процесса обучения и улучшения производительности модели.

  3. Функции активации: Архитектура ResNet обычно использует функцию активации ReLU (линейная функция с отсечкой) для введения нелинейности в модель.

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

Реализация блока ResNet

  1. Остаточное соединение: Главной особенностью ResNet является остаточное соединение, которое позволяет сети обходить некоторые слои, добавляя вход слоя к его выходу. Это помогает устранить проблему истощения градиента.
class ResNetBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResNetBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
 
    def forward(self, x):
        residual = self.shortcut(x)
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out += residual
        out = self.relu(out)
        return out
  1. Shortcut Connection: В дополнение к остаточному соединению, ResNet также использует "соединение с переходом" для согласования размеров входа и выхода блока ResNet, если это необходимо.

Создание полной модели ResNet

  1. Сложение блоков ResNet: Чтобы создать полную модель ResNet, вам нужно объединить несколько блоков ResNet, настроив количество слоев и количество фильтров в каждом блоке.

  2. Настройка количества слоев: Модели ResNet представлены в различных вариантах, таких как ResNet-18, ResNet-34, ResNet-50, ResNet-101 и ResNet-152, которые имеют разное количество слоев. Количество слоев влияет на сложность и производительность модели.

Реализация ResNet-18 в PyTorch

Определение модели ResNet-18

  1. Входной слой: Входной слой модели ResNet-18 обычно принимает изображение определенного размера, например, 224x224 пикселей.

  2. Сверточные слои: Начальные сверточные слои модели ResNet-18 извлекают базовые признаки из входного изображения.

  3. Блоки ResNet: Основу модели ResNet-18 составляет складывание нескольких блоков ResNet, которые используют остаточные соединения для обучения более глубокой сети.

  4. Полносвязный слой: После сверточных слоев и блоков ResNet модель будет иметь полносвязный слой для выполнения конечной классификации или задачи предсказания.

  5. Выходной слой: Выходной слой модели ResNet-18 будет иметь число единиц, соответствующее числу классов в решаемой задаче.

class ResNet18(nn.Module):
    def __init__(self, num_classes=10):
        super(ResNet18, self).__init__()
        self.in_channels = 64
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
 
        self.layer1 = self._make_layer(64, 64, 2, stride=1)
        self.layer2 = self._make_layer(64, 128, 2, stride=2)
        self.layer3 = self._make_layer(128, 256, 2, stride=2)
        self.layer4 = self._make_layer(256, 512, 2, stride=2)
 
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)
 
    def _make_layer(self, in_channels, out_channels, num_blocks, stride):
        layers = []
        layers.append(ResNetBlock(in_channels, out_channels, stride))
        self.in_channels = out_channels
        for i in range(1, num_blocks):
            layers.append(ResNetBlock(out_channels, out_channels))
        return nn.Sequential(*layers)
 
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)
 
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
 
        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

Инициализация модели

Чтобы создать экземпляр модели ResNet-18, можно просто создать объект класса ResNet18:

model = ResNet18(num_classes=10)

Вывод информации о модели

Вы можете вывести подробную информацию об архитектуре модели ResNet-18 с помощью функции summary() из библиотеки torchsummary:

from torchsummary import summary
summary(model, input_size=(3, 224, 224))

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

Обучение модели ResNet-18

Подготовка набора данных

Загрузка и подгрузка набора данных

Для этого примера мы будем использовать набор данных CIFAR-10, который является широко используемым эталоном для задач классификации изображений. Вы можете загрузить набор данных, используя модуль torchvision.datasets.CIFAR10:

# Загрузка и подгрузка набора данных CIFAR-10
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())

Предварительная обработка данных

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

# Определение преобразований данных
transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
 
transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
 
# Создание загрузчиков данных
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=2)

Определение цикла обучения

Установка устройства (CPU или GPU)

Чтобы воспользоваться ускорением GPU, вы можете переместить модель и данные на GPU:

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

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

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)

Реализация цикла обучения

Цикл обучения будет включать в себя следующие шаги:

  1. Прямой проход через модель
  2. Вычисление потерь
  3. Обратное распространение градиентов
  4. Обновление параметров модели
  5. Отслеживание потерь и точности обучения
num_epochs = 100
train_losses = []
train_accuracies = []
val_losses = []
val_accuracies = []
 
for epoch in range(num_epochs):
    # Фаза обучения
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    for i, (inputs, labels) in enumerate(train_loader):
        inputs, labels = inputs.to(device), labels.to(device)
        
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
 
## Оптимизация модели
 
### Регуляризация
 
Регуляризация - это техника, используемая для предотвращения переобучения в моделях глубокого обучения. Переобучение происходит, когда модель хорошо работает на обучающих данных, но не обобщается на новые, невиданные данные. Техники регуляризации помогают модели лучше обобщаться, вводя штраф за сложность или добавляя шум в процесс обучения.
 
Одна из популярных техник регуляризации - это L2-регуляризация, также известная как уменьшение весов. Этот метод добавляет член штрафа к функции потерь, пропорциональный квадрату величины весов модели. Функция потерь с L2-регуляризацией может быть записана следующим образом:

loss = исходная_потеря + лямбда * сумма(w^2)


где `лямбда` - это коэффициент регуляризации, а `w` - это веса модели.

Другая популярная техника регуляризации - это Dropout. Dropout случайным образом устанавливает часть активаций в слое равными нулю во время обучения, что позволяет модели учить более надежные функции. Это помогает предотвратить переобучение и может улучшить обобщающую способность модели.

Вот пример реализации Dropout в модели PyTorch:

```python
import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(64, 128)
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = self.dropout(x)
        x = self.fc2(x)
        return x

В этом примере слой Dropout применяется после первого полносвязного слоя с коэффициентом отсева 0,5, что означает, что 50% активаций будут случайным образом установлены в ноль во время обучения.

Алгоритмы оптимизации

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

Стохастический градиентный спуск (SGD)

SGD - это самый базовый алгоритм оптимизации, где градиенты вычисляются на одном тренировочном примере или на небольшой партии примеров, и веса обновляются соответственно. SGD может быть медленным в сходимости, но он прост и эффективен.

import torch.optim as optim
 
model = MyModel()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

Adam

Adam (Адаптивная оценка момента) - это более продвинутый алгоритм оптимизации, который вычисляет адаптивные скорости обучения для каждого параметра. Он объединяет преимущества момента и RMSProp, что делает его популярным выбором для многих задач глубокого обучения.

optimizer = optim.Adam(model.parameters(), lr=0.001)

AdaGrad

AdaGrad (Адаптивный градиент) - это алгоритм оптимизации, который адаптирует скорость обучения для каждого параметра на основе исторических градиентов. Он эффективен для разреженных данных, но может страдать от агрессивного уменьшения скорости обучения со временем.

optimizer = optim.Adagrad(model.parameters(), lr=0.01)

RMSProp

RMSProp (Метод корневого среднеквадратичного перемещения) - это другой алгоритм адаптивного изменения скорости обучения, который поддерживает скользящее среднее квадратов градиентов. Он особенно полезен для нестационарных целей, таких как цели, обнаруженные в рекуррентных нейронных сетях.

optimizer = optim.RMSprop(model.parameters(), lr=0.001, alpha=0.99)

Выбор алгоритма оптимизации зависит от конкретной задачи, структуры модели и особенностей данных. Часто бывает полезно экспериментировать с различными алгоритмами и сравнивать их производительность на вашей задаче.

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

Перенос обучения - это техника, при которой модель, обученная на большом наборе данных, используется в качестве отправной точки для модели на другой, но связанной задаче. Это может быть особенно полезно, когда целевой набор данных небольшой, так как он позволяет модели использовать особенности, изученные на большем наборе данных.

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

Вот пример того, как настроить предварительно обученную модель ResNet для задачи классификации изображений в PyTorch:

import torchvision.models as models
import torch.nn as nn
 
# Загрузка предварительно обученной модели ResNet
resnet = models.resnet18(pretrained=True)
 
# Заморозка параметров предварительно обученной модели
for param in resnet.parameters():
    param.requires_grad = False
 
# Замена последнего слоя новым полносвязным слоем
num_features = resnet.fc.in_features
resnet.fc = nn.Linear(num_features, 10)  # Предполагается, что 10 классов
 
# Обучение модели на новом наборе данных
optimizer = optim.Adam(resnet.fc.parameters(), lr=0.001)

В этом примере мы сначала загружаем предварительно обученную модель ResNet18 и замораживаем параметры нижних слоев. Затем мы заменяем последний полносвязный слой на новый слой с необходимым количеством выходов для нашей целевой задачи (в этом случае 10 классов). Наконец, мы обучаем модель с использованием оптимизатора Adam, обновляя только параметры нового полносвязного слоя.

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

Интерпретируемость модели

По мере того, как модели глубокого обучения становятся более сложными и широко распространенными, становится все важнее иметь возможность интерпретировать модели. Интерпретируемость относится к способности понять и объяснить внутренний процесс принятия решений модели.

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

Вот пример того, как реализовать механизм внимания в модели PyTorch для задачи обработки естественного языка:

import torch.nn as nn
import torch.nn.functional as F
 
class AttentionModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim):
        super(AttentionModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, bidirectional=True, batch_first=True)
        self.attention = nn.Linear(hidden_dim * 2, 1)
 
    def forward(self, input_ids):
        # Встраивание входных данных
        embedded = self.embedding(input_ids)
 
        # Пропуск встроенных данных через LSTM
        lstm_output, _ = self.lstm(embedded)
 
        # Вычисление весов внимания
        attention_weights = F.softmax(self.attention(lstm_output), dim=1)
 
        # Вычисление взвешенной суммы выходов LSTM
        context = torch.sum(attention_weights * lstm_output, dim=1)
 
        return context

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

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

Другая техника для улучшения интерпретируемости модели - это использование анализа важности функций. Это включает определение наиболее важных функций, которые использует модель для прогнозирования. Одним из популярных методов для этого являются значения Шэпли, которые предоставляют способ оценить вклад каждой функции в вывод модели.

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

Заключение

В этом руководстве мы рассмотрели различные темы, связанные с областью глубокого обучения, включая оптимизацию модели, перенос обучения и интерпретируемость модели. Мы обсудили такие техники, как регуляризация, алгоритмы оптимизации и механизмы внимания, и предоставили примеры того, как реализовать эти концепции в PyTorch.

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

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

Как легко использовать MLflow на DatabricksКак использовать возможности графического процессора TensorFlow