Pytorchで変圧器モデルを構築するための包括的なガイド

このチュートリアルの目的は、Pytorchを使用してトランスモデルを構築する方法を包括的に理解することです。トランスは、現代の機械学習で最も強力なモデルの1つです。彼らは、特に言語翻訳やテキストの要約などの自然言語処理（NLP）タスクにおいて、分野に革命をもたらしました。長期的な依存関係と並列計算を処理する能力により、これらのタスクの長期的なメモリ（LSTM）ネットワークは、これらのタスクの変圧器に置き換えられています。 このガイドに使用されているツールは、変圧器を構築するために使用されているツールは、そのシンプルさ、汎用性、効率で知られる人気のオープンソース機械学習ライブラリであるPytorchです。動的な計算グラフと広範なライブラリにより、Pytorchは機械学習と人工知能の領域の研究者と開発者にとって頼りになりました。

Pytorchに不慣れな人のために、Datacampのコースへの訪問であるPytorchでの深い学習の紹介は、しっかりとした接地に推奨されます。

紙で最初に導入された注意は、Vaswaniらによって必要なすべてです、トランスはそれ以来、それらのユニークな設計と効果のために多くのNLPタスクの基礎になりました。 トランスの中心にあるのは、注意メカニズム、特に「自己関節」の概念であり、モデルが入力データのさまざまな部分を比較検討し、優先順位を付けることができます。このメカニズムは、トランスがデータの長距離依存関係を管理できるようにするものです。これは、モデルが出力を生成するときに入力のさまざまな部分に焦点を合わせることを可能にする重み付けスキームです。

このメカニズムにより、モデルは入力シーケンス内の異なる単語または機能を考慮し、それぞれが特定の出力を生成するための重要性を意味する「重み」を割り当てることができます。 たとえば、文の翻訳タスクでは、特定の単語を翻訳しながら、モデルは、ターゲットワードに文法的または意味的に関連する単語に、より高い注意の重みを割り当てる場合があります。このプロセスにより、変圧器は、シーケンス内の互いからの距離に関係なく、単語または機能の間の依存関係をキャプチャできます。 NLPの分野におけるトランスの影響を誇張することはできません。彼らは多くのタスクで従来のモデルよりも優れており、より微妙な方法で人間の言語を理解し生成するための優れた能力を示しています。

NLPをより深く理解するために、Pythonコースでの自然言語処理のDatacampの紹介が推奨されるリソースです。

Pytorch

のセットアップ

トランスの構築に飛び込む前に、作業環境を正しくセットアップすることが不可欠です。何よりもまず、Pytorchをインストールする必要があります。 Pytorch（現在の安定したバージョン-2.0.1）は、PIPまたはCondaパッケージマネージャーを介して簡単にインストールできます。

PIPの場合、コマンドを使用してください：

condaの場合、コマンドを使用してください：

pip3 install torch torchvision torchaudio

PytorchをCPUで使用することについては、Pytorchドキュメントを親切にご覧ください。 さらに、さらに、深い学習の概念を基本的に理解することは有益です。これらは、変圧器の運用を理解するための基本であるためです。復習が必要な人にとって、PythonのDatacampコースディープラーニングは、深い学習の重要な概念をカバーする貴重なリソースです。

Pytorch

でトランスモデルを構築します

トランスモデルを構築するには、次の手順が必要です。

ライブラリとモジュールのインポート

基本的なビルディングブロックの定義 - マルチヘッドの注意、位置ごとのフィードフォワードネットワーク、位置エンコーディング

エンコーダーブロックの構築

