PyTorch モデルのトレーニングを高速化するための 9 つのヒント!

[[353240]]

ニューラルネットワークをこのようにしないでください

正直に言えば、あなたのモデルはおそらくまだ石器時代のものでしょう。おそらく、まだ 32 ビット精度や GASP を使用したり、1 つの GPU だけでトレーニングしたりしているのではないでしょうか。

ニューラル ネットワークを高速化する方法に関するガイドはオンライン上にたくさんありますが、チェックリストはありません。このチェックリストを使用して、ステップごとに実行し、モデルのパフォーマンスを最大限に引き出すようにしてください。

このガイドでは、ネットワークを最大限に活用するための最も単純な構成から最も複雑な変更まですべてを網羅しています。 Pytorch-lightning Trainer で使用できる Pytorch コードの例と関連フラグを紹介します。これにより、自分でコードを記述する必要がなくなります。

**このガイドは誰向けですか? **Pytorch を使用してディープラーニング モデルに取り組んでいる人、研究者、博士課程の学生、学者など。ここで説明するモデルのトレーニングには、数日、場合によっては数週間または数か月かかることもあります。

以下を取り上げます:

• DataLoader の使用
• DataLoaderのワーカー数
• バッチサイズ
• 勾配累積
• 保存された計算グラフ
• シングルに移動
• 16ビット混合精度トレーニング
• 複数の GPU への移行 (モデル複製)
• 複数の GPU ノード (8 個以上の GPU) への移行
• モデルの加速について考えるためのヒント

パイトーチライトニング

[[353241]]

ここで説明するすべての最適化は、Pytorch ライブラリ Pytorch-lightning で見つけることができます。 Lightning は Pytorch の上のラッパーであり、トレーニングを自動化しながら研究者に主要なモデル コンポーネントの完全な制御を提供します。 Lightning は最新のベストプラクティスを使用し、間違いが発生する可能性のある場所を最小限に抑えます。

MNIST 用の LightningModel を定義し、Trainer を使用してモデルをトレーニングします。

 pytorch_lightningからTrainerをインポート 
モデル= LightningModule (…)  
トレーナー=トレーナー()  
トレーナー.フィット(モデル)

1. データローダー

おそらく、ここで最も簡単に速度を向上できます。データの読み込みを高速化するために h5py または numpy ファイルを保存する時代は終わりました。Pytorch データローダーを使用すると、画像データの読み込みが簡単になります (NLP データについては、TorchText を参照してください)。

Lightning では、トレーニング ループを指定する必要はなく、dataLoaders と Trainer を定義するだけで、必要なときに呼び出されます。

データセット= MNIST (ルート= self .hparams.data_root、トレーニングトレーニング= train、ダウンロード= True )  
ローダー= DataLoader (データセット、 batch_size = 32 、 shuffle = True )
バッチインローダーの場合:  
  x, y =バッチ   
  モデル.トレーニングステップ(x, y)  
  ...

2. DataLoader のワーカー数

もう 1 つの驚くべき高速化は、バッチ読み込みを並列で実行できることです。したがって、一度に 1 つのバッチをロードする代わりに、一度に nb_workers バッチをロードできます。

 ＃遅い 
ローダー= DataLoader (データセット、 batch_size = 32 、 shuffle = True )  
 # 高速（ワーカーを 10 個使用）
ローダー= DataLoader (データセット、 batch_size = 32 、 shuffle = True 、 num_workers = 10 )

3. バッチサイズ

[[353244]]

次の最適化手順を開始する前に、バッチ サイズを CPU-RAM または GPU-RAM で許可されている最大値まで増やします。

次のセクションでは、バッチ サイズを継続的に増やすためにメモリ フットプリントを削減する方法に焦点を当てます。

学習率を再度更新する必要がある場合があることに注意してください。経験則としては、バッチ サイズが 2 倍になると学習率も 2 倍になるということです。

4. 勾配の蓄積

計算リソースの制限に達した場合、バッチ サイズはまだ小さすぎる (たとえば 8) ため、勾配降下法で適切な推定値を提供するには、より大きなバッチ サイズをシミュレートする必要があります。

バッチ サイズを 128 にしたいとします。バッチ サイズ 8 で 16 回のフォワード パスとバックワード パスを実行し、その後に 1 つの最適化ステップを実行する必要があります。

 # 最後のステップをクリア 
オプティマイザ.zero_grad()  
 # 16 累積勾配ステップ 
