AI & GPU
2024年のクラスター管理: 包括的なガイド

2024年のクラスター管理: 包括的なガイド

Misskey AI

クラスター管理: 深層学習インフラストラクチャの最適化

クラスター管理の定義

クラスター管理は、深層学習の世界で重要な役割を果たします。複雑なモデルの学習と展開には、単一のマシンの能力を超えるコンピューティングの需要があります。適切に設計され、効率的に管理されたクラスターは、深層学習ワークフローのパフォーマンス、スケーラビリティ、信頼性を大幅に向上させることができます。

クラスター管理の核心は、CPU、GPU、メモリなどのコンピューティングリソースを調整および最適化して、深層学習ワークロードの動的なニーズに対応することです。これには、クラスターのプロビジョニングと構成、リソースの割り当て、ジョブのスケジューリング、パフォーマンスの監視、障害耐性と高可用性の確保などのタスクが含まれます。

深層学習用のクラスター管理システムの主要コンポーネントは以下のとおりです:

  1. リソース管理: 深層学習ワークロードのニーズに合わせて、CPUやGPU、メモリなどのコンピューティングリソースを割り当てて管理する。
  2. ジョブのスケジューリング: リソースの利用率と処理能力を最適化するために、深層学習ジョブを効率的にスケジューリングし、優先順位付けする。
  3. 監視とオブザーバビリティ: クラスターの健全性、パフォーマンスメトリクス、ボトルネックの特定などを追跡する。
  4. 障害耐性と高可用性: ノードの障害に耐え、中断のないサービスを維持する。
  5. セキュリティとアクセス制御: クラスター内のユーザー認証、承認、安全な通信を実装する。
  6. 深層学習フレームワークとの統合: シームレスな連携を実現する。ディープラーニングのフレームワークであるTensorFlow、PyTorch、MXNetなどとの統合により、クラスター管理機能を活用することができます。

クラスター管理を習得することで、ディープラーニングのインフラストラクチャの可能性を最大限に引き出し、モデルの高速な学習、リソースの効率的な利用、全体的なパフォーマンスの向上を実現できます。

クラスターアーキテクチャの考慮事項

ディープラーニング用のクラスターを設計する際には、いくつかの重要なアーキテクチャ上の要因を考慮する必要があります。

ハードウェアの選択

ディープラーニングクラスターのハードウェア選択は非常に重要です。これは、ワークロードのパフォーマンスとスケーラビリティに直接影響するためです。主なハードウェアコンポーネントは以下のとおりです:

  1. CPUs: CPUアーキテクチャとコア数の選択は、特に推論やプリ/ポストプロセッシングのステップにおいて、ディープラーニングタスクのパフォーマンスに大きな影響を与えます。
  2. GPUs: クラスター内のGPUの数、タイプ、機能は、全体的なディープラーニング処理能力を決定します。一般的なオプションにはNVIDIAのVolタ、Ampere、Turing アーキテクチャがあります。
  3. メモリ: 大規模なモデルやバッチを学習や推論で処理するには、十分なシステムメモリとGPUメモリが不可欠です。

ネットワークインフラストラクチャ

クラスターのネットワークインフラストラクチャは、分散ディープラーニングワークロードのパフォーマンスに大きな影響を与えます。一般的なオプションには以下のようなものがあります:

  1. Ethernet: 10 GbEや25 GbEなどの標準的なEthernetは、コストパフォーマンスが良く、広く採用されているネットワークソリューションです。
  2. InfiniBand: EDRやHDRなどの高性能InfiniBandインターコネクトは、低レイテンシーと高帯域幅の通信を提供するため、分散ディープラーニングに適しています。
  3. その他の高速オプション: RoCE(RDMA over Converged Ethernet)やNVLinkなどの新しい技術も、パフォーマンスの面で有利です。

ストレージソリューション