1. デコーダーブロックの構築
2. エンコーダーレイヤーとデコーダーレイヤーを組み合わせて完全な変圧器ネットワークを作成する
1。必要なライブラリとモジュールのインポート
コア機能のためにPytorchライブラリのインポート、ニューラルネットワークの作成のためのニューラルネットワークモジュール、トレーニングネットワークの最適化モジュール、およびデータの取り扱いのためのデータユーティリティ機能から始めます。さらに、数学操作用の標準のPython Mathモジュールと、複雑なオブジェクトのコピーを作成するためのコピーモジュールをインポートします。
5. これらのツールは、モデルのアーキテクチャを定義し、データを管理し、トレーニングプロセスを確立するための基盤を設定します。

2。基本的なビルディングブロックの定義：マルチヘッドの注意、位置ごとのフィードフォワードネットワーク、位置エンコーディング

マルチヘッドの注意

マルチヘッド注意メカニズムは、シーケンス内の各位置のペア間の注意を計算します。入力シーケンスのさまざまな側面をキャプチャする複数の「注意ヘッド」で構成されています。

マルチヘッドの注意について詳しく知るには、この注意メカニズムセクションの大規模な言語モデル（LLMS）概念コースをご覧ください。

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

図1。マルチヘッドの注意（出典：著者によって作成された画像）

クラスの定義と初期化：

クラスは、Pytorchのnn.moduleのサブクラスとして定義されています。

d_model：入力の次元。 num_heads：入力を分割するための注意の数。

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

初期化は、d_modelがnum_headsによって分割可能であるかどうかをチェックし、クエリ、キー、値、および出力の変換ウェイトを定義します。

スケーリングされたDOT-Product Atterness：

pip3 install torch torchvision torchaudio

1. 注意スコアの計算：attn_scores = torch.matmul（q、k.transpose（-2、-1）） / math.sqrt（self.d_k）。ここで、注意スコアは、クエリ（q）とキー（k）のDOT積を取得し、キーディメンション（D_K）の平方根でスケーリングすることによって計算されます。 マスクの適用：マスクが提供されている場合、特定の値をマスクするための注意スコアに適用されます。
注意の計算重量：注意スコアはSoftMax関数を通して渡され、それらを1に合計する確率に変換します。
2. 出力の計算：注意の最終出力は、注意の重みに値（v）を掛けることによって計算されます。
3. ヘッドの分割：

このメソッドは、入力xを形状（batch_size、num_heads、seq_length、d_k）に再形成します。これにより、モデルは複数の注意ヘッドを同時に処理し、並列計算を可能にします。 ヘッドの組み合わせ：

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

各ヘッドに個別に注意を合わせた後、この方法は結果を単一のテンソルの形状（batch_size、seq_length、d_model）に結合します。これにより、結果がさらに処理されるように準備します。

フォワードメソッド：

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

フォワードメソッドは、実際の計算が発生する場所です：

線形変換の適用：クエリ（q）、キー（k）、および値（v）は、初期化で定義された重みを使用して、最初に線形変換を通過します。

スプリットヘッド：変換されたq、k、vは、split_headsメソッドを使用して複数のヘッドに分割されます。

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

Scaled Dot-Productの注意：Scaled_dot_product_attentionメソッドは、スプリットヘッドで呼び出されます。

ヘッドの組み合わせ：各ヘッドの結果は、combine_headsメソッドを使用して単一のテンソルに戻します。

出力変換の適用：最後に、合計テンソルは出力線形変換を通過します。

1. 要約すると、マルチヘッドマットクラスは、変圧器モデルで一般的に使用されるマルチヘッド注意メカニズムをカプセル化します。入力を複数の注意ヘッドに分割し、各ヘッドに注意を向け、結果を組み合わせることができます。そうすることで、モデルはさまざまなスケールで入力データのさまざまな関係をキャプチャし、モデルの表現力を向上させることができます。
ポジションごとのフィードフォワードネットワーク
3. クラスの定義：
このクラスは、PytorchのNn.moduleのサブクラスです。つまり、ニューラルネットワークレイヤーを使用するために必要なすべての機能を継承します。

初期化：

pip3 install torch torchvision torchaudio