スケール損失= 0    
範囲(16)内のaccumulated_step_iの場合:  
出力= model.forward ()  
損失= some_loss (out,y)  
     損失.後方()  
      スケール損失 += loss.item()      
 # 8ステップ後に重みを更新します。実効バッチ= 8 * 16  
オプティマイザ.ステップ()  
 # 損失は累積バッチ数に応じて拡大されるようになりました 
実際の損失=スケール損失/ 16

Lightning では、accumulate_grad_batches=16 を設定するだけですべてが自動的に実行されます。

トレーナー=トレーナー( accumulate_grad_batches = 16 )  
トレーナー.フィット(モデル)

5. 保持された計算グラフ

[[353246]]

記憶力を爆発的に高める最も簡単な方法の 1 つは、損失を記録して保存することです。

損失= []  
 ...  
損失.append(損失)
 print(f'現在の損失: {torch.mean(losses)'})

上記の問題は、損失にグラフ全体のコピーがまだ含まれていることです。この場合は、.item() を呼び出して解放します。

 ![1_CER3v8cok2UOBNsmnBrzPQ](Pytorch で超高速ニューラル ネットワークをトレーニングするための 9 つのヒント.assets/1_CER3v8cok2UOBNsmnBrzPQ.gif)# 悪い 
損失.append(損失)  
 ＃良い 
損失.append(損失.item())

Lightning は、計算グラフのコピーが保持されないように細心の注意を払っています。

6. シングルGPUトレーニング

[[353247]]

前の手順を完了したら、GPU トレーニングに進みます。 GPU でのトレーニングでは、複数の GPU コアにわたって数学的な計算が並列化されます。得られる速度向上は、使用する GPU の種類によって異なります。個人には2080Ti、企業にはV100をお勧めします。

一見すると、これは大変そうに思えるかもしれませんが、実際に必要なことは 2 つだけです。1) モデルを GPU に移動し、2) モデルにデータを実行するたびに、データを GPU に配置します。

 # モデルを GPU に配置する 
モデル.cuda(0)  
 # データを GPU に置きます (変数の Cuda は Cuda のコピーを返します)  
 x x = x.cuda(0)  
 # 現在はGPUで実行されています 
モデル(x)

Lightningを使用する場合は、何もする必要はなく、Trainer(gpus=1)を設定するだけです。

 # トレーニングに GPU 0 を使用するように Lightning に指示します 
トレーナー=トレーナー( gpus =[0])  
トレーナー.フィット(モデル)

GPU でトレーニングするときに注意すべき主な点は、CPU と GPU 間の転送回数を制限することです。

 ＃ 高い 
 x x = x.cuda(0) # 非常に高価 
 x x = x.cpu()  
 x x = x.cuda(0)

メモリが不足している場合は、メモリを節約するためにデータを CPU に戻さないでください。 GPU に頼る前に、他の方法でコードや GPU 間のメモリ配分を最適化してみてください。

もう 1 つ注意すべき点は、GPU 同期を強制する操作を呼び出すことです。メモリ キャッシュをクリアすることが一例です。

 # 本当に悪い考えです。すべての GPU が追いつくまで停止します 
 torch.cuda.empty_cache()

ただし、Lightning を使用する場合、問題が発生する可能性があるのは Lightning モジュールを定義するときだけです。 Lightning はこのような間違いを起こさないように特別な注意を払っています。

7. 16ビット精度

16 ビット精度は、メモリ使用量を半分に削減する驚くべき技術です。ほとんどのモデルは 32 ビット精度の数値を使用してトレーニングされます。しかし、最近の研究では、16 ビット モデルも適切に機能することがわかりました。混合精度とは、一部のものに 16 ビットを使用し、重みなどのものは 32 ビットのままにすることを意味します。

Pytorch で 16 ビットの精度を使用するには、NVIDIA の apex ライブラリをインストールし、モデルに次の変更を加えます。

 # モデルとオプティマイザで16ビットを有効にする 
モデル、オプティマイザ= amp .initialize(モデル、オプティマイザ、 opt_level = 'O2' )  
 # .backward を実行するときは、amp に実行させて損失をスケールできるようにします 
 amp.scale_loss(loss, optimizer) を scaled_loss として使用します。 
     スケール損失.後方()

amp パッケージがこのほとんどを処理します。勾配が爆発したり 0 に近づいたりする場合でも、損失をスケーリングします。

Lightning では、16 ビットを有効にするためにモデルを変更する必要はなく、上記で説明した操作を実行する必要もありません。 Trainer(精度=16)を設定するだけです。

