deepspeed

Deepspeed スキル

公式ドキュメントから生成された、deepspeed 開発に関する包括的な支援です。

このスキルを使用するタイミング

このスキルは次の場合に発動されるべきです:

• deepspeed を使用しているとき
• deepspeed の機能や API について質問するとき
• deepspeed のソリューションを実装するとき
• deepspeed のコードをデバッグするとき
• deepspeed のベストプラクティスを学ぶとき

クイックリファレンス

よくあるパターン

パターン 1: DeepNVMe 目次 必要条件 DeepNVMe ハンドルの作成 DeepNVMe ハンドルの使用 ブロッキングファイル書き込み ノンブロッキングファイル書き込み 並列ファイル書き込み ピン留めテンソル まとめ 謝辞 付録 高度なハンドル作成 パフォーマンスチューニング DeepNVMe API 一般的な I/O API GDS 固有の API ハンドル設定 API このチュートリアルでは、DeepNVMe を使用して、永続ストレージとホストまたはデバイスメモリ上に存在するテンソルの間でデータ転送を行う方法を説明します。DeepNVMe は、Non-Volatile Memory Express (NVMe) Solid State Drive (SSD)、Linux Asynchronous I/O (libaio)、および NVIDIA Magnum IOTM GPUDirect® Storage (GDS) を基盤とした強力な最適化を通じて、ディープラーニングアプリケーションにおける I/O 操作のパフォーマンスと効率を向上させます。

必要条件

DeepNVMe を使用するために、環境が正しく構成されていることを確認してください。まず、DeepSpeed バージョン 0.15.0 以上をインストールする必要があります。次に、DeepSpeed のインストールで DeepNVMe オペレーターが利用可能であることを確認してください。async_io オペレーターは DeepNVMe のすべての機能に必要であり、gds オペレーターは GDS 機能にのみ必要です。ds_report の出力を確認し、互換性ステータスが [OKAY] になっていることで、各オペレーターの利用可否を確認できます。以下は、async_io と gds の両方のオペレーターが利用可能であることを確認する ds_report の出力の抜粋です。

async_io オペレーターが利用できない場合は、使用している Linux ディストリビューション向けの適切な libaio ライブラリのバイナリをインストールする必要があります。たとえば、Ubuntu ユーザーは apt install libaio-dev を実行する必要があります。一般に、ds_report の出力には次のような役立つヒントが含まれているため、注意深く確認してください。

[WARNING] async_io requires the dev libaio .so object and headers but these were not found. [WARNING] async_io: please install the libaio-dev package with apt [WARNING] If libaio is already installed (perhaps from source), try setting the CFLAGS and LDFLAGS environment variables to where it can be found.

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

DeepNVMe ハンドルの作成

DeepNVMe の機能には、aio_handle と gds_handle という 2 つの抽象化を通じてアクセスできます。aio_handle はホストテンソルとデバイステンソルの両方で使用できます。一方、gds_handle は CUDA テンソルでのみ動作しますが、より効率的です。

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 も同様に動作することに注意してください。Python シェルで aio_handle オブジェクトに対してタブ補完を使用すると、利用可能な API を確認できます。以下は 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(

I/O 操作を実行するために注目すべき API は、pread と pwrite という部分文字列を含む名前のものです。簡潔にするため、ファイル書き込み API、すなわち sync_pwrite、async_pwrite、pwrite に焦点を当てます。sync_pwrite と async_pwrite は pwrite の特殊化であるため、以下では sync_pwrite と async_pwrite のみを取り上げます。

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

sync_pwrite は、Python のファイル書き込みの標準的なブロッキングセマンティクスを提供します。以下の例は、sync_pwrite を使用して 1GB の CUDA テンソルをローカルの 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 の重要な最適化は、Python スレッドが計算と I/O 操作を重ね合わせられるようにするノンブロッキング I/O セマンティクスです。async_pwrite はファイル書き込みのノンブロッキングセマンティクスを提供します。Python スレッドは後で wait() を使用して I/O 操作と同期できます。async_write は、複数の連続したノンブロッキング I/O 操作を送信するためにも使用でき、その後は単一の wait() で完了を待つことができます。

以下の例は、async_pwrite を使用して 1GB の CUDA テンソルをローカルの 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 とノンブロッキング 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 Accelerator が提供する仕組みを使用できます。次の例は、ピン留めされた 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 は CUDA テンソルをピン留めするための new_pinned_device_tensor() と pin_device_tensor() 関数を提供します。次の例は、ピン留めされた CUDA テンソルをローカルの 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 handle constructor

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

前述のとおり、対象のワークロードまたは環境で DeepNVMe の最大パフォーマンスを達成するには、適切に構成された aio_handle または gds_handle ハンドルを使用する必要があります。構成を容易にするため、最適な DeepNVMe 構成の探索を自動化するユーティリティ ds_nvme_tune を提供しています。ds_nvme_tune は、ユーザーが指定した、またはデフォルトの構成空間を自動的に探索し、読み取りと書き込みの両方で最良のパフォーマンスを示すオプションを推奨します。

以下は、ds_nvme_tune を使用して、GPU メモリと /local_nvme にマウントされたローカル NVMe SSD の間の aio_handle データ転送をチューニングする使用例です。この例では、チューニングに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 SSD を搭載した 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 ...] I/O テストを実行するディレクトリ。NVMe デバイス上の書き込み可能なディレクトリ。 --sweep_config SWEEP_CONFIG パフォーマンススイープの構成 JSON ファイル。 --no_read 読み取りパフォーマンスの測定を無効にします。 --no_write 書き込みパフォーマンスの測定を無効にします。 --io_size IO_SIZE パフォーマンス測定で読み書きする I/O のバイト数。 --gpu GPU デバイスと NVME デバイスの間のテンソル転送をテストします。 --gds NVIDIA GPUDirectStorage オペレーターでスイープを実行します。 --flush_page_cache ページキャッシュはフラッシュされず、報告される読み取り速度が実際より高くなる場合があります。sudo アクセスが必要です。 --log_dir LOG_DIR パフォーマンスログファイルの出力ディレクトリ。デフォルトは ./_aio_bench_logs です。 --loops LOOPS 操作の繰り返し回数 --verbose デバッグ情報を出力します。

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	queue depth の設定を返す
get_single_submit	single_submit が有効かどうかを返す
get_intra_op_parallelism	I/O の並列度を返す
get_block_size	I/O のブロックサイズの設定を返す
get_overlap_events	overlap_event が有効かどうかを返す

Updated: November 5, 2025 Previous Next

libaio

パターン 2: NLG モデル向けの Mixture of Experts

目次

1. インストール
2. NLG+MoE モデルのトレーニング 2.1. モデルへの変更 2.2. 標準 MoE モデルの事前トレーニング 2.3. PR-MoE モデルの事前トレーニング 2.4. モデルサイズを小さくした MoS のトレーニング

このチュートリアルでは、DeepSpeed Mixture of Experts (MoE) を NLG モデルに適用する方法を紹介します。これにより、トレーニングコストを 5 分の 1 に削減し、MoE モデルのサイズを 3 分の 1 に縮小できます(詳細は当社のブログを参照してください)。例として、Megatron-LM フレームワークの GPT-3 に類似したモデルを使用します。このチュートリアルを読む前に、Mixture of Experts および Megatron-LM による GPT の事前トレーニングに関するチュートリアルを先にお読みいただくことをお勧めします。

1. インストール

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

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

2.1. モデルへの変更

GPT スタイルのモデルに MoE を適用するため、主に megatron/model/ 内で Megatron フレームワークにいくつかの変更を加え、モデルに 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: これらの設定は、1 つのエキスパートが処理できるトークンの数を決定します。値を大きくすると収束が良くなる可能性がありますが、エキスパート間の負荷が偏るため、トレーニングが遅くなります。

--disable-moe-token-dropping: 1 つのエキスパートが処理できるトークン数の制限を完全に取り除きます。上記と同じ理由から、これは推論・評価時のみの使用を推奨します。

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

PR-MoE は、Pyramid-Residual-MoE の略で、新たに設計された MoE モデルです。標準 MoE と比べてパラメーター効率が最大 3 倍向上します。詳細は当社のブログをご覧ください。

PR-MoE モデルのトレーニングスクリプトの例は、examples_deepspeed/MoE の下に用意しています。標準 MoE と比べて、PR-MoE モデルにはいくつか異なるハイパーパラメーターがあります。

--num-experts: Pyramid-MoE を有効にするには、単一の数値ではなく、MoE レイヤーの数と同じ長さのリストを指定する必要があります。モデルの後段(出力に近い側)ほど多くのエキスパートを使用することを推奨します。

--mlp-type: [standard, residual] から選択します。residual を指定すると、Residual-MoE が有効になります。

標準 MoE と PR-MoE に対する上記の新しいハイパーパラメーターに加えて、NLG+MoE モデルでは、ベースとなる dense モデルと比べて学習率を下げ、学習率減衰の期間を長くすると効果的であることがわかりました。チューニングの詳細は、トレーニングスクリプトの例に記載しています。

トレーニングデータについては、社内データを公開することはできませんが、Megatron-LM の事前トレーニングに使用できる公開データは、そのまま MoE モデルのトレーニングに使用できます(実験と同等のモデル品質が得られない可能性があることにご注意ください)。例えば、dense モデルと MoE モデルの両方について The Pile データセット(pile.eleuther.ai、github.com/EleutherAI/the-pile)で評価しました。下の表 1 は、この公開データが社内データと同程度の評価結果をもたらすことを示しています。

モデルサイズ LAMBADA: 補完予測 PIQA: 常識推論 BoolQ: 読解 RACE-h: 読解 TriviaQA: 質問応答 WebQs: 質問応答 Dense NLG: 350M、社内データ 0.5203 0.6931 0.5364 0.3177 0.0321 0.0157 350M、公開 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、公開 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: 各種 dense および MoE の NLG モデルのゼロショット評価結果(最後の 6 列)。すべてのゼロショット評価結果は精度指標を使用しています。

2.4. モデルサイズを小さくした MoS のトレーニング

MoS は Mixture-of-Students の略で、大規模な MoE モデルを圧縮するための段階的な蒸留ベースの手法です。MoS は、モデルサイズをさらに 12.5% 削減し、PR-MoE と組み合わせると、標準 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 を使用すると、最終的な生徒モデルの精度に悪影響を及ぼす可能性があることがわかりました。実験では、段階的な蒸留手法を用いました。つまり、トレーニングの早い段階(例えば 40 万ステップ後)で蒸留を打ち切り、残りのトレーニングでは標準の言語モデリング損失のみに対して最適化を行いました。

トレーニングスクリプトの例は、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 つの条件を満たす必要があります。 Getting Started ガイドを使用して、DeepSpeed を学習スクリプトに組み込んでいること。 LRRT を設定するパラメーターを、モデルのパラメーターに追加していること。 LRRT のパラメーターは以下のとおりです。

LRRT パラメーター LRRT は、事前に定義した量だけ学習率を事前に定義した間隔で線形に増加させることで動作します。そのため LRRT は、モデル学習中に学習率をどのように、いつ変更するかを定義するため、学習率スケジュールの一種です。

LRRT を設定するには、次のパラメーターを設定する必要があります。

lr_range_test_min_lr : 学習の初期学習率 (float) lr_range_test_step_size: 学習率を拡大する間隔。学習ステップ数で定義 (integer) lr_range_test_step_rate: 学習率を増加させるためのスケーリング係数 (float) lr_range_test_staircase: true の場合、学習率は lr_range_test_step_size 学習ステップごとに変更され、false の場合は学習ステップごとに変更されます (boolean)

必要なモデル設定の変更 次の特徴を持つ LRRT スケジュールの例で、必要なモデル設定の変更を説明します。

初期学習率 0.0001 で学習を開始する スケーリング率 5 を使用する 200 学習ステップのスケーリング間隔を使用する 学習ステップごとに学習率をスケーリングする。つまり staircase は使用しない

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

"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 } }

例: 大きなバッチサイズ向けのチューニング 社内の本番モデルを、より大きいバッチサイズでも効率よく収束させるようにチューニングした経験をもとに、LRRT がデータサイエンティストにどのように役立つかを説明します。このとき、GPU 1 基（バッチサイズ 512）から GPU 4 基（バッチサイズ 2048）へスケールアウトしました。目標は、大きいバッチサイズでのモデル学習を、同じ量のデータサンプルを使った小さいバッチサイズの性能に匹敵させることでした。ここでの課題は、大きいバッチサイズでの学習が収束しにくいという、よく知られた問題です。

私たちのアプローチでは、この問題に対処するために DeepSpeed の 1Cycle スケジュールを使用し、そのスケジュールの設定に LRRT を使いました。以下のプロットでは、バッチサイズ 2048 で効果的に学習できる最大学習率を見つけるために LRRT を使用した様子を示しています。左のプロットは、最初の 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 スケジュールは、3000 バッチ後に検証損失 0.46 を達成しますが、これは固定学習率では 9000 バッチ経っても達成できません。緩やかに増加する 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 つのパラメーターです。cycle_min_lr の設定には、より緩やかな LRRT スケジュール (lr_range_test_step_rate=5) を選びました。これは最良の損失を達成し、急速に増加するスケジュールはかなり早く発散するためです。cycle_max_lr は 0.005 に設定しました。プロットでは、もう少し高い学習率でも性能がまだ向上していることが示されていますが、最大学習率まで待つと、モデルが発散の直前にあり、回復不能になる可能性があると分かったためです。学習率が 0.005 になるまでに 8000 バッチかかるため、cycle_first_step_size と (cycle_second_step_size) は、4 基の GPU が 8000 バッチを処理するのに必要なステップ数である 2000 に設定しました。

この簡単な例が、独自のチューニングの課題に LRRT を活用するアイデアの一助になれば幸いです。

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

lr_range_test_min_lr