1. d_model：モデルの入力と出力の次元。
2. d_ff：フィードフォワードネットワーク内の内側のレイヤーの次元。
3. self.fc1およびself.fc2：d_modelとd_ffで定義されている入力および出力寸法を備えた2つの完全に接続された（線形）レイヤー。
self.relu：relu（修正線形単位）活性化関数は、2つの線形層の間に非線形性を導入します。

フォワードメソッド：

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

x：フィードフォワードネットワークへの入力。

1. self.fc1（x）：入力は最初に最初の線形層（fc1）を通過します。
self.relu（...）：FC1の出力は、Reluアクティベーション関数を通過します。 reluはすべての負の値をゼロに置き換え、モデルに非線形性を導入します。
2. self.fc2（...）：アクティブ化された出力は2番目の線形層（FC2）を通過し、最終出力を生成します。
要約すると、PositionWiseFeedForwardクラスは、その間にRELUアクティベーション関数を持つ2つの線形層で構成される位置ごとのフィードフォワードニューラルネットワークを定義します。トランスモデルのコンテキストでは、このフィードフォワードネットワークは各位置に個別に適用されます。トランス内の注意メカニズムによって学習された機能を変換するのに役立ち、注意出力の追加処理ステップとして機能します。
3. 位置エンコーディング
4. 位置エンコーディングは、入力シーケンスに各トークンの位置情報を注入するために使用されます。さまざまな周波数の正弦およびコサイン関数を使用して、位置エンコーディングを生成します。

クラスの定義：

クラスは、Pytorchのnn.moduleのサブクラスとして定義されており、標準のPytorch層として使用できるようにします。

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

初期化：

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

d_model：モデルの入力の次元。

max_seq_length：位置エンコーディングが事前に計算されるシーケンスの最大長。

PE：ゼロで満たされたテンソル。位置エンコーディングが入力されます。 位置：シーケンス内の各位置の位置インデックスを含むテンソル。

div_term：特定の方法で位置インデックスを拡大するために使用される用語。

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

正弦関数は、均一なインデックスに適用され、コサイン関数はPEの奇妙なインデックスに適用されます。
1. 最後に、PEはバッファとして登録されます。つまり、モジュールの状態の一部になりますが、トレーニング可能なパラメーターとは見なされません。
2. フォワードメソッド：
フォワードメソッドは、ポジションエンコーディングを入力xに追加するだけです。
PEの最初のx.size（1）要素を使用して、位置エンコーディングがxの実際のシーケンス長と一致するようにします。
6. 概要