トレーナー=トレーナー( amp_level = 'O2' 、 use_amp = False )  
トレーナー.フィット(モデル)

8. 複数のGPUへの移行

さて、事態は本当に面白くなってきました。マルチ GPU トレーニングを実行する方法は 3 つ (おそらくそれ以上) あります。

バッチトレーニング

A) モデルを各GPUにコピーする、B) 各GPUにバッチの一部を与える

最初のアプローチは「バッチ トレーニング」と呼ばれます。この戦略では、モデルを各 GPU にコピーし、各 GPU がバッチの一部を取得します。

 # 各GPUにモデルをコピーし、バッチの4分の1を各GPUに渡します 
モデル= DataParallel (モデル、デバイス=[0, 1, 2, 3])  
 # out には 4 つの出力があります (各 GPU に 1 つずつ)  
出力=モデル(x.cuda(0))

Lightning では、GPU の数を増やしてトレーナーに伝えるだけで、他に何もする必要はありません。

 # トレーニングに4つのGPUを使用するようにLightningに指示する 
トレーナー=トレーナー( gpus =[0, 1, 2, 3])  
トレーナー.フィット(モデル)

モデル配布トレーニング

モデルの異なる部分を異なるGPUに配置し、バッチを順番に移動する

モデルが大きすぎてメモリ内に完全に収まらない場合があります。たとえば、エンコーダーとデコーダーを備えたシーケンスツーシーケンス モデルでは、出力を生成するときに 20 GB の RAM を消費する可能性があります。この場合、エンコーダーとデコーダーを別々の GPU に配置する必要があります。

 # 各モデルが非常に大きいため、両方をメモリに収めることができません 
エンコーダ_rnn.cuda(0)  
デコーダー_rnn.cuda(1)  
 # GPU 0 のエンコーダーを介して入力を実行する 
エンコーダ出力=エンコーダrnn (x.cuda(0))  
 # 次の GPU のデコーダーを介して出力を実行します 
出力=デコーダー_rnn (エンコーダー_out.cuda(1))  
 # 通常、すべての出力をGPU 0に戻します 
アウトアウト= out.cuda(0)

このタイプのトレーニングでは、Lightning で GPU を指定する必要はありません。LightningModule 内のモジュールを正しい GPU に配置する必要があります。

クラス MyModule(LightningModule):  
    デフ__init__():  
 self.encoder = RNN (...)  
 self.decoder = RNN (...)  
    def forward(x): 
         # モデルは最初の転送後には移動されません。  
        # すでに正しいGPUに搭載されています 
        自己.エンコーダ.cuda(0)  
        自己デコーダーcuda(1)  
出力=自己.encoder(x)  
 out =自己.decoder(out.cuda(1))       
  # トレーナーにGPUを渡さない
モデル= MyModule ()  
トレーナー=トレーナー()  
トレーナー.フィット(モデル)

両方の混合

上記の場合でも、エンコーダーとデコーダーは並列操作のメリットを享受できます。

 # これらの行を変更 
 self.encoder = RNN (...)  
 self.decoder = RNN (...)  
 # これらに 
 # 各 RNN は異なる GPU セットに基づいています 
 self.encoder = DataParallel (self.encoder、デバイス=[0, 1, 2, 3])  
 self.decoder = DataParallel (self.encoder、デバイス=[4、5、6、7])  
 # 転送中...  
出力=自己.encoder(x.cuda(0))  
 # デバイスの最初の GPU の入力を通知 
 sout = self .decoder(out.cuda(4)) # < ---ここでの4

複数の GPU を使用する場合に考慮すべき事項:

• モデルがすでに GPU 上にある場合、model.cuda() は何も実行しません。
• 入力は常にデバイス リストの最初のデバイスに配置します。
• デバイス間でデータを転送するのはコストがかかるため、最後の手段として使用してください。
• オプティマイザーと勾配は GPU 0 に保存されるため、GPU 0 で使用されるメモリは他の GPU よりもはるかに大きくなる可能性があります。

9. マルチノードGPUトレーニング

各マシンの各 GPU ごとにモデルのコピーが存在します。各マシンはデータの一部を取得し、その部分のみをトレーニングします。各マシンは勾配を同期できます。

ここまでくれば、Imagenet をわずか数分でトレーニングできるようになります。これは思ったほど難しくはありませんが、コンピューティング クラスターに関する詳細な知識が必要になる場合があります。これらの手順では、クラスター上で SLURM を使用していることを前提としています。

