PyTorch: построение модели Transformer

Transformer — одна из самых мощных моделей в современном машинном обучении.

Модель Transformer — это архитектура глубокого обучения, основанная на механизме самовнимания. Она произвела революцию в области обработки естественного языка (NLP) и стала основой современных моделей глубокого обучения, таких как BERT, GPT и др.

Transformer — это ключевая архитектура в современном NLP. Благодаря мощной способности моделировать дальние зависимости и эффективным преимуществам параллельных вычислений она превосходит традиционные сети Long Short-Term Memory (LSTM) в таких задачах, как перевод текста и суммирование текста.

Если вы ещё не понимаете Transformer, можете обратиться к:Введение в модель Transformer。

Построение модели Transformer с помощью PyTorch

Этапы построения модели Transformer следующие:

1. Импортируйте необходимые библиотеки и модули

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

import torch
import torch.nn as nn
import torch.optim as optim
import torch.utils.data as data
import math
import copy

Описание:

  • torch: основная библиотека PyTorch, используемая для операций с тензорами и автоматического дифференцирования.

  • torch.nn: модуль нейронных сетей PyTorch, содержащий различные слои и функции потерь.

  • torch.optim: модуль алгоритмов оптимизации, таких как Adam, SGD и т. д.

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

  • copy: используется для глубокого копирования объектов.

Определите базовые строительные блоки: многоголовое внимание, позиционно-независимая сеть прямого распространения, позиционное кодирование

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

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

Пример

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        assert d_model % num_heads == 0, "d_model должен делиться на num_heads"
       
        self.d_model = d_model    # Размерность модели (например, 512)
        self.num_heads = num_heads # Количество голов внимания (например, 8)
        self.d_k = d_model // num_heads # Размерность каждой головы (например, 64)
       
        # Определить слои линейного преобразования (без смещения)
        self.W_q = nn.Linear(d_model, d_model) # Преобразование запроса
        self.W_k = nn.Linear(d_model, d_model) # Преобразование ключа
        self.W_v = nn.Linear(d_model, d_model) # Преобразование значения
        self.W_o = nn.Linear(d_model, d_model) # Преобразование выхода
       
    def scaled_dot_product_attention(self, Q, K, V, mask=Отсутствует):
        """
Вычислить внимание с масштабированным скалярным произведением
Форма входных данных:
            Q: (batch_size, num_heads, seq_length, d_k)
K, V: такие же, как Q
Форма выходных данных: (batch_size, num_heads, seq_length, d_k)
        """

        # Вычислить оценки внимания (скалярное произведение Q и K)
        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
       
        # Применить маску (например, маску заполнения или маску будущей информации)
        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
       
        # Вычислить веса внимания (нормализация softmax)
        attn_probs = torch.softmax(attn_scores, dim=-1)
       
        # Взвешенная сумма векторов значений
        output = torch.matmul(attn_probs, V)
        return output
       
    def split_heads(self, x):
        """
Разделить входной тензор на несколько голов
Форма входных данных: (batch_size, seq_length, d_model)
Форма выходных данных: (batch_size, num_heads, seq_length, d_k)
        """

        batch_size, seq_length, d_model = x.size()
        return x.view(batch_size, seq_length, self.num_heads, self.d_k).transpose(1, 2)
       
    def combine_heads(self, x):
        """
Объединить выходы нескольких голов обратно в исходную форму
Форма входных данных: (batch_size, num_heads, seq_length, d_k)
Форма выходных данных: (batch_size, seq_length, d_model)
        """

        batch_size, _, seq_length, d_k = x.size()
        return x.transpose(1, 2).contiguous().view(batch_size, seq_length, self.d_model)
       
    def forward(self, Q, K, V, mask=Отсутствует):
        """
Прямое распространение
Форма входа: Q/K/V: (batch_size, seq_length, d_model)
Форма выходных данных: (batch_size, seq_length, d_model)
        """

        # Линейное преобразование и разделение на несколько голов
        Q = self.split_heads(self.W_q(Q)) # (batch, heads, seq_len, d_k)
        K = self.split_heads(self.W_k(K))
        V = self.split_heads(self.W_v(V))
       
        # Вычисление внимания
        attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
       
        # Объединить головы и применить выходное преобразование
        output = self.W_o(self.combine_heads(attn_output))
        return output

Описание:

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

  • Внимание на основе масштабированного скалярного произведения: Вычислить скалярное произведение запросов и ключей, масштабировать его, использовать softmax для вычисления весов внимания и в конце взять взвешенную сумму значений.

  • Маска: Используется для маскирования недопустимых позиций (например, дополненных частей).

Позиционно-независимая сеть прямого распространения

Пример