ディープラーニングクラスターのストレージインフラストラクチャは非常に重要です。データアクセスとI/Oパフォーマンスにおける重要な役割を果たします。一般的なストレージオプションには以下のようなものがあります:

  1. 共有ファイルシステム: NFS、GlusterFS、Lustreなどの分散ファイルシステムは、深層学習のデータやモデルチェックポイントを格納するための集中化された拡張可能なストレージソリューションを提供します。
  2. オブジェクトストレージ: Amazon S3、Google Cloud Storage、Azure Blob Storageなどのクラウドベースのオブジェクトストレージサービスは、深層学習アセットの保存とアクセスに適した高スケーラブルかつコスト効率的な代替手段を提供します。
  3. 分散ストレージ: HDFSやCephなどの分散ストレージシステムは、深層学習クラスターに対する拡張可能で耐障害性のあるストレージソリューションを提供できます。

ストレージソリューションの選択は、データ量、アクセスパターン、深層学習ワークロードのパフォーマンス要件などの要因によって異なります。

クラスターのプロビジョニングとデプロイ

信頼性の高いスケーラブルなインフラストラクチャを確保するためには、深層学習クラスターを効率的にプロビジョニングおよびデプロイすることが不可欠です。以下は主な考慮事項です:

自動化されたクラスターのセットアップと設定

クラスターのセットアップと設定プロセスを自動化すると、デプロイの効率と一貫性が大幅に向上します。Ansible、Terraform、カスタムスクリプトなどのツールを使用して、ハードウェアのプロビジョニング、オペレーティングシステムのインストール、クラスターコンポーネントの設定を自動化できます。

コンテナ化とオーケストレーション

Docker などのコンテナ化ツールや、Kubernetes などのオーケストレーションプラットフォームを使用すると、深層学習ワークロードのデプロイと管理が簡素化されます。コンテナは一貫性のあるポータブルなランタイム環境を提供し、オーケストレーションシステムは、スケーリング、ロードバランシング、障害許容性などのタスクを処理します。

例えば、Kubernetesを使用して深層学習クラスターを管理できます。各深層学習ジョブをKubernetesジョブまたはデプロイメントとして展開し、Kubernetesがこれらの深層学習ワークロードのスケジューリング、スケーリング、障害許容性を処理します。これにより、クラ.以下は、提供されたマークダウンファイルの日本語翻訳です。コードの部分は翻訳せず、コメントのみ翻訳しています。ファイルの先頭に追加のコメントは付けていません。

# ディープラーニングジョブのKubernetesデプロイメントの例
apiVersion: batch/v1
kind: Job
metadata:
  name: my-deep-learning-job
spec:
  template:
    spec:
      containers:
      - name: deep-learning-container
        image: my-deep-learning-image:latest
        command: ["python", "train_model.py"]
        resources:
          limits:
            nvidia.com/gpu: 1
      restartPolicy: OnFailure

クラスターリソースのスケーリング

需要に応じてクラスターリソースを上下にスケーリングする機能は、効率的なディープラーニングワークロード管理に不可欠です。これは、水平スケーリング(ノードの追加や削除)や垂直スケーリング(既存のノードのリソース調整)などの手法で実現できます。

Kubernetesやクラウドベースのクラスター管理サービスなどのツールと連携したオートスケーリングメカニズムを使うことで、ワークロードの変化に応じてクラスターを自動的にスケーリングし、最適なリソース利用とコスト効率を実現できます。

リソース割り当てとスケジューリング

ディープラーニングクラスターのパフォーマンスと効率を最大化するには、効果的なリソース割り当てとジョブスケジューリングが不可欠です。

効率的なリソース利用

CPUやGPU、メモリなどのクラスターリソースを効率的に活用することが、ディープラーニングワークロードにとって重要です。これには以下のような手法が役立ちます:

  1. ワークロードに応じたリソース割り当て: モデルサイズ、バッチサイズ、ハードウェアの好みなどの要因を考慮して、各ディープラーニングジョブに適したリソースを割り当てる。
  2. オーバーサブスクリプションとプリエンプション: リソースのコントロールされたオーバーサブスクリプションと、低優先度のジョブのプリエンプションを行い、ピーク需要に対応する。
  3. GPUの仮想化: NVIDIA MPS(Multi-Process Service)などのGPU仮想化技術を活用し、複数のディープラーニングジョブ間でGPUを共有する。

ジョブのスケジューリングと優先順位付け