Pytorch では、各ノードの各 GPU でモデルを複製し、勾配を同期することで、マルチノード トレーニングが可能になります。したがって、各モデルは各 GPU で独立して初期化され、すべてのモデルから勾配更新を受信することを除いて、基本的にデータのパーティションで独立してトレーニングされます。

概要:

1. 各 GPU でモデルのコピーを初期化します (各モデルが同じ重みに初期化されるようにシードを設定してください。そうしないと失敗します)。
2. データセットをサブセットに分割します (DistributedSampler を使用)。各 GPU は独自の小さなサブセットのみをトレーニングします。
3. .backward() では、すべてのレプリカがすべてのモデルの勾配のコピーを受け取ります。これはモデル間の唯一の通信です。

Pytorch には、これを実行する DistributedDataParallel という優れた抽象化があります。 DDP を使用するには、次の 4 つのことを行う必要があります。

 tng_dataloader() を定義します:  
 d = MNIST ()  
     # 4: 分散サンプラーを追加する 
     # サンプラーはtngデータの一部を各マシンに送信します 
 dist_sampler =分散サンプラー(データセット)  
データローダー= DataLoader (d、シャッフル= False 、サンプラー= dist_sampler )     
  main_process_entrypoint(gpu_nb)を定義します。  
     # 2: すべてのマシンのすべてのGPU間の接続を設定する 
     # すべての GPU が単一の GPU「ルート」に接続します 
     # デフォルトでは env:// を使用します 
ワールド= nb_gpus * nb_nodes  
     dist.init_process_group("nccl",ランク= gpu_nb 、ワールドworld_size = world)        
      # 3: DPPでモデルをラップする 
     torch.cuda.set_device(gpu_nb)  
     モデル.cuda(gpu_nb)  
モデル= DistributedDataParallel (モデル、デバイスID =[gpu_nb])     
      # 今すぐモデルをトレーニングします...     
  __name__ == '__main__' の場合:  
     # 1: プロセスの数を生成する 
     # クラスターは各マシンに対してmainを呼び出します 
     mp.spawn(メインプロセスエントリポイント、 nprocs = 8 )

ただし、Lightning では、ノードの数を設定するだけで、残りの作業は自動的に処理されます。

 # 128 ノードの 1024 GPU でトレーニング
トレーナー=トレーナー( nb_gpu_nodes = 128 、 gpus =[0、1、2、3、4、5、6、7])

Lightning には SlurmCluster マネージャーも付属しており、SLURM ジョブの正しい詳細を送信するのに便利です。

10. メリット！単一ノードで複数のGPUを使用してトレーニングを高速化

分散データ並列は勾配同期のための通信のみを実行するため、データ並列よりもはるかに高速であることがわかります。したがって、単一のマシンでトレーニングする場合でも、DataParallel ではなく、distributedDataParallel を使用するのがよい方法です。

Lightning では、distributed_backend を ddp に設定し、GPU の数を設定することでこれを簡単に実現できます。

 # 同じマシン上の 4 つの GPU でトレーニングすると、DataParallel よりもはるかに高速になります 
トレーナー=トレーナー(分散バックエンド= 'ddp' 、 gpus = [0, 1, 2, 3])

モデルの加速に関する考察

このガイドでは、ネットワーク速度を向上させるためのヒントをいくつか紹介しますが、ボトルネックを見つけて問題を考える方法についても説明します。

モデルをいくつかの部分に分割しました。

まず、データの読み込みにボトルネックがないことを確認します。このために、私は説明した既存のデータ読み込みソリューションを使用しましたが、それらのソリューションのいずれもニーズを満たさない場合は、オフライン処理と h5py などの高性能データ ストアへのキャッシュを検討してください。

次に、トレーニング ステップで何を行うかを見てみましょう。フォワードパスが高速であることを確認し、過剰な計算を避け、CPU と GPU 間のデータ転送を最小限に抑えます。最後に、GPU の速度を低下させるようなことは避けてください (このガイドで説明されています)。

次に、通常は GPU メモリのサイズによって制限されるバッチ サイズを最大化しようとしました。ここで、大きなバッチ サイズを使用する場合に、複数の GPU 間でレイテンシを分散して最小限に抑える方法に焦点を当てる必要があります (たとえば、複数の GPU 間で 8000 以上の有効バッチ サイズを使用することを試みる場合があります)。

ただし、バッチサイズが大きい場合は注意が必要です。具体的な質問については、関連する文献を調べて、人々が何を見落としているかを確認してください。