パターン 5： トレーニングの概要と機能 目次 簡単に実現できる分散型で効果的かつ効率的なトレーニング 速度 メモリ効率 スケーラビリティ 通信効率 データ効率 長いシーケンス長への対応 効果を高める高速な収束 優れた使いやすさ 機能 混合精度による分散トレーニング 混合精度トレーニング シングル GPU、マルチ GPU、マルチノードでのトレーニング パイプライン並列処理 モデル並列処理 カスタムモデル並列処理のサポート Megatron-LM との統合 Zero Redundancy Optimizer オプティマイザーの状態と勾配の分割 アクティベーションの分割 定数バッファー最適化（CBO） 連続メモリ最適化（CMO） ZeRO-Offload 追加のメモリと帯域幅の最適化 スマート勾配累積 通信のオーバーラップ トレーニング機能 シンプルなトレーニング API アクティベーションチェックポイント API 勾配クリッピング 混合精度での自動損失スケーリング トレーニングオプティマイザー 通信量を最大 26 倍削減する 1-bit Adam、0/1 Adam、1-bit LAMB オプティマイザー Fused Adam オプティマイザーと任意の torch.optim.Optimizer CPU-Adam：高性能なベクトル化 Adam 実装 メモリ帯域幅を最適化した FP16 オプティマイザー LAMB オプティマイザーによる大規模バッチトレーニング ZeRO オプティマイザーによるメモリ効率の高いトレーニング トレーニング方式に依存しないチェックポイント 高度なパラメーター探索 学習率範囲テスト 1Cycle 学習率スケジュール シンプルなデータローダー データ効率 カリキュラム学習 パフォーマンス分析とデバッグ ウォールクロック時間の内訳 アクティベーションチェックポイント関数の計測 FLOPS プロファイラー 自動チューニング モニター 通信ログ スパースアテンション Mixture of Experts（MoE） 概要 高度なディープラーニングモデルのトレーニングは困難です。モデルの設計に加えて、モデル研究者は分散トレーニング、混合精度、勾配累積、チェックポイントなど、最先端のトレーニング手法も設定する必要があります。それでも、研究者が期待するシステムパフォーマンスや収束速度を達成できないことがあります。大規模なモデルでは、さらに困難になります。純粋なデータ並列処理では簡単にメモリ不足になり、モデル並列処理の利用も容易ではありません。DeepSpeed は、こうした課題に対処し、モデルの開発とトレーニングを高速化します。 簡単に実現できる分散型で効果的かつ効率的なトレーニング DeepSpeed API は PyTorch の軽量なラッパーです。つまり、PyTorch で使い慣れたすべての機能を、新しいプラットフォームを学ぶことなく利用できます。さらに、DeepSpeed は分散トレーニング、混合精度、勾配累積、チェックポイントなど、最先端のトレーニング手法に伴う定型処理をすべて管理するため、モデル開発に集中できます。最も重要なのは、PyTorch モデルにわずか数行のコード変更を加えるだけで、DeepSpeed 独自の効率性と有効性を活用し、速度とスケールを向上できることです。 速度 DeepSpeed は、計算／通信／メモリ／I/O の効率を高める最適化と、高度なハイパーパラメーター調整やオプティマイザーによる有効性の最適化を組み合わせることで、高いパフォーマンスと高速な収束を実現します。たとえば、DeepSpeed は 1024 基の V100 GPU（64 台の DGX-2）を使って 44 分で、また 256 基の GPU（16 台の DGX-2）を使って 2.4 時間で、BERT-large を同等の性能までトレーニングします。 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 は Azure GPU 上で GPT2（15 億パラメーター）を、最先端の NVIDIA Megatron より 3.75 倍高速にトレーニングします。 詳細はこちら：GPT チュートリアル メモリ効率 DeepSpeed はメモリ効率の高いデータ並列処理を提供し、モデル並列処理なしでのモデルのトレーニングを可能にします。たとえば、DeepSpeed は単一 GPU で最大 130 億パラメーターのモデルをトレーニングできます。これに対し、既存のフレームワーク（例：PyTorch の Distributed Data Parallel）では、14 億パラメーターのモデルでメモリ不足になります。 DeepSpeed は、ZeRO（Zero Redundancy Optimizer）と呼ばれる新しいソリューションにより、トレーニング時のメモリ使用量を削減します。メモリ状態がデータ並列プロセス間で複製される基本的なデータ並列処理とは異なり、ZeRO はモデル状態と勾配を分割して、大幅にメモリを節約します。さらに、アクティベーションメモリと断片化したメモリも削減します。現在の実装（ZeRO-2）は、最先端の手法と比べてメモリ使用量を最大 8 倍削減します。ZeRO については論文、および ZeRO-1 と ZeRO-2 に関するブログ記事をご覧ください。 この大幅なメモリ削減により、DeepSpeed の早期導入者は、Turing-NLG と呼ばれる 170 億超のパラメーターを持つ言語モデル（LM）をすでに開発し、LM 分野で新たな SOTA を確立しています。 GPU リソースが限られているモデル研究者向けに、ZeRO-Offload は CPU と GPU の両方のメモリを活用して大規模モデルをトレーニングします。単一 GPU を搭載したマシンで、ユーザーはメモリ不足を起こすことなく最大 130 億パラメーターのモデルを実行できます。これは既存の手法の 10 倍の規模でありながら、競争力のあるスループットを実現します。この機能により、数十億パラメーターのモデルのトレーニングが幅広く利用可能になり、多くのディープラーニング実践者がより大規模で優れたモデルを探求できるようになります。 スケーラビリティ DeepSpeed は、効率的なデータ並列処理、モデル並列処理、パイプライン並列処理と、それらの組み合わせ（3D 並列処理）をサポートします。DeepSpeed の 3D 並列処理は、1 兆を超えるパラメーターを持つモデルを実行するためのシステムサポートを提供します。詳細はプレスリリースとチュートリアルをご覧ください。 DeepSpeed は大規模モデルをより効率的に実行でき、15 億から数千億まで、さまざまなサイズのモデルで最大 10 倍の高速化を実現します。具体的には、ZeRO を活用したデータ並列処理は、さまざまな種類のモデル並列処理を補完し、組み合わせて使用できます。これにより、モデル並列処理の度合いを抑え、バッチサイズを大きくしてモデルを収容できるため、モデル並列処理のみを使う場合と比べて大幅なパフォーマンス向上が得られます。 詳細はこちら：ZeRO 論文、GPT チュートリアル 図は、Megatron-LM 単独の場合と比べた DeepSpeed（ZeRO を活用したデータ並列処理と NVIDIA 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 Data Efficiency Library は、カリキュラム学習による効率的なデータサンプリングと、ランダムなレイヤー単位のトークンドロップによる効率的なデータルーティングを提供します。この組み合わせにより、GPT-3／BERT の事前学習および GPT／ViT のファインチューニングで、データ量を最大 2 倍、時間を最大 2 倍節約できます。または、同じデータ量／時間でモデルの品質をさらに向上させることができます。詳細はチュートリアルをご覧ください。 長いシーケンス長への対応 DeepSpeed は、テキスト、画像、音声など、モデル入力の長いシーケンスを扱うための重要な技術であるスパースアテンションカーネルを提供します。従来の密な Transformer と比べて、桁違いに長い入力シーケンスを処理でき、精度を維持しながら最大 6 倍高速に実行できます。また、最先端のスパース実装と比べても 1.5～3 倍高速です。さらに、スパースカーネルは柔軟なスパース形式を効率的に実行できるため、ユーザーは独自のスパース構造を開発できます。詳細はこちらをご覧ください。 効果を高める高速な収束 DeepSpeed は、高度なハイパーパラメーター調整と LAMB などの大規模バッチサイズ向けオプティマイザーをサポートします。これらはモデルのトレーニング効果を高め、目標精度に収束するまでに必要なサンプル数を削減します。 詳細はこちら：チューニングチュートリアル 優れた使いやすさ PyTorch モデルで DeepSpeed と ZeRO を有効にするために必要なコード変更は、わずか数行です。既存のモデル並列処理ライブラリと比べて、DeepSpeed ではコードの再設計やモデルのリファクタリングは必要ありません。また、モデルの次元（アテンションヘッド数、隠れ層のサイズなど）、バッチサイズ、その他のトレーニングパラメーターに制限はありません。 最大 130 億パラメーターのモデルでは、モデル並列処理を必要とせず、ZeRO を活用したデータ並列処理を簡単に利用できます。一方、標準的なデータ並列処理では、14 億パラメーターを超えるモデルでメモリ不足になります。さらに、DeepSpeed では、ZeRO を活用したデータ並列処理と、NVIDIA の Megatron-LM によるテンソル分割などのカスタムモデル並列処理を柔軟に組み合わせて利用できます。 機能 以下に機能の概要を示します。説明と使用方法については、詳細な機能概要をご覧ください。 混合精度による分散トレーニング 16 ビット混合精度 シングル GPU／マルチ GPU／マルチノード モデル並列処理 カスタムモデル並列処理のサポート Megatron-LM との統合 パイプライン並列処理 3D 並列処理 Zero Redundancy Optimizer オプティマイザーの状態と勾配の分割 アクティベーションの分割 定数バッファー最適化 連続メモリ最適化 ZeRO-Offload モデルのトレーニングに CPU／GPU の両方のメモリを活用 単一 GPU で 100 億モデルのトレーニングをサポート 超高速の密な Transformer カーネル スパースアテンション メモリと計算効率に優れたスパースカーネル 密な方式より 10 倍長いシーケンスをサポート さまざまなスパース構造を柔軟にサポート 1-bit Adam、0/1 Adam、1-bit LAMB カスタム通信コレクティブ 通信量を最大 26 倍削減 追加のメモリと帯域幅の最適化 スマート勾配累積 通信／計算のオーバーラップ トレーニング機能 シンプルなトレーニング API 勾配クリッピング 混合精度での自動損失スケーリング トレーニングオプティマイザー Fused Adam オプティマイザーと任意の torch.optim.Optimizer メモリ帯域幅を最適化した FP16 オプティマイザー LAMB オプティマイザーによる大規模バッチトレーニング ZeRO オプティマイザーによるメモリ効率の高いトレーニング CPU-Adam トレーニング方式に依存しないチェックポイント 高度なパラメーター探索 学習率範囲テスト 1Cycle 学習率スケジュール シンプルなデータローダー データ効率 カリキュラム学習による効率的なデータサンプリングと、ランダムなレイヤー単位のトークンドロップによる効率的なデータルーティング GPT-3／BERT の事前学習および GPT／ViT のファインチューニングで、データ量を最大 2 倍、時間を最大 2 倍節約 または、同じデータ量／時間でモデルの品質をさらに向上 カリキュラム学習 トレーニング中に、より簡単な例や単純な例から順に提示する、カリキュラム学習ベースのデータパイプライン トークン単位の収束速度を維持しながら、8 倍／4 倍大きなバッチサイズ／学習率で安定した GPT-2 の事前学習を実現し、3.3 倍高速化 ほかの多くの DeepSpeed 機能と併用可能 上記の Data Efficiency Library は、より汎用的なカリキュラム学習をサポートします。この従来のカリキュラム学習機能も引き続きサポートされていますが、Data Efficiency Library の使用を推奨します。 段階的なレイヤードロップ 効率的で堅牢な圧縮トレーニング 事前学習の収束を最大 2.5 倍高速化 パフォーマンス分析とデバッグ Mixture of Experts（MoE） title：「機能の概要」 layout：single permalink：/features/ toc：true toc_label：「目次」 — 混合精度による分散トレーニング 混合精度トレーニング deepspeed_config JSON で次のように設定すると、16 ビット（FP16）トレーニングを有効にできます。 "fp16": { "enabled": true, "loss_scale": 0, "loss_scale_window": 1000, "hysteresis": 2, "consecutive_hysteresis": false, "min_loss_scale": 1 } シングル GPU、マルチ GPU、マルチノードでのトレーニング hostfile でリソースを指定するだけで、シングル GPU、単一ノードのマルチ GPU、またはマルチノードのマルチ GPU 実行を簡単に切り替えられます。 deepspeed --hostfile=
<client_entry.py>
--deepspeed --deepspeed_config ds_config.json スクリプト <client_entry.py> は、 で指定されたリソース上で実行されます。 パイプライン並列処理 DeepSpeed は、メモリと通信の効率に優れたトレーニングのためにパイプライン並列処理を提供します。DeepSpeed はデータ、モデル、パイプラインの各並列処理を組み合わせたハイブリッド方式をサポートし、3D 並列処理を使用して 1 兆を超えるパラメーターにスケールしています。パイプライン並列処理は通信効率も向上させ、帯域幅の低いクラスターでトレーニングを最大 7 倍高速化しています。 モデル並列処理 カスタムモデル並列処理のサポート DeepSpeed は、Megatron-LM などのテンソル分割方式を含む、あらゆる形式のモデル並列処理をサポートします。そのために、モデル並列処理フレームワークに、次のような簿記機能を実装するモデル並列ユニット（mpu）を提供することのみを求めます。 mpu.get_model_parallel_rank() mpu.get_model_parallel_group() mpu.get_model_parallel_world_size() mpu.get_data_parallel_rank() mpu.get_data_parallel_group() mpu.get_data_parallel_world_size() Megatron-LM との統合 DeepSpeed は Megatron と完全に互換性があります。詳細は Megatron-LM チュートリアルをご覧ください。 Zero Redundancy Optimizer Zero Redundancy Optimizer（ZeRO）は DeepSpeed の中核であり、モデル並列処理だけでは実現できない規模の大規模モデルのトレーニングを可能にします。ZeRO を有効にすると、モデル並列処理なしで 130 億を超えるパラメーターを持つモデルを、また現在世代のハードウェアでモデル並列処理を使って最大 2000 億パラメーターのモデルをトレーニングできます。詳細は ZeRO 論文、DeepSpeed との統合に関する GPT チュートリアルをご覧ください。 オプティマイザーの状態と勾配の分割 ZeRO のオプティマイザー状態と勾配の分割は、モデル状態（オプティマイザー状態、勾配、パラメーター）を複製するのではなく、データ並列プロセス間で分割することで、標準的なデータ並列処理と比べてモデル状態のメモリ使用量を 8 倍削減します。 アクティベーションの分割 アクティベーションの分割は、モデル並列トレーニング（MP）中のアクティベーションによるメモリ使用量を削減できる ZeRO のメモリ最適化機能です。MP では、一部のアクティベーションがすべての MP プロセスで必要となり、MP GPU 間で複製されることがあります。アクティベーションの分割は、順伝播で計算に使用したアクティベーションを分割状態で保存します。逆伝播で再び必要になる直前に、これらのアクティベーションをすべて集約します。アクティベーションを分割状態で保存することで、DeepSpeed の ZeRO は MP の並列度に比例してアクティベーションのメモリ使用量を削減できます。 定数バッファー最適化（CBO） CBO は、メモリ使用量を一定のサイズに抑えながら、高いネットワークスループットとメモリスループットを実現します。正規化や allreduce コレクティブなどのメモリ／ネットワーク負荷の高い操作では、パフォーマンスはオペランドのサイズに左右されます。すべてのオペランドを単一の大きなオペランドにまとめると、大きなスループットを実現できますが、不要なメモリオーバーヘッドが生じます。DeepSpeed の CBO は、小さなオペランドを事前定義されたサイズ程度のバッファーにまとめ、不要なメモリオーバーヘッドを生じさせることなく高いパフォーマンスを実現します。 連続メモリ最適化（CMO） CMO はトレーニング中のメモリ断片化を削減し、連続したメモリが不足してメモリ不足エラーが発生するのを防ぎます。メモリ断片化は、短期間だけ使用されるメモリオブジェクトと長期間使用されるメモリオブジェクトが交互に配置されることで生じます。順伝播中、アクティベーションチェックポイントは長期間保持されますが、再計算されたアクティベーションは短期間しか保持されません。同様に、逆伝播中はアクティベーション勾配が短期間しか保持されない一方、パラメーター勾配は長期間保持されます。CMO はアクティベーションチェックポイントとパラメーター勾配を連続バッファーに移動し、メモリ断片化を防ぎます。 ZeRO-Offload ZeRO-Offload は、GPU とホスト CPU の両方にある計算リソースとメモリリソースを活用し、最小限の GPU リソースで効率的にトレーニングできるモデルの最大サイズを拡大します。単一の NVIDIA V100 GPU で最大 130 億パラメーターのモデルをトレーニングでき、これは最先端の手法より 10 倍大きい規模でありながら、GPU あたり 30 テラフロップスを超える高いトレーニングスループットを維持します。詳細は ZeRO-Offload のリリースブログと DeepSpeed との統合チュートリアルをご覧ください。 追加のメモリと帯域幅の最適化 スマート勾配累積 勾配累積では、有効バッチを複数の逐次的なマイクロバッチに分割し、それらのマイクロバッチ間でパラメーター勾配を平均することで、限られたメモリでも大きなバッチサイズを実行できます。さらに、各マイクロバッチの勾配をすべての GPU 間で平均するのではなく、シーケンスの各ステップでローカルに平均し、シーケンスの最後に単一の allreduce を実行して、全 GPU にわたる有効バッチの平均勾配を生成します。この方法では、特に有効バッチあたりのマイクロバッチ数が多い場合、各マイクロバッチでグローバルに平均する方法と比べて通信量を大幅に削減できます。 通信のオーバーラップ 逆伝播中、DeepSpeed は、すでに計算済みのパラメーター勾配を平均するために必要な通信を、進行中の勾配計算とオーバーラップさせることができます。この計算と通信のオーバーラップにより、バッチサイズが比較的小さくても、DeepSpeed はより高いスループットを実現できます。 トレーニング機能 シンプルなトレーニング API DeepSpeed のコア API は、少数のメソッドで構成されています。 初期化：initialize トレーニング：backward、step 引数解析：add_config_arguments チェックポイント：load_checkpoint、store_checkpoint DeepSpeed は、このドキュメントで説明するほとんどの機能をこれらの API からサポートしています。また、機能を有効化／無効化するために deepspeed_config JSON ファイルを使用します。詳細はコア API ドキュメントをご覧ください。 アクティベーションチェックポイント API DeepSpeed のアクティベーションチェックポイント API は、アクティベーションチェックポイントの分割、CPU チェックポイント、連続メモリ最適化をサポートし、レイヤー単位のプロファイリングも可能にします。詳細はコア API ドキュメントをご覧ください。 勾配クリッピング { "gradient_clipping": 1.0 } DeepSpeed は、ユーザーが指定した最大勾配ノルムに基づいて、内部で勾配クリッピングを処理します。詳細はコア API ドキュメントをご覧ください。 混合精度での自動損失スケーリング DeepSpeed は混合精度トレーニングの損失スケーリングを内部で処理します。損失スケーリングのパラメーターは deepspeed_config JSON ファイルで指定できます。詳細はコア API ドキュメントをご覧ください。 トレーニングオプティマイザー 通信量を最大 26 倍削減する 1-bit Adam、0/1 Adam、1-bit LAMB オプティマイザー DeepSpeed には、1-bit Adam、0/1 Adam、1-bit LAMB という 3 種類の通信効率に優れたオプティマイザーがあります。これらは Adam／LAMB と同等の収束性能を提供し、通信量を最大 26 倍削減します。そのため、帯域幅が制限されたクラスターで、BERT-Large の事前学習では最大 6.6 倍、SQuAD のファインチューニングでは最大 2.7 倍のスループット向上を実現します。使用方法とパフォーマンスの詳細については、1-bit Adam チュートリアル、1-bit Adam ブログ記事、0/1 Adam チュートリアル、1-bit LAMB チュートリアルをご覧ください。技術的な詳細については、1-bit Adam 論文、0/1 Adam 論文、1-bit LAMB 論文をご覧ください。 Fused Adam オプティマイザーと任意の torch.optim.Optimizer DeepSpeed では、NVIDIA の高性能な ADAM 実装、または torch の torch.optim.Optimizer クラスを継承する任意のトレーニングオプティマイザーを選択できます。 CPU-Adam：高性能なベクトル化 Adam 実装 CPU 上で Adam オプティマイザーを効率的に実装し、パラメーター更新のパフォーマンスをほぼ 1 桁向上させます。CPU-Adam の実装には、Intel-x86 アーキテクチャーの AVX SIMD 命令を使用しています。AVX-512 と AVX-2 の両方の命令セットをサポートします。DeepSpeed はデフォルトで AVX-2 を使用しますが、DeepSpeed のインストール時にビルドフラグ DS_BUILD_AVX512 を 1 に設定することで AVX-512 に切り替えられます。AVX-512 を使うと、モデルサイズが 10 億から 100 億パラメーターの場合に、torch-adam と比べて 5.1～6.5 倍の高速化が得られます。 メモリ帯域幅を最適化した FP16 オプティマイザー 混合精度トレーニングは、DeepSpeed FP16 オプティマイザーが処理します。このオプティマイザーは FP16 トレーニングを処理するだけでなく、高い効率も実現します。重み更新のパフォーマンスは主にメモリ帯域幅によって決まり、実効メモリ帯域幅は入力オペランドのサイズに左右されます。FP16 オプティマイザーは、モデルのすべてのパラメーターを単一の大きなバッファーにまとめ、単一のカーネルで重みを更新することで、実現可能なメモリ帯域幅を最大化するように設計されています。 LAMB オプティマイザーによる大規模バッチトレーニング DeepSpeed では、LAMB オプティマイザーを有効にすることで、大きなバッチサイズでのトレーニングを簡単に行えます。LAMB の詳細は論文をご覧ください。 ZeRO オプティマイザーによるメモリ効率の高いトレーニング DeepSpeed は、モデル並列処理なしで最大 130 億パラメーターのモデルを、16-way モデル並列処理で最大 2000 億パラメーターのモデルをトレーニングできます。ZeRO オプティマイザーによるメモリ効率の向上が、このモデルサイズの飛躍的な拡大を可能にします。詳細は ZeRO 論文をご覧ください。 トレーニング方式に依存しないチェックポイント DeepSpeed は、データ並列トレーニング、モデル並列トレーニング、混合精度トレーニング、それら 3 つの組み合わせ、または大規模モデルを可能にするゼロオプティマイザーのいずれを使用している場合でも、チェックポイント処理を簡単にします。詳細は Getting Started ガイドとコア API ドキュメントをご覧ください。 高度なパラメーター探索 DeepSpeed は、大規模バッチへのスケーリングでより速く収束するよう、複数の学習率スケジュールをサポートします。 学習率範囲テスト 学習率範囲テストのチュートリアルをご覧ください。 1Cycle 学習率スケジュール 1Cycle 学習率スケジュールのチュートリアルをご覧ください。 シンプルなデータローダー データの読み込みでは、DeepSpeed がデータ並列処理とモデル並列処理を抽象化します。ユーザーは PyTorch データセットを用意するだけで、DeepSpeed データローダーが適切なバッチの作成を自動的に処理します。 データ効率 Data Efficiency チュートリアルをご覧ください。 カリキュラム学習 Curriculum Learning チュートリアルをご覧ください。 上記の Data Efficiency Library は、より汎用的なカリキュラム学習をサポートします。この従来のカリキュラム学習機能も引き続きサポートされていますが、Data Efficiency Library の使用を推奨します。 パフォーマンス分析とデバッグ DeepSpeed は、パフォーマンス分析とデバッグのためのツールを提供します。 ウォールクロック時間の内訳 DeepSpeed は、トレーニングの各部分にかかった時間を詳しく表示します。deepspeed_config ファイルで次のように設定すると、この機能を有効にできます。 { "wall_clock_breakdown": true, } アクティベーションチェックポイント関数の計測 アクティベーションチェックポイントが有効な場合、deepspeed_config ファイルで各チェックポイント関数の順伝播と逆伝播にかかる時間をプロファイリングできます。 { "activation_checkpointing": { "profile": true } } FLOPS プロファイラー DeepSpeed FLOPS プロファイラーは PyTorch モデルの時間、FLOPS、パラメーター数を計測し、ボトルネックとなっているモジュールやレイヤーを表示します。DeepSpeed ランタイムと併用する場合、次のように deepspeed_config ファイルで FLOPS プロファイラーを設定できます。 { "flops_profiler": { "enabled": true, "profile_step": 1, "module_depth": -1, "top_modules": 3, "detailed": true, } } FLOPS プロファイラーはスタンドアロンパッケージとしても使用できます。詳細は Flops Profiler チュートリアルをご覧ください。 自動チューニング DeepSpeed Autotuner は、モデル情報、システム情報、ヒューリスティックを使用して、ZeRO ステージ、マイクロバッチサイズ、その他の ZeRO 設定を効率的に調整します。自動チューニング機能を使用するために、DeepSpeed ユーザーがコードを変更する必要はありません。"autotuning": {"enabled": true} が自動チューニングを有効にするための最小限の設定ですが、ユーザーは自動チューニングのプロセスを構成するほかのパラメーターも指定できます。以下に、自動チューニング設定の主なパラメーターとデフォルト値を示します。詳細は Autotuning チュートリアルをご覧ください。 { "autotuning": { "enabled": true, "results_dir": null, "exps_dir": null, "overwrite": false, "metric": "throughput", "num_nodes": null, "num_gpus": null, "start_profile_step": 3, "end_profile_step": 5, "fast": true, "num_tuning_micro_batch_sizes": 3, "tuner_type": "model_based", "tuner_early_stopping": 5, "tuner_num_trials": 50, "arg_mappings": null } } FLOPS プロファイラーはスタンドアロンパッケージとしても使用できます。詳細は Flops Profiler チュートリアルをご覧ください。 モニター DeepSpeed Monitor は、PyTorch の TensorBoard、WandB、または CSV ファイルなど、1 つ以上のモニタリングバックエンドにトレーニング指標をリアルタイムで記録します。deepspeed_config ファイルで次のように設定し、1 つ以上のバックエンドを構成できます。 { "tensorboard": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } "wandb": { "enabled": true, "team": "my_team", "group": "my_group", "project": "my_project" } "csv_monitor": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } } Monitor を追加して、カスタム指標やクライアントコードを記録することもできます。詳細は Monitor チュートリアルをご覧ください。 通信ログ DeepSpeed は、deepspeed.comm 内で起動されたすべての通信操作をログに記録できます。次のように deepspeed_config ファイルで通信ロガーを設定できます。 { "comms_logger": { "enabled": true, "verbose": false, "prof_all": true, "debug": false } } その後、クライアントコードで deepspeed.comm.log_summary() を呼び出すと、概要を出力できます。詳細と使用例については、Communication Logging チュートリアルをご覧ください。 スパースアテンション DeepSpeed は長いシーケンスに対応するため、スパースアテンションを提供します。Sparse Attention チュートリアルをご覧ください。 --deepspeed_sparse_attention "sparse_attention": { "mode": "fixed", "block": 16, "different_layout_per_head": true, "num_local_blocks": 4, "num_global_blocks": 1, "attention": "bidirectional", "horizontal_global_attention": false, "num_different_global_patterns": 4 } Mixture of Experts（MoE） DeepSpeed による Mixture of Experts（MoE）モデルのトレーニングについては、詳細なチュートリアルをご覧ください。

