Deepspeed スキル

公式ドキュメントから生成されたdeepspeed開発の包括的なサポート。

このスキルを使用する場合

このスキルは以下の場合にトリガーされます：

• deepspeedで作業する場合
• deepspeedの機能またはAPIについて質問する場合
• deepspeedソリューションを実装する場合
• deepspeedコードをデバッグする場合
• deepspeedのベストプラクティスを学ぶ場合

クイックリファレンス

一般的なパターン

パターン1: DeepNVMe コンテンツ要件 DeepNVMe ハンドルの作成 DeepNVMe ハンドルの使用 ブロッキングファイル書き込み ノンブロッキングファイル書き込み 並列ファイル書き込み ピン留めされたテンソル まとめ 謝辞 付録 高度なハンドル作成 パフォーマンス チューニング DeepNVMe API 一般的な I/O API GDS固有の API ハンドル設定 API このチュートリアルでは、永続ストレージとホストメモリまたはデバイスメモリに配置されるテンソル間でのデータ転送にDeepNVMeを使用する方法を示します。DeepNVMeは、不揮発性メモリエクスプレス（NVMe）ソリッドステートドライブ（SSD）、Linux非同期I/O（libaio）、およびNVIDIA Magnum IO™ GPUDirect®ストレージ（GDS）に基づいた強力な最適化を通じて、ディープラーニングアプリケーションのI/O操作のパフォーマンスと効率を向上させます。

要件 DeepNVMeを使用するために環境が正しく設定されていることを確認してください。まず、DeepSpeed バージョン >= 0.15.0 をインストールする必要があります。次に、DeepNVMe オペレータが DeepSpeed インストール内で利用可能であることを確認してください。任意のDeepNVMe機能にはasync_ioオペレータが必要であり、GDS機能にはgdsオペレータのみが必要です。ds_reportの出力を検査して、互換性ステータスが[OKAY]であることを確認することで、各オペレータの利用可能性を確認できます。以下は、async_ioとgdsオペレータの両方の利用可能性を確認するds_reportの出力スニペットです。async_ioオペレータが利用できない場合は、Linuxフレーバー用に適切なlibaioライブラリバイナリをインストールする必要があります。たとえば、Ubuntuユーザーはapt install libaio-devを実行する必要があります。一般的に、ds_reportの出力を慎重に検査して、以下のような有用なヒントを確認する必要があります：

[WARNING] async_ioにはdev libaio .soオブジェクトとヘッダーが必要ですが、見つかりません。 [WARNING] async_io: apt でlibaio-devパッケージをインストールしてください [WARNING] libaioが既にインストール済み（おそらくソースから）の場合は、CFLAGS と LDFLAGS 環境変数を見つけられる場所に設定してください。

gdsオペレータを有効にするには、ベアメタルシステムまたはAzure VM用の適切なガイドを参照してNVIDIA GDSをインストールする必要があります（近日公開予定）。

DeepNVMe ハンドルの作成

DeepNVMe機能には、aio_handleとgds_handleという2つの抽象化を通じてアクセスできます。aio_handleはホストおよびデバイステンソルの両方で使用可能です。一方、gds_handleはCUDATensorのみで機能しますが、より効率的です。DeepNVMeを使用するための最初のステップは、目的のハンドルを作成することです。aio_handleはasync_ioオペレータが必要であり、gds_handleはasync_ioとgdsオペレータの両方が必要です。以下のスニペットは、それぞれaio_handleとgds_handleの作成を示しています。

aio_handleの作成

from deepspeed.ops.op_builder import AsyncIOBuilder
aio_handle = AsyncIOBuilder().load().aio_handle()

gds_handleの作成

from deepspeed.ops.op_builder import GDSBuilder
gds_handle = GDSBuilder().load().gds_handle()

簡潔にするため、上記の例はデフォルトパラメータを使用したハンドル作成を示しています。デフォルトパラメータで作成されたハンドルは、ほとんどの環境で良好なパフォーマンスを提供することが期待されます。ただし、以下の高度なハンドル作成を参照してください。

DeepNVMe ハンドルの使用

aio_handleとgds_handleは、ファイルへのテンソル保存またはファイルからのテンソル読み込み用の同一のAPIを提供します。これらのAPIの共通の特徴は、目的のI/O操作の引数としてテンソルとファイルパスを取ることです。最適なパフォーマンスのため、I/O操作にはピン留めされたデバイスまたはホストテンソルを使用する必要があります（詳細はここを参照）。簡潔にするため、このチュートリアルではaio_handleを使用して説明しますが、gds_handleも同様に機能することに注意してください。利用可能なAPIはPythonシェルでaio_handleオブジェクトのタブ補完を通じて確認できます。これは h... のタブ補完を使用して説明されています。