効果的なジョブスケジューリングと優先順位付けの仕組みを導入することが重要です。優先順位付けシステムは、クラスター上でのディープラーニングワークロードの実行を管理するために不可欠です。これには以下が含まれます:

  1. ワークロードに対応したスケジューリング: リソース要件、期限、優先順位に基づいてジョブをスケジューリングし、全体的なクラスタースループットを最適化する。
  2. 公平なリソース配分: ユーザーやチーム間でリソースを公平かつ公平に分配し、リソースの独占や飢餓状態を防ぐ。
  3. 動的な優先順位付け: 期限、モデルのパフォーマンス、ビジネスの重要性などの要因に基づいて、ジョブの優先順位を調整し、SLAを満たし、ビジネス成果を最適化する。

リソース配分とジョブのスケジューリングを慎重に管理することで、ディープラーニングクラスターを最高の効率で運用し、より迅速かつ効率的に結果を得ることができます。

モニタリングと可視化

効果的なモニタリングと可視化は、ディープラーニングクラスターの健全性とパフォーマンスを維持するために不可欠です。

クラスターの健全性とパフォーマンスの追跡

クラスターの健全性とパフォーマンスを密接に監視することは、ボトルネックを特定し、リソース利用を最適化し、ディープラーニングワークフローの信頼性を確保するために不可欠です。これには以下のメトリクスを追跡することが含まれます:

  1. ハードウェアの利用状況: クラスター全体のCPU、GPU、メモリの使用状況。
  2. ネットワークのパフォーマンス: クラスターのネットワークインフラストラクチャのバンド幅、レイテンシ、スループット。
  3. ストレージのパフォーマンス: ストレージソリューションのI/Oスループット、レイテンシ、容量の利用状況。
  4. ジョブレベルのメトリクス: 損失、精度、実行時間などの学習と推論のパフォーマンス。

Prometheus、Grafana、クラウドベースのモニタリングサービスなどのツールを使用して、これらのメトリクスを収集、可視化、分析することで、ディープラーニングクラスターの健全性とパフォーマンスに関する貴重な洞察を得ることができます。

ログと イベント管理

包括的なログとイベント管理は、トラブルシューティングと理解のために不可欠です。深層学習クラスター

このクラスターには以下のものが含まれます:

  1. システムログ: オペレーティングシステム、コンテナランタイム、クラスター管理サービスからのログ。
  2. アプリケーションログ: 深層学習フレームワーク、トレーニングスクリプト、推論パイプラインによって生成されるログ。
  3. 監査ログ: ユーザーアクション、リソース割り当て、その他の管理活動の記録。

これらのログを集約し分析することで、迅速な問題の特定と解決、深層学習モデルの出自の追跡、規制要件への準拠を確保できます。

障害許容性と高可用性

深層学習クラスターの障害許容性と高可用性を確保することは、サービスの中断のない運用と信頼性の高いモデルのトレーニングと展開に不可欠です。

ノード障害への対応

大規模クラスターでは、ノード障害は避けられません。クラスター管理システムはこれらを適切に処理できる必要があります:

  1. 自動ノード置換: 障害ノードを新しい健全なノードに自動的に置き換え、クラスターの全体的な容量を維持する。
  2. ワークロードの再分散: 障害ノードからのワークロードを他の健全なノードに再分散し、ジョブの中断なく継続実行できるようにする。
  3. チェックポイントと再開: 深層学習フレームワークのチェックポイント機能を活用し、最後のセーブ状態から再開できるようにする。

複製と冗長性

クリティカルなクラスターコンポーネントに複製と冗長性を実装することで、全体の耐障害性を高められます:

  1. 複製コントロールプレーン: 深層学習ワークロードの展開と管理を調整するクラスター管理コントロールプレーンの高可用性を確保する。
  2. 冗長ストレージ: 複製やディストリビューテッドストレージソリューションを通じて、深層学習データとモデルチェックポイントの複数コピーを維持する。
  3. バックアップと災害復旧: 定期的なバックアップと迅速な復旧プロセスを実装し、深刻な障害からの復旧を可能にする。ロバストなバックアップと災害復旧の戦略を講じて、データ損失から保護し、大規模な事故からの迅速な復旧を可能にする。

自己修復メカニズム