7. ポジショニングクラスは、シーケンス内のトークンの位置に関する情報を追加します。変圧器モデルにはトークンの順序に関する固有の知識が欠けているため（その自己関節メカニズムのため）、このクラスはモデルがシーケンス内のトークンの位置を考慮するのに役立ちます。使用される正弦波関数は、モデルがシーケンス内の各位置に対してユニークでスムーズなエンコードを生成するため、相対的な位置に簡単に対応できるようにするために選択されます。

   3。エンコーダーブロックの構築

   

   図2。トランスネットワークのエンコーダー部分（出典：元の論文からの画像）

   pip3 install torch torchvision torchaudio

   クラスの定義：

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

   クラスは、Pytorchのnn.moduleのサブクラスとして定義されています。つまり、Pytorchのニューラルネットワークの構成要素として使用できます。
   初期化：

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

   パラメーター：
   d_model：入力の次元。
   1. num_heads：マルチヘッドの注意の注意の数。
   d_ff：位置ごとのフィードフォワードネットワークの内側層の次元。
   2. ドロップアウト：正則化に使用されるドロップアウト率。
   4. コンポーネント：

   self.self_attn：マルチヘッドの注意メカニズム。

   self.feed_forward：ポジションごとのフィードフォワードニューラルネットワーク。
   1. self.norm1およびself.norm2：レイヤーの正規化。レイヤーの入力を滑らかにするために適用されます。
   self.dropout：ドロップアウトレイヤー。トレーニング中にいくつかのアクティベーションをゼロにランダムに設定することで過剰適合を防ぐために使用されます。
   3. フォワードメソッド：

   入力：

   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

   x：エンコーダーレイヤーへの入力

   マスク：入力の特定の部分を無視するオプションマスク。

   1. 手順の処理：
   自己告発：入力xは、マルチヘッドの自己触たちメカニズムを介して渡されます。

   add＆normalize（注意後）：注意出力が元の入力（残留接続）に追加され、その後、norm1を使用したドロップアウトと正規化が続きます。 フィードフォワードネットワーク：前のステップからの出力は、ポジションごとのフィードフォワードネットワークに渡されます。 追加＆正規化（フィードフォワード後）：ステップ2と同様に、フィードフォワード出力がこの段階の入力（残差接続）に追加され、その後、ノルム2を使用したドロップアウトと正規化が続きます。

   出力：エンコーダーレイヤーの出力として処理されたテンソルが返されます。
   1. 概要：

   2. encoderLayerクラスは、変圧器のエンコーダーの単一層を定義します。マルチヘッドの自己関節メカニズムをカプセル化し、その後に位置的にフィードフォワードニューラルネットワークが続き、残留接続、層の正規化、ドロップアウトが適用されます。これらのコンポーネントは、エンコーダが入力データ内の複雑な関係をキャプチャし、それらをダウンストリームタスクの有用な表現に変換することができます。通常、複数のそのようなエンコーダーレイヤーが積み重ねられて、トランスモデルの完全なエンコーダー部分を形成します。

      4。デコーダーブロックの構築

      

      pip3 install torch torchvision torchaudio

      クラスの定義：

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

      初期化：

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

      パラメーター：

      d_model：入力の次元。
      num_heads：マルチヘッドの注意の注意の数。
      2. d_ff：フィードフォワードネットワーク内の内側の層の次元。
      3. ドロップアウト：正規化のためのドロップアウト率。
      コンポーネント

      ：

      self.self_attn：ターゲットシーケンスのマルチヘッドの自己触たちメカニズム。
      1. self.cross_attn：エンコーダの出力に対応するマルチヘッドの注意メカニズム。
      self.feed_forward：ポジションごとのフィードフォワードニューラルネットワーク。
      self.norm1、self.norm2、self.norm3：レイヤー正規化コンポーネント。
      self.dropout：正規化のためのドロップアウトレイヤー。
      5. フォワード

      メソッド：

      input

      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

      ：

      x：デコーダーレイヤーへの入力

      enc_output：対応するエンコーダーからの出力（クロスアテンションステップで使用）。
      1. src_mask：エンコーダの出力の特定の部分を無視するためのソースマスク。
      tgt_mask：デコーダーの入力の特定の部分を無視するためのターゲットマスク。
      3. 手順の処理：
      4. 1. ターゲットシーケンスの自己関節：入力xは、自己触媒メカニズムを通じて処理されます。
         ADD＆Normalize（自己attentionの後）：自己attentionからの出力が元のXに追加され、その後、DropoutとNorm1を使用した正規化が続きます。 エンコーダー出力との交差に関する攻撃：前のステップからの正規化された出力は、エンコーダの出力ENC_OUTPUT。
         2. ADD＆NORMELIZE（相互出席後）：通過からの出力がこの段階の入力に追加され、その後、norm2。
         を使用したドロップアウトと正規化が続きます。
         3. フィードフォワードネットワーク：前のステップからの出力は、フィードフォワードネットワークに渡されます。
         add＆normalize（フィードフォワード後）：フィードフォワード出力がこの段階の入力に追加され、その後、norm3を使用したドロップアウトと正規化が続きます。
         4. 出力：処理されたテンソルは、デコーダーレイヤーの出力として返されます。
         5. 概要：
         7. デコーダーレイヤークラスは、変圧器のデコーダーの単一層を定義します。マルチヘッドの自己関節メカニズム、マルチヘッド交差アテナンスメカニズム（エンコーダの出力に対応）、位置的にフィードフォワードニューラルネットワーク、および対応する残差接続、層の正規化、ドロップアウト層で構成されています。この組み合わせにより、デコーダーは、ターゲットシーケンスとソースシーケンスの両方を考慮して、エンコーダの表現に基づいて意味のある出力を生成できます。エンコーダーと同様に、通常、複数のデコーダーレイヤーがスタックされ、トランスモデルの完全なデコーダー部分が形成されます。
         次に、包括的な変圧器モデルを構築するために、エンコーダーブロックとデコーダーブロックがまとめられています。
         5。エンコーダーレイヤーとデコーダーレイヤーを組み合わせて完全なトランスネットワークを作成
         図4。トランスネットワーク（出典：元の論文からの画像）

