Panduan Komprehensif untuk Membangun Model Transformer dengan Pytorch

Tujuan tutorial ini adalah untuk memberikan pemahaman yang komprehensif tentang cara membina model pengubah menggunakan pytorch. Transformer adalah salah satu model yang paling berkuasa dalam pembelajaran mesin moden. Mereka telah merevolusikan bidang ini, terutamanya dalam tugas pemprosesan bahasa semulajadi (NLP) seperti terjemahan bahasa dan ringkasan teks. Rangkaian memori jangka pendek (LSTM) telah digantikan oleh transformer dalam tugas-tugas ini kerana keupayaan mereka untuk mengendalikan ketergantungan jarak jauh dan pengiraan selari.

Alat yang digunakan dalam panduan ini untuk membina Transformer adalah Pytorch, sebuah perpustakaan pembelajaran mesin sumber terbuka yang popular yang terkenal dengan kesederhanaan, fleksibiliti, dan kecekapannya. Dengan graf pengiraan yang dinamik dan perpustakaan yang luas, Pytorch telah menjadi penyelidik dan pemaju dalam bidang pembelajaran mesin dan kecerdasan buatan.

Bagi mereka yang tidak dikenali dengan Pytorch, lawatan ke kursus DataCamp, Pengenalan kepada Pembelajaran Deep dengan Pytorch disyorkan untuk asas yang kukuh.

pertama kali diperkenalkan dalam perhatian kertas adalah semua yang anda perlukan oleh Vaswani et al., Transformer telah menjadi asas banyak tugas NLP kerana reka bentuk dan keberkesanannya yang unik.

Di tengah-tengah Transformers adalah mekanisme perhatian, khususnya konsep 'perhatian diri,' yang membolehkan model untuk menimbang dan mengutamakan bahagian-bahagian data input yang berlainan. Mekanisme ini adalah apa yang membolehkan transformer menguruskan ketergantungan jarak jauh dalam data. Ia pada asasnya adalah skim pembobotan yang membolehkan model memberi tumpuan kepada bahagian -bahagian input yang berlainan apabila menghasilkan output.

Mekanisme ini membolehkan model mempertimbangkan perkataan atau ciri yang berbeza dalam urutan input, memberikan setiap satu 'berat' yang menandakan kepentingannya untuk menghasilkan output yang diberikan.

Contohnya, dalam tugas terjemahan kalimat, sambil menerjemahkan perkataan tertentu, model mungkin memberikan berat perhatian yang lebih tinggi kepada kata -kata yang berkaitan dengan tatabahasa atau semantik dengan kata sasaran. Proses ini membolehkan pengubah untuk menangkap kebergantungan antara perkataan atau ciri, tanpa mengira jarak mereka antara satu sama lain dalam urutan.

Kesan Transformers dalam bidang NLP tidak boleh dilebih -lebihkan. Mereka telah mengatasi model tradisional dalam banyak tugas, menunjukkan keupayaan unggul untuk memahami dan menjana bahasa manusia dengan cara yang lebih bernuansa.

Untuk pemahaman yang lebih mendalam tentang NLP, pengenalan DataCamp untuk pemprosesan bahasa semulajadi dalam kursus python adalah sumber yang disyorkan.

Menyediakan Pytorch

Sebelum menyelam ke dalam membina pengubah, adalah penting untuk menubuhkan persekitaran kerja dengan betul. Pertama dan terpenting, pytorch perlu dipasang. Pytorch (versi stabil semasa - 2.0.1) boleh dipasang dengan mudah melalui pengurus pakej PIP atau Conda.

untuk pip, gunakan arahan:

untuk conda, gunakan arahan:

pip3 install torch torchvision torchaudio

untuk menggunakan pytorch dengan CPU sila lawati dokumentasi pytorch.

Selain itu, bermanfaat untuk mempunyai pemahaman asas tentang konsep pembelajaran mendalam, kerana ini akan menjadi asas untuk memahami operasi transformer. Bagi mereka yang memerlukan penyegaran, kursus DataCamp Deep Learning in Python adalah sumber yang berharga yang merangkumi konsep utama dalam pembelajaran mendalam.

Membina model pengubah dengan pytorch

Untuk membina model Transformer, langkah -langkah berikut adalah perlu:

1. mengimport perpustakaan dan modul
2. Mendefinisikan blok bangunan asas-perhatian multi-kepala, rangkaian feed-forward yang bijak, pengekodan posisi
3. membina blok encoder
4. membina blok penyahkod
5. menggabungkan lapisan encoder dan decoder untuk membuat rangkaian pengubah lengkap

1. Mengimport perpustakaan dan modul yang diperlukan

Kami akan bermula dengan mengimport perpustakaan Pytorch untuk fungsi teras, modul rangkaian saraf untuk mewujudkan rangkaian saraf, modul pengoptimuman untuk rangkaian latihan, dan fungsi utiliti data untuk mengendalikan data. Di samping itu, kami akan mengimport modul matematik python standard untuk operasi matematik dan modul salinan untuk membuat salinan objek kompleks.