クラスター管理システムに自己修復メカニズムを組み込むことで、復旧プロセスを自動化し、障害の影響を最小限に抑えることができます。これには以下が含まれます:

  1. 自動障害検知: クラスターの障害兆候を継続的にモニタリングし、適切な復旧アクションをトリガーする。
  2. 自動修復: 手動介入なしに、失敗したサービスの再起動や、健全でないノードの交換など、事前定義された復旧手順を実行する。
  3. 優雅な劣化: 障害に直面してもクラスターが優雅に劣化し、重要な機能を維持し、最も重要なワークロードを優先できるようにする。

障害耐性と高可用性を念頭に置いてディープラーニングクラスターを設計することで、予期せぬ課題に直面しても、ディープラーニングインフラストラクチャの信頼性と回復力を確保できます。

畳み込みニューラルネットワーク (CNN)

畳み込みニューラルネットワーク (CNN) は、画像認識と分類の分野で特に成功を収めている、特殊化されたタイプのニューラルネットワークです。画素間の空間的関係を活用するのに対し、従来のニューラルネットワークは各入力特徴を独立して扱います。

CNN アーキテクチャの主要コンポーネントは以下のとおりです:

  1. 畳み込み層: これらの層は、入力画像に対して一連の学習可能なフィルターを適用し、エッジ、形状、テクスチャなどの特徴を抽出します。フィルターは学習過程で学習され、複数の畳み込み層を積み重ねることで、より高次の特徴を検出できるようになります。
import torch.nn as nn
 