クラスの定義：

初期化：

pip3 install torch torchvision torchaudio

コンストラクターは、次のパラメーターを取得します

src_vocab_size：ソース語彙サイズ。

tgt_vocab_size：ターゲットの語彙サイズ。

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

d_model：モデルの埋め込みの次元。 num_heads：マルチヘッドの注意メカニズムの注意ヘッドの数。

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

num_layers：エンコーダーとデコーダーの両方のレイヤー数。

d_ff：フィードフォワードネットワーク内の内側のレイヤーの次元。

max_seq_length：位置エンコーディングの最大シーケンス長。
ドロップアウト：正規化のためのドロップアウトレート。
3. そして、それは次のコンポーネントを定義します：
1. self.encoder_embedding：ソースシーケンスの埋め込み層。
2. self.decoder_embedding：ターゲットシーケンスの埋め込み層。
3. self.positional_encoding：位置エンコーディングコンポーネント。
4. self.encoder_layers：エンコーダーレイヤーのリスト。
5. self.decoder_layers：デコーダーレイヤーのリスト。
6. self.fc：ターゲット語彙サイズへの最終的な完全に接続された（線形）レイヤーマッピング。
self.dropout：ドロップアウトレイヤー。

MASKメソッドを生成：

この方法は、ソースとターゲットシーケンスのマスクを作成するために使用され、パディングトークンが無視され、ターゲットシーケンスのトレーニング中に将来のトークンが表示されないことを保証します。

pip3 install torch torchvision torchaudio

フォワードメソッド：

このメソッドは、変圧器のフォワードパスを定義し、ソースとターゲットシーケンスを取得し、出力予測を作成します。

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

入力埋め込みと位置エンコーディング：ソースとターゲットシーケンスは、最初にそれぞれの埋め込み層を使用して埋め込まれ、次に位置エンコーディングに追加されます。

エンコーダーレイヤー：ソースシーケンスはエンコーダーレイヤーに渡され、最終エンコーダ出力は処理されたソースシーケンスを表します。

デコーダーレイヤー：ターゲットシーケンスとエンコーダーの出力はデコーダーレイヤーを通過し、デコーダーの出力が生じます。
最終線形レイヤー：デコーダーの出力は、完全に接続された（線形）層を使用してターゲット語彙サイズにマッピングされます。
2. output：
最終出力は、ターゲットシーケンスに対するモデルの予測を表すテンソルです。
4. 概要：

トランスクラスは、埋め込み、位置エンコーディング、エンコーダー層、デコーダーレイヤーなど、トランスモデルのさまざまなコンポーネントをまとめます。トレーニングと推論のための便利なインターフェイス、マルチヘッドの注意の複雑さ、フィードフォワードネットワーク、およびレイヤー正規化を提供します。 この実装は、標準の変圧器アーキテクチャに従って、機械翻訳、テキストの要約などのシーケンスからシーケンスへのタスクに適しています。マスキングを含めることで、モデルがシーケンス内の因果依存関係を順守し、トークンのパディングを無視し、将来のトークンからの情報漏れを防ぐことができます。 これらの連続したステップは、トランスモデルに入力シーケンスを効率的に処理し、対応する出力シーケンスを生成できるようにします。