Alat ini menetapkan asas untuk menentukan seni bina model, menguruskan data, dan mewujudkan proses latihan.

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

2. Mendefinisikan Blok Bangunan Asas: Perhatian Multi-Head, Rangkaian Feed-Forward-Feed-Bease, Pengekodan Posisi

Perhatian Multi-Head

Mekanisme perhatian multi-kepala mengira perhatian antara setiap pasangan kedudukan dalam urutan. Ia terdiri daripada pelbagai "kepala perhatian" yang menangkap aspek yang berbeza dari urutan input.

Untuk mengetahui lebih lanjut mengenai perhatian multi-kepala, lihat bahagian Mekanisme Perhatian ini dari Konsep Konsep Model Besar (LLMS).

Rajah 1. Perhatian Multi-Head (Sumber: Imej Dibuat oleh Pengarang)

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

definisi kelas dan permulaan:

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        # Ensure that the model dimension (d_model) is divisible by the number of heads
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        
        # Initialize dimensions
        self.d_model = d_model # Model's dimension
        self.num_heads = num_heads # Number of attention heads
        self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
        
        # Linear layers for transforming inputs
        self.W_q = nn.Linear(d_model, d_model) # Query transformation
        self.W_k = nn.Linear(d_model, d_model) # Key transformation
        self.W_v = nn.Linear(d_model, d_model) # Value transformation
        self.W_o = nn.Linear(d_model, d_model) # Output transformation
        
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        # Calculate attention scores
        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        # Apply mask if provided (useful for preventing attention to certain parts like padding)
        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
        
        # Softmax is applied to obtain attention probabilities
        attn_probs = torch.softmax(attn_scores, dim=-1)
        
        # Multiply by values to obtain the final output
        output = torch.matmul(attn_probs, V)
        return output
        
    def split_heads(self, x):
        # Reshape the input to have num_heads for multi-head attention
        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):
        # Combine the multiple heads back to original shape
        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=None):
        # Apply linear transformations and split heads
        Q = self.split_heads(self.W_q(Q))
        K = self.split_heads(self.W_k(K))
        V = self.split_heads(self.W_v(V))
        
        # Perform scaled dot-product attention
        attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
        
        # Combine heads and apply output transformation
        output = self.W_o(self.combine_heads(attn_output))
        return output

Kelas ditakrifkan sebagai subclass Nn.Module Pytorch.

d_model: dimensi input.
num_heads: bilangan kepala perhatian untuk memecah input ke.

Pemeriksaan permulaan jika d_model boleh dibahagikan dengan num_heads, dan kemudian mentakrifkan berat transformasi untuk pertanyaan, kunci, nilai, dan output.

perhatian dot-produk yang berskala:

pip3 install torch torchvision torchaudio

1. Mengira skor perhatian: attn_scores = obor.matmul (q, k.transpose (-2, -1)) / math.sqrt (self.d_k). Di sini, skor perhatian dikira dengan mengambil produk dot pertanyaan (q) dan kunci (k), dan kemudian berskala oleh akar kuadrat dimensi utama (D_K).
2. Memohon topeng: Jika topeng disediakan, ia digunakan untuk skor perhatian untuk menutup nilai tertentu.
3. mengira berat perhatian: Skor perhatian dilalui melalui fungsi softmax untuk mengubahnya menjadi kebarangkalian yang jumlahnya hingga 1.
4. Mengira output: Output akhir perhatian dikira dengan mengalikan berat perhatian dengan nilai (v).

Pemisahan kepala:

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

Kaedah ini membentuk semula input x ke dalam bentuk (batch_size, num_heads, seq_length, d_k). Ia membolehkan model memproses pelbagai kepala perhatian serentak, yang membolehkan pengiraan selari.

menggabungkan kepala:

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

Selepas memohon perhatian kepada setiap kepala secara berasingan, kaedah ini menggabungkan hasilnya kembali ke dalam satu tensor bentuk (batch_size, seq_length, d_model). Ini menyediakan keputusan untuk pemprosesan selanjutnya.