>python
Python 3.10.12 (main, Jul 29 2024, 16:56:48)
[GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from deepspeed.ops.op_builder import AsyncIOBuilder
>>> h = AsyncIOBuilder().load().aio_handle()
>>> h.
h.async_pread(
h.free_cpu_locked_tensor(
h.get_overlap_events(
h.get_single_submit(
h.new_cpu_locked_tensor(
h.pwrite(
h.sync_pread(
h.wait(
h.async_pwrite(
h.get_block_size(
h.get_queue_depth(
h.get_intra_op_parallelism(
h.pread(
h.read(
h.sync_pwrite(
h.write(

関心のあるAPIは、preadとpwriteサブストリングを含む名前のものです。簡潔にするため、ファイル書き込みAPI、すなわちsync_pwrite、async_pwrite、およびpwriteに焦点を当てます。これらは pwrite の特殊化であるため、以下では sync_pwrite と async_pwrite のみについて説明します。

ブロッキングファイル書き込み

sync_pwriteは、Pythonファイル書き込みの標準的なブロッキングセマンティクスを提供します。以下の例は、sync_pwriteを使用して1GBのCUDATensorをローカルNVMeファイルに保存する方法を示しています。

>>> import os
>>> os.path.isfile('/local_nvme/test_1GB.pt')
False
>>> import torch
>>> t=torch.empty(1024**3, dtype=torch.uint8).cuda()
>>> from deepspeed.ops.op_builder import AsyncIOBuilder
>>> h = AsyncIOBuilder().load().aio_handle()
>>> h.sync_pwrite(t,'/local_nvme/test_1GB.pt')
>>> os.path.isfile('/local_nvme/test_1GB.pt')
True
>>> os.path.getsize('/local_nvme/test_1GB.pt')
1073741824

ノンブロッキングファイル書き込み

重要なDeepNVMe最適化は、ノンブロッキングI/Oセマンティクスであり、PythonスレッドがI/O操作と計算をオーバーラップできます。async_pwriteはファイル書き込みのノンブロッキングセマンティクスを提供します。Pythonスレッドは後でwait()を使用してI/O操作と同期できます。async_writeはまた複数の背中合わせのノンブロッキングI/O操作を送信するためにも使用でき、これらはその後単一のwait()を使用してブロックされる可能性があります。以下の例は、async_pwriteを使用して1GBのCUDATensorをローカルNVMeファイルに保存する方法を示しています。

>>> import os
>>> os.path.isfile('/local_nvme/test_1GB.pt')
False
>>> import torch
>>> t=torch.empty(1024**3, dtype=torch.uint8).cuda()
>>> from deepspeed.ops.op_builder import AsyncIOBuilder
>>> h = AsyncIOBuilder().load().aio_handle()
>>> h.async_pwrite(t,'/local_nvme/test_1GB.pt')
>>> h.wait()
1
>>> os.path.isfile('/local_nvme/test_1GB.pt')
True
>>> os.path.getsize('/local_nvme/test_1GB.pt')
1073741824

ノンブロッキングI/O操作の警告：データレースと破損を回避するため、.wait()は送信元テンソルの書き込みと宛先テンソルの読み込みをシリアル化するために注意深く使用する必要があります。たとえば、ノンブロッキングファイル書き込み中のtの以下の更新は安全でなく、/local_nvme/test_1GB.ptを破損する可能性があります。

>>> t=torch.empty(1024**3, dtype=torch.uint8).cuda()
>>> from deepspeed.ops.op_builder import AsyncIOBuilder
>>> h = AsyncIOBuilder().load().aio_handle()
>>> h.async_pwrite(t,'/local_nvme/test_1GB.pt')
>>> t += 1  # <--- データレース；h.wait()を前に置いて回避

同様の安全性の問題は、.wait()同期なしでノンブロッキングファイル読み込みの宛先テンソルを読み込むことに適用されます。

並列ファイル書き込み

重要なDeepNVMe最適化は、個別のI/O操作を並列化する能力です。この最適化は、DeepNVMeハンドルを構築するときに目的の並列化の度合いを指定することで有効になります。その後のそのハンドルとのI/O操作は、要求されたホストまたはデバイススレッドの数に自動的に並列化されます。I/O並列化はブロッキングまたはノンブロッキングI/O APIのいずれかと組み合わせ可能です。以下の例は、async_pwriteを使用したファイル書き込みの4方向並列化を示しています。ハンドル作成で並列化の度合いを指定するためにintra_op_parallelism引数の使用に注目してください。

>>> import os
>>> os.path.isfile('/local_nvme/test_1GB.pt')
False
>>> import torch
>>> t=torch.empty(1024**3, dtype=torch.uint8).cuda()
>>> from deepspeed.ops.op_builder import AsyncIOBuilder
>>> h = AsyncIOBuilder().load().aio_handle(intra_op_parallelism=4)
>>> h.async_pwrite(t,'/local_nvme/test_1GB.pt')
>>> h.wait()
1
>>> os.path.isfile('/local_nvme/test_1GB.pt')
True
>>> os.path.getsize('/local_nvme/test_1GB.pt')
1073741824

ピン留めされたテンソル

DeepNVMe最適化の重要な部分は、I/O操作用の直接メモリアクセス（DMA）を使用することであり、ホストまたはデバイステンソルがピン留めされている必要があります。ホストテンソルをピン留めするには、PyTorchまたはDeepSpeed Acceleratorsが提供するメカニズムを使用できます。以下の例は、ピン留めされたCPUテンソルをローカルNVMeファイルに書き込む方法を示しています。

>>> import os
>>> os.path.isfile('/local_nvme/test_1GB.pt')
False
>>> import torch
>>> t=torch.empty(1024**3, dtype=torch.uint8).pin_memory()
>>> from deepspeed.ops.op_builder import AsyncIOBuilder
>>> h = AsyncIOBuilder().load().aio_handle()
>>> h.async_pwrite(t,'/local_nvme/test_1GB.pt')
>>> h.wait()
1
>>> os.path.isfile('/local_nvme/test_1GB.pt')
True
>>> os.path.getsize('/local_nvme/test_1GB.pt')
1073741824

一方、gds_handleはnew_pinned_device_tensor()およびpin_device_tensor()関数を提供してCUDATensorをピン留めします。以下の例は、ピン留めされたCUDATensorをローカルNVMeファイルに書き込む方法を示しています。

>>> import os
>>> os.path.isfile('/local_nvme/test_1GB.pt')
False
>>> import torch
>>> t=torch.empty(1024**3, dtype=torch.uint8).cuda()
>>> from deepspeed.ops.op_builder import GDSBuilder
>>> h = GDSBuilder().load().gds_handle()
>>> h.pin_device_tensor(t)
>>> h.async_pwrite(t,'/local_nvme/test_1GB.pt')
>>> h.wait()
1
>>> os.path.isfile('/local_nvme/test_1GB.pt')
True
>>> os.path.getsize('/local_nvme/test_1GB.pt')
1073741824
>>> h.unpin_device_tensor(t)

まとめ

上記の資料がDeepNVMeを始めるのに役立つことを望んでいます。以下のリンクを使用して、実際のディープラーニングアプリケーションにおけるDeepNVMeの使用も確認できます。

• ZeRO-InferenceおよびZeRO-Infinityのパラメータスワッパー
• ZeRO-Infinityのオプティマイザスワッパー
• ZeRO-Infinityの勾配スワッパー
• シンプルなファイルの読み書き操作

謝辞

このチュートリアルは、Guanhua Wang、Masahiro Tanaka、およびStas Bekmanからのフィードバックによって大幅に改善されました。

付録

高度なハンドル作成

DeepNVMeで最高のI/Oパフォーマンスを達成するには、ハンドル作成の慎重な設定が必要です。特に、aio_handleおよびgds_handleコンストラクタのパラメータはパフォーマンス上重要です。なぜなら、DeepNVMeが基盤となるストレージサブシステム（つまり、libaio、GDS、PCIe、およびSSD）とどのように相互作用するかを決定するからです。便宜上、デフォルトパラメータ値を使用してハンドルを作成することが可能にされており、これはほとんどのシナリオで適切なパフォーマンスを提供します。ただし、環境で利用可能なすべてのパフォーマンスを絞り出すには、おそらくコンストラクタパラメータの調整が必要になります。すなわち、block_size、queue_depth、single_submit、overlap_events、およびintra_op_parallelismです。

aio_handleコンストラクタパラメータとデフォルト値は以下で示されています：

>>> from deepspeed.ops.op_builder import AsyncIOBuilder
>>> help(AsyncIOBuilder().load().aio_handle())
Help on aio_handle in module async_io object:
class aio_handle(pybind11_builtins.pybind11_object)
 | Method resolution order:
 | aio_handle
 | pybind11_builtins.pybind11_object
 | builtins.object
 |
 | Methods defined here:
 |
 | __init__(...)
 | __init__(self: async_io.aio_handle, block_size: int = 1048576, queue_depth: int = 128, single_submit: bool = False, overlap_events: bool = False, intra_op_parallelism: int = 1) -> None
 |
 | AIO ハンドルコンストラクタ

パフォーマンス チューニング

前述のように、ターゲットのワークロードまたは環境のためにピークDeepNVMeパフォーマンスを達成するには、最適に設定されたaio_handleまたはgds_handleハンドルを使用する必要があります。設定の利便性のために、最適なDeepNVMe設定の発見を自動化するds_nvme_tuneというユーティリティを提供しています。

ds_nvme_tuneはユーザー指定またはデフォルト設定空間を自動的に探索し、最適な読み取りおよび書き込みパフォーマンスを提供するオプションを推奨します。以下は、/local_nvmeにマウントされたローカルNVMe SSD間のGPUメモリとのaio_handleデータ転送のチューニングにds_nvme_tuneを使用する例です。この例はds_nvme_tuneのデフォルト設定空間を使用してチューニングしました。

$ ds_nvme_tune --nvme_dir /local_nvme --gpu
Running DeepNVMe performance tuning on ['/local_nvme/']
Best performance (GB/sec): read = 3.69, write = 3.18
{
  "aio": {
    "single_submit": "false",
    "overlap_events": "true",
    "intra_op_parallelism": 8,
    "queue_depth": 32,
    "block_size": 1048576
  }
}

上記のチューニングは、2つのNVIDIA A6000-48GB GPU、252GBのDRAM、ピーク読み書き速度がそれぞれ5.6 GB/sおよび4.3 GB/sのCS3040 NVMe 2TB SDDを備えたLambdaワークステーションで実行されました。チューニングには約4分半かかりました。結果に基づいて、以下のように設定されたaio_handleを使用することで、読み取りおよび書き込み転送速度がそれぞれ3.69 GB/secおよび3.18 GB/secであることが期待できます。

>>> from deepspeed.ops.op_builder import AsyncIOBuilder
>>> h = AsyncIOBuilder().load().aio_handle(block_size=1048576, queue_depth=32, single_submit=False, overlap_events=True, intra_op_parallelism=8)

ds_nvme_tuneのフルコマンドラインオプションは、通常の-hまたは--helpで取得できます。

usage: ds_nvme_tune [-h] --nvme_dir NVME_DIR [NVME_DIR ...] [--sweep_config SWEEP_CONFIG] [--no_read] [--no_write] [--io_size IO_SIZE] [--gpu] [--gds] [--flush_page_cache] [--log_dir LOG_DIR] [--loops LOOPS] [--verbose]

options:
  -h, --help            show this help message and exit
  --nvme_dir NVME_DIR [NVME_DIR ...]
                        Directory in which to perform I/O tests. A writeable directory on a NVMe device.
  --sweep_config SWEEP_CONFIG
                        Performance sweep configuration json file.
  --no_read             Disable read performance measurements.
  --no_write            Disable write performance measurements.
  --io_size IO_SIZE     Number of I/O bytes to read/write for performance measurements.
  --gpu                 Test tensor transfers between GPU device and NVME device.
  --gds                 Run the sweep over NVIDIA GPUDirectStorage operator
  --flush_page_cache    Page cache will not be flushed and reported read speeds may be higher than actual ***Requires sudo access***.
  --log_dir LOG_DIR     Output directory for performance log files. Default is ./_aio_bench_logs
  --loops LOOPS         Count of operation repetitions
  --verbose             Print debugging information.

DeepNVMe API

便宜上、DeepNVMe APIのリストと簡潔な説明を提供します。

一般的な I/O API

以下の関数は、aio_handleとgds_handleの両方でのI/O操作に使用されます。

関数	説明
async_pread	テンソルへのノンブロッキングファイル読み込み
sync_pread	テンソルへのブロッキングファイル読み込み
pread	ブロッキングおよびノンブロッキングオプション付きのファイル読み込み
async_pwrite	テンソルからのノンブロッキングファイル書き込み
sync_pwrite	テンソルからのブロッキングファイル書き込み
pwrite	ブロッキングおよびノンブロッキングオプション付きのファイル書き込み
wait	ノンブロッキングI/O操作の完了を待つ

GDS固有の API

以下の関数はgds_handleに対してのみ利用可能です

関数	説明
new_pinned_device_tensor	デバイステンソルを割り当ててピン留めする
free_pinned_device_tensor	デバイステンソルをピン留め解除して解放する
pin_device_tensor	デバイステンソルをピン留めする
unpin_device_tensor	デバイステンソルをピン留め解除する

ハンドル設定 API

以下のAPIはハンドル設定を調べるために使用できます。

関数	説明
get_queue_depth	キュー深度設定を返す
get_single_submit	single_submitが有効であるかどうかを返す
get_intra_op_parallelism	I/O並列化の度合いを返す
get_block_size	I/Oブロックサイズ設定を返す
get_overlap_events	overlap_eventが有効であるかどうかを返す

更新日：2025年11月5日 前へ 次へ

libaio

パターン2: NLGモデルのための専門家の混合 コンテンツ 1. インストール 2. NLG+MoEモデルのトレーニング 2.1. モデルへの変更 2.2. 標準MoEモデルの事前トレーニング 2.3. PR-MoEモデルの事前トレーニング 2.4. モデルサイズを削減したMoSのトレーニング このチュートリアルでは、DeepSpeed Mixture of Experts（MoE）をNLGモデルに適用する方法を紹介します。これはトレーニング コストを5倍削減し、MoEモデルサイズを3倍削減します（詳細はブログを参照）。Megatron-LMフレームワークのGPT-3のようなモデルを例として使用します。このチュートリアルを読む前に、まずMixture of Expertsと Megatron-LM GPT事前トレーニングに関するチュートリアルを読むことをお勧めします。

1. インストール

DeepSpeed v0.6.0以上をインストールしてMoE機能を使用する必要があります。NLGモデルの例のためのMoEはMegatron-DeepSpeedリポジトリのMoEフォルダの下にあります。

2. NLG+MoE モデルのトレーニング

2.1. モデルへの変更

MoEをGPTスタイルモデルに適用するために、Megatronフレームワークで複数の変更を加えました。主にmegatron/model/にあり、モデルにMoEレイヤーを追加します。

2.2. 標準MoE モデルの事前トレーニング

examples_deepspeed/MoEの下に例トレーニングスクリプトを提供しています。これはブログで実験を実行するために使用しました。標準MoEモデルのための新しいハイパーパラメータがいくつかあります：

--num-experts: MoEレイヤーごとの専門家の数。実験では128に設定しました。より多くの専門家はより良い収束を提供する傾向がありますが、それは収穫逓減です。

--moe-expert-parallel-size: MoE専門家並列化の度合い。言い換えれば、各GPU上にはnum-experts/moe-expert-parallel-sizeの専門家がいます。したがって--moe-expert-parallel-sizeはGPUの数とも--num-expertsも超えてはいけません。

--moe-loss-coeff: モデルロスへのMoEロス追加のためのスケーリング係数。実験では0.01が良い設定であることがわかりました。

--moe-train-capacity-factor, --moe-eval-capacity-factor, --moe-min-capacity: これらの設定は、単一の専門家が処理できるトークン数を決定します。より大きな数はより良い収束をもたらす可能性がありますが、異なる専門家間での負荷がより不均衡になるため、トレーニングが遅くなります。

--disable-moe-token-dropping: これは単一の専門家が処理できるトークン数の制限を完全に削除します。上記と同じ理由から、推論/評価の際にのみこれを使用することをお勧めします。

2.3. PR-MoE モデルの事前トレーニング

PR-MoEは新しく設計されたMoEモデルで、Pyramid-Residual-MoEの略です。これは標準MoEと比較してパラメータ効率を最大3倍向上させます。詳細についてはブログを参照してください。examples_deepspeed/MoEの下に例トレーニングスクリプトを提供しています。標準MoEと比較して、PR-MoEモデルのハイパーパラメータが異なるいくつかあります：

--num-experts: 単一の数字を提供する代わりに、Pyramid-MoEを有効にするには、長さはMoEレイヤーの数と同じであるリストを提供する必要があります。モデルの後期段階（出力に近い）でより多くの専門家を使用することをお勧めします。

--mlp-type: [standard, residual]から選択。residualの場合、Residual-MoEが有効になります。

標準MoEとPR-MoEのための上記の新しいハイパーパラメータに加えて、NLG+MoEモデルのために、ベースの密度モデルと比較して学習率を低下させ、学習率減衰期間を増加させることが役立つことがわかりました。チューニングの詳細は、例のトレーニングスクリプトで見つけることができます。トレーニングデータに関して、内部データをリリースすることはできませんが、Megatron-LMの事前トレーニング用の任意の公開データを直接使用してMoEモデルをトレーニングできます（ただし、実験のモデルの品質とまったく同じことを提供しないかもしれません）。たとえば、Pileデータセット（pile.eleuther.ai、github.com/EleutherAI/the-pile）を密度とMoEの両方のモデルで評価しました。以下の表1は、この公開データが内部データと同様の評価結果を提供することを示しています。

モデルサイズ	LAMBADA: 完成予測	PIQA: 常識推論	BoolQ: 読解	RACE-h: 読解	TriviaQA: 質問応答	WebQs: 質問応答
Dense NLG: 350M, 内部データ	0.5203	0.6931	0.5364	0.3177	0.0321	0.0157
350M, public Pile	0.5106	0.6589	0.5933	0.3196	0.0257	0.0064
Standard MoE NLG: 350M+MoE-128, 内部データ	0.6270	0.7459	0.6046	0.3560	0.1658	0.0517
350M+MoE-128, public Pile	0.6128	0.7323	0.6040	0.3349	0.1111	0.0335
PR-MoE NLG: 350M+MoE-128, 内部データ	0.6365	0.7399	0.5988	0.3569	0.1630	0.0473
PR-MoE + MoS NLG: 350M+MoE-128, 内部データ	0.6346	0.7334	0.5807	0.3483	0.1369	0.0522

表1：異なる密度とMoE NLGモデルのゼロショット評価結果（最後の6列）。すべてのゼロショット評価結果は精度メトリックを使用します。

2.4. モデルサイズを削減したMoS のトレーニング

MoS（Mixture-of-Students）は、大規模MoEモデルを圧縮するためのステージ蒸留ベースのテクニックです。MoSはモデルサイズをさらに12.5%削減し、標準MoEと比較してPR-MoEと組み合わせると最大3.7倍のモデルサイズ削減をもたらします。削減されたモデルサイズは推論中のレイテンシーとコストの削減に役立ちます。MoSモデルをトレーニングするには、いくつかの追加パラメータを指定する必要があります。PR-MoEを例として使用します：

--mos: これは知識蒸留を介してMixture-of-Studentsを有効にします。

--load-teacher: これは教師モデルチェックポイントのパスを指定します。これはMoSを使用するための必須引数であり、教師モデルチェックポイントは標準MoEまたはPR-MoEをトレーニングすることで取得できます。

num-layers-teacher, --hidden-size-teacher, --hidden-size-teacher, --num-experts-teacher: 教師モデルチェックポイントパスに加えて、レイヤー数、隠れ次元サイズ、MoEレイヤーごとの専門家の数などの教師モデルアーキテクチャも指定する必要があります。PR-MoEの場合、教師モデルの専門家のリストも提供する必要があります。そこではいくつかの専門家レイヤーを教師モデルから削除します。

上記の新しいパラメータに加えて、トレーニング全体を通じて教師PR-MoEを使用することは、最終的な学生モデルの精度に悪影響を与える可能性があることを観察しています。実験では、ステージ蒸留法を使用して、トレーニング過程の早期に蒸留を停止し（例えば、400Kステップ後）、トレーニングの残りについては標準言語モデルロスに対してのみ最適化を実行します。examples_deepspeed/MoEの下に例トレーニングスクリプトを提供しています。パラメータ設定の詳細は、例のトレーニングスクリプトで見つけることができます。MoSのパフォーマンス結果は、ブログポストと論文から見ることができます。

更新日：2025年11月5日 前へ 次へ

megatron/model/

パターン3: MoS（Mixture-of-Students）は、大規模MoEモデルを圧縮するためのステージ蒸留ベースのテクニックです。MoSはモデルサイズをさらに12.5%削減し、標準MoEと比較してPR-MoEと組み合わせると最大3.7倍のモデルサイズ削減をもたらします。削減されたモデルサイズは推論中のレイテンシーとコストの削減に役立ちます。MoSモデルをトレーニングするには、いくつかの追加パラメータを指定する必要があります。PR-MoEを例として使用します：

--mos

パターン4: 学習率範囲テスト コンテンツ 学習率範囲テスト（LRRT） 前提条件 LRRTパラメータ 必要なモデル構成の変更 PyTorchの例：大規模バッチサイズのチューニング このチュートリアルは、PyTorchで学習率範囲テストを実行するためにを使用する方法を示しています。

学習率範囲テスト（LRRT）

学習率範囲テスト（LRRT）は、発散なしにモデルをトレーニングするために使用できる最大学習率値を発見するための方法です。データサイエンティストは、大きな学習率が小さい学習率よりも速いモデル収束につながるため、この情報に関心を持つことが多いです。さらに、大きな学習率はCLRおよび1Cycleなどの学習率スケジュールで重要です。これらは大きなバッチサイズで効果的にトレーニングするために使用されます。DeepSpeedはPyTorchフレームワークのモデルトレーニングのためにLRRTを提供します。

前提条件

DeepSpeedのLRRTを使用するには、次の2つの条件を満たす必要があります：

入門ガイドを使用してトレーニングスクリプトにDeepSpeedを統合します。LRRTを設定するためのパラメータをモデルのパラメータに追加します。LRRTパラメータは以下で定義されています。

LRRT パラメータ

LRRTは、事前定義された量の学習率を事前定義された間隔で線形に増加させることで機能します。したがって、LRRTはモデルトレーニング中に学習率がどのように、いつ変わるかを定義するため、学習率スケジュールの形式です。LRRTを設定するには、これらのパラメータを設定する必要があります：

lr_range_test_min_lr: トレーニングの初期学習率（フロート）

lr_range_test_step_size: 学習率をスケールアップする間隔。トレーニングステップで定義（整数）

lr_range_test_step_rate: 学習率を増加させるためのスケーリング係数（フロート）

lr_range_test_staircase: 真の場合、学習率はlr_range_test_step_sizeトレーニングステップごとに変更されます。そうでない場合、学習率はトレーニングステップごとに変更されます（ブール値）

必要なモデル構成の変更

次のLRRTスケジュールの例を使用して、必要なモデル構成の変更を説明します：

初期学習率0.0001でトレーニングを開始します スケーリング率5を使用します スケーリング間隔200トレーニングステップを使用します 学習率をトレーニングステップごとにスケーリングします。つまり、階段を使用しません

PyTorch

PyTorchモデルの場合、LRRTは学習率スケジューラとして実装されます。これは、PyTorchバージョン1.0.1以降で利用可能な機能です。したがって、以下に示すように、"LRRangeTest"型の"scheduler"エントリをモデル構成に追加できます：

"scheduler": {
  "type": "LRRangeTest",
  "params": {
    "lr_range_test_min_lr": 0.0001,
    "lr_range_test_step_size": 200,
    "lr_range_test_step_rate": 5,
    "lr_range_test_staircase": false
  }
}

例：大規模バッチサイズのチューニング

1つのGPU（バッチサイズ512）から4つのGPU（バッチサイズ2048）に拡張する際の、大規模バッチサイズで効率的に収束するための内部本番モデルのチューニング経験を含む、LRRTがデータサイエンティストにどのように役立つかを説明する例を示します。目標は、同じ量のデータサンプルを使用して、より小さなバッチサイズのパフォーマンスと一致させるために、より大規模なバッチサイズでモデルをトレーニングすることです。ここでの課題は、大規模なバッチサイズトレーニングの遅い収束の既知の問題です。私たちのアプローチは、DeepSpeedの1Cycleスケジュールを使用してこの問題に取り組み、LRRTを使用してスケジュールを設定することでした。以下のプロットでは、LRRTを使用してバッチサイズ2048での効果的なトレーニングのための最大学習率を発見する方法を示しています。左のプロットは、トレーニングの最初の9000バッチ上の検証ロスに対する大規模学習率の影響を示しています。右のプロットは、同じ期間のトレーニング中の学習率値を示しています。グリッドサーチを使用して、バッチサイズ2048の最適な固定学習率が0.0002であることを発見しました。青い線（lr=0.0002）は、この固定学習率でトレーニングを表します。このプロットを2つのLRRTスケジュールと比較します。オレンジ色（lr_range_test_step_rate=5）および灰色（lr_range_test_step_rate=50）の線は、lr_range_test_step_rate値のみが異なる同様のLRRTスケジュールを表します。LRRTスケジュールは同じベース学習率から開始されていますが、灰色の線の学習率はオレンジ色の線よりも約10倍速く成長します。さらに、LRRTスケジュールの学習率は、提示されたデータポイントではブルーラインのそれより大きく成長していました。その後、灰色の線を「速く成長」LRRTスケジュール、オレンジ色の線を「遅く成長」LRRTスケジュールと呼びます。この小さな例から、次の観察を行います。

より大きな学習率は明らかにモデルのパフォーマンスに利益をもたらし、ある時点まで。高速成長LRRTスケジュールは、固定学習率が9000バッチで達成しない3000バッチ後に0.46の検証ロスを達成します。遅く成長するLRRTは6000バッチ後までそのスコアと一致していませんが、固定学習率に対して継続的なパフォーマンス上の利点を維持します。

トレーニングモデルに有用な学習率値の上限があります。速く成長するLRRTスケジュールはこの境界に迅速に当たり、発散しますが、同じ理由で遅く成長するLRRTは後に発散します。

LRRTは、トレーニングデータの2%未満を使用して、これらの境界を迅速に発見するのに役立ちました。これらの境界は、学習率スケジュールを構築するための有用な情報です。

LRRTからの観察は、以下に示される問題を解決する1Cycleスケジュールの学習率境界とサイクルスパンを設定するのに役立ちました。

"OneCycle": {
  "cycle_min_lr": 0.002,
  "cycle_max_lr": 0.005,
  "cycle_first_step_size": 2000,
  "cycle_second_step_size": 2000,
  ...
}

経験では、これらは1Cycleスケジュールの4つの最も重要なパラメータです。より遅いLRRTスケジュール（lr_range_test_step_rate=5）を使用してcycle_min_lrを設定しました。これは最良のロスを達成し、高速なスケジュールは十分に迅速に発散するからです。cycle_max_lrを0.005に設定しました。プロットはパフォーマンスがわずかに高い学習率で改善し続けていることを示しているにもかかわらず。これは、最大学習率まで待つと、モデルが発散の時点にあり、回復不可能な可能性があることを観察したためです。学習率が0.005になるまでに8000バッチがかかるため、cycle_first_step_size と（cycle_second_step_size）を2000に設定しました。これは、4つのGPUが8000バッチを処理するのに必要なステップ数です。この簡潔な例があなた自身のユニークなチューニング課題のためにLRRTを使用するためのあなたの想像力を引き出すことを望んでいます。

更新日：2025年11月5日 前へ 次へ

lr_range_test_min_lr

パターン5: トレーニング概要と機能 コンテンツ 概要 容易な分散、効果的、および効率的なトレーニング スピード メモリ効率 スケーラビリティ 通信効率 データ効率 長いシーケンス長のサポート 効果的な高速収束 良好なユーザビリティ 機能 分散トレーニング混合精度 混合精度トレーニング シングルGPU、マルチGPU、およびマルチノードトレーニング パイプライン並列化 モデル並列化 カスタムモデル並列化のサポート Megatron-LMとの統合 ゼロ冗長オプティマイザ オプティマイザ状態と勾配パーティショニング アクティベーション パーティショニング 定数バッファ最適化（CBO） 連続メモリ最適化（CMO） ZeRO-Offload 追加のメモリと帯域幅の最適化 スマート勾配蓄積 通信オーバーラップ トレーニング機能 簡略化されたトレーニング API アクティベーション チェックポイント API 勾配クリッピング 混合精度で自動損失スケーリング トレーニング オプティマイザ 最大26倍少ない通信を備えた1-bit Adam、0/1 Adam、および1-bit LAMBオプティマイザ フューズドアダムオプティマイザと任意のtorch.optim.Optimizer CPU-Adam：Adamの高パフォーマンスベクトル化実装 メモリ帯域幅最適化FP16オプティマイザ LAMB オプティマイザを使用した大規模バッチトレーニング ZeRO Optimizerでのメモリ効率トレーニング トレーニング不可知チェックポイント 高度なパラメータサーチ 学習率範囲テスト 1Cycle学習率スケジュール 簡略化されたデータローダー データ効率 カリキュラム学習 パフォーマンス分析とデバッグ ウォールクロック分解 アクティベーション チェックポイント機能のタイミング Flopsプロファイラー オートチューニング 通信ログ スパース注意 Mixture of Experts（MoE） 概要 高度なディープラーニングモデルのトレーニングは困難です。モデルの設計を超えて、モデル科学者はまた、分散トレーニング、混合精度、勾配蓄積、チェックポイントなどの最先端のトレーニング技術を設定する必要があります。それでも、科学者は望ましいシステムパフォーマンスと収束率を達成しないかもしれません。大規模モデルサイズはさらに困難です。大規模なモデルは純粋なデータ並列化でメモリ不足になり、モデル並列化を使用することは困難です。DeepSpeedはこれらの課題に対処し、モデル開発とトレーニングを加速します。

容易な分散、効果的、および効率的なトレーニング

DeepSpeed APIはPyTorchの軽量ラッパーです。これは、PyTorchで愛するすべてを使用できることを意味し、新しいプラットフォームを学ぶ必要がないことを意味します。さらに、DeepSpeedは、分散トレーニング、混合精度、勾配蓄積、チェックポイントなど、すべてのボイラープレートのような最先端のトレーニング技術を管理し、モデル開発に集中することができます。最も重要なことに、DeepSpeedの独特の効率と効果性の利点を活用して、わずか数行のコード変更でPyTorchモデルの速度を上げてスケーリングできます。

スピード

DeepSpeedは、計算/通信/メモリ/IOの効率最適化と、高度なハイパーパラメータチューニングとオプティマイザの効果最適化の組み合わせを通じて、高性能と高速な収束を達成します。例えば：

• DeepSpeedはBERT-largeを1024 V100 GPU（64 DGX-2ボックス）で44分で、256 GPU（16 DGX-2ボックス）で2.4時間でパリティにトレーニングします。

BERT-largeトレーニング時間	デバイス	ソース	トレーニング時間
1024 V100 GPU	DeepSpeed	44分
256 V100 GPU	DeepSpeed	2.4時間
64 V100 GPU	DeepSpeed	8.68時間
16 V100 GPU	DeepSpeed	33.22時間

BERTコードとチュートリアルは近日公開予定です。

• DeepSpeedはGPT2（15億パラメータ）を、Azure GPUでの最先端のNVIDIA Megatronより3.75倍高速にトレーニングします。詳細：GPTチュートリアル

メモリ効率

DeepSpeedはメモリ効率のよいデータ並列化を提供し、モデル並列化なしでモデルのトレーニングを可能にします。例えば、DeepSpeedは単一のGPUで最大130億パラメータのモデルをトレーニングできます。比較では、既存のフレームワーク（例：PyTorchの分散データ並列）は140億パラメータモデルでメモリ不足に実行されます。DeepSpeedはZero Redundancy Optimizer（ZeRO）と呼ばれる新規のソリューションを通じてトレーニングメモリフットプリントを削減します。基本的なデータ並列化とは異なり、メモリ状態がデータ並列プロセス間で複製される場合、ZeROはモデル状態と勾配をパーティション分割して、大幅なメモリを節約します。さらに、アクティベーションメモリとフラグメント化されたメモリも削減します。現在の実装（ZeRO-2）は、最先端に対して最大8倍のメモリを削減します。ZeRO についての詳細については、論文を読むことができます。また、ZeRO-1とZeRO-2に関連するブログポストも参照してください。このメモリ削減が印象的であることで、DeepSpeedの初期採用者は、Turing-NLGという170億パラメータを超える言語モデル（LM）を既に製作し、LMカテゴリで新しいSOTAを確立しました。限られたGPUリソースを持つモデル科学者のために、ZeRO-OffloadはCPUとGPUメモリの両方を活用して大規模モデルのトレーニングを実行します。単一のGPUを備えたマシンを使用して、ユーザーは、既存のアプローチより10倍大きいメモリ不足でメモリ不足に実行することなく、最大130億パラメータのモデルを実行でき、競争力のあるスループットを得ることができます。この機能は多数パラメータモデルトレーニングを民主化し、多くのディープラーニング実践者がより大きく、より優れたモデルを探索するためのウィンドウを開きます。

スケーラビリティ

DeepSpeedは効率的なデータ並列化、モデル並列化、パイプライン並列化、およびそれらの組み合わせをサポートしており、これを3D並列化と呼びます。DeepSpeedの3D並列化は、数兆のパラメータを持つモデルを実行するためのシステムサポートを提供します。プレスリリースとチュートリアルで詳細を読むことができます。DeepSpeedは大規模モデルをより効率的に実行でき、15億から100億のさまざまなサイズのモデルに対して最大10倍高速化できます。より具体的には、ZeRO駆動データ並列化は、異なるタイプのモデル並列化と相補的で組み合わせることができます。これにより、DeepSpeedはモデル並列化の度合いが低く、バッチサイズが高いモデルに適合でき、モデル並列化だけを使用する場合と比較して大幅なパフォーマンスゲインを提供します。詳細：ZeROペーパーとGPTチュートリアル。

図はDeepSpeed（ZeRO駆動データ並列化とNVIDIA Megatron-LMのモデル並列化を組み合わせて）を使用するDeepSpeed（Megatron-LMだけを使用する）の上のシステムスループット改善を示しています。

通信効率

DeepSpeedのパイプライン並列化は、分散トレーニング中の通信量を削減します。これにより、ユーザーはマルチ数十億パラメータモデルを2–7倍高速に帯域幅が限定されたクラスターでトレーニングできます。

1-bit Adam、0/1 Adam、および1-bit LAMBは通信量を最大26倍削減し、Adamと同様の収束効率を達成し、異なるタイプのGPUクラスターとネットワークにスケーリングすることができます。1-bit Adam ブログポスト、1-bit Adam チュートリアル、0/1 Adam チュートリアル、1-bit LAMB チュートリアル。

データ効率

DeepSpeed データ効率ライブラリは、カリキュラム学習を通じた効率的なデータサンプリングと、ランダムレイヤーワイズトークン落下を通じた効率的なデータルーティングを提供します。合成ソリューションにより、GPT-3/BERT事前トレーニング中およびGPT/ViT微調整中に最大2倍のデータと2倍の時間節約が可能です。または、同じデータ/時間下でモデル品質をさらに向上させます。チュートリアルで詳細を参照してください。

長いシーケンス長のサポート

DeepSpeedはスパース注意カーネルを提供します。このカーネルは、テキスト、画像、または音声のモデル入力の長いシーケンスをサポートするための重要なテクノロジーです。古典的な密度トランスフォーマーと比較して、それはオーダーオブマグニチュード長い入力シーケンスをパワーし、比較可能な精度で最大6倍高速な実行を取得します。さらに、最先端のスパース実装を上回り、1.5～3倍高速な実行が可能です。さらに、スパースカーネルは柔軟なスパース形式の効率的な実行をサポートし、ユーザーがカスタムスパース構造を革新できるようにします。詳細はここをご覧ください。

効果的な高速収束

DeepSpeedは、LAMBなどの高度なハイパーパラメータチューニングと大規模バッチサイズオプティマイザをサポートしています。これらはモデルトレーニ