Pytorch Transformerモデルのトレーニング
サンプルデータの準備

説明のために、この例ではダミーデータセットが作成されます。ただし、実際のシナリオでは、より実質的なデータセットが採用され、プロセスには、ソース言語とターゲット言語の両方の語彙マッピングの作成とともにテキストの前処理が含まれます。

pip3 install torch torchvision torchaudio

ハイパーパラメーター：

これらの値は、変圧器モデルのアーキテクチャと動作を定義しています：

1. src_vocab_size、tgt_vocab_size：ソースとターゲットシーケンスのボキャブラリーサイズ、両方とも5000に設定されています。
d_model：512に設定されたモデルの埋め込みの次元。
num_heads：マルチヘッド注意メカニズムの注意ヘッドの数、8に設定されています
3. num_layers：エンコーダーとデコーダーの両方のレイヤー数、6に設定されています。
d_ff：2048に設定されたフィードフォワードネットワークの内側層の次元。
4. max_seq_length：位置エンコーディングの最大シーケンス長、100に設定。
ドロップアウト：正規化のドロップアウトレート、0.1に設定します
6. トランスインスタンスの作成：
この行は、変圧器クラスのインスタンスを作成し、指定されたハイパーパラメーターで初期化します。インスタンスには、これらのハイパーパラメーターで定義されたアーキテクチャと動作があります。 ランダムなサンプルデータの生成

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

次の行は、ランダムソースとターゲットシーケンスを生成します：

src_data：1とsrc_vocab_sizeの間のランダムな整数、形状（64、max_seq_length）のソースシーケンスのバッチを表します。 TGT_DATA：1からTGT_VOCAB_SIZEの間のランダムな整数。形状のターゲットシーケンスのバッチ（64、max_seq_length）を表します。 これらのランダムシーケンスは、トランスモデルへの入力として使用でき、64の例と長さ100のシーケンスを持つデータのバッチをシミュレートすることができます。

概要：
コードスニペットは、変圧器モデルを初期化し、モデルに供給できるランダムソースとターゲットシーケンスを生成する方法を示します。選択したハイパーパラメーターは、変圧器の特定の構造と特性を決定します。このセットアップは、モデルが機械翻訳やテキストの要約などの実際のシーケンスからシーケンスへのタスクでトレーニングおよび評価される大きなスクリプトの一部である可能性があります。
2. モデルのトレーニング
3. 次に、モデルは前述のサンプルデータを使用してトレーニングされます。ただし、実際のシナリオでは、非常に大きなデータセットが採用され、通常、トレーニングと検証のために異なるセットに分割されます。

損失関数とオプティマイザー：

Criterion = nn.Crossentropyloss（Ingrore_index = 0）：損失関数をクロスエントロピー損失として定義します。 Ingrore_index引数は0に設定されています。つまり、損失は0のインデックスを持つターゲットを考慮しません（通常、トークンのパディング用に予約されています）。

optimizer = optim.adam（...）：学習率は0.0001および特定のベータ値を持つオプティマイザーをAdamとして定義します。

モデルトレーニングモード：

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

1. Transformer.Train（）：トランスモデルをトレーニングモードに設定し、トレーニング中にのみ適用するドロップアウトのような動作を可能にします。

トレーニングループ：