Kaedah ke hadapan:

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        # Ensure that the model dimension (d_model) is divisible by the number of heads
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        
        # Initialize dimensions
        self.d_model = d_model # Model's dimension
        self.num_heads = num_heads # Number of attention heads
        self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
        
        # Linear layers for transforming inputs
        self.W_q = nn.Linear(d_model, d_model) # Query transformation
        self.W_k = nn.Linear(d_model, d_model) # Key transformation
        self.W_v = nn.Linear(d_model, d_model) # Value transformation
        self.W_o = nn.Linear(d_model, d_model) # Output transformation
        
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        # Calculate attention scores
        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        # Apply mask if provided (useful for preventing attention to certain parts like padding)
        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
        
        # Softmax is applied to obtain attention probabilities
        attn_probs = torch.softmax(attn_scores, dim=-1)
        
        # Multiply by values to obtain the final output
        output = torch.matmul(attn_probs, V)
        return output
        
    def split_heads(self, x):
        # Reshape the input to have num_heads for multi-head attention
        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):
        # Combine the multiple heads back to original shape
        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=None):
        # Apply linear transformations and split heads
        Q = self.split_heads(self.W_q(Q))
        K = self.split_heads(self.W_k(K))
        V = self.split_heads(self.W_v(V))
        
        # Perform scaled dot-product attention
        attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
        
        # Combine heads and apply output transformation
        output = self.W_o(self.combine_heads(attn_output))
        return output

Kaedah hadapan adalah di mana pengiraan sebenar berlaku:

1. Gunakan transformasi linear: Pertanyaan (Q), Kekunci (K), dan Nilai (V) pertama kali diluluskan melalui transformasi linear menggunakan berat yang ditakrifkan dalam inisialisasi.
2. Kepala Split: Q, K, V yang diubah dibahagikan kepada beberapa kepala menggunakan kaedah split_heads.
3. Memohon perhatian dot-produk berskala: Kaedah scaled_dot_product_attention dipanggil pada kepala berpecah.
4. Gabungkan kepala: Hasil dari setiap kepala digabungkan kembali ke dalam tensor tunggal menggunakan kaedah Combine_heads.
5. Gunakan transformasi output: Akhirnya, tensor gabungan diluluskan melalui transformasi linear output.

Secara ringkasnya, kelas multiheadattention merangkumi mekanisme perhatian multi-kepala yang biasa digunakan dalam model pengubah. Ia menjaga memisahkan input ke dalam pelbagai kepala perhatian, memohon perhatian kepada setiap kepala, dan kemudian menggabungkan hasilnya. Dengan berbuat demikian, model dapat menangkap pelbagai hubungan dalam data input pada skala yang berbeza, meningkatkan keupayaan ekspresif model.

Rangkaian Feed-Forward Position-bijak

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):

definisi kelas:

def scaled_dot_product_attention(self, Q, K, V, mask=None):

Kelas adalah subclass Nn.Module Pytorch, yang bermaksud ia akan mewarisi semua fungsi yang diperlukan untuk bekerja dengan lapisan rangkaian saraf.

Inisialisasi:

pip3 install torch torchvision torchaudio

1. d_model: dimensi input dan output model.
2. d_ff: dimensi lapisan dalaman dalam rangkaian feed-forward.
3. self.fc1 dan self.fc2: Dua lapisan yang disambungkan sepenuhnya (linear) dengan dimensi input dan output seperti yang ditakrifkan oleh d_model dan d_ff.
4. self.relu: relu (unit linear yang diperbetulkan) fungsi pengaktifan, yang memperkenalkan bukan linear antara kedua-dua lapisan linear.

Kaedah ke hadapan:

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

1. x: input ke rangkaian ke hadapan.
2. self.fc1 (x): Input pertama kali dilalui melalui lapisan linear pertama (FC1).
3. self.relu (...): Output FC1 kemudian dilalui melalui fungsi pengaktifan relu. Relu menggantikan semua nilai negatif dengan sifar, memperkenalkan bukan linear ke dalam model.
4. self.fc2 (...): Output diaktifkan kemudian dilalui melalui lapisan linear kedua (FC2), menghasilkan output akhir.

Ringkasnya, kelas PositionwiseFeedForward mentakrifkan rangkaian neural feed-forward kedudukan yang terdiri daripada dua lapisan linear dengan fungsi pengaktifan relu di antara. Dalam konteks model pengubah, rangkaian ke hadapan ini digunakan untuk setiap kedudukan secara berasingan dan identik. Ia membantu dalam mengubah ciri -ciri yang dipelajari oleh mekanisme perhatian dalam pengubah, bertindak sebagai langkah pemprosesan tambahan untuk output perhatian.

pengekodan posisi

Pengekodan posisi digunakan untuk menyuntik maklumat kedudukan setiap token dalam urutan input. Ia menggunakan fungsi sinus dan kosinus frekuensi yang berbeza untuk menghasilkan pengekodan kedudukan.

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