class PositionWiseFeedForward(nn.Module):
    def __init__(self, d_model, d_ff):
        super(PositionWiseFeedForward, self).__init__()
        self.fc1 = nn.Linear(d_model, d_ff)  # Первый полносвязный слой
        self.fc2 = nn.Linear(d_ff, d_model)  # Второй полносвязный слой
        self.relu = nn.ReLU()  # Функция активации

    def forward(self, x):
        # Вычисление в сети прямого распространения
        return self.fc2(self.relu(self.fc1(x)))

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

Позиционное кодирование

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

Используйте функции синуса и косинуса разных частот для генерации позиционных кодировок.

Пример

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_seq_length):
        super(PositionalEncoding, self).__init__()
        pe = torch.zeros(max_seq_length, d_model)  # Инициализировать матрицу позиционного кодирования
        position = torch.arange(0, max_seq_length, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)  # Использовать функцию синуса для чётных позиций
        pe[:, 1::2] = torch.cos(position * div_term)  # Использовать функцию косинуса для нечётных позиций
        self.register_buffer('pe', pe.unsqueeze(0))  # Зарегистрировать как буфер
       
    def forward(self, x):
        # Добавить позиционное кодирование к входу
        return x + self.pe[:, :x.size(1)]

Построение блока энкодера (слой энкодера)

Слой энкодера:Содержит механизм самовнимания и сеть прямого распространения; каждый подуровень сопровождается остаточными соединениями и нормализацией слоя.

Пример

class EncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout):
        super(EncoderLayer, self).__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)  # Механизм самовнимания
        self.feed_forward = PositionWiseFeedForward(d_model, d_ff)  # Сеть прямого распространения
        self.norm1 = nn.LayerNorm(d_model)  # Нормализация слоя
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)  # Dropout
       
    def forward(self, x, mask):
        # Механизм самовнимания
        attn_output = self.self_attn(x, x, x, mask)
        x = self.norm1(x + self.dropout(attn_output))  # Остаточное соединение и нормализация слоя
       
        # Сеть прямого распространения
        ff_output = self.feed_forward(x)
        x = self.norm2(x + self.dropout(ff_output))  # Остаточное соединение и нормализация слоя
        return x

Соберите модуль декодера

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

Пример

class DecoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout):
        super(DecoderLayer, self).__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)  # Механизм самовнимания
        self.cross_attn = MultiHeadAttention(d_model, num_heads)  # Механизм перекрёстного внимания
        self.feed_forward = PositionWiseFeedForward(d_model, d_ff)  # Сеть прямого распространения
        self.norm1 = nn.LayerNorm(d_model)  # Нормализация слоя
        self.norm2 = nn.LayerNorm(d_model)
        self.norm3 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)  # Dropout
       
    def forward(self, x, enc_output, src_mask, tgt_mask):
        # Механизм самовнимания
        attn_output = self.self_attn(x, x, x, tgt_mask)
        x = self.norm1(x + self.dropout(attn_output))  # Остаточное соединение и нормализация слоя
       
        # Механизм перекрёстного внимания
        attn_output = self.cross_attn(x, enc_output, enc_output, src_mask)
        x = self.norm2(x + self.dropout(attn_output))  # Остаточное соединение и нормализация слоя
       
        # Сеть прямого распространения
        ff_output = self.feed_forward(x)
        x = self.norm3(x + self.dropout(ff_output))  # Остаточное соединение и нормализация слоя
        return x

Соберите полную модель Transformer

Пример

class Transformer(nn.Module):
    def __init__(self, src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout):
        super(Transformer, self).__init__()
        self.encoder_embedding = nn.Embedding(src_vocab_size, d_model)  # Встраивание слов энкодера
        self.decoder_embedding = nn.Embedding(tgt_vocab_size, d_model)  # Встраивание слов декодера
        self.positional_encoding = PositionalEncoding(d_model, max_seq_length)  # Позиционное кодирование

        # Слои энкодера и декодера
        self.encoder_layers = nn.ModuleList([EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)])
        self.decoder_layers = nn.ModuleList([DecoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)])

        self.fc = nn.Linear(d_model, tgt_vocab_size)  # Финальный полносвязный слой
        self.dropout = nn.Dropout(dropout)  # Dropout

    def generate_mask(self, src, tgt):
        # Маска источника: маскировать токены заполнения (предполагается, что индекс заполнения равен 0)
        # Форма: (batch_size, 1, 1, seq_length)
        src_mask = (src != 0).unsqueeze(1).unsqueeze(2)
   
        # Маска цели: маскировать токены заполнения и будущую информацию
        # Форма: (batch_size, 1, seq_length, 1)
        tgt_mask = (tgt != 0).unsqueeze(1).unsqueeze(3)
        seq_length = tgt.size(1)
        # Сгенерировать маску в виде верхнетреугольной матрицы, чтобы предотвратить просмотр будущей информации во время декодирования
        nopeak_mask = (1 - torch.triu(torch.ones(1, seq_length, seq_length), diagonal=1)).bool()
        tgt_mask = tgt_mask & nopeak_mask  # Объединить маску заполнения и маску будущей информации
        return src_mask, tgt_mask

    def forward(self, src, tgt):
        # Сгенерировать маски
        src_mask, tgt_mask = self.generate_mask(src, tgt)
       
        # Часть энкодера
        src_embedded = self.dropout(self.positional_encoding(self.encoder_embedding(src)))
        enc_output = src_embedded
        for enc_layer in self.encoder_layers:
            enc_output = enc_layer(enc_output, src_mask)
       
        # Часть декодера
        tgt_embedded = self.dropout(self.positional_encoding(self.decoder_embedding(tgt)))
        dec_output = tgt_embedded
        for dec_layer in self.decoder_layers:
            dec_output = dec_layer(dec_output, enc_output, src_mask, tgt_mask)
       
        # Финальный вывод
        output = self.fc(dec_output)
        return output