コードスニペットは、典型的なトレーニングループを使用して100エポックのモデルをトレーニングします。
範囲のエポックの場合（100）：100を超えるトレーニングエポックを繰り返します
optimizer.zero_grad（）：前の繰り返しから勾配をクリアします。
output = transformer（src_data、tgt_data [：,：-1]）：ソースデータとターゲットデータ（各シーケンスの最後のトークンを除く）をトランスを介して渡します。これは、ターゲットが1つのトークンによってシフトされるシーケンスからシーケンスへのタスクで一般的です。
2. 損失= Criterion（...）：モデルの予測とターゲットデータの間の損失を計算します（各シーケンスの最初のトークンを除く）。損失は​​、データを1次元テンソルに再形成し、エントロピー損失関数を使用して計算されます。
loss.backward（）：モデルのパラメーターに対する損失の勾配を計算します。
3. Optimizer.Step（）：計算された勾配を使用してモデルのパラメーターを更新します
print（f "epoch：{epoch 1}、loss：{loss.item（）}"）：その時代の現在のエポック数と損失値を印刷します。
5. 概要：
6. このコードスニペットは、100エポックのランダムに生成されたソースとターゲットシーケンスでトランスモデルをトレーニングします。 Adam Optimizerとクロスエントロピー損失関数を使用します。損失は​​エポックごとに印刷されているため、トレーニングの進捗状況を監視できます。現実世界のシナリオでは、ランダムソースとターゲットシーケンスを、機械翻訳などのタスクからの実際のデータに置き換えます。
変圧器モデルのパフォーマンス評価
モデルをトレーニングした後、そのパフォーマンスは検証データセットまたはテストデータセットで評価できます。以下は、これがどのように行われるかの例です：

評価モード：

transformer.eval（）：変圧器モデルを評価モードに配置します。トレーニング中にのみ使用されるドロップアウトのような特定の動作をオフにするため、これは重要です。

ランダム検証データを生成します：

pip3 install torch torchvision torchaudio

val_src_data：1とsrc_vocab_sizeの間のランダムな整数。形状（64、max_seq_length）を持つ検証ソースシーケンスのバッチを表します。

val_tgt_data：1とTGT_VOCAB_SIZEの間のランダムな整数。形状（64、max_seq_length）の検証ターゲットシーケンスのバッチを表します。
1. 検証ループ：
Torch.no_grad（）を使用して
1. ：検証中に勾配を計算する必要がないため、勾配計算を無効にします。これにより、メモリの消費を削減し、計算をスピードアップできます
val_output = transformer（val_src_data、val_tgt_data [：,： -1]）：変圧器を介して検証ソースデータと検証ターゲットデータ（各シーケンスの最後のトークンを除く）を渡します。
2. val_loss = Criterion（...）：モデルの予測と検証ターゲットデータの間の損失を計算します（各シーケンスの最初のトークンを除く）。損失は​​、データを1次元テンソルに再形成し、以前に定義されたクロスエントロピー損失関数を使用して計算されます。
print（f "検証損失：{val_loss.item（）}"）：検証損失値を印刷します
4. 概要：
このコードスニペットは、ランダムに生成された検証データセットのトランスモデルを評価し、検証損失を計算し、印刷します。実際のシナリオでは、ランダム検証データを、取り組んでいるタスクの実際の検証データに置き換える必要があります。検証損失は、モデルが目に見えないデータでどれだけうまく実行されているかを示すことができます。これは、モデルの一般化能力の重要な尺度です。

トランスとハグの顔の詳細については、私たちのチュートリアル、変圧器の使用と抱きしめの顔を紹介するのが便利です。 結論とさらなるリソース

結論として、このチュートリアルは、深い学習のための最も汎用性の高いツールの1つであるPytorchを使用してトランスモデルを構築する方法を示しました。並列化の能力とデータの長期的な依存関係をキャプチャする能力により、変圧器はさまざまな分野、特に翻訳、要約、感情分析などのNLPタスクで大きな可能性を秘めています。 高度な深い学習の概念とテクニックの理解を深めることに熱心な人のために、データサンプでケラスを使用してコースの高度な深い学習を探ることを検討してください。また、Pytorchを使用したシンプルなニューラルネットワークの構築について別のチュートリアルで読むこともできます。

以上がPytorchで変圧器モデルを構築するための包括的なガイドの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。