definisi kelas:

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        # Ensure that the model dimension (d_model) is divisible by the number of heads
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        
        # Initialize dimensions
        self.d_model = d_model # Model's dimension
        self.num_heads = num_heads # Number of attention heads
        self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
        
        # Linear layers for transforming inputs
        self.W_q = nn.Linear(d_model, d_model) # Query transformation
        self.W_k = nn.Linear(d_model, d_model) # Key transformation
        self.W_v = nn.Linear(d_model, d_model) # Value transformation
        self.W_o = nn.Linear(d_model, d_model) # Output transformation
        
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        # Calculate attention scores
        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        # Apply mask if provided (useful for preventing attention to certain parts like padding)
        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
        
        # Softmax is applied to obtain attention probabilities
        attn_probs = torch.softmax(attn_scores, dim=-1)
        
        # Multiply by values to obtain the final output
        output = torch.matmul(attn_probs, V)
        return output
        
    def split_heads(self, x):
        # Reshape the input to have num_heads for multi-head attention
        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):
        # Combine the multiple heads back to original shape
        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=None):
        # Apply linear transformations and split heads
        Q = self.split_heads(self.W_q(Q))
        K = self.split_heads(self.W_k(K))
        V = self.split_heads(self.W_v(V))
        
        # Perform scaled dot-product attention
        attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
        
        # Combine heads and apply output transformation
        output = self.W_o(self.combine_heads(attn_output))
        return output

Kelas ditakrifkan sebagai subclass Nn.Module Pytorch, yang membolehkannya digunakan sebagai lapisan pytorch standard.

Inisialisasi:

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):

d_model: dimensi input model.
max_seq_length: Panjang maksimum urutan yang mana pengekodan posisi pra-komput.
pe: tensor yang dipenuhi dengan sifar, yang akan dihuni dengan pengekodan kedudukan.
Posisi: Tensor yang mengandungi indeks kedudukan untuk setiap kedudukan dalam urutan.
div_term: Istilah yang digunakan untuk skala indeks kedudukan dengan cara tertentu.
Fungsi sinus digunakan untuk indeks walaupun dan fungsi kosinus ke indeks ganjil PE.
Akhirnya, PE didaftarkan sebagai penampan, yang bermaksud ia akan menjadi sebahagian daripada keadaan modul tetapi tidak akan dianggap sebagai parameter yang boleh dilatih.

Kaedah ke hadapan:

def scaled_dot_product_attention(self, Q, K, V, mask=None):

Kaedah ke hadapan hanya menambah pengekodan kedudukan ke input x.

Ia menggunakan unsur -unsur X.size (1) pertama PE untuk memastikan bahawa pengekodan posisi sesuai dengan panjang urutan sebenar x.

Ringkasan

Kelas PosisiCoding menambah maklumat mengenai kedudukan token dalam urutan. Oleh kerana model pengubah tidak mempunyai pengetahuan yang melekat pada susunan token (disebabkan oleh mekanisme perhatiannya sendiri), kelas ini membantu model untuk mempertimbangkan kedudukan token dalam urutan. Fungsi sinusoidal yang digunakan dipilih untuk membolehkan model dengan mudah belajar untuk menghadiri kedudukan relatif, kerana mereka menghasilkan pengekodan yang unik dan lancar untuk setiap kedudukan dalam urutan.

3. Membina Blok Pengekod

Rajah 2. Bahagian pengekod rangkaian pengubah (sumber: imej dari kertas asal)

pip3 install torch torchvision torchaudio

definisi kelas:

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

Kelas ditakrifkan sebagai subclass Nn.Module Pytorch, yang bermaksud ia boleh digunakan sebagai blok bangunan untuk rangkaian saraf di Pytorch.

Inisialisasi:

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

Parameter:

1. d_model: dimensi input.
2. num_heads: bilangan kepala perhatian dalam perhatian multi-kepala.
3. d_ff: Dimensi lapisan dalaman dalam rangkaian feed-forward yang bijak.
4. dropout: Kadar dropout yang digunakan untuk regularization.

Komponen:

1. self.self_attn: Mekanisme perhatian multi-kepala.
2. self.feed_forward: Rangkaian neural feed-forward kedudukan yang bijak.
3. self.norm1 dan self.Norm2: normalisasi lapisan, digunakan untuk melicinkan input lapisan.
4. self.dropout: Lapisan dropout, digunakan untuk mengelakkan overfitting dengan menetapkan secara rawak beberapa pengaktifan kepada sifar semasa latihan.

Kaedah ke hadapan:

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        # Ensure that the model dimension (d_model) is divisible by the number of heads
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        
        # Initialize dimensions
        self.d_model = d_model # Model's dimension
        self.num_heads = num_heads # Number of attention heads
        self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
        
        # Linear layers for transforming inputs
        self.W_q = nn.Linear(d_model, d_model) # Query transformation
        self.W_k = nn.Linear(d_model, d_model) # Key transformation
        self.W_v = nn.Linear(d_model, d_model) # Value transformation
        self.W_o = nn.Linear(d_model, d_model) # Output transformation
        
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        # Calculate attention scores
        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        # Apply mask if provided (useful for preventing attention to certain parts like padding)
        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
        
        # Softmax is applied to obtain attention probabilities
        attn_probs = torch.softmax(attn_scores, dim=-1)
        
        # Multiply by values to obtain the final output
        output = torch.matmul(attn_probs, V)
        return output
        
    def split_heads(self, x):
        # Reshape the input to have num_heads for multi-head attention
        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):
        # Combine the multiple heads back to original shape
        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=None):
        # Apply linear transformations and split heads
        Q = self.split_heads(self.W_q(Q))
        K = self.split_heads(self.W_k(K))
        V = self.split_heads(self.W_v(V))
        
        # Perform scaled dot-product attention
        attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
        
        # Combine heads and apply output transformation
        output = self.W_o(self.combine_heads(attn_output))
        return output