torch.optim.Optimizer

パターン 6: Flops Profiler 目次 概要 FLOPS 測定 マルチ GPU、マルチノード、データ並列、モデル並列 使用方法 DeepSpeed ランタイムでの使用方法 例: Megatron-LM DeepSpeed ランタイム外での使用方法 モデル推論 例: AlexNet 例: Bert モデルトレーニング ワークフロー 例 トレーニングワークフロー このチュートリアルでは、DeepSpeed Flops Profiler を紹介し、その使用例を示します。 概要 FLOPS 測定 マルチ GPU、マルチノード、データ並列、モデル並列 使用方法 概要 ハードウェアリソースを効果的に使用することは、優れたパフォーマンスを得るために不可欠ですが、大規模なモデルのトレーニングや推論における既存の実装のパフォーマンス非効率は、見つけにくく、特定のモジュールコンポーネントに帰属させにくいことがよくあります。DeepSpeed Flops Profiler を使用すると、ユーザーはモデルおよびそのサブモジュールのトレーニング・推論速度（レイテンシ、スループット）と効率（1 秒あたりの浮動小数点演算数、すなわち FLOPS）を容易に測定でき、既存の実装における非効率の解消に役立てることができます。以下は、A100 GPU 上でバッチサイズ 80 の BERT-Large（NVIDIA）を対象とした出力例です。 -------------------------- DeepSpeed Flops Profiler -------------------------- Profile Summary at step 10: Notations: data parallel size (dp_size), model parallel size(mp_size), number of parameters (params), number of multiply-accumulate operations(MACs), number of floating-point operations (flops), floating-point operations per second (FLOPS), fwd latency (forward propagation latency), bwd latency (backward propagation latency), step (weights update latency), iter latency (sum of fwd, bwd and step latency) world size: 1 data parallel size: 1 model parallel size: 1 batch size per GPU: 80 params per gpu: 336.23 M params of model = params per GPU * mp_size: 336.23 M fwd MACs per GPU: 3139.93 G fwd flops per GPU: 6279.86 G fwd flops of model = fwd flops per GPU * mp_size: 6279.86 G fwd latency: 76.67 ms bwd latency: 108.02 ms fwd FLOPS per GPU = fwd flops per GPU / fwd latency: 81.9 TFLOPS bwd FLOPS per GPU = 2 * fwd flops per GPU / bwd latency: 116.27 TFLOPS fwd+bwd FLOPS per GPU = 3 * fwd flops per GPU / (fwd+bwd latency): 102.0 TFLOPS step latency: 34.09 us iter latency: 184.73 ms samples/second: 433.07 ----------------------------- Aggregated Profile per GPU ----------------------------- Top modules in terms of params, MACs or fwd latency at different model depths: depth 0: params - {'BertForPreTrainingPreLN': '336.23 M'} MACs - {'BertForPreTrainingPreLN': '3139.93 GMACs'} fwd latency - {'BertForPreTrainingPreLN': '76.39 ms'} depth 1: params - {'BertModel': '335.15 M', 'BertPreTrainingHeads': '32.34 M'} MACs - {'BertModel': '3092.96 GMACs', 'BertPreTrainingHeads': '46.97 GMACs'} fwd latency - {'BertModel': '34.29 ms', 'BertPreTrainingHeads': '3.23 ms'} depth 2: params - {'BertEncoder': '302.31 M', 'BertLMPredictionHead': '32.34 M'} MACs - {'BertEncoder': '3092.88 GMACs', 'BertLMPredictionHead': '46.97 GMACs'} fwd latency - {'BertEncoder': '33.45 ms', 'BertLMPredictionHead': '2.61 ms'} depth 3: params - {'ModuleList': '302.31 M', 'Embedding': '31.79 M', 'Linear': '31.26 M'} MACs - {'ModuleList': '3092.88 GMACs', 'Linear': '36.23 GMACs'} fwd latency - {'ModuleList': '33.11 ms', 'BertPredictionHeadTransform': '1.83 ms''} depth 4: params - {'BertLayer': '302.31 M', 'LinearActivation': '1.05 M''} MACs - {'BertLayer': '3092.88 GMACs', 'LinearActivation': '10.74 GMACs'} fwd latency - {'BertLayer': '33.11 ms', 'LinearActivation': '1.43 ms'} depth 5: params - {'BertAttention': '100.76 M', 'BertIntermediate': '100.76 M'} MACs - {'BertAttention': '1031.3 GMACs', 'BertIntermediate': '1030.79 GMACs'} fwd latency - {'BertAttention': '19.83 ms', 'BertOutput': '4.38 ms'} depth 6: params - {'LinearActivation': '100.76 M', 'Linear': '100.69 M'} MACs - {'LinearActivation': '1030.79 GMACs', 'Linear': '1030.79 GMACs'} fwd latency - {'BertSelfAttention': '16.29 ms', 'LinearActivation': '3.48 ms'} ------------------------------ Detailed Profile per GPU ------------------------------ Each module profile is listed after its name in the following order: params, percentage of total params, MACs, percentage of total MACs, fwd latency, percentage of total fwd latency, fwd FLOPS BertForPreTrainingPreLN( 336.23 M, 100.00% Params, 3139.93 GMACs, 100.00% MACs, 76.39 ms, 100.00% latency, 82.21 TFLOPS, (bert): BertModel( 335.15 M, 99.68% Params, 3092.96 GMACs, 98.50% MACs, 34.29 ms, 44.89% latency, 180.4 TFLOPS, (embeddings): BertEmbeddings(...) (encoder): BertEncoder( 302.31 M, 89.91% Params, 3092.88 GMACs, 98.50% MACs, 33.45 ms, 43.79% latency, 184.93 TFLOPS, (FinalLayerNorm): FusedLayerNorm(...) (layer): ModuleList( 302.31 M, 89.91% Params, 3092.88 GMACs, 98.50% MACs, 33.11 ms, 43.35% latency, 186.8 TFLOPS, (0): BertLayer( 12.6 M, 3.75% Params, 128.87 GMACs, 4.10% MACs, 1.29 ms, 1.69% latency, 199.49 TFLOPS, (attention): BertAttention( 4.2 M, 1.25% Params, 42.97 GMACs, 1.37% MACs, 833.75 us, 1.09% latency, 103.08 TFLOPS, (self): BertSelfAttention( 3.15 M, 0.94% Params, 32.23 GMACs, 1.03% MACs, 699.04 us, 0.92% latency, 92.22 TFLOPS, (query): Linear(1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 182.39 us, 0.24% latency, 117.74 TFLOPS,...) (key): Linear(1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 57.22 us, 0.07% latency, 375.3 TFLOPS,...) (value): Linear(1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 53.17 us, 0.07% latency, 403.91 TFLOPS,...) (dropout): Dropout(...) (softmax): Softmax(...) ) (output): BertSelfOutput( 1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 114.68 us, 0.15% latency, 187.26 TFLOPS, (dense): Linear(1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 64.13 us, 0.08% latency, 334.84 TFLOPS, ...) (dropout): Dropout(...) ) ) (PreAttentionLayerNorm): FusedLayerNorm(...) (PostAttentionLayerNorm): FusedLayerNorm(...) (intermediate): BertIntermediate( 4.2 M, 1.25% Params, 42.95 GMACs, 1.37% MACs, 186.68 us, 0.24% latency, 460.14 TFLOPS, (dense_act): LinearActivation(4.2 M, 1.25% Params, 42.95 GMACs, 1.37% MACs, 175.0 us, 0.23% latency, 490.86 TFLOPS,...) ) (output): BertOutput( 4.2 M, 1.25% Params, 42.95 GMACs, 1.37% MACs, 116.83 us, 0.15% latency, 735.28 TFLOPS, (dense): Linear(4.2 M, 1.25% Params, 42.95 GMACs, 1.37% MACs, 65.57 us, 0.09% latency, 1310.14 TFLOPS,...) (dropout): Dropout(...) ) ) ... (23): BertLayer(...) ) ) (pooler): BertPooler(...) ) (cls): BertPreTrainingHeads(...) ) ------------------------------------------------------------------------------ サマリープロファイルでは、DeepSpeed Flops Profiler はモデルのパラメータ数、浮動小数点演算数（flops）、FLOPS、レイテンシ、および 1 秒あたりのサンプル数（samples/second）によるスループットを出力します。このプロファイルは、現在のモデル実行がハードウェアのピーク性能に対してどの程度の性能差を持つかを示し、ユーザーがより良いパフォーマンスのためにトレーニングまたは推論の設定（例：ハイパーパラメータ、データ並列、モデル並列、システム構成など）を調整する助けになります。DeepSpeed Flops Profiler はまた、モデルアーキテクチャ内の異なるモデル深度における重要なモジュール（集計プロファイル）と、モジュールごとの詳細なプロファイル（詳細プロファイル）も測定します。これらのプロファイルを使用することで、DeepSpeed のユーザーは各レイヤーやサブモジュールが全体のモデルの複雑さや性能にどのように寄与しているかを理解できます。その後、ユーザーはモデル設計を調整またはリファクタリングして性能を向上させることができます。たとえば、このプロファイラーを使えば、DeepSpeed のユーザーは小さなレイヤーを積み重ねる方が大きなレイヤーを使うより軽量または高性能であるかどうかを定量的に判断できます。集計プロファイルと詳細プロファイルにより、ボトルネックとなるモジュールも素早く特定できます。上記の BERT-Large の例では、DeepSpeed Flops Profiler を使用した結果、BertLayer が最も重要なレイヤーであり、線形モジュールとともに多くの dropout、softmax、layer norm を含んでいることが分かりました。これらのモジュールは flops の負荷は大きくないものの、多数の GPU カーネル呼び出しを発生させ、メモリへの過剰な読み書き要求を生み出します。詳細プロファイルに示されたこのパターンは、カーネルフュージョンに最適であることを示しており、データ移動を削減するために融合 Transformer カーネルを開発しました（DeepSpeedBert を参照）。最適化を適用した後、DeepSpeed Flops Profiler の出力において、GPU あたりの FLOPS とトレーニングのサンプル数/秒の全体が 25% 向上したことが確認されています。DeepSpeed Flops Profiler は、ユーザーコードを変更することなく DeepSpeed ランタイムと併用することも、DeepSpeed とは独立したスタンドアロンパッケージとして使用することもできます。DeepSpeed でモデルのトレーニングを行う場合、プロファイラーは DeepSpeed の設定ファイルで有効にできます。スタンドアロンパッケージとしては、プロファイラー API をトレーニングコードと推論コードの両方で使用できます。DeepSpeed のプロファイラーはまだ活発に開発中であり、初期機能のみを含んでいます。今後まもなく、さらに多くの魅力的な機能が追加される予定ですので、ぜひご注目ください。 FLOPS 測定 既存の flops 計算ツールや手法と同様に、DeepSpeed Flops Profiler はモジュールの順伝播の flops を測定し、逆伝播の flops は順伝播の 2 倍と見積もります。PyTorch の演算子ごとの flops を計算する PyTorch プロファイラーとは異なり、DeepSpeed Flops Profiler はモデル内のモジュール単位で flops を測定し、モデルの実行に関するより詳細な知見をユーザーに提供します。flops の推定は部分的に ptflops に着想を得ていますが、主な違いは、DeepSpeed Flops Profiler がモジュールレベルで直接 flops の計算をサポートするだけでなく、モジュール内で呼び出される torch.nn.functional も捕捉して flops を推定できる点です。そのため、DeepSpeed Flops Profiler は Megatron-LM の ParallelTransformerLayer、ParallelSelfAttention、RowParallelLinear など、モデル内のカスタムモジュールにも対応できます。これは、ユーザーが各カスタムモジュールごとに flops 計算関数を記述する必要がある ptflops とは対照的です。 マルチ GPU、マルチノード、データ並列、モデル並列 DeepSpeed Flops Profiler は、GPU ごとのプロファイルに加えて、ワールドサイズ、データ並列サイズ、モデル並列サイズを出力します。マルチ GPU またはマルチノードで実行されるモデルの場合、プロファイルされる flops とパラメータ数に影響するのはモデル並列の変更（例：Megatron-LM の --model-parallel-size）のみです。すなわち、model_parallel_size * flops = total_flops および model_parallel_size * parameters = total_parameters となります。データ並列サイズやワールドサイズ（GPU またはノードの数に関連）は、GPU ごとのプロファイルには影響しません。 使用方法 DeepSpeed Flops Profiler は、DeepSpeed ランタイムと併用することも、スタンドアロンパッケージとして使用することもできます。DeepSpeed でモデルのトレーニングを行う場合、プロファイラーは deepspeed の設定ファイルで、ユーザーコードを変更せずに設定できます。DeepSpeed ランタイム外で flops プロファイラーを使用するには、DeepSpeed をインストールし、flops_profiler パッケージをインポートして API を直接使用します。それぞれの使用例を以下に示します。 DeepSpeed ランタイムでの使用方法 DeepSpeed でモデルのトレーニングを行う場合、プロファイラーは deepspeed の設定ファイルで設定できます。プロファイラーを使用するために明示的な API 呼び出しは必要ありません。deepspeed の設定 json ファイルに以下のフィールドを追加することで、プロファイラーを有効にできます。詳細は flops profiler を参照してください。 { "flops_profiler": { "enabled": true, "profile_step": 1, "module_depth": -1, "top_modules": 1, "detailed": true, "output_file": null } } 例: Megatron-LM DeepSpeed で Megatron-LM を実行する方法については、当社のチュートリアル Megatron-LM を参照してください。以下に、12 層の Megatron-LM モデル（hidden_size = 8192、num_attention_heads = 32、batch_size = 1024、seq_length = 1024）の出力例を示します。 -------------------------- DeepSpeed Flops Profiler -------------------------- Profile Summary at step 10: Notations: data parallel size (dp_size), model parallel size(mp_size), number of parameters (params), number of multiply-accumulate operations(MACs), number of floating-point operations (flops), floating-point operations per second (FLOPS), fwd latency (forward propagation latency), bwd latency (backward propagation latency), step (weights update latency), iter latency (sum of fwd, bwd and step latency) world size: 1 data parallel size: 1 model parallel size: 1 batch size per GPU: 1024 params per gpu: 1.29 M params of model = params per GPU * mp_size: 1.29 M fwd MACs per GPU: 41271.95 G fwd flops per GPU: 82543.9 G fwd flops of model = fwd flops per GPU * mp_size: 82543.9 G fwd latency: 1.89 s bwd latency: 5.38 s fwd FLOPS per GPU = fwd flops per GPU / fwd latency: 43.68 TFLOPS bwd FLOPS per GPU = 2 * fwd flops per GPU / bwd latency: 30.7 TFLOPS fwd+bwd FLOPS per GPU = 3 * fwd flops per GPU / (fwd+bwd latency): 34.07 TFLOPS step latency: 34.12 s iter latency: 41.39 s samples/second: 24.74 ----------------------------- Aggregated Profile per GPU ----------------------------- Top 1 modules in terms of params, MACs or fwd latency at different model depths: depth 0: params - {'GPT2Model': '1.29 M'} MACs - {'GPT2Model': '41271.95 GMACs'} fwd latency - {'GPT2Model': '1.84 s'} depth 1: params - {'TransformerLanguageModel': '1.29 M'} MACs - {'TransformerLanguageModel': '39584.03 GMACs'} fwd latency - {'TransformerLanguageModel': '1.83 s'} depth 2: params - {'ParallelTransformer': '1.29 M'} MACs - {'ParallelTransformer': '39584.03 GMACs'} fwd latency - {'ParallelTransformer': '1.81 s'} depth 3: params - {'ModuleList': '1.28 M'} MACs - {'ModuleList': '39584.03 GMACs'} fwd latency - {'ModuleList': '1.3 s'} depth 4: params - {'ParallelTransformerLayerPart2': '688.15 k'} MACs - {'ParallelTransformerLayerPart2': '26388.28 GMACs'} fwd latency - {'ParallelTransformerLayerPart2': '865.73 ms'} depth 5: params - {'ParallelMLP': '491.54 k'} MACs - {'ParallelMLP': '26388.28 GMACs'} fwd latency - {'ParallelMLP': '849.4 ms'} ------------------------------ Detailed Profile per GPU ------------------------------ Each module profile is listed after its name in the following order: params, percentage of total params, MACs, percentage of total MACs, fwd latency, percentage of total fwd latency, fwd FLOPS Note: 1. A module can have torch.nn.module or torch.nn.functional to compute logits (e.g. CrossEntropyLoss). They are not counted as submodules, thus not to be printed out. However they make up the difference between a parent's MACs(or latency) and the sum of its submodules'. 1. Number of floating-point operations is a theoretical estimation, thus FLOPS computed using that could be larger than the maximum system throughput. 2. The fwd latency listed in the top module's profile is directly captured at the module forward function in PyTorch, thus it's less than the fwd latency shown above which is captured in DeepSpeed. GPT2Model( 1.29 M, 100.00% Params, 41271.95 GMACs, 100.00% MACs, 1.84 s, 100.00% latency, 44.78 TFLOPS, (language_model): TransformerLanguageModel( 1.29 M, 100.00% Params, 39584.03 GMACs, 95.91% MACs, 1.83 s, 99.11% latency, 43.34 TFLOPS, (embedding): Embedding( 2, 0.00% Params, 0 MACs, 0.00% MACs, 18.1 ms, 0.98% latency, 0.0 FLOPS, (word_embeddings): VocabParallelEmbedding(1, 0.00% Params, 0 MACs, 0.00% MACs, 164.75 us, 0.01% latency, 0.0 FLOPS, ) (position_embeddings): Embedding(1, 0.00% Params, 0 MACs, 0.00% MACs, 489.23 us, 0.03% latency, 0.0 FLOPS, 1024, 8192) (embedding_dropout): Dropout(0, 0.00% Params, 0 MACs, 0.00% MACs, 93.94 us, 0.01% latency, 0.0 FLOPS, p=0.1, inplace=False) ) (transformer): ParallelTransformer( 1.29 M, 100.00% Params, 39584.03 GMACs, 95.91% MACs, 1.81 s, 98.11% latency, 43.78 TFLOPS, (layers): ModuleList( 1.28 M, 98.73% Params, 39584.03 GMACs, 95.91% MACs, 1.3 s, 70.66% latency, 60.79 TFLOPS, (0): ParallelTransformerLayerPart1( 49.15 k, 3.80% Params, 1099.65 GMACs, 2.66% MACs, 23.5 ms, 1.27% latency, 93.6 TFLOPS, (input_layernorm): FusedLayerNorm(16.38 k, 1.27% Params, 0 MACs, 0.00% MACs, 128.75 us, 0.01% latency, 0.0 FLOPS, torch.Size([8192]), eps=1e-05, elementwise_affine=True) (attention): ParallelSelfAttention( 32.77 k, 2.53% Params, 1099.65 GMACs, 2.66% MACs, 22.8 ms, 1.24% latency, 96.46 TFLOPS, (query_key_value): ColumnParallelLinear(24.58 k, 1.90% Params, 824.63 GMACs, 2.00% MACs, 8.93 ms, 0.48% latency, 184.7 TFLOPS, ) (scale_mask_softmax): FusedScaleMaskSoftmax(0, 0.00% Params, 134.22 MMACs, 0.00% MACs, 151.16 us, 0.01% latency, 1.78 TFLOPS, ) (attention_dropout): Dropout(0, 0.00% Params, 0 MACs, 0.00% MACs, 79.63 us, 0.00% latency, 0.0 FLOPS, p=0.1, inplace=False) (dense): RowParallelLinear(8.19 k, 0.63% Params, 274.88 GMACs, 0.67% MACs, 2.67 ms, 0.14% latency, 205.81 TFLOPS, ) ) ) (1): ParallelTransformerLayerPart2( 57.35 k, 4.43% Params, 2199.02 GMACs, 5.33% MACs, 77.53 ms, 4.21% latency, 56.73 TFLOPS, (post_attention_layernorm): FusedLayerNorm(16.38 k, 1.27% Params, 0 MACs, 0.00% MACs, 116.11 us, 0.01% latency, 0.0 FLOPS, torch.Size([8192]), eps=1e-05, elementwise_affine=True) (mlp): ParallelMLP( 40.96 k, 3.16% Params, 2199.02 GMACs, 5.33% MACs, 76.19 ms, 4.13% latency, 57.72 TFLOPS, (dense_h_to_4h): ColumnParallelLinear(32.77 k, 2.53% Params, 1099.51 GMACs, 2.66% MACs, 10.79 ms, 0.59% latency, 203.81 TFLOPS, ) (dense_4h_to_h): RowParallelLinear(8.19 k, 0.63% Params, 1099.51 GMACs, 2.66% MACs, 14.38 ms, 0.78% latency, 152.95 TFLOPS, ) ) ) ... (23): ParallelTransformerLayerPart2(...) ) (final_layernorm): FusedLayerNorm(16.38 k, 1.27% Params, 0 MACs, 0.00% MACs, 110.86 us, 0.01% latency, 0.0 FLOPS, torch.Size([8192]), eps=1e-05, elementwise_affine=True) ) ) ) ------------------------------------------------------------------------------ DeepSpeed ランタイム外での使用方法 プロファイラーは、DeepSpeed ランタイムの外でスタンドアロンパッケージとして使用できます。DeepSpeed をインストールし、flops_profiler パッケージをインポートするだけで API を直接使用できます。DeepSpeed のインストール方法については、DeepSpeed のインストールを参照してください。 モデル推論 推論時に学習済みモデルをプロファイルするには、get_model_profile 関数を使用します。以下に例を示します。 例: AlexNet 次の例は、DeepSpeed flops profiler を使用して AlexNet をプロファイルする方法を示しています。 import torchvision.models as models import torch from deepspeed.profiling.flops_profiler import get_model_profile from deepspeed.accelerator import get_accelerator with get_accelerator().device(0): model = models.alexnet() batch_size = 256 flops, macs, params = get_model_profile(model=model, # model input_shape=(batch_size, 3, 224, 224), # input shape to the model. If specified, the model takes a tensor with this shape as the only positional argument. args=None, # list of positional arguments to the model. kwargs=None, # dictionary of keyword arguments to the model. print_profile=True, # prints the model graph with the measured profile attached to each module detailed=True, # print the detailed profile module_depth=-1, # depth into the nested modules, with -1 being the inner most modules top_modules=1, # the number of top modules to print aggregated profile warm_up=10, # the number of warm-ups before measuring the time of each module as_string=True, # print raw numbers (e.g. 1000) or as human-readable strings (e.g. 1k) output_file=None, # path to the output file. If None, the profiler prints to stdout. ignore_modules=None) # the list of modules to ignore in the profiling 例: Bert from functools import partial import torch from transformers import BertForSequenceClassification, BertTokenizer from deepspeed.profiling.flops_profiler import get_model_profile from deepspeed.accelerator import get_accelerator def bert_input_constructor(batch_size, seq_len, tokenizer): fake_seq = "" for _ in range(seq_len - 2): # ignore the two special tokens [CLS] and [SEP] fake_seq += tokenizer.pad_token inputs = tokenizer([fake_seq] * batch_size, padding=True, truncation=True, return_tensors="pt") labels = torch.tensor([1] * batch_size) inputs = dict(inputs) inputs.update({"labels": labels}) return inputs with get_accelerator().device(0): tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForSequenceClassification.from_pretrained('bert-base-uncased') batch_size = 4 seq_len = 128 enable_profile = True if enable_profile: flops, macs, params = get_model_profile( model, kwargs=bert_input_constructor(batch_size, seq_len, tokenizer), print_profile=True, detailed=True, ) else: inputs = bert_input_constructor((batch_size, seq_len), tokenizer) outputs = model(inputs) モデルトレーニング ワークフロー トレーニングワークフローでモデルの順伝播をプロファイルするには、FlopsProfiler クラスを使用します。FlopsProfiler クラスは次のメソッドを提供します。 start_profile() - プロファイリングを開始します get_total_flops(as_string=False) - モデル内の浮動小数点演算の総数を返します get_total_macs(as_string=False) - モデル内の MAC の総数を返します get_total_params(as_string=False) - モデル内のパラメータの総数を返します print_model_profile(profile_step=1, module_depth=-1, top_modules=3, detailed=True, output_file=None) - モデルのプロファイルを出力します stop_profile() - プロファイリングを停止します。モデル内の flops のカウントを停止します。 end_profile() - クリーンアップを行います。プロファイリング中にモデルに追加されたプロファイル用の属性を削除します。これはプロファイリングの終了時に、get_total_flops、get_total_params、または print_model_profile の後に呼び出す必要があります。 トレーニングワークフローの例 以下は、一般的なトレーニングワークフローにおけるこの使用方法の例です。 from deepspeed.profiling.flops_profiler import FlopsProfiler model = Model() prof = FlopsProfiler(model) profile_step = 5 print_profile= True for step, batch in enumerate(data_loader): # start profiling at training step "profile_step" if step == profile_step: prof.start_profile() # forward() method loss = model(batch) # end profiling and print output if step == profile_step: # if using multi nodes, check global_rank == 0 as well prof.stop_profile() flops = prof.get_total_flops() macs = prof.get_total_macs() params = prof.get_total_params() if print_profile: prof.print_model_profile(profile_step=profile_step) prof.end_profile() # runs backpropagation loss.backward() # weight update optimizer.step() Updated: November 5, 2025 Previous Next

80

パターン 7: DeepSpeed 設定 JSON の内容 バッチサイズ関連パラメーター オプティマイザーパラメーター スケジューラーパラメーター 通信オプション FP16 トレーニングオプション BFLOAT16 トレーニングオプション 自動混合精度 (AMP) トレーニングオプション 勾配クリッピング FP16 トレーニング向け ZeRO 最適化 パラメーターのオフロード オプティマイザーのオフロード 非同期 I/O ロギング オートチューニング FLOPS プロファイラー アクティベーションチェックポイント スパースアテンション データ効率 カリキュラム学習 モニタリングモジュール 弾性トレーニング設定 (V0.1 および V0.2) 通信ロギング 圧縮 レイヤー削減 重み量子化 アクティベーション量子化 スパース剪定 行剪定 ヘッド剪定 チャネル剪定 チェックポイントオプション データ型オプション

バッチサイズ関連パラメーター

注: train_batch_size は train_micro_batch_size_per_gpu * gradient_accumulation_steps * GPU 数 と等しくなければなりません。簡単のため、3 つのパラメーターのうち 2 つだけを指定することもでき、最後の 1 つは DeepSpeed が自動的に推論します。

train_batch_size: [整数]

値の例

有効なトレーニングバッチサイズです。モデルの 1 回の更新ステップに使われるデータサンプル数です。train_batch_size は、単一の GPU が 1 回の順伝播/逆伝播で処理するバッチサイズ (train_micro_batch_size_per_gpu とも呼ばれます)、勾配累積ステップ数 (gradient_accumulation_steps とも呼ばれます)、および GPU 数から集計されます。train_micro_batch_size_per_gpu と gradient_accumulation_steps の両方が指定されている場合は省略できます。

32

train_micro_batch_size_per_gpu: [整数]

説明

デフォルト

勾配累積を行わない場合に、1 つの GPU が 1 ステップで処理するバッチサイズです。train_batch_size と gradient_accumulation_steps の両方が指定されている場合は省略できます。

train_batch_size の値

gradient_accumulation_steps: [整数]

説明

デフォルト

勾配を平均化して適用する前に勾配を累積するトレーニングステップ数です。通信の頻度が下がるため、スケーラビリティの向上に役立つ場合があります。また、GPU ごとにより大きなバッチサイズで学習できるようになるという効果もあります。train_batch_size と train_micro_batch_size_per_gpu の両方が指定されている場合は省略できます。

1

オプティマイザーパラメーター

optimizer: [辞書]

フィールド

値の例

type

オプティマイザー名です。DeepSpeed は Adam、AdamW、OneBitAdam、Lamb、OneBitLamb のオプティマイザーをネイティブでサポートしています (詳細は こちら を参照してください)。その他のオプティマイザーは torch からインポートされます。

"Adam"

params

オプティマイザーをインスタンス化するためのパラメーターの辞書です。パラメーター名はオプティマイザーのコンストラクターのシグネチャ (例: Adam の場合) と一致している必要があります。

{"lr": 0.001, "eps": 1e-8}

Adam を使用するオプティマイザーの例

"optimizer": { "type": "Adam", "params": { "lr": 0.001, "betas": [ 0.8, 0.999 ], "eps": 1e-8, "weight_decay": 3e-7 } }

Adam オプティマイザーは、torch.optim.Adam の標準パラメーターに加えて、次の 2 つの params キー/値もサポートします。

“params” キー

説明

デフォルト

torch_adam

独自の fused adam 実装の代わりに、torch の adam 実装を使用します。

false

adam_w_mode

L2 正則化 (AdamW としても知られます) を適用します。

true

1-bit Adam 固有のパラメーターを使用するオプティマイザーの別の例は次のとおりです。

"optimizer": { "type": "OneBitAdam", "params": { "lr": 0.001, "betas": [ 0.8, 0.999 ], "eps": 1e-8, "weight_decay": 3e-7, "freeze_step": 400, "cuda_aware": false, "comm_backend_name": "nccl" } }

1-bit Adam オプティマイザーは、標準の Adam に加えて、次の 3 つの params キー/値をサポートします (詳細はチュートリアルを参照してください)。

“params” キー

説明

デフォルト

freeze_step

通信に 1-bit 圧縮を適用する前のウォームアップステップ数です。

100000

cuda_aware

基盤となる MPI ライブラリが CUDA-Aware 通信をサポートしていることを示します。

false

comm_backend_name

使用するバックエンド実装を示します。

“nccl”

1-bit Adam の派生オプティマイザーとして 0/1 Adam があります。これは、適応的な分散の凍結と、オプティマイザー状態に対する 1-bit 同期によって、1-bit Adam をさらに最適化するものです。

"optimizer": { "type": "ZeroOneAdam", "params": { "lr": 1e-3, "weight_decay": 0.01, "bias_correction": false, "var_freeze_step": 1000, "var_update_scaler": 16, "local_step_scaler": 1000, "local_step_clipper": 16, "cuda_aware": false, "comm_backend_name": "nccl" } }

0/1 Adam は、標準の Adam に加えて、次の params キー/値をサポートします (詳細はチュートリアルを参照してください)。

“params” キー

説明

デフォルト

var_freeze_step

分散を更新する最後のステップです。

100000

var_update_scaler

分散を更新する間隔です。

16

local_step_scaler

学習率ポリシーに従ってローカルステップの間隔をスケーリングする間隔です。

32678

local_step_clipper

学習率ポリシーにおけるローカルステップの最大間隔です。

16

cuda_aware

基盤となる MPI ライブラリが CUDA-Aware 通信をサポートしていることを示します。

false

comm_backend_name

使用するバックエンド実装を示します。

“nccl”

1-bit LAMB オプティマイザーの別の例

"optimizer": { "type": "OneBitLamb", "params": { "lr": 11e-3, "weight_decay": 0.01, "bias_correction": false, "max_coeff": 0.3, "min_coeff": 0.01, "freeze_step": 1000, "cuda_aware": false, "comm_backend_name": "nccl", "coeff_beta": 0.9, "factor_max": 4.0, "factor_min": 0.5, "factor_threshold": 0.1 } }

1-bit LAMB オプティマイザーは、標準の LAMB に加えて、次の params キー/値をサポートします (詳細はチュートリアルを参照してください)。

“params” キー

説明

デフォルト

max_coeff

元の LAMB アルゴリズムおよび 1-bit LAMB のウォームアップ段階におけるスケーリング係数の上限です。

10.0

min_coeff

元の LAMB アルゴリズムおよび 1-bit LAMB のウォームアップ段階におけるスケーリング係数の下限です。

0.01

freeze_step

通信に 1-bit 圧縮を適用する前のウォームアップステップ数です。

100000

cuda_aware

基盤となる MPI ライブラリが CUDA-Aware 通信をサポートしていることを示します。

false

comm_backend_name

使用するバックエンド実装を示します。

“nccl”

coeff_beta

LAMB 係数の移動平均の計算に使用される係数です。

0.9

factor_max

圧縮段階で凍結された LAMB 係数に適用するスケーリング係数の最大値です。

4.0

factor_min

圧縮段階で凍結された LAMB 係数に適用するスケーリング係数の最小値です。

0.5

factor_threshold

ステップ間でスケーリング係数がどの程度変動できるかのしきい値です。

0.1

スケジューラーパラメーター

model_engine.step() が実行されるたびに、DeepSpeed は各トレーニングステップでスケジューラーの step() メソッドを呼び出します。

scheduler: [辞書]

フィールド

値の例

type

スケジューラー名です。サポートされているスケジューラーの一覧は こちら を参照してください。

"WarmupLR"

params

スケジューラーをインスタンス化するためのパラメーターの辞書です。パラメーター名はスケジューラーのコンストラクターのシグネチャと一致している必要があります。

{"warmup_min_lr": 0, "warmup_max_lr": 0.001}

スケジューラーの例

"scheduler": { "type": "WarmupLR", "params": { "warmup_min_lr": 0, "warmup_max_lr": 0.001, "warmup_num_steps": 1000 } }

通信オプション

communication_data_type: [文字列]

説明

デフォルト

勾配平均化の際に、選択したデータ型で通信を行います。デフォルトでは、選択された動作モードによって決まります。

None

prescale_gradients: [真偽値]

説明

デフォルト

allreduce の前に勾配をスケーリングします。

false

gradient_predivide_factor: [浮動小数点数]

説明

デフォルト

勾配平均化の前に、勾配を指定した係数で事前除算します。多数の GPU にスケールする際に、fp16 の安定性を改善できる場合があります。

1.0

sparse_gradients: [真偽値]

説明

デフォルト

torch.nn.Embedding の勾配のスパース圧縮を有効にします。この機能は、現在はあまり使われなくなったため、事実上非推奨です。torch.sparse 関連の機能とは互換性がないことに注意してください。

false

FP16 トレーニングオプション

注: このモードは、後述する amp モードと併用できません。

fp16: [辞書]

説明

デフォルト

NVIDIA の Apex パッケージを利用した混合精度/FP16 トレーニングの設定です。利用可能な辞書キーを含む例を以下に示します。 注: このモードは Apex の AMP モードを使用するものではありません。AMP モードはより柔軟な混合精度トレーニングを可能にしますが、このモードは AMP の O2 モードに近いものです。より複雑な混合精度モードを使用したい場合は、後述の AMP サポートを参照してください。 現時点で ZeRO を使用する場合は、このモードを使用する必要があります。

None

"fp16": { "enabled": true, "auto_cast": false, "loss_scale": 0, "initial_scale_power": 16, "loss_scale_window": 1000, "hysteresis": 2, "consecutive_hysteresis": false, "min_loss_scale": 1 }

fp16:enabled: [真偽値]

説明

デフォルト

enabled は FP16 パラメーターで、FP16 トレーニングを有効にするかどうかを示します。

false

fp16:auto_cast: [真偽値]

説明

デフォルト

auto_cast は、入力を自動的に fp16 にキャストします。

false

fp16:loss_scale: [浮動小数点数]

説明

デフォルト

loss_scale は FP16 パラメーターで、FP16 トレーニングの損失スケーリング値を表します。デフォルト値の 0.0 では動的損失スケーリングが行われます。それ以外の値を指定すると、その値が固定の静的損失スケーリングとして使用されます。

0.0

fp16:initial_scale_power: [整数]

説明

デフォルト

initial_scale_power は FP16 パラメーターで、初期の動的損失スケールの累乗を表します。実際の損失スケールは 2initial_scale_power として計算されます。

16

fp16:loss_scale_window: [整数]

説明

デフォルト

loss_scale_window は FP16 パラメーターで、動的損失スケール値を上げ下げする際の評価ウィンドウを表します。

1000

fp16:hysteresis: [整数]

説明

デフォルト

hysteresis は FP16 パラメーターで、動的損失スケーリングにおける遅延シフトを表します。

2

fp16:consecutive_hysteresis: [真偽値]

説明

デフォルト

consecutive_hysteresis は FP16 パラメーターで、オーバーフローしない反復に到達した場合にヒステリシスを補充するかどうかを表します。

false

fp16:min_loss_scale: [整数]

説明

デフォルト

min_loss_scale は FP16 パラメーターで、動的損失スケール値の最小値を表します。

1

BFLOAT16 トレーニングオプション

注: このモードは、後述する amp モードと併用できません。 注: このモードは、前述の fp16 モードと併用できません。

bf16: [辞書]

説明

デフォルト

FP16 の代替として bfloat16 浮動小数点形式を使用するための設定です。BFLOAT16 にはハードウェアサポートが必要です (例: NVIDIA A100)。利用可能な辞書キーを含む例を以下に示します。 bfloat16 によるトレーニングでは損失スケーリングは不要です。

None

"bf16": { "enabled": true }

bf16:enabled: [真偽値]

説明

デフォルト

enabled は BFLOAT16 トレーニングを有効にするかどうかを示します。

false

自動混合精度 (AMP) トレーニングオプション

注: このモードは、前述の fp16 モードと併用できません。また、このモードは現時点では ZeRO と互換性がありません。

amp: [辞書]

説明

デフォルト

NVIDIA の Apex AMP パッケージを利用した自動混合精度 (AMP) トレーニングの設定です。利用可能な辞書キーを含む例を以下に示します。 上記の fp16 モードおよび ZeRO とは互換性がありません。"enabled" 以外のパラメーターはすべて AMP の initialize 呼び出しに渡されます。API と説明については、こちらの apex.amp.initialize のドキュメントを参照してください。

None

"amp": { "enabled": true, ... "opt_level": "O1", ... }

amp:enabled: [真偽値]

説明

デフォルト

enabled は amp パラメーターで、AMP トレーニングを有効にするかどうかを示します。

false

amp のパラメーター: [さまざま]

説明

デフォルト

"enabled" 以外のパラメーターはすべて AMP の initialize 呼び出しに渡されます。API と説明については、こちらの apex.amp.initialize のドキュメントを参照してください。

None

勾配クリッピング

gradient_clipping: [浮動小数点数]

説明

デフォルト

値 1.0 で勾配クリッピングを有効にします。

FP16 トレーニング向け ZeRO 最適化

ZeRO メモリ最適化の有効化と設定

"zero_optimization": { "stage": [0|1|2|3], "allgather_partitions": [true|false], "allgather_bucket_size": 5e8, "overlap_comm": false, "reduce_scatter": [true|false], "reduce_bucket_size": 5e8, "contiguous_gradients" : [true|false], "offload_param": { ... }, "offload_optimizer": { ... }, "stage3_max_live_parameters" : 1e9, "stage3_max_reuse_distance" : 1e9, "stage3_prefetch_bucket_size" : 5e8, "stage3_param_persistence_threshold" : 1e6, "sub_group_size" : 1e12, "elastic_checkpoint" : [true|false], "stage3_gather_16bit_weights_on_model_save": [true|false], "ignore_unused_parameters": [true|false], "round_robin_gradients": [true|false], "zero_hpz_partition_size": 1, "zero_quantized_weights": [true|false], "zero_quantized_gradients": [true|false], "log_trace_cache_warnings": [true|false], }

zero_optimization: [辞書]

説明

デフォルト

ZeRO メモリ最適化を有効にします。FP16/BF16/FP32 および Adam オプティマイザーと互換性があります。

false

stage: [整数]

説明

デフォルト

ZeRO オプティマイザーのステージを選択します。ステージ 0、1、2、3 は、それぞれ無効、オプティマイザー状態の分割、オプティマイザー + 勾配状態の分割、オプティマイザー + 勾配 + パラメーターの分割を表します。

0

allgather_partitions: [真偽値]

説明

デフォルト

各ステップの終わりに、すべての GPU から更新済みパラメーターを収集する際に、allgather の集合通信を使うか、一連の broadcast の集合通信を使うかを選択します。

true

allgather_bucket_size: [整数]

説明

デフォルト

一度に allgather する要素数です。大規模モデルで allgather に必要なメモリを制限します。

5e8

overlap_comm: [真偽値]

説明

デフォルト

勾配のリダクションを逆伝播の計算と重ね合わせることを試みます。

false

reduce_scatter: [真偽値]

説明

デフォルト

勾配の平均化に allreduce の代わりに reduce または reduce scatter を使用します。

true

reduce_bucket_size: [整数]

説明

デフォルト

一度に reduce/allreduce する要素数です。大規模モデルで必要なメモリを制限します。

5e8

contiguous_gradients: [真偽値]

説明

デフォルト

勾配が生成されるたびに、連続したバッファーにコピーします。逆伝播中のメモリの断片化を避けます。

True

load_from_fp32_weights: [真偽値]

説明

デフォルト

チェックポイント内の fp32 のコピーから fp32 のマスター重みを初期化するか (精度低下なし)、モデルの fp16 のコピーから初期化するか (精度低下あり) を選択します。チェックポイントにオプティマイザー状態がない場合でも、オプティマイザー状態を初期化するために使用できます。

True

grad_hooks: [真偽値]

説明

デフォルト

ZeRO ステージ 1 で使用します。逆伝播中に勾配のリダクションを行うバックワードフックを有効にするか、逆伝播の終了まで待つかを選択します。

True

round_robin_gradients: [真偽値]

説明

デフォルト

ステージ 1 および 2 向けの CPU オフロード最適化です。細粒度の勾配分割により、ランク間で CPU メモリへの勾配コピーを並列化します。性能上の利点は、勾配累積ステップ数 (オプティマイザーステップ間でのコピーが増える) や GPU 数 (並列性が増す) が大きいほど大きくなります。

False

offload_param: [辞書]

説明

デフォルト

モデルパラメーターを CPU または NVMe にオフロードします。これにより、より大きなモデルやバッチサイズのために GPU メモリを解放できます。ステージ 3 でのみ有効です。詳細は こちら を参照してください。

False

offload_optimizer: [辞書]

説明

デフォルト

オプティマイザー状態を CPU または NVMe にオフロードし、オプティマイザーの計算を CPU で行います。これにより、より大きなモデルやバッチサイズのために GPU メモリを解放できます。ZeRO ステージ 1、2、3 で有効です。詳細は こちら を参照してください。

False

stage3_max_live_parameters: [整数]

説明

デフォルト

解放前に GPU ごとに常駐させるパラメーターの最大数です。小さい値はメモリ使用量を抑えますが、通信が増えます。

1e9

stage3_max_reuse_distance: [整数]

説明

デフォルト

このしきい値内で再利用されるパラメーターは解放しません。小さい値はメモリ使用量を抑えますが、通信が増えます。

1e9

stage3_prefetch_bucket_size: [整数]

説明

デフォルト

パラメーターのプリフェッチに使用する固定バッファーのサイズです。小さい値はメモリ使用量を抑えますが、通信によるストールが増える場合があります。

5e8

stage3_param_persistence_threshold: [整数]

説明

デフォルト

このしきい値より小さいパラメーターは分割しません。小さい値はメモリ使用量を抑えますが、特に遅延が支配的な小さなメッセージでは通信が大幅に増える場合があります。

1e5

stage3_gather_16bit_weights_on_model_save: [真偽値]

説明

デフォルト

save_16bit_model() でモデルを保存する前に重みを統合します。重みは GPU 間で分割されているため state_dict には含まれません。このオプションが有効な場合、この関数は重みを自動的に収集してから fp16 のモデル重みを保存します。

False

stage3_module_granularity_threshold: [整数]

| 説明 | デフォルト | |——————————————————————————————————————————————————————————————————————————————————————————–| ——- | | モジュールの粒度は、parameter_count / (1 + descendant_count) の比率によって決まります。ZeRO3 は、粒度がしきい値未満のモジュールを細粒度として分類し、パラメーター取得時に統合された単位として扱います。これにより、個別のフックによるホストおよび通信のオーバーヘッドが減少します。 | 0 |

zero_hpz_partition_size: [整数]

説明

デフォルト

ZeRO++ の階層的パーティショニング ZeRO (hpZ) の二次テンソルグループにおけるランク数です。デフォルトの 1 は hpZ を使用しないことを意味します。理想的な値は、1 ノードあたりの GPU 数です。

1

zero_quantized_weights: [真偽値]

説明

デフォルト

ZeRO++ の通信効率の高い量子化重みを有効にするかどうかを示すブール値です。

False

zero_quantized_gradients: [真偽値]

説明

デフォルト

ZeRO++ の通信効率の高い量子化勾配を有効にするかどうかを示すブール値です。

False

log_trace_cache_warnings: [真偽値]

説明

デフォルト

パラメーターシャーディングのトレースキャッシュ最適化からの警告 (キャッシュ無効化イベントなど) をログに出力します。

False

cpu_offload: [真偽値]

非推奨: cpu_offload は非推奨であり、将来削除される予定です。代わりに offload_optimizer を使用してください。

説明

デフォルト

オプティマイザーのメモリと計算を CPU にオフロードします。これにより、より大きなモデルやバッチサイズのために GPU メモリを解放できます。ZeRO ステージ 1 および 2 で有効です。

False

パラメーターのオフロード

ZeRO によるパラメーターの CPU/NVMe へのオフロードの有効化と設定です。ZeRO ステージ 3 でのみ利用可能です。"device" の値が指定されていないか、サポートされていない場合は、アサーションが発生することに注意してください。

"offload_param": { "device": "[cpu|nvme]", "nvme_path": "/local_nvme", "pin_memory": [true|false], "buffer_count": 5, "buffer_size": 1e8, "max_in_cpu": 1e9 }

device: [文字列]

説明

デフォルト

モデルパラメーターをオフロードするデバイスメモリです。サポートされている値は cpu と nvme です。

cpu

nvme_path: [文字列]

説明

デフォルト

パラメーターのオフロードに使用する NVMe デバイスのファイルシステムパスです。

/local_nvme

pin_memory: [真偽値]

説明

デフォルト

ページロックされた CPU メモリにオフロードします。追加のメモリオーバーヘッドと引き換えに、スループットが向上する場合があります。

false

buffer_count: [整数]

説明

デフォルト

NVMe へのパラメーターのオフロードに使用するバッファープール内のバッファー数です。

5

buffer_size: [整数]

説明

デフォルト

NVMe へのパラメーターのオフロードに使用するバッファープール内のバッファーサイズです。

1e8

max_in_cpu: [整数]

説明

デフォルト

NVMe へのオフロードが有効な場合に CPU メモリ内に保持するパラメーター要素数です。

1e9

オプティマイザーのオフロード

ZeRO によるオプティマイザーの計算の CPU へのオフロード、および状態の CPU/NVMe へのオフロードの有効化と設定です。CPU へのオフロードは ZeRO ステージ 1、2、3 で利用可能です。NVMe へのオフロードは ZeRO ステージ 3 でのみ利用可能です。"device" の値が指定されていないか、サポートされていない場合は、アサーションが発生することに注意してください。

"offload_optimizer": { "device": "[cpu|nvme]", "nvme_path": "/local_nvme", "pin_memory": [true|false], "ratio": 0.3, "buffer_count": 4, "fast_init": false }

device: [文字列]

説明

デフォルト

オプティマイザー状態をオフロードするデバイスメモリです。サポートされている値は cpu と nvme です。device の設定にかかわらず、オプティマイザーの計算は CPU にオフロードされます。

cpu

nvme_path: [文字列]

説明

デフォルト

オプティマイザー状態のオフロードに使用する NVMe デバイスのファイルシステムパスです。

/local_nvme

pin_memory: [真偽値]

説明

デフォルト

ページロックされた CPU メモリにオフロードします。追加のメモリオーバーヘッドと引き換えに、スループットが向上する場合があります。

false

ratio: [浮動小数点数]

説明

デフォルト

CPU 側で更新 (つまりオプティマイザーステップ) されるパラメーターの割合です。

1

buffer_count: [整数]

説明

デフォルト

NVMe へのオプティマイザー状態のオフロードに使用するバッファープール内のバッファー数です。オプティマイザーがパラメーターごとに保持する状態数以上である必要があります。たとえば、Adam オプティマイザーは 4 つの状態 (パラメーター、勾配、モーメンタム、分散) を持ちます。

4

fast_init: [真偽値]

説明

デフォルト

NVMe へのオフロード時に、オプティマイザーの高速初期化を有効にします。

false

非同期 I/O

パラメーターおよびオプティマイザー状態を永続ストレージ (NVMe) にオフロードするための非同期 I/O モジュールの設定です。このモジュールは Linux ネイティブの非同期 I/O (libaio) を使用します。

"aio": { "block_size": 1048576, "queue_depth": 8, "thread_count": 1, "single_submit": false, "overlap_events": true }

block_size: [整数]

説明

デフォルト

I/O ブロックサイズ (バイト単位) です。

1048576

queue_depth: [整数]

説明

デフォルト

I/O キューの深さです。

8

thread_count: [整数]

説明

デフォルト

ユーザースレッドから送信される読み取り/書き込みごとの、リクエスト内並列性です。

1

single_submit: [真偽値]

説明

デフォルト

リクエストのブロックを 1 回で送信するのではなく、複数の個別リクエストとして記憶装置に送信します。

false

overlap_events: [真偽値]

説明

デフォルト

以前のリクエストの完了を待たずに、重ね合わせた方法で記憶装置にリクエストを送信します。

true

ignore_unused_parameters: [真偽値]

説明

デフォルト

モジュール内の未使用パラメーターは、静的ネットワークでは想定外ですが、動的ネットワークでは正常な場合があります。このオプションは、未使用パラメーターが検出された際にトレーニングをエラーメッセージとともに終了させるかどうかを制御します。デフォルトは True で、未使用パラメーターは無視されトレーニングは継続されます。現在はステージ 2 でのみ使用されます。

True

ロギング

steps_per_print: [整数]

説明

デフォルト

N トレーニングステップごとに進捗レポートを出力します。レポートには、トレーニングステップ数、スキップされたオプティマイザー更新の数 (混合精度トレーニングでのオーバーフローが原因と思われるもの)、現在の学習率、現在のモーメンタムが含まれます。

10

wall_clock_breakdown: [真偽値]

説明

デフォルト

順伝播/逆伝播/更新のトレーニングフェーズの遅延時間の計測を有効にします。

false

dump_state: [真偽値]

説明

デフォルト

初期化後に DeepSpeed オブジェクトの状態情報を出力します。

false

オートチューニング

{ "autotuning": { "enabled": false, "results_dir": "autotuning_results", "exps_dir": "autotuning_exps", "overwrite": false, "metric": "throughput", "start_profile_step": 3, "end_profile_step": 5, "fast": true, "max_train_batch_size": null, "mp_size": 1, "num_tuning_micro_batch_sizes": 3, "tuner_type": "model_based", "tuner_early_stopping": 5, "tuner_num_trials": 50, "arg_mappings": null } }

enabled: [真偽値]

説明

デフォルト

オートチューナーを有効にします。

false

results_dir: [文字列]

説明

デフォルト

オートチューニング実験の結果ディレクトリへのパスです。デフォルトでは、DeepSpeed を起動した作業ディレクトリに作成されます。

“autotuning_results”

exps_dir: [文字列]

説明

デフォルト

オートチューニング実験の記述ディレクトリへのパスです。デフォルトでは、DeepSpeed を起動した作業ディレクトリに作成されます。

“autotuning_exps”

overwrite: [真偽値]

説明

デフォルト

すでに結果が存在するオートチューニング実験を再実行するかどうかです。true に設定すると、既存の結果が上書きされます。

false

metric: [文字列]

説明

デフォルト

オートチューニング実験のランキングに使用する性能指標です。現在、latency、throughput、FLOPS がサポートされており、それぞれ、トレーニングステップの遅延時間、1 秒あたりのトレーニングサンプル数、GPU ごとに達成された 1 秒あたりの浮動小数点演算数を指します。

throughput

start_profile_step: [整数]

説明

デフォルト

オートチューニング実験でプロファイリングを開始するグローバルなトレーニングステップです。正確な性能測定にはウォームアップが必要であることに注意してください。

3

end_profile_step: [整数]

説明

デフォルト

オートチューニング実験でプロファイリングを終了するグローバルなトレーニングステップです。start_profile_step 以上である必要があります。

5

fast: [真偽値]

説明

デフォルト

高速モデルのオートチューニングを有効にします。この場合、ZeRO ステージと GPU ごとのマイクロバッチサイズのみがチューニングされます。

true

max_train_batch_size: [整数]

説明

デフォルト

モデルトレーニングにおける最大トレーニングバッチサイズ (グローバルな有効バッチサイズ) です。

null

mp_size: [整数]

説明

デフォルト

モデル並列処理の度合いです。

1

num_tuning_micro_batch_sizes: [整数]

説明

デフォルト

探索するマイクロバッチサイズの数です。

3

tuner_type: [文字列]

説明

デフォルト

ZeRO ステージ内でのオートチューニング空間の探索順序を定義するアルゴリズムです。

model_based

tuner_early_stopping: [整数]

説明

デフォルト

現在の最良の実験を超えて実行する実験の数です。その数の範囲内でより良い実験が見つからなければ、オートチューナーは探索を停止します。

5

tuner_num_trials: [整数]

説明

デフォルト

ZeRO ステージ内でチューニング空間を探索する実験の最大数です。

50

FLOPS プロファイラー

{ "flops_profiler": { "enabled": false, "profile_step": 1, "module_depth": -1, "top_modules": 1, "detailed": true, "output_file": null, } }

enabled: [真偽値]

説明

デフォルト

FLOPS プロファイラーを有効にします。これにより wall_clock_breakdown も有効になります。

false

profile_step: [整数]

説明

デフォルト

プロファイリングを行うグローバルなトレーニングステップです。正確な時間計測にはウォームアップステップが必要であることに注意してください。

1

module_depth: [整数]

説明

デフォルト

集計されたモジュール情報を出力するモデルの深さです。-1 に設定すると、最上位のモジュールから最も内側のモジュールまで (最大深さ) の情報を出力します。

-1

top_modules: [整数]

説明

デフォルト

集計されたプロファイル出力を、指定した上位モジュール数に制限します。

1

detailed: [真偽値]

説明

デフォルト

詳細なモデルプロファイルを出力するかどうかです。

true

output_file: [文字列]

説明

デフォルト

出力ファイルへのパスです。None の場合、プロファイラーは標準出力に出力します。

null

アクティベーションチェックポイント

"activation_checkpointing": { "partition_activations": false, "cpu_checkpointing": false, "contiguous_memory_optimization": false, "number_checkpoints": null, "synchronize_checkpoint_boundary": false, "profile": false }

partition_activations: [真偽値]

説明

デフォルト

モデル並列処理と併用する場合に、アクティベーションの分割を有効にします。

false

cpu_checkpointing: [真偽値]

説明

デフォルト

partition_activations が有効な場合、分割されたアクティベーションを CPU にオフロードします。

false

contiguous_memory_optimization: [真偽値]

説明

デフォルト

分割されたアクティベーションをメモリ上で連続するようにコピーします。

false

number_checkpoints: [整数]

説明

デフォルト

contiguous_memory_optimization のためにメモリバッファーを割り当てる際に使用する、アクティベーションチェックポイントの総数です。

None

synchronize_checkpoint_boundary: [真偽値]

説明

デフォルト

各チェックポイント境界で get_accelerator().synchronize() を挿入します。

false

profile: [真偽値]

説明

デフォルト

各チェックポイント関数の順伝播と逆伝播の時間を記録します。

false

スパースアテンション

sparse_attention: [辞書]

フィールド

値の例

mode

スパース性の構造タイプを決定する文字列です。DeepSpeed は現在 "dense"、"fixed"、"bigbird"、"bslongformer"、"variable" をサポートしています。

"fixed"

block

ブロックサイズを決定する整数です。現在のスパース自己アテンションの実装は、ブロック化されたスパース行列に基づいています。このパラメーターは、そのブロックのサイズ (Block X Block) を定義します。

16

different_layout_per_head

各ヘッドに異なるスパース性レイアウトを割り当てるかどうかを決定する真偽値です。可能な場合に満たされます。

false

num_local_blocks

各ブロック行内のランダムブロック数を決定する整数です。"fixed" モードでのみ使用されます。

4

num_global_blocks

ローカルウィンドウ内の連続するブロックのうち、グローバルアテンションにおけるそのウィンドウの代表として使用されるブロック数を決定する整数です。"fixed" および "bigbird" モードで使用されます。

1

attention

アテンションの種類を決定する文字列です。"unidirectional" は自己回帰モデルのように、トークンがコンテキスト内で自分より前に出現するトークンのみにアテンションする形式です。この場合、アテンション行列の上三角は空になります。"bidirectional" は BERT のように、トークンが前後の任意のトークンにアテンションできる形式です。この場合、アテンション行列の上三角部分は下三角部分の鏡像になります。"fixed" および "variable" モードで使用されます。

"bidirectional"

horizontal_global_attention

ローカルウィンドウの代表となるグローバルブロックが、他のすべてのブロックにもアテンションするかどうかを決定する真偽値です。アテンションの種類が "bidirectional" の場合のみ有効です。アテンション行列で見ると、グローバルアテンションは縦方向のブロックだけでなく横方向のブロックも含むことを意味します。"fixed" および "variable" モードで使用されます。

false

num_different_global_patterns

異なるグローバルアテンションレイアウトの数を決定する整数です。グローバルアテンションは、どのブロックがローカルウィンドウの代表になるかで固定できますが、複数のヘッドがあるため、各ヘッドが異なるグローバル代表を使用できます。"fixed" モードでのみ使用されます。

4

num_random_blocks

各ブロック行内のランダムブロック数を決定する整数です。"variable" および "bigbird" モードで使用されます。

0

local_window_blocks

各ローカルアテンションウィンドウ内のブロック数を決定する整数のリストです。最初の数値が最初のローカルウィンドウのブロック数、2 番目の数値が 2 番目のウィンドウのブロック数、…、最後の数値が残りのローカルウィンドウのブロック数を決定します。"variable" モードでのみ使用されます。

[4]

global_block_indices

どのブロックをグローバルアテンションとして扱うかを決定する整数のリストです。指定されたインデックスのブロックには、他のすべてのトークンブロックがアテンションし、それらのブロックは他のすべてのトークンブロックにアテンションします。global_block_end_indices パラメーターが設定されている場合、このパラメーターは各グローバルウィンドウの開始インデックスとして使用されます。"variable" および "bslongformer" モードで使用されます。

[0]

global_block_end_indices

グローバルウィンドウのブロックの終了インデックスを決定する整数のリストです。デフォルトでは使用されません。設定する場合は、global_block_indices パラメーターと同じサイズでなければなりません。2 つのパラメーターを組み合わせると、各インデックス i について、global_block_indices[i] から global_block_end_indices[i] まで (終了インデックスを含まない) のブロックがグローバルアテンションとして扱われます。"variable" および "bslongformer" モードで使用されます。

None

num_sliding_window_blocks

スライディングローカルアテンションウィンドウ内のブロック数を決定する整数です。"bigbird" および "bslongformer" モードで使用されます。

3

sparse_attention の例

"sparse_attention": { "mode": "fixed", "block": 16, "different_layout_per_head": true, "num_local_blocks": 4, "num_global_blocks": 1, "attention": "bidirectional", "horizontal_global_attention": false, "num_different_global_patterns": 4, "num_random_blocks": 0, "local_window_blocks": [4], "global_block_indices": [0], "global_block_end_indices": None, "num_sliding_window_blocks": 3 }

データ効率

DeepSpeed Data Efficiency Library には、カリキュラム学習とランダムレイヤーワイズトークンドロップ (random-LTD) の 2 つの手法が含まれています。DeepSpeed Data Efficiency Library の使い方の詳細は、チュートリアルを参照してください。

"data_efficiency": { "enabled": true, "seed": 1234, "data_routing": { "enabled": true, "random_ltd":{ "enabled": true, "total_layer_num": 24, "random_ltd_layer_num": 22, "random_ltd_layer_id": [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22], "model_mask_name": "attention_mask", "model_type": "decoder", "hidden_state_order": "seq_batch_dim", "random_ltd_schedule": { "min_value": 128, "max_value": 2048, "schedule_type":"fixed_linear", "schedule_config": { "require_steps": 200000, "seq_per_step": 16 } } } }, "data_sampling": { "enabled": true, "num_epochs": 1, "num_workers": 0, "curriculum_learning": { "enabled": true, "data_cluster_path": "/path/to/data_clusters", "curriculum_metrics": { "vocabularyrarity": { "index_to_sample_path": "/path/to/index_to_sample", "index_to_metric_path": "/path/to/index_to_metric", "difficulty_type": "percentile", "clustering_type": "schedule_based", "min_difficulty": 1, "max_difficulty": 100, "schedule_type": "fixed_root", "schedule_config": { "total_curriculum_step": 110000, "difficulty_step": 1, "root_degree": 2 } } } } } }

data_efficiency: [辞書]

フィールド

値

デフォルト

enabled: [真偽値]

データ効率を有効にするかどうかです。

false

seed: [整数]

データサンプリングのランダムシードです。

1234

data_routing: [辞書]

データルーティング手法の設定です。

N/A

data_sampling: [辞書]

データサンプリング手法の設定です。

N/A

data_routing: [辞書]

フィールド

値

デフォルト

enabled: [真偽値]

データルーティング手法を有効にするかどうかです。

false

random_ltd: [辞書]

random-LTD 手法の設定です。

N/A

data_sampling: [辞書]

フィールド

値

デフォルト

enabled: [真偽値]

データサンプリング手法を有効にするかどうかです。

false

num_epochs: [整数]

元のデータセットを反復する最大エポック数です。

1000

num_workers: [整数]

データローダーのワーカー数です。

0

curriculum_learning: [辞書]

カリキュラム学習手法の設定です。

N/A

random_ltd: [辞書]

フィールド

値

デフォルト

enabled: [真偽値]

random-LTD 手法を有効にするかどうかです。

false

total_layer_num: [整数]

事前学習/ファインチューニングモデルのレイヤー数 (深さ) です。

N/A

random_ltd_layer_num: [整数]

random-LTD を適用するレイヤーの数です。

N/A

random_ltd_layer_id: [リスト]

random-LTD を適用する正確なレイヤー ID です。このリストの長さは random_ltd_layer_num と同じでなければなりません。

N/A

model_mask_name: [文字列]

attention_mask の変数名です。ライブラリによって名前は異なり、たとえば att_mask などがあります。Hugging Face モデルでは "attention_mask" という名前です。ユーザーは元のモデルファイルの forward 関数を確認する必要があります。元のモデルの forward 関数におけるアテンションマスクの入力がキーワード/名前付き引数ではない場合 (例: attention_mask=None)、ユーザーはそれをキーワード/名前付き引数に変更し、そのキーワードを model_mask_name として指定する必要があります。

N/A

model_type: [文字列]

ユーザーはモデルがデコーダーかエンコーダーかを判別する必要があります。現在サポートしているのはこの 2 種類のみです。

N/A

hidden_state_order: [文字列]

ユーザーは隠れ状態テンソルの入力順序を把握する必要があります。通常は、バッチ、シーケンス、次に隠れ次元の順である batch_seq_dim です。場合によっては、seq_batch_dim のようにバッチとシーケンスの順序が入れ替わります。現在サポートしているのはこの 2 種類です。

N/A

random_ltd_schedule: [辞書]

トークンドロップ後の有効シーケンス長のスケジュールです。random-LTD はトークンのドロップを徐々に減らし、有効シーケンス長を増やしていく線形関数です。

N/A

min_value: [整数]

ステップ/イテレーション 0 における初期の有効シーケンス長 (トークンドロップ後) です。

N/A

max_value: [整数]

最大の有効シーケンス長 (通常はトークンドロップがない場合) です。通常はベースラインのシーケンス長に設定します。

N/A

schedule_type: [文字列]

シーケンス長は min_value から始まり max_value に達する線形増加関数に従います。現在サポートしているのはこの種類のみです。

N/A

schedule_config: [辞書]

線形増加関数の設定です。

N/A

require_steps: [整数]

min_value から max_value に到達するために必要なイテレーション数です。

N/A

seq_per_step: [整数]

有効シーケンス長は、常にこの seq_per_step の倍数になります。NVIDIA Tensor Core による高速化を有効にするには、FP16 データの場合は 8 の倍数、INT8 データの場合は 16 の倍数に設定します。

N/A

curriculum_learning: [辞書]

フィールド

値

デフォルト

enabled: [真偽値]

カリキュラム学習手法を有効にするかどうかです。

false

data_cluster_path: [文字列]

同じ難易度範囲内のデータサンプルのインデックスをカリキュラム学習が保存するディレクトリへのパスです。

N/A

curriculum_metrics: [辞書]

希望するすべてのカリキュラム指標とその設定を含む辞書です。各指標は個別のサブ辞書となり、キーが指標名、値が以下の設定になります。

N/A

index_to_sample_path: [文字列]

オフラインのデータ分析で生成される index_to_sample ファイルへのパスです。データ分析では 2 種類の index_to_sample ファイルが生成されることに注意してください。metric_name_index_to_sample_percentile_merged ファイルは性能向上のために連結されたインデックスですが、difficulty_type=percentile の場合にのみ機能します。difficulty_type=value を使用する場合は、metric_name_index_to_sample ファイルを使用するように変更する必要があります。

N/A

index_to_metric_path: [文字列]

オフラインのデータ分析で生成される index_to_metric_path ファイルへのパスです。

N/A

difficulty_type: [文字列]

トレーニング中に許容される最大難易度をどのように増やすかを指定します。現在サポートしているのは value (絶対値で増加) と percentile (難易度のパーセンタイルで増加) です。

N/A

clustering_type: [文字列]

現在サポートしているのは schedule_based (以下の難易度スケジュール (ペーシング関数) に基づいてデータをクラスタリング) と single_cluster (クラスタリング不要で、カリキュラム学習はシーケンス長の切り詰めなどのデータ後処理によって実現されると考えられる) です。

N/A

min_difficulty: [整数]

最初のステップにおける開始難易度です。difficulty_type=value の場合、min_difficulty は絶対的な難易度値です。difficulty_type=percentile の場合、min_difficulty は難易度のパーセンタイル値です。

N/A

max_difficulty: [整数]

最終的な最大難易度です。difficulty_type=value の場合、max_difficulty は絶対的な難易度値です。difficulty_type=percentile の場合、max_difficulty は難易度のパーセンタイル値です。

N/A

schedule_type: [文字列]

トレーニング中に許容される最大難易度が min_difficulty から max_difficulty までどのように増加するかを定義する難易度スケジュール (ペーシング関数) です。現在サポートしているのは fixed_linear、fixed_root、fixed_discrete、custom です。

N/A

schedule_config: [辞書]

ペーシング関数の設定です。schedule_type=custom の場合、この辞書は不要です。代わりに、トレーニング中に最大許容難易度を更新するコールバック関数を提供する必要があります (deepspeed/runtime/engine.py の set_custom_curriculum_learning_schedule API 経由)。以下の設定はすべて schedule_config に属します。

N/A

total_curriculum_step: [整数]

カリキュラム学習が最小難易度から最大難易度に到達するまでのステップ数です。fixed_linear および fixed_root スケジュールで使用されます。

N/A

difficulty_step: [整数]

各ステップで決定される最大許容難易度レベルは、この difficulty_step の倍数でなければなりません。これは NVIDIA Tensor Core による高速化を利用するためです (FP16 は 8 の倍数、INT8 は 16 の倍数が必要です)。fixed_linear および fixed_root スケジュールで使用されます。

N/A

root_degree: [整数]

ルート関数の次数です。次数 2 は平方根、次数 3 は立方根を意味します。次数 1 は線形と同等です。fixed_root スケジュールで使用されます。

N/A

difficulty: [リスト]

スケジュール中に使用する最大許容難易度レベルのリストです。fixed_discrete スケジュールで使用されます。

N/A

max_step: [リスト]

最大許容難易度レベルを変更するステップのリストです。fixed_discrete スケジュールで使用されます。

N/A

カリキュラム学習

注: 2022 年 12 月 12 日、より汎用的なカリキュラム学習のサポートを提供する DeepSpeed Data Efficiency Library をリリースしました。以下のレガシーなカリキュラム学習機能も引き続きサポートされていますが、Data Efficiency Library の使用を推奨します。

"curriculum_learning": { "enabled": true, "curriculum_type": "seqlen", "min_difficulty": 8, "max_difficulty": 1024, "schedule_type": "fixed_linear", "schedule_config": { "total_curriculum_step": 40000, "difficulty_step": 8 } }

enabled: [真偽値]

説明

デフォルト

カリキュラム学習を有効にするには true に設定します

false

curriculum_type: [文字列]

説明

デフォルト

カリキュラムの難易度指標の種類です。現在サポートしているのは seqlen です。

N/A

min_difficulty: [整数]

説明

デフォルト

開始時の難易度レベルです

N/A

max_difficulty: [整数]

説明

デフォルト

最終的な難易度レベルです

N/A

schedule_type: [文字列]

説明

デフォルト

カリキュラムスケジュールの種類です。現在サポートしているのは fixed_linear、fixed_root、fixed_discrete です。

N/A

total_curriculum_step: [整数]

説明

デフォルト

カリキュラム学習の総ステップ数です。schedule_type が fixed_linear および fixed_root の場合の schedule_config の 1 つです。

N/A

difficulty_step: [整数]

説明

デフォルト

カリキュラム学習の難易度は、常にこの difficulty_step の倍数でなければなりません。NVIDIA Tensor Core による高速化を有効にするには、FP16 データの場合は 8 の倍数、INT8 データの場合は 16 の倍数に設定します。schedule_type が fixed_linear および fixed_root の場合の schedule_config の 1 つです。

N/A

root_degree: [整数]

説明

デフォルト

カリキュラムスケジュール関数のルートの次数です。schedule_type が fixed_root の場合の schedule_config の 1 つです。

N/A

difficulty: [整数のリスト]

説明

デフォルト

スケジュール中に使用する難易度レベルのリストです。schedule_type が fixed_discrete の場合の schedule_config の 1 つです。

N/A

max_step: [整数のリスト]

説明

デフォルト

難易度レベルを変更するステップのリストです。schedule_type が fixed_discrete の場合の schedule_config の 1 つです。

N/A

モニタリングモジュール

注: DeepSpeed は PyTorch を通じて TensorBoard にログを出力します。TensorBoard へのログ出力には tensorboard パッケージのインストールが必要です (詳細は PyTorch のドキュメントを参照してください)。

注: WandB へのログ出力には wandb パッケージのインストールが必要です (詳細は WandB のドキュメントを参照してください)。

注: Comet へのログ出力には comet_ml パッケージのインストールが必要です (詳細は Comet のドキュメントを参照してください)。

DeepSpeed の Monitor モジュールは、トレーニングの詳細を TensorBoard 互換ファイル、WandB、Comet、または単純な CSV ファイルに記録できます。以下は、DeepSpeed が自動的に記録する内容の概要です。

フィールド

説明

条件

Train/Samples/train_loss

トレーニング損失です。

なし

Train/Samples/lr

トレーニング中の学習率です。

なし

Train/Samples/loss_scale

fp16 を使用したトレーニング時の損失スケールです。

fp16 が有効である必要があります

Train/Eigenvalues/ModelBlockParam_{i}

パラメーターブロックごとの固有値です。

eigenvalue が有効である必要があります

Train/Samples/elapsed_time_ms_forward

順伝播の全体の所要時間です。

flops_profiler.enabled または wall_clock_breakdown

Train/Samples/elapsed_time_ms_backward

逆伝播の全体の所要時間です。

flops_profiler.enabled または wall_clock_breakdown

Train/Samples/elapsed_time_ms_backward_inner

勾配リダクションの時間を含まない逆伝播の時間です。勾配リダクションが重ね合わされていない場合にのみ該当します。重ね合わされている場合、inner の時間は逆伝播全体の時間とほぼ同じになります。

flops_profiler.enabled または wall_clock_breakdown

Train/Samples/elapsed_time_ms_backward_allreduce

allreduce 演算の全体の所要時間です。

flops_profiler.enabled または wall_clock_breakdown

Train/Samples/elapsed_time_ms_step

オプティマイザーステップの時間です。

flops_profiler.enabled または wall_clock_breakdown

tensorboard: [辞書]

フィールド

値

デフォルト

enabled

TensorBoard へのログ出力を有効にするかどうかです。

false

output_path

TensorBoard ログを書き込む場所へのパスです。None の場合、出力パスは学習スクリプトの起動パス配下に設定されます。

null

job_name

現在のジョブの名前です。output_path 内に新しいディレクトリとして作成されます。

"DeepSpeedJobName"

tensorboard 設定の例:

"tensorboard": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" }

wandb: [辞書]

フィールド

値

デフォルト

enabled

WandB へのログ出力を有効にするかどうかです。

false

group

WandB グループの名前です。実行をまとめるために使用できます。

None

team

WandB チームの名前です。

None

project

WandB プロジェクトの名前です。

deepspeed

wandb 設定の例:

"wandb": { "enabled": true, "group": "my_group", "team": "my_team", "project": "my_project" }

comet: [辞書]

フィールド

値

デフォルト

enabled

Comet へのログ出力を有効にするかどうかです。

false

workspace

Comet のワークスペース名です。

None

project

Comet のプロジェクト名です。

None

samples_log_interval

samples_log_interval サンプルを処理するごとに、メトリクスを Comet に送信します。

100

experiment_name

ログ出力に使用する Comet 実験の名前です。

None

api_key

Comet の API キーです。コードに Comet API キーを保存することは推奨されません。

None

experiment_key

ログ出力に使用する Comet 実験のキーです。32 文字以上 50 文字以下の英数字の文字列である必要があります。

None

online

True の場合、データは Comet サーバーに記録されます。それ以外の場合は、オフラインの実験としてローカルに保存されます。デフォルトは True です。

None

mode

Comet 実験の開始方法を制御します。"get": experiment_key の値で識別される既存の実験へのログ出力を継続します。"create": 常に新しい実験を作成します。HPO のスイープに便利です。"get_or_create" (デフォルト): 必要に応じて新しい実験を開始するか、既存の実験へのログ出力を継続します。

None

comet 設定の例:

"comet": { "enabled": true, "workspace": "my_workspace", "project": "my_project", "samples_log_interval": 50, "experiment_name": "llama-fine-tuning", "experiment_key": "0c4a1c4a90664f2a8084e600b19a9d7", "online": false, "mode": "get", }

csv_monitor: [辞書]

フィールド

値

デフォルト

enabled

ローカルの CSV ファイルへのログ出力を有効にするかどうかです。

false

output_path

CSV ファイルを書き込む場所へのパスです。None の場合、出力パスは学習スクリプトの起動パス配下に設定されます。

null

job_name

現在のジョブの名前です。output_path 内に新しいディレクトリとして作成されます。

"DeepSpeedJobName"

csv_monitor 設定の例:

"csv_monitor": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" }

弾性トレーニング設定 (V0.1 および V0.2)

"elasticity": { "enabled": true, "max_train_batch_size": "seqlen", "micro_batch_sizes": 8, "min_gpus": 1024, "max_gpus": "fixed_linear", "min_time": "seqlen", "version": 8, "ignore_non_elastic_batch_info": 1024, "num_gpus_per_node": "fixed_linear", "model_parallel_size": MODEL_PARALLEL_SIZE }

フィールド

説明

デフォルト

enabled

弾性トレーニングにおけるグローバルバッチサイズの計算を有効にします。

false

max_train_batch_size

トレーニングで使用できる最大バッチサイズです。

2000

micro_batch_sizes

許容されるマイクロバッチサイズです。train_micro_batch_size_per_gpu と同じです。

[2,4,6]

min_gpus

v0.1 および v0.2 で、高度に合成的なバッチサイズを計算する際に探索する GPU の最小数です。

1

max_gpus

v0.1 および v0.2 で、高度に合成的なバッチサイズを計算する際に探索する GPU の最大数です。

10000

min_time

スケジューラーが再びスケーリングするまでの最小実行時間 (分) です (v0.1 でのみ使用)。0 は不明を意味します。

0

prefer_large_batch

適切なバッチサイズを探す際に、指定された最大トレーニングバッチサイズに最も近いものを見つけようとします。

true

version

使用する弾性ロジックのバージョンです。

0.2

ignore_non_elastic_batch_info

弾性設定の外部で提供されたすべてのバッチ情報を無視します。混乱を避けるため、すべてのバッチ関連情報は弾性設定内でのみ指定することを求めています。

false

num_gpus_per_node

ノードあたりの GPU 数です。この情報は、v0.2 でモデル並列トレーニングをサポートするために使用されます (v0.2 でのみ使用)。

1

model_parallel_size

テンソルまたはモデル並列のサイズです (v0.2 でのみ使用)。

1

通信ロギング

DeepSpeed は、deepspeed.comm を介して起動された通信操作を自動的に検出して記録できる柔軟な通信ロギングツールを提供します。

注: 正確なタイミング情報を提供するため、すべての通信ロギング呼び出しは同期されます。モデルが非同期通信操作を多用する場合、これにより性能が低下する可能性があります。

ログが蓄積されたら、deepspeed.comm.log_summary() で要約できます。詳細と使用例については、チュートリアルを参照してください。

comms_logger: [辞書]

フィールド

値

デフォルト

enabled

通信ロギングを有効にするかどうかです。

false

verbose

各通信操作をすぐに出力するかどうかです。

false

prof_all

すべての操作をプロファイリングするかどうかです。

true

debug

各通信操作の log_name に、呼び出し元の関数を追加します。

false

prof_ops

ログ出力する通信操作のリストです (指定された操作のみがプロファイリングされます)。

[]

推奨される comms_logger 設定の例:

"comms_logger": { "enabled": true, "verbose": false, "prof_all": true, "debug": false }

特定の操作のみをログ出力する場合の comms_logger 設定の例:

"comms_logger": { "enabled": true, "verbose": false, "prof_all": false, "debug": false, "prof_ops": ["all_reduce", "all_gather"] }

圧縮

注: 圧縮には、レイヤー削減、重み量子化、アクティベーション量子化、スパース剪定、行剪定、ヘッド剪定、チャネル剪定の 7 つのコンポーネントがあります。それぞれを簡単な JSON の例とともに説明します。DeepSpeed Compression ライブラリの使い方の詳細は、チュートリアルを参照してください。

レイヤー削減

注: レイヤー削減は、知識蒸留 (詳細はチュートリアルを参照してください) と併用するとはるかに効果的に機能します。

"compression_training": { "layer_reduction": { "enabled": true, "keep_number_layer": 5, "module_name_prefix": "bert.encoder.layer", "teacher_layer": [ 2, 4, 6, 8, 10 ], "other_module_name": [ "bert.pooler", "bert.embeddings", "classifier" ] } }

layer_reduction: [辞書]

フィールド

値

デフォルト

enabled: [真偽値]

レイヤー削減を有効にするかどうかです。

false

keep_number_layer: [リスト]

モデルで保持するレイヤー数です。

N/A

module_name_prefix: [文字列]

関連する重みパラメーターを再初期化するモデルのモジュールに共通する名前の接頭辞です。

N/A

teacher_layer: [リスト]

重みパラメーターを再初期化するレイヤーです。リストの長さは keep_number_layer と同じです。

N/A

other_module_name: [リスト]

関連する重みパラメーターを再初期化するモジュールの名前です。module_name_prefix の補完または代替として使用されます。たとえば、"other_module_name": ["bert.encoder.layer.2","bert.encoder.layer.4"] は、"module_name_prefix":"bert.encoder.layer" と "teacher_layer": [2,4] と同等です。

N/A

重み量子化

"compression_training": { "weight_quantization": { "shared_parameters":{ "enabled": true, "quantizer_kernel": false, "schedule_offset": 0, "quantize_groups": 1, "quantize_verbose": false, "quantization_type": "symmetric", "rounding": "nearest", "quantize_weight_in_forward": false, "fp16_mixed_quantize":{ "enabled": false, "quantize_change_ratio": 0.001 } }, "different_groups":{ "wq1": { "params": { "start_bits": 8, "target_bits": 8, "quantization_period": 50 }, "modules": [ "attention.self", "intermediate" ] }, "wq2": { "params": { "start_bits": 4, "target_bits": 4, "quantization_period": 50 }, "modules": [ "attention.output" ] } } } }

shared_parameters: [辞書]

すべての重み量子化グループで共有されるパラメーターです。

フィールド

値

デフォルト

enabled: [真偽値]

重み量子化を有効にするかどうかです。

false

quantizer_kernel: [真偽値]

4 ビット以上の量子化に DeepSpeed の量子化カーネルを使用します。DeepSpeed FP16 オプティマイザーを使用している場合にのみ有効にできます。

false

schedule_offset: [整数]

スケジュールされたステップ数の後に重み量子化を有効にします (ウォームアップステップとして扱うことができます)。

0

quantize_groups: [整数]

重み行列を異なる数のグループに分割し、それぞれが独自のスケーリング係数を持ちます。

1

quantize_verbose: [真偽値]

量子化に関連するログを出力します。

false

quantization_type: [文字列]

量子化アルゴリズムを選択します。symmetric (対称) または asymmetric (非対称) です。

"symmetric"

rounding: [文字列]

量子化に関連する丸めアルゴリズムです。nearest (最近傍) または stochastic (確率的) です。

"nearest"

quantize_weight_in_forward: [真偽値]

オプティマイザーステップまたは順伝播ステップで重みを量子化します。FP32 オプティマイザーでトレーニングする場合は true に設定する必要があります。

false

fp16_mixed_quantize: [辞書]

FP16 の値と量子化された値を混合して使用します。

N/A

enabled: [真偽値]

FP16 混合量子化を有効にするかどうかです。

false

quantize_change_ratio: [浮動小数点数]

初期の量子化値の割合です。徐々に 1 まで増加します。

0.001

different_groups: [辞書]

異なる量子化セットです。異なる量子化パラメーターに使用されます。この例では 2 つの異なるセットを示しています。実際には、要件に応じてセットの数を選択できます。

フィールド

値

デフォルト

params: [辞書]

start_bits: [整数]

量子化の開始ビット数です。徐々に目標ビット数まで減らされます。

8

target_bits: [整数]

量子化の目標ビット数です。start_bits 以下である必要があります。

8

quantization_period: [整数]

n ステップごとに、量子化ビット数が 1 減らされます。

1

modules: [リスト]

params の設定に関連付けられる重みパラメーターの範囲です。

"All Linear and CONV2D layers"

アクティベーション量子化

"compression_training": { "activation_quantization": { "shared_parameters":{ "enabled": true, "quantization_type": "asymmetric", "range_calibration": "dynamic", "schedule_offset": 50 }, "different_groups":{ "aq1": { "params": { "bits": 8 }, "modules": [ "attention.output" ] } } } }

shared_parameters: [辞書]

すべてのアクティベーション量子化グループで共有されるパラメーターです。

フィールド

値

デフォルト

enabled: [真偽値]

アクティベーション量子化を有効にするかどうかです。

false

quantization_type: [文字列]

量子化アルゴリズムを選択します。symmetric (対称) または asymmetric (非対称) です。

"symmetric"

range_calibration: [文字列]

推論時に dynamic (トークンごとまたは画像ごと) または static (モメンタムを使用した固定の最小/最大値) を使用します。

"static"

schedule_offset: [整数]

スケジュールされたステップ数の後にアクティベーション量子化を有効にします (ウォームアップステップとして扱うことができます)。

0

different_groups: [辞書]

異なる量子化セットです。異なる量子化パラメーターに使用されます。この例では 1 つのセットを示しています。実際には、要件に応じてセットの数を選択できます。

フィールド

値

デフォルト

params: [辞書]

bits: [整数]

アクティベーションに使用するビット数です。目標ビット数であり、4 以上である必要があります。

8

modules: [リスト]

params の設定に関連付けられる重みパラメーターの範囲です。

"All Linear and CONV2D layers"

スパース剪定

"compression_training": { "sparse_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 30, "method": "l1" }, "different_groups":{ "sp1": { "params": { "dense_ratio": 0.5 }, "modules": [ "attention.self" ] } } } }

"compression_training": { "sparse_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 30, "schedule_offset_end": 90, "schedule_offset_stride": 15, "method": "snip_momentum", "block_pattern": "4x1", "dense_ratio": 0.4, "excluded_modules": ['classifier', 'pooler'] }, "different_groups":{ } } }

shared_parameters: [辞書]

すべてのスパース剪定グループで共有されるパラメーターです。

フィールド

値

デフォルト

enabled: [真偽値]

スパース剪定を有効にするかどうかです。

false

schedule_offset: [整数]

スケジュールされたステップ数の後にスパース剪定を有効にします (ウォームアップステップとして扱うことができます)。

0

schedule_offset_end: [整数]

スケジュールされたステップ数の後にスパース剪定を無効にします。snip_momentum では必須です。

0

schedule_offset_stride: [整数]

トレーニングステップにおける剪定の間隔です。snip_momentum では必須です。

"1"

method: [文字列]

剪定方法を選択します。l1 (静的、大きさに基づく)、topk (動的、学習可能)、または snip_momentum (構造化剪定) です。

"l1"

block_pattern: [文字列]

構造化剪定のブロックパターンを選択します。NxM または N:M (N と M は整数) です。たとえば "4x1" や "2:4" が一般的なブロックパターンです。snip_momentum では必須です。

"4x1"

dense_ratio: [浮動小数点数]

目標とするグローバルなスパース性の割合を求めるために使用します。snip_momentum では必須です。

"0.1"

excluded_modules: [リスト]

出力層などの特定のモジュールを剪定対象から除外します。

[]

different_groups: [辞書]

異なる剪定セットです。異なる剪定パラメーターに使用されます。この例では 1 つのセットを示しています。実際には、要件に応じてセットの数を選択できます。snip_momentum 手法の場合は、空のままにしてもかまいません。

フィールド

値

デフォルト

params: [辞書]

dense_ratio: [浮動小数点数]

剪定後に保持する重みの割合です。

0.5

modules: [リスト]

params の設定に関連付けられる重みパラメーターの範囲です。

"All Linear and CONV2D layers"

行剪定

注: 行剪定は、連続する 2 つの線形層 (例: Transformer の Feed Forward Network) 向けに設計された機能です。そのため、最初の線形層 (BERT の場合は intermediate.dense 層) に行剪定を使用することをお勧めします。この行列の行次元を減らすと、後続の行列の列数 (BERT の場合は layer.\w+.output.dense 層) を減らすのに役立ちます。他の線形層にも機能するはずです。

"compression_training": { "row_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 20, "method": "topk" }, "different_groups":{ "rp1": { "params": { "dense_ratio": 0.5 }, "modules": [ "intermediate.dense" ], "related_modules":[ ["layer.\w+.output.dense"] ] } } } }

shared_parameters: [辞書]

すべての行剪定グループで共有されるパラメーターです。

フィールド

値

デフォルト

enabled: [真偽値]

行剪定を有効にするかどうかです。

false

schedule_offset: [整数]

スケジュールされたステップ数の後に行剪定を有効にします (ウォームアップステップとして扱うことができます)。

0

method: [文字列]

剪定方法を選択します。l1 (静的、大きさに基づく) または topk (動的、学習可能) です。

"l1"

different_groups: [辞書]

異なる剪定セットです。異なる剪定パラメーターに使用されます。この例では 1 つのセットを示しています。実際には、要件に応じてセットの数を選択できます。

フィールド

値

デフォルト

params: [辞書]

dense_ratio: [浮動小数点数]

剪定後に保持する重みの割合です。

0.5

modules: [リスト]

params の設定に関連付けられる重みパラメーターの範囲です。

"All Linear and CONV2D layers"

related_modules: [リストのリスト]

行剪定されたモジュールに関連するモジュールです。列剪定を行うことができます。

None

ヘッド剪定

注: ヘッド剪定は、2 つのアテンション層 (例: Transformer の Multi Head Attention) 向けに設計された機能です。現時点では、Transformer の出力行列 (BERT の場合は attention.output.dense) にのみ適用できます。出力行列を剪定すると、Query/Key/Value 行列も剪定される場合があります。

"compression_training": { "head_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 10, "method": "topk", "num_heads": 12 }, "different_groups":{ "rp1": { "params": { "dense_ratio": 0.5 }, "modules": [ "attention.output.dense" ], "related_modules":[ ["self.query", "self.key", "self.value"] ] } } } }

shared_parameters: [辞書]

すべてのヘッド剪定グループで共有されるパラメーターです。

フィールド

値

デフォルト

enabled: [真偽値]

ヘッド剪定を有効にするかどうかです。

false

schedule_offset: [整数]

スケジュールされたステップ数の後にヘッド剪定を有効にします (ウォームアップステップとして扱うことができます)。

0

method: [文字列]

剪定方法を選択します。現時点では topk (動的、学習可能) のみをサポートしています。

"topk"

num_heads: [整数]

ヘッドの数です (ユーザーが指定する必要があります)。

N/A

different_groups: [辞書]

異なる剪定セットです。異なる剪定パラメーターに使用されます。この例では 1 つのセットを示しています。実際には、要件に応じてセットの数を選択できます。

フィールド

値

デフォルト

params: [辞書]

dense_ratio: [浮動小数点数]

剪定後に保持する重みの割合です。

0.5

modules: [リスト]

params の設定に関連付けられる重みパラメーターの範囲です。

"All Linear and CONV2D layers"

related_modules: [リストのリスト]

ヘッド剪定されたモジュール (出力行列) に関連するモジュール (通常は Q/K/V) です。現時点では、この機能は BERT に対してのみ機能します。

None

チャネル剪定

注: チャネル剪定は、連続する 2 つの CONV2d 層 (例: ResNet の残差接続) 向けに設計された機能です。そのため、最初の CONV2d 層にチャネル剪定を使用することをお勧めします。この層の出力チャネル数を減らすと、後続の層の入力チャネル数を減らすのに役立ちます。他の CONV2d 層にも機能するはずです。

"compression_training": { "channel_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 0, "method": "topk" }, "different_groups":{ "cp1": { "params": { "dense_ratio": 0.5 }, "modules": [ "layer....conv1" ], "related_modules": [ ["layer....conv2", "layer....bn1"] ] } } } }

shared_parameters: [辞書]

すべてのチャネル剪定グループで共有されるパラメーターです。

フィールド

値

デフォルト

enabled: [真偽値]

チャネル剪定を有効にするかどうかです。

false

schedule_offset: [整数]

スケジュールされたステップ数の後にチャネル剪定を有効にします (ウォームアップステップとして扱うことができます)。

0

method: [文字列]

剪定方法を選択します。l1 (静的、大きさに基づく) または topk (動的、学習可能) です。

"l1"

different_groups: [辞書]

異なる剪定セットです。異なる剪定パラメーターに使用されます。この例では 1 つのセットを示しています。実際には、要件に応じてセットの数を選択できます。

フィールド

値

デフォルト

params: [辞書]

dense_ratio: [浮動小数点数]

剪定後に保持する重みの割合です。

0.5

modules: [リスト]

params の設定に関連付けられる重みパラメーターの範囲です。

"All CONV2D layers"

related_modules: [リストのリスト]

チャネル剪定されたモジュールに関連するモジュールです。

None

チェックポイントオプション

"checkpoint": { "tag_validation"="Warn", "load_universal"=false, "use_node_local_storage"=false, "parallel_write":{ "pipeline_stage": false } }

tag_validation: [“Ignore” “Warn” “Fail”]

説明

デフォルト

すべてのランクでチェックポイントタグの一貫性を確認するチェックのレベルを有効にします。異なるワールドサイズで復元する場合に便利です。

“Warn”

load_universal: [真偽値]

説明

デフォルト

すべてに対して最新のチェックポイントを読み込みます。

false

use_node_local_storage: [真偽値]

説明

デフォルト

true の場合、DeepSpeed はローカルランクに基づいてモデルパラメーターの状態とチェックポイントの状態を保存するため、共有ファイルシステムにアクセスせずにチェックポイントを読み込めます。

false

pipeline_stage: [真偽値]

説明

デフォルト

パイプラインステージを使用してチェックポイントの書き込みを並列化します。

false

データ型オプション

"data_types": { "grad_accum_dtype"=["fp32"|"fp16"|"bf16"] } }

grad_accum_dtype: [“fp32” “fp16” “bf16”]

説明

デフォルト

勾配累積を行うデータ型を指定します。None の場合、デフォルトではモデルの型と一致させます。

None

32

Pattern 8: モニタリング 概要 使い方 自動モニタリング カスタムモニタリング このチュートリアルでは、DeepSpeed Monitor を紹介し、その使用例を示します。 概要 使い方 概要 トレーニング中のモデルとシステムのメトリクスをモニタリングすることは、ハードウェアリソースを十分に活用するために不可欠です。DeepSpeed Monitor は、PyTorch の TensorBoard、WandB、Comet、単純な CSV ファイルなど、1 つ以上のモニタリングバックエンドを通じてメトリクスのライブロギングを可能にします。以下は TensorBoard のライブモニタリングビューです。 以下は WandB のライブモニタリングビューです。 以下は Comet のライブモニタリングビューです。 使い方 DeepSpeed Monitor は deepspeed の設定ファイル内で構成します。DeepSpeed は、wall_clock_breakdown 設定オプションで追跡されるものを含め、主要なトレーニングメトリクスを自動的にモニタリングします。さらに、ユーザーは独自のカスタムイベントやメトリクスをログに記録することもできます。 自動モニタリング カスタムモニタリング 自動モニタリング DeepSpeed を使用してモデルのトレーニングを行う場合、Monitor は DeepSpeed の設定ファイル内で構成できます。Monitor を使用するために明示的な API 呼び出しは必要ありません。DeepSpeed の設定 json ファイルに次のフィールドを追加することで Monitor を有効にできます。詳細は「Monitoring」を参照してください。 { "tensorboard": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } "wandb": { "enabled": true, "team": "my_team", "group": "my_group", "project": "my_project" } "comet": { "enabled": true, "project": "my_project", "experiment_name": "my_experiment" } "csv_monitor": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } } DeepSpeed は、設定に含まれる利用可能かつ有効なすべてのモニタリングバックエンドに自動的にログを記録し、上記のようなライブモニタリングビューを生成します。 カスタムモニタリング 自動モニタリングに加えて、ユーザーはクライアントスクリプト内で独自のカスタムメトリクスをログに記録できます。現在、Monitor オブジェクトを初期化する方法は 2 つあります。 （推奨）- MonitorMaster(ds_config.monitor_config) オブジェクトを作成します。これにより、DeepSpeed の設定に含まれるすべてのモニターバックエンドが自動的に初期化されます。 特定の TensorBoardMonitor(ds_config.monitor_config)、WandbMonitor(ds_config.monitor_config)、csvMonitor(ds_config.monitor_config) オブジェクトを作成します。これらは、DeepSpeed の設定に含まれる特定のモニターバックエンドのみを初期化します。 カスタムモニターを作成する手順は次のとおりです。 使用したいモニターの import を追加します。 DeepSpeed 設定の monitor_config を使ってモニターを初期化します。 [("label", value, ds_engine.global_samples), ...] の形式で、1 つ以上の 3 要素タプルのリストを作成します。* 手順 3 のリストに対して monitor.write_events を呼び出します。* 注 - 一部のモニターバックエンドは、混在したサンプル値をサポートしていません。各 3 要素タプルでは、必ず DeepSpeed エンジンオブジェクトの global_samples 属性を使用してください。 使用例については、変更した次の DeepSpeedExamples/cifar の例を参照してください。 # ステップ 1: モニター（必要に応じて DeepSpeed 設定も）をインポートする from deepspeed.monitor.monitor import MonitorMaster from deepspeed.runtime.config import DeepSpeedConfig # ステップ 2: DeepSpeed 設定でモニターを初期化する（必要に応じて DeepSpeed 設定オブジェクトを取得する） ds_config = DeepSpeedConfig("ds_config.json") monitor = MonitorMaster(ds_config.monitor_config) for epoch in range(2): running_loss = 0.0 for i, data in enumerate(trainloader): pre = time.time() inputs, labels = data[0].to(model_engine.local_rank), data[1].to( model_engine.local_rank) if fp16: inputs = inputs.half() outputs = model_engine(inputs) loss = criterion(outputs, labels) model_engine.backward(loss) model_engine.step() post = time.time() # ステップ 3: 3 要素タプルのレコードのリストを作成する（この場合は 1 件のみ） events = [("Time per step", post-pre, model_engine.global_samples)] # ステップ 4: ステップ 3 のリストに対して monitor.write_events を呼び出す monitor.write_events(events) Updated: November 5, 2025 Previous Next

wall_clock_breakdown

Example Code Patterns

Example 1 (python):

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

リファレンスファイル

このスキルには、references/ 内に包括的なドキュメントが含まれています:

• 08.md - 08 ドキュメント
• 09.md - 09 ドキュメント
• 2020.md - 2020 ドキュメント
• 2023.md - 2023 ドキュメント
• assets.md - Assets ドキュメント
• mii.md - Mii ドキュメント
• other.md - その他のドキュメント
• tutorials.md - チュートリアル ドキュメント

詳細な情報が必要な場合は、view を使用して特定のリファレンスファイルを読み込んでください。

このスキルの使い方

初心者の方へ

基礎的な概念については、getting_started または tutorials のリファレンスファイルから始めてください。

特定の機能について

詳細な情報については、該当するカテゴリのリファレンスファイル(api、guides など)を使用してください。

コード例について

上記のクイックリファレンスセクションには、公式ドキュメントから抽出された一般的なパターンが含まれています。

リソース

references/

公式ソースから抽出され、整理されたドキュメントです。これらのファイルには以下が含まれます:

• 詳細な説明
• 言語指定付きのコード例
• 元のドキュメントへのリンク
• すばやく移動するための目次

scripts/

一般的な自動化タスクのためのヘルパースクリプトを追加してください。

assets/

テンプレート、定型コード、サンプルプロジェクトを追加してください。

注意事項

• このスキルは公式ドキュメントから自動生成されました
• リファレンスファイルは、元のドキュメントの構造と例を保持しています
• コード例には、より良いシンタックスハイライトのための言語検出が含まれています
• クイックリファレンスのパターンは、ドキュメント内の一般的な使用例から抽出されています

更新方法

更新されたドキュメントでこのスキルを最新の状態にするには:

1. 同じ設定でスクレイパーを再実行します
2. スキルが最新の情報で再構築されます