Описание:

  • Модель TransformerСодержит части энкодера и декодера, каждая из которых состоит из нескольких слоёв, объединённых в стек.

  • Генерация маскиИспользуется для маскирования недопустимых позиций и будущей информации.

  • Прямое распространениеПоследовательно проходит через энкодер и декодер и в итоге выводится через полносвязный слой.

Описание параметров инициализации модели:

class Transformer(nn.Module):
    def __init__(
        self, 
        src_vocab_size,  # 源语言词汇表大小(如英文单词数)
        tgt_vocab_size,  # 目标语言词汇表大小(如中文单词数)
        d_model=512,     # 模型维度(每个词向量的长度)
        num_heads=8,     # 多头注意力的头数
        num_layers=6,    # 编码器/解码器的堆叠层数
        d_ff=2048,       # 前馈网络隐藏层维度
        max_seq_length=100, # 最大序列长度(用于位置编码)
        dropout=0.1      # Dropout概率
    ):

Обучение модели Transformer в PyTorch

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

Пример

# Гиперпараметры
src_vocab_size = 5000  # Размер исходного словаря
tgt_vocab_size = 5000  # Размер целевого словаря
d_model = 512  # Размерность модели
num_heads = 8  # Количество голов внимания
num_layers = 6  # Количество слоёв энкодера и декодера
d_ff = 2048  # Внутренняя размерность сети прямого распространения
max_seq_length = 100  # Максимальная длина последовательности
dropout = 0.1  # Вероятность dropout

# Инициализация модели
transformer = Transformer(src_vocab_size, tgt_vocab_size, d_model, num_heads, num_layers, d_ff, max_seq_length, dropout)

# Сгенерировать случайные данные
src_data = torch.randint(1, src_vocab_size, (64, max_seq_length))  # Исходная последовательность
tgt_data = torch.randint(1, tgt_vocab_size, (64, max_seq_length))  # Целевая последовательность

# Определяем функцию потерь и оптимизатор
criterion = nn.CrossEntropyLoss(ignore_index=0)  # Игнорировать потерю для части с заполнением
optimizer = optim.Adam(transformer.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9)

# Цикл обучения
transformer.train()
for epoch in range(100):
    optimizer.zero_grad()  # Очистить градиенты, чтобы предотвратить накопление
   
    # Удалить последнее слово при подаче целевой последовательности (используется для предсказания следующего слова)
    output = transformer(src_data, tgt_data[:, :-1])  
   
    # При вычислении функции потерь целевая последовательность начинается со второго слова (т. е. предсказать следующее слово)
    # Форма выходных данных: (batch_size, seq_length-1, tgt_vocab_size)
    # Форма целевых данных: (batch_size, seq_length-1)
    loss = criterion(
        output.contiguous().view(-1, tgt_vocab_size),
        tgt_data[:, 1:].contiguous().view(-1)
    )
   
    loss.backward()        # Обратное распространение
    optimizer.step()       # Обновить параметры
    print(f"Эпоха: {epoch+1}, Потери: {loss.item()}")

Оценка модели

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

Пример

transformer.eval()
# Генерация валидационных данных
val_src_data = torch.randint(1, src_vocab_size, (64, max_seq_length))
val_tgt_data = torch.randint(1, tgt_vocab_size, (64, max_seq_length))
# Предположим, что входные данные — это батч английских предложений и соответствующих им китайских переводов (преобразованных в индексы)
# Пример данных:
# src_data: [[3, 14, 25, ..., 0, 0], ...] # Английские предложения (0 — токен заполнения)
# tgt_data: [[5, 20, 36, ..., 0, 0], ...] # Китайские переводы (0 — токен заполнения)
# Примечание: в практических приложениях текст требует предварительной обработки, такой как токенизация, кодирование и паддинг
with torch.no_grad():
    val_output = transformer(val_src_data, val_tgt_data[:, :-1])
    val_loss = criterion(val_output.contiguous().view(-1, tgt_vocab_size), val_tgt_data[:, 1:].contiguous().представление(-1))
    print(f"Потери при валидации: {val_loss.item()}")
Другие расширения