input:

1. x: input ke lapisan encoder.
2. topeng: topeng pilihan untuk mengabaikan bahagian tertentu input.

Langkah -langkah pemprosesan:

1. Pencegahan diri: Input x diluluskan melalui mekanisme ketentuan diri multi-kepala.
2. Tambah & Normalkan (selepas perhatian): Output perhatian ditambah kepada input asal (sambungan sisa), diikuti dengan putus sekolah dan normalisasi menggunakan Norm1.
3. Rangkaian Feed-Forward: Output dari langkah sebelumnya diluluskan melalui rangkaian Feed-Forward yang bijak.
4. Tambah & Normalkan (selepas suapan ke hadapan): Sama seperti Langkah 2, output ke hadapan suapan ditambahkan ke input tahap ini (sambungan sisa), diikuti dengan keciciran dan normalisasi menggunakan Norm2.
5. output: Tensor yang diproses dikembalikan sebagai output lapisan encoder.

Ringkasan:

Kelas Encoderlayer mentakrifkan satu lapisan pengekod pengubah. Ia merangkumi mekanisme ketentuan diri pelbagai kepala diikuti oleh rangkaian saraf ke hadapan yang bijak, dengan sambungan sisa, normalisasi lapisan, dan keciciran yang digunakan sesuai. Komponen ini bersama -sama membolehkan pengekod untuk menangkap hubungan kompleks dalam data input dan mengubahnya menjadi perwakilan yang berguna untuk tugas hiliran. Biasanya, pelbagai lapisan pengekod tersebut disusun untuk membentuk bahagian pengekod lengkap model pengubah.

4. Membina blok penyahkod

pip3 install torch torchvision torchaudio

definisi kelas:

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

Inisialisasi:

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

Parameter :

d_model: dimensi input.
num_heads: bilangan kepala perhatian dalam perhatian multi-kepala.
d_ff: dimensi lapisan dalaman dalam rangkaian ke hadapan.
dropout: Kadar dropout untuk regularization.

Komponen :

self.self_attn: Mekanisme perhatian diri multi-kepala untuk urutan sasaran.
self.cross_attn: Mekanisme perhatian multi-kepala yang menghadiri output encoder.
self.feed_forward: Rangkaian neural feed-forward kedudukan yang bijak.
self.norm1, self.norm2, self.norm3: Komponen normalisasi lapisan.
self.dropout: Lapisan dropout untuk regularization.

forward kaedah :

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        # Ensure that the model dimension (d_model) is divisible by the number of heads
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        
        # Initialize dimensions
        self.d_model = d_model # Model's dimension
        self.num_heads = num_heads # Number of attention heads
        self.d_k = d_model // num_heads # Dimension of each head's key, query, and value
        
        # Linear layers for transforming inputs
        self.W_q = nn.Linear(d_model, d_model) # Query transformation
        self.W_k = nn.Linear(d_model, d_model) # Key transformation
        self.W_v = nn.Linear(d_model, d_model) # Value transformation
        self.W_o = nn.Linear(d_model, d_model) # Output transformation
        
    def scaled_dot_product_attention(self, Q, K, V, mask=None):
        # Calculate attention scores
        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        # Apply mask if provided (useful for preventing attention to certain parts like padding)
        if mask is not None:
            attn_scores = attn_scores.masked_fill(mask == 0, -1e9)
        
        # Softmax is applied to obtain attention probabilities
        attn_probs = torch.softmax(attn_scores, dim=-1)
        
        # Multiply by values to obtain the final output
        output = torch.matmul(attn_probs, V)
        return output
        
    def split_heads(self, x):
        # Reshape the input to have num_heads for multi-head attention
        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):
        # Combine the multiple heads back to original shape
        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=None):
        # Apply linear transformations and split heads
        Q = self.split_heads(self.W_q(Q))
        K = self.split_heads(self.W_k(K))
        V = self.split_heads(self.W_v(V))
        
        # Perform scaled dot-product attention
        attn_output = self.scaled_dot_product_attention(Q, K, V, mask)
        
        # Combine heads and apply output transformation
        output = self.W_o(self.combine_heads(attn_output))
        return output

input :

x: input ke lapisan penyahkod.
enc_output: output dari pengekod yang sepadan (digunakan dalam langkah silang).
src_mask: topeng sumber untuk mengabaikan bahagian tertentu dari output encoder.
tgt_mask: topeng sasaran untuk mengabaikan bahagian tertentu input penyahkod.