class ConvBlock(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0):
        super(ConvBlock, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_c.
```以下は、提供されたマークダウンファイルの日本語翻訳です。コードの部分は翻訳せず、コメントのみ翻訳しています。ファイルの先頭に追加のコメントは付けていません。
 
```python
# 畳み込み層 (Convolutional Layers)
# これらの層は、入力特徴マップから新しい特徴マップを抽出します。
# 一般的な操作には、畳み込み、バッチ正規化、活性化関数があります。
 
import torch.nn as nn
 
class ConvBlock(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0):
        super(ConvBlock, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
 
    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x
  1. プーリング層 (Pooling Layers): これらの層は、特徴マップの空間的な次元を縮小しつつ、最も重要な特徴を保持します。一般的なプーリング操作には、最大プーリングと平均プーリングがあります。
import torch.nn as nn
 
class MaxPooling(nn.Module):
    def __init__(self, kernel_size, stride=2):
        super(MaxPooling, self).__init__()
        self.pool = nn.MaxPool2d(kernel_size, stride=stride)
 
    def forward(self, x):
        x = self.pool(x)
        return x
  1. 全結合層 (Fully Connected Layers): これらの層は、従来の neural network 層と似ており、畳み込み層やプーリング層で抽出された特徴に基づいて最終的な分類や予測を行います。
import torch.nn as nn
 
class FCBlock(nn.Module):
    def __init__(self, in_features, out_features):
        super(FCBlock, self).__init__()
        self.fc = nn.Linear(in_features, out_features)
        self.bn = nn.BatchNorm1d(out_features)
        self.relu = nn.ReLU(inplace=True)
 
    def forward(self, x):
        x = self.fc(x)
        x = self.bn(x)
        x = self.relu(x)
        return x

CNN のアーキテクチャは通常、畳み込み層とプーリング層の交互の繰り返しに、最後に1つ以上の全結合層が続く構造になっています。これにより、ネットワークは階層的な特徴を学習することができ、初期の層では低レベルの特徴(エッジ、形状など)を、後の層では高レベルの特徴(物体の部品、物体など)を学習することができます。

以下は、画像分類用の簡単な CNN アーキテクチャの例です:

import torch.nn as nn
 
class CNN(nn.Module):
    def __init__(self, num_classes):
        super(CNN, self).__init__()
        # ここにネットワークの定義を記述
```こちらが日本語訳になります。コードの部分は翻訳していません。
 
lf.conv1 = ConvBlock(3, 32, 3, padding=1)
        self.pool1 = MaxPooling(2)
        self.conv2 = ConvBlock(32, 64, 3, padding=1)
        self.pool2 = MaxPooling(2)
        self.fc1 = FCBlock(64 * 7 * 7, 512)
        self.fc2 = nn.Linear(512, num_classes)
 
    def forward(self, x):
        # 入力xをconv1に通す
        x = self.conv1(x)
        # 池化層pool1に通す
        x = self.pool1(x)
        # conv2に通す
        x = self.conv2(x)
        # 池化層pool2に通す
        x = self.pool2(x)
        # 全結合層に入力するためにフラット化する
        x = x.view(x.size(0), -1)
        # 全結合層fc1に通す
        x = self.fc1(x)
        # 最終的な全結合層fc2に通す
        x = self.fc2(x)
        return x
 
このモデルは、2つのconvolutional層、2つのmax-pooling層、2つの全結合層で構成されています。convolutional層は入力画像から特徴を抽出し、pooling層は特徴マップの空間的な次元を削減します。最後の全結合層で最終的な分類を行います。
 
## 再帰型ニューラルネットワーク (RNN)
 
再帰型ニューラルネットワーク (RNN) は、テキスト、音声、時系列データなどの順序性のあるデータを処理するのに適したニューラルネットワークの一種です。順方向ニューラルネットワークとは異なり、RNNは「隠れ状態」を維持することで、過去の入力情報を活用できます。
 
RNNアーキテクチャの主な構成要素は以下の通りです:
 
1. **再帰セル**: 再帰セルはRNNの基本的な構成要素です。現在の入力と前の隠れ状態を受け取り、現在の隠れ状態と出力を生成します。
 
```python
import torch.nn as nn
 
class RNNCell(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(RNNCell, self).__init__()
        # 入力から隠れ状態への変換
        self.i2h = nn.Linear(input_size, hidden_size)
        # 前の隠れ状態から現在の隠れ状態への変換
        self.h2h = nn.Linear(hidden_size, hidden_size)
        self.activation = nn.Tanh()
 
    def forward(self, x, h_prev):
        # 現在の隠れ状態を計算
        h_current = self.activation(self.i2h(x) + self.h2h(h_prev))
        return h_current
  1. 系列処理: RNNは入力系列を順番に処理し、隠れ状態を更新していきます。以下は、提供されたマークダウンファイルの日本語翻訳です。コードの部分は翻訳せず、コメントのみ翻訳しています。ファイルの先頭に追加のコメントは付けていません。
import torch.nn as nn
 
class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(RNN, self).__init__()
        self.num_layers = num_layers # レイヤー数
        self.hidden_size = hidden_size # 隠れ層のサイズ
        self.rnn_cells = nn.ModuleList([RNNCell(input_size if i == 0 else hidden_size, hidden_size) for i in range(num_layers)]) # RNNセルのリスト
        self.fc = nn.Linear(hidden_size, output_size) # 全結合層
 
    def forward(self, x):
        batch_size, seq_len, _ = x.size() # バッチサイズ、系列長、入力サイズ
        h = torch.zeros(self.num_layers, batch_size, self.hidden_size, device=x.device) # 初期隠れ状態
        for t in range(seq_len): # 系列長の分だけループ
            for i in range(self.num_layers): # レイヤー数の分だけループ
                if i == 0: # 最下層の場合
                    h[i] = self.rnn_cells[i](x[:, t, :], h[i]) # 入力と前の隠れ状態から新しい隠れ状態を計算
                else: # それ以外の場合
                    h[i] = self.rnn_cells[i](h[i-1], h[i]) # 前の隠れ状態から新しい隠れ状態を計算
        return self.fc(h[-1]) # 最終的な隠れ状態から出力を計算

この例では、RNNは複数のRNNセルから構成されています。各セルは現在の入力と前の隠れ状態を処理して新しい隠れ状態を生成します。最終的な隠れ状態は全結合層に入力され、出力が生成されます。

RNNは、言語モデリング、機械翻訳、音声認識などのタスクに特に有効です。これらのタスクでは、入力データの順序とコンテキストが重要です。

Long Short-Term Memory (LSTM)とGated Recurrent Unit (GRU)

基本的なRNNでは長期依存関係を捉えるのが難しい場合があります。これは勾配の消失や爆発の問題が原因です。この問題を解決するために、2つの主要なRNNの変種が開発されました: Long Short-Term Memory (LSTM)とGated Recurrent Unit (GRU)です。

Long Short-Term Memory (LSTM)

LSTMは、入力データの長期依存関係をより良く捉えるために、より複雑なセル構造を持つRNNの一種です。LSTMセルの主要な構成要素は以下の通りです:

  1. Forget Gate: 何の情報を忘れるかを決定します。以下は、提供されたマークダウンファイルの日本語翻訳です。コードの部分は翻訳せず、コメントのみ翻訳しています。ファイルの先頭に追加のコメントは付けていません。

前の細胞状態は忘れられるべきです。 2. 入力ゲート: 現在の入力と前の隠れ状態から、新しい情報をどのように細胞状態に追加するかを決定します。 3. 出力ゲート: 現在の入力、前の隠れ状態、および細胞状態に基づいて、新しい隠れ状態をどのように決定するかを決定します。

import torch.nn as nn
 
class LSTMCell(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(LSTMCell, self).__init__()
        self.i2h = nn.Linear(input_size, 4 * hidden_size)
        self.h2h = nn.Linear(hidden_size, 4 * hidden_size)
        self.activation = nn.Tanh()
 
    def forward(self, x, states):
        h_prev, c_prev = states
        gates = self.i2h(x) + self.h2h(h_prev)
        forget_gate, input_gate, cell_gate, output_gate = gates.chunk(4, 1)
 
        f_t = torch.sigmoid(forget_gate)
        i_t = torch.sigmoid(input_gate)
        g_t = self.activation(cell_gate)
        o_t = torch.sigmoid(output_gate)
 
        c_t = f_t * c_prev + i_t * g_t
        h_t = o_t * self.activation(c_t)
 
        return h_t, c_t

門付き再帰ユニット (GRUs)

GRUsはLSTMsのより単純なバリアントで、少し異なるセル構造を持っています。GRUsには2つのゲート、更新ゲートとリセットゲートがあり、これらがセル内の情報の流れを制御します。

import torch.nn as nn
 
class GRUCell(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(GRUCell, self).__init__()
        self.i2h = nn.Linear(input_size, 3 * hidden_size)
        self.h2h = nn.Linear(hidden_size, 3 * hidden_size)
        self.activation = nn.Tanh()
 
    def forward(self, x, h_prev):
        gates = self.i2h(x) + self.h2h(h_prev)
        update_gate, reset_gate, new_state_gate = gates.chunk(3, 1)
 
        update_gate = torch.sigmoid(update_gate)
        reset_gate = torch.sigmoid(reset_gate)
        new_state = self.activation(reset_gate * h_prev + (1 - reset_gate) * new_state_gate)
        h_t = update_gate * h_prev + (1 - update_gate) * new_state
 
        return h_t
```以下は、提供されたマークダウンファイルの日本語翻訳です。コードの部分は翻訳せず、コメントのみ翻訳しています。ファイルの先頭に追加のコメントは付けていません。
 
        return h_t

LSTMとGRUは、機械翻訳、言語モデリング、音声認識などのさまざまなシーケンス間タスクで効果的であることが示されています。LSTMとGRUの選択は、プロジェクトの特定の問題、データ、計算上の制約によって異なります。

Transformers

Transformersは、近年特に自然言語処理(NLP)の分野で注目を集めている新しいタイプのニューラルネットワークアーキテクチャです。RNNのように順次的にシーケンスを処理するのとは異なり、Transformersは自己注意メカニズムを使用して、入力シーケンス内のすべての要素間の関係を捉えることができ、長距離依存関係をより良くモデル化できます。

Transformerアーキテクチャの主要なコンポーネントは以下のとおりです:

  1. エンコーダ: エンコーダは、入力シーケンスを処理し、シーケンス内の各要素の文脈表現を生成する責任があります。
  2. デコーダ: デコーダは、エンコーダからの文脈表現を受け取り、出力シーケンスを1つずつ生成します。
  3. 自己注意: 自己注意メカニズムにより、モデルは特定の要素の表現を計算する際に、入力シーケンス内のさまざまな部分を重み付けできます。これにより、シーケンス内のすべての要素間の関係をキャプチャできます。

Transformerエンコーダ層の簡単な例は以下のとおりです:

import torch.nn as nn
import torch.nn.functional as F
 
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        self.d_model = d_model
        self.num_heads = num_heads
        .