Langkah -langkah pemprosesan:

1. Pencegahan diri pada urutan sasaran: Input x diproses melalui mekanisme perhatian diri.
2. Tambah & Normalisasi (selepas penunjuk diri): Output dari perhatian diri ditambah kepada x asal, diikuti dengan putus sekolah dan normalisasi menggunakan Norm1.
3. Pencegahan silang dengan output encoder: Output yang dinormalisasi dari langkah sebelumnya diproses melalui mekanisme penerangan silang yang menghadiri enc_output output encoder.
4. Tambah & Normalisasi (selepas penerangan silang): Output dari penerangan silang ditambah ke input tahap ini, diikuti dengan putus sekolah dan normalisasi menggunakan Norm2.
5. Rangkaian Feed-Forward: Output dari langkah sebelumnya dilalui melalui rangkaian ke hadapan.
6. Tambah & Normalkan (selepas suapan ke hadapan): Output ke hadapan suapan ditambah kepada input tahap ini, diikuti dengan putus sekolah dan normalisasi menggunakan norm3.
7. output: Tensor yang diproses dikembalikan sebagai output lapisan penyahkod.

Ringkasan:

Kelas Decoderlayer mentakrifkan satu lapisan penyahkod pengubah. Ia terdiri daripada mekanisme perhatian diri pelbagai kepala, mekanisme penangkapan silang pelbagai (yang menghadiri output pengekod), rangkaian saraf ke hadapan yang bijak, dan sambungan sisa yang sama, normalisasi lapisan, dan lapisan dropout. Gabungan ini membolehkan penyahkod untuk menghasilkan output yang bermakna berdasarkan perwakilan encoder, dengan mengambil kira kedua -dua urutan sasaran dan urutan sumber. Seperti pengekod, lapisan penyahkod berbilang biasanya disusun untuk membentuk bahagian penyahkod lengkap model pengubah.

Seterusnya, blok pengekod dan penyahkod dibawa bersama untuk membina model pengubah komprehensif.

5. Menggabungkan lapisan pengekod dan penyahkod untuk membuat rangkaian pengubah lengkap

Rajah 4. Rangkaian Transformer (Sumber: Imej dari Kertas Asal)

pip3 install torch torchvision torchaudio

definisi kelas:

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

Inisialisasi:

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

Pembina mengambil parameter berikut:

src_vocab_size: saiz perbendaharaan kata sumber.
TGT_VOCAB_SIZE: Saiz perbendaharaan kata sasaran.
d_model: dimensi embedding model.
num_heads: bilangan kepala perhatian dalam mekanisme perhatian multi-kepala.
num_layers: bilangan lapisan untuk kedua -dua pengekod dan penyahkod.
d_ff: dimensi lapisan dalaman dalam rangkaian feed-forward.
max_seq_length: Panjang urutan maksimum untuk pengekodan kedudukan.
dropout: kadar dropout untuk regularization.

dan ia mentakrifkan komponen berikut:

1. self.encoder_embedding: Lapisan embedding untuk urutan sumber.
2. self.decoder_embedding: Lapisan embedding untuk urutan sasaran.
3. self.positional_encoding: komponen pengekodan posisi.
4. self.encoder_layers: senarai lapisan pengekod.
5. self.decoder_layers: senarai lapisan penyahkod.
6. self.fc: Pemetaan lapisan yang disambungkan sepenuhnya (linear) untuk mensasarkan saiz perbendaharaan kata.
7. self.dropout: lapisan dropout.

menghasilkan kaedah topeng:

pip3 install torch torchvision torchaudio

Kaedah ini digunakan untuk membuat topeng untuk urutan sumber dan sasaran, memastikan bahawa token padding diabaikan dan token masa depan tidak dapat dilihat semasa latihan untuk urutan sasaran.

Kaedah ke hadapan:

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

Kaedah ini mentakrifkan pas hadapan untuk pengubah, mengambil urutan sumber dan sasaran dan menghasilkan ramalan output.

1. Pengekodan input dan pengekodan kedudukan: Sumber dan urutan sasaran pertama kali tertanam menggunakan lapisan embedding masing -masing dan kemudian ditambah ke pengekodan kedudukan mereka.
2. lapisan pengekod: urutan sumber dilalui melalui lapisan encoder, dengan output encoder akhir yang mewakili urutan sumber yang diproses.
3. Lapisan Decoder: Urutan sasaran dan output encoder dilalui melalui lapisan penyahkod, mengakibatkan output decoder.
4. Lapisan Linear Akhir: Output decoder dipetakan ke saiz perbendaharaan kata sasaran menggunakan lapisan yang disambungkan sepenuhnya (linear).

output:

output akhir adalah tensor yang mewakili ramalan model untuk urutan sasaran.

Ringkasan:

Kelas Transformer menyatukan pelbagai komponen model pengubah, termasuk embeddings, pengekodan kedudukan, lapisan encoder, dan lapisan penyahkod. Ia menyediakan antara muka yang mudah untuk latihan dan kesimpulan, merangkumi kerumitan perhatian multi-kepala, rangkaian ke hadapan, dan normalisasi lapisan.

Pelaksanaan ini mengikuti seni bina pengubah standard, menjadikannya sesuai untuk tugas-tugas urutan-ke-urutan seperti terjemahan mesin, ringkasan teks, dan lain-lain. Kemasukan pelekat memastikan model itu mematuhi kebergantungan kausal dalam urutan, mengabaikan token padding dan menghalang kebocoran maklumat dari token masa depan.

Langkah -langkah berurutan ini memberi kuasa kepada model pengubah untuk memproses urutan input dengan cekap dan menghasilkan urutan output yang sepadan.

Melatih Model Transformer Pytorch

Penyediaan data sampel

Untuk tujuan ilustrasi, dataset dummy akan dibuat dalam contoh ini. Walau bagaimanapun, dalam senario praktikal, dataset yang lebih besar akan digunakan, dan prosesnya akan melibatkan pra -proses teks bersama -sama dengan penciptaan pemetaan perbendaharaan kata untuk kedua -dua sumber sumber dan sasaran.

pip3 install torch torchvision torchaudio

HyperParameters:

Nilai -nilai ini menentukan seni bina dan tingkah laku model pengubah:

src_vocab_size, tgt_vocab_size: saiz perbendaharaan kata untuk urutan sumber dan sasaran, kedua -duanya ditetapkan kepada 5000.
d_model: dimensi embedding model, ditetapkan kepada 512.
num_heads: bilangan kepala perhatian dalam mekanisme perhatian multi-kepala, ditetapkan kepada 8.
num_layers: bilangan lapisan untuk kedua -dua pengekod dan penyahkod, ditetapkan ke 6.
d_ff: dimensi lapisan dalaman dalam rangkaian ke hadapan, ditetapkan ke 2048.
max_seq_length: Panjang urutan maksimum untuk pengekodan kedudukan, ditetapkan kepada 100.
dropout: Kadar dropout untuk regularization, ditetapkan kepada 0.1.

Mewujudkan contoh pengubah:

conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia

Baris ini mewujudkan contoh kelas pengubah, memulakannya dengan hiperparameter yang diberikan. Contohnya akan mempunyai seni bina dan tingkah laku yang ditakrifkan oleh hiperparameter ini.

Menjana Data Sampel Rawak:

baris berikut menjana sumber rawak dan urutan sasaran:

src_data: Integer rawak antara 1 dan src_vocab_size, mewakili kumpulan urutan sumber dengan bentuk (64, max_seq_length).
tgt_data: Integer rawak antara 1 dan tgt_vocab_size, mewakili kumpulan urutan sasaran dengan bentuk (64, max_seq_length).
Urutan rawak ini boleh digunakan sebagai input kepada model pengubah, mensimulasikan kumpulan data dengan 64 contoh dan urutan panjang 100.

Ringkasan:

Coretan kod menunjukkan cara memulakan model pengubah dan menghasilkan sumber rawak dan urutan sasaran yang boleh dimasukkan ke dalam model. Hiperparameter yang dipilih menentukan struktur dan sifat tertentu pengubah. Persediaan ini boleh menjadi sebahagian daripada skrip yang lebih besar di mana model dilatih dan dinilai pada tugas-tugas urutan-ke-urutan sebenar, seperti terjemahan mesin atau ringkasan teks.

Latihan model

Seterusnya, model akan dilatih menggunakan data sampel yang disebutkan di atas. Walau bagaimanapun, dalam senario dunia nyata, dataset yang lebih besar akan digunakan, yang biasanya akan dibahagikan kepada set yang berbeza untuk tujuan latihan dan pengesahan.

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

Fungsi kehilangan dan pengoptimum:

kriteria = nn.crossentropyloss (ignife_index = 0): mentakrifkan fungsi kerugian sebagai kehilangan silang entropi. Argumen Obending_index ditetapkan kepada 0, yang bermaksud kerugian tidak akan mempertimbangkan sasaran dengan indeks 0 (biasanya dikhaskan untuk token padding).
optimizer = optim.adam (...): Menentukan pengoptimasi sebagai Adam dengan kadar pembelajaran 0.0001 dan nilai beta khusus.

Mod Latihan Model:

1. transformer.train (): Menetapkan model pengubah ke mod latihan, membolehkan tingkah laku seperti dropout yang hanya digunakan semasa latihan.

gelung latihan:

coretan kod melatih model untuk 100 zaman menggunakan gelung latihan biasa:

1. untuk Epoch dalam julat (100): Melangkah lebih dari 100 zaman latihan.
2. optimizer.zero_grad (): membersihkan kecerunan dari lelaran sebelumnya.
3. output = transformer (src_data, tgt_data [:,: -1]): Meluluskan data sumber dan data sasaran (tidak termasuk token terakhir dalam setiap urutan) melalui pengubah. Ini adalah perkara biasa dalam tugas-tugas urutan-ke-urutan di mana sasaran dipindahkan oleh satu token.
4. kerugian = kriteria (...): Mengira kerugian antara ramalan model dan data sasaran (tidak termasuk token pertama dalam setiap urutan). Kerugian dikira dengan membentuk semula data ke dalam tensor satu dimensi dan menggunakan fungsi kehilangan silang entropi.
5. loss.backward (): Mengira kecerunan kerugian berkenaan dengan parameter model.
6. Optimizer.Step (): Kemas kini parameter model menggunakan kecerunan yang dikira.
7. cetak (f "epoch: {epoch 1}, kehilangan: {loss.item ()}"): Mencetak nombor zaman semasa dan nilai kerugian untuk zaman itu.

Ringkasan:

Coretan kod ini melatih model pengubah pada sumber dan urutan sasaran yang dijana secara rawak untuk 100 zaman. Ia menggunakan pengoptimuman Adam dan fungsi kehilangan silang entropi. Kerugian dicetak untuk setiap zaman, membolehkan anda memantau kemajuan latihan. Dalam senario dunia sebenar, anda akan menggantikan sumber rawak dan urutan sasaran dengan data sebenar dari tugas anda, seperti terjemahan mesin.

Penilaian Prestasi Model Transformer

Selepas melatih model, prestasinya boleh dinilai pada dataset pengesahan atau dataset ujian. Berikut adalah contoh bagaimana ini dapat dilakukan:

pip3 install torch torchvision torchaudio

Mod penilaian:

1. transformer.eval (): Meletakkan model pengubah dalam mod penilaian. Ini penting kerana ia mematikan tingkah laku tertentu seperti keciciran yang hanya digunakan semasa latihan.

Menjana data pengesahan rawak:

1. val_src_data: Integer rawak antara 1 dan src_vocab_size, mewakili kumpulan urutan sumber pengesahan dengan bentuk (64, max_seq_length).
2. val_tgt_data: Integer rawak antara 1 dan TGT_VOCAB_SIZE, mewakili satu kumpulan sasaran sasaran pengesahan dengan bentuk (64, max_seq_length).

gelung pengesahan:

1. dengan obor.no_grad (): Melumpuhkan pengiraan kecerunan, kerana kita tidak perlu mengira kecerunan semasa pengesahan. Ini dapat mengurangkan penggunaan memori dan mempercepatkan perhitungan.
2. val_output = transformer (val_src_data, val_tgt_data [:,: -1]): melepasi data sumber pengesahan dan data sasaran pengesahan (tidak termasuk token terakhir dalam setiap urutan) melalui pengubah.
val_loss = kriteria (...): Mengira kerugian antara ramalan model dan data sasaran pengesahan (tidak termasuk token pertama dalam setiap urutan). Kerugian dikira dengan membentuk semula data ke dalam tensor satu dimensi dan menggunakan fungsi kehilangan entropi yang telah ditetapkan sebelumnya.
cetak (f "kehilangan pengesahan: {val_loss.item ()}"): Mencetak nilai kehilangan pengesahan.

Ringkasan:

Coretan kod ini menilai model pengubah pada dataset pengesahan yang dijana secara rawak, mengira kehilangan pengesahan, dan mencetaknya. Dalam senario dunia sebenar, data pengesahan rawak harus digantikan dengan data pengesahan sebenar dari tugas yang anda sedang kerjakan. Kerugian pengesahan dapat memberi anda petunjuk bagaimana model anda melaksanakan pada data yang tidak kelihatan, yang merupakan ukuran kritikal keupayaan generalisasi model.

3

kesimpulan dan sumber selanjutnya

Kesimpulannya, tutorial ini menunjukkan cara membina model pengubah menggunakan pytorch, salah satu alat yang paling serba boleh untuk pembelajaran mendalam. Dengan kapasiti mereka untuk bersesuaian dan keupayaan untuk menangkap kebergantungan jangka panjang dalam data, transformer mempunyai potensi besar dalam pelbagai bidang, terutama tugas NLP seperti terjemahan, ringkasan, dan analisis sentimen.

Bagi mereka yang bersemangat untuk memperdalam pemahaman mereka tentang konsep dan teknik pembelajaran mendalam, pertimbangkan untuk meneroka kursus pembelajaran mendalam dengan keras di DataCamp. Anda juga boleh membaca tentang membina rangkaian saraf mudah dengan pytorch dalam tutorial yang berasingan.

Atas ialah kandungan terperinci Panduan Komprehensif untuk Membangun Model Transformer dengan Pytorch. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!