翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# 独自の深層学習モデルを持ち込む
**重要**
Amazon Web Services (AWS) は、SageMaker Training Compiler の新しいリリースやバージョンがないことを発表しました。SageMaker Training では、既存の AWS Deep Learning Containers (DLC) を通じて SageMaker Training Compiler を引き続き使用できます。既存の DLCs は引き続きアクセス可能ですが、 [AWS Deep Learning Containers Framework サポートポリシー](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html)に従って AWS、 からパッチや更新プログラムを受け取ることはできなくなります。
このガイドでは、トレーニングスクリプトをコンパイラで高速化されたトレーニングジョブに適応させる方法を説明します。トレーニングスクリプトの準備は、次の内容に応じて異なります。
+ シングルコアトレーニングや分散トレーニングなどのトレーニング設定。
+ トレーニングスクリプトの作成に使用するフレームワークとライブラリ。
使用するフレームワークに応じて、次のトピックのいずれかを選択します。
**Topics**
+ [PyTorch](training-compiler-pytorch-models.md)
+ [TensorFlow](training-compiler-tensorflow.md)
**注記**
トレーニングスクリプトの準備が完了したら、SageMaker AI フレームワーク推定器クラスを使用して SageMaker トレーニングジョブを実行できます。詳細については、「[SageMaker Training Compiler を有効化する](training-compiler-enable.md)」の前述のトピックを参照してください。
# PyTorch
独自の PyTorch モデルを SageMaker AI に持ち込み、SageMaker Training Compiler を使用してトレーニングジョブを実行します。
**Topics**
+ [Hugging Face Transformer を使用する PyTorch モデル](#training-compiler-pytorch-models-transformers)
## Hugging Face Transformer を使用する PyTorch モデル
[Hugging Face Transformers](https://huggingface.co/docs/transformers/index) を使用する PyTorch モデルは、PyTorch の [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) API に基づいています。Hugging Face Transformers には、自然言語処理 (NLP) モデルを構成する労力を軽減するのに役立つ PyTorch 用の[トレーナー](https://huggingface.co/docs/transformers/main_classes/trainer)クラスと事前トレーニング済みのモデルのクラスも用意されています。トレーニングスクリプトを準備した後、[SageMaker Training Compiler を有効化する](training-compiler-enable.md) の次のトピックに進むときに、SageMaker AI `PyTorch` または `HuggingFace` の推定器と SageMaker Training Compiler 設定を使用してトレーニングジョブを起動できます。
**ヒント**
トレーニングスクリプトで Transformers を使用して NLP モデルのトークナイザを作成する場合は、必ず `padding='max_length'` を指定して静的な入力テンソル形状を使用してください。バッチ内の最長シーケンスにパディングすると、各トレーニングバッチのテンソル形状が変化する可能性があるため、`padding='longest'` は使用しないでください。動的入力形状は、モデルの再コンパイルをトリガーし、合計トレーニング時間が長くなる可能性があります。Transformer トークナイザのパディングオプションの詳細については、「*Hugging Face Transformer ドキュメント*」の「[Padding and truncation](https://huggingface.co/docs/transformers/pad_truncation)」を参照してください。
**Topics**
+ [Hugging Face Transformers `Trainer` クラスを使用する大規模言語モデル](#training-compiler-pytorch-models-transformers-trainer)
+ [PyTorch を直接使用する大規模言語モデル (Hugging Face Transformers Trainer API なし)](#training-compiler-pytorch-models-non-trainer)
### Hugging Face Transformers `Trainer` クラスを使用する大規模言語モデル
Transformer ライブラリの Trainer クラスを使用する場合、トレーニングスクリプトに変更を加える必要はありません。SageMaker Training Compiler は、推定器クラスを通じて有効化すると、Trainer モデルを自動的にコンパイルします。次のコードは、Hugging Face Trainer API を使用する PyTorch トレーニングスクリプトの基本形式を示しています。
```
from transformers import Trainer, TrainingArguments
training_args=TrainingArguments(**kwargs)
trainer=Trainer(args=training_args, **kwargs)
```
**Topics**
+ [シングル GPU のトレーニングの場合](#training-compiler-pytorch-models-transformers-trainer-single-gpu)
+ [分散トレーニングの場合](#training-compiler-pytorch-models-transformers-trainer-distributed)
+ [`Trainer` を用いた SageMaker Training Compiler の使用のベストプラクティス](#training-compiler-pytorch-models-transformers-trainer-best-practices)
#### シングル GPU のトレーニングの場合
[https://huggingface.co/docs/transformers/main_classes/trainer](https://huggingface.co/docs/transformers/main_classes/trainer) クラスを使用する場合、コードを変更する必要はありません。
#### 分散トレーニングの場合
**PyTorch v1.1.0 以降**
SageMaker Training Compiler で分散トレーニングを実行するには、トレーニングスクリプトに次の `_mp_fn()` 関数を追加し、`main()` 関数をラップする必要があります。これにより、`_mp_fn(index)` 関数の呼び出しは PyTorch (`pytorchxla`) 用の SageMaker AI 分散ランタイムからトレーニングスクリプトの `main()` 関数にリダイレクトされます。
```
def _mp_fn(index):
main()
```
この関数は、分散トレーニング用のクラスター内にある現在の GPU のランクを示す `index` 引数を受け入れます。サンプルスクリプトをさらに見つけるには、「[Hugging Face Transformers language modeling example scripts](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling)」を参照してください。
**PyTorch v1.10.2 以前を使用する v4.17 以前の Transformers の場合**
SageMaker Training Compiler は、分散トレーニングジョブを起動する代替メカニズムを使用するため、トレーニングスクリプトを変更する必要はありません。代わりに、SageMaker Training Compiler では SageMaker AI 分散トレーニングランチャースクリプトを `entry_point` 引数に渡し、トレーニングスクリプトを SageMaker AI Hugging Face 推定器の `hyperparameters` 引数に渡す必要があります。
#### `Trainer` を用いた SageMaker Training Compiler の使用のベストプラクティス
+ [transformers.TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments) の設定時に `optim` 引数を `adamw_torch_xla` に設定して、SyncFree オプティマイザを使用していることを確認してください。「*Hugging Face Transformers のドキュメント*」の「[Optimizer](https://huggingface.co/docs/transformers/v4.23.1/en/perf_train_gpu_one#optimizer)」も参照してください。
+ データ処理パイプラインのスループットがトレーニングスループットよりも高いことを確認してください。このために、[transformers.TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments) クラスの `dataloader_num_workers` 引数と `preprocessing_num_workers` 引数を微調整できます。通常、これらは GPU の数以上で、CPU の数より少ない必要があります。
トレーニングスクリプトの調整が完了したら、「[SageMaker Training Compiler を使用して PyTorch トレーニングジョブを実行する](training-compiler-enable-pytorch.md)」に進みます。
### PyTorch を直接使用する大規模言語モデル (Hugging Face Transformers Trainer API なし)
PyTorch を直接使用するトレーニングスクリプトがある場合は、PyTorch トレーニングスクリプトに変更を加えて、PyTorch/XLA を実装する必要があります。手順に従ってスクリプトを変更し、PyTorch /XLA プリミティブを適切にセットアップします。
**Topics**
+ [シングル GPU のトレーニングの場合](#training-compiler-pytorch-models-non-trainer-single-gpu)
+ [分散トレーニングの場合](#training-compiler-pytorch-models-non-trainer-distributed)
+ [PyTorch/XLA を用いた SageMaker Training Compiler の使用のベストプラクティス](#training-compiler-pytorch-models-best-practices)
#### シングル GPU のトレーニングの場合
1. 最適化ライブラリをインポートします。
```
import torch_xla
import torch_xla.core.xla_model as xm
```
1. ターゲットデバイスを `torch.device("cuda")` ではなく XLA に変更します。
```
device=xm.xla_device()
```
1. PyTorch の[自動混合精度](https://pytorch.org/docs/stable/amp.html) (AMP) を使用する場合は、次のようにします。
1. `torch.cuda.amp` を次のように置き換えます。
```
import torch_xla.amp
```
1. `torch.optim.SGD` および `torch.optim.Adam` を次のように置き換えます。
```
import torch_xla.amp.syncfree.Adam as adam
import torch_xla.amp.syncfree.SGD as SGD
```
1. `torch.cuda.amp.GradScaler` を次のように置き換えます。
```
import torch_xla.amp.GradScaler as grad_scaler
```
1. AMP を使用しない場合は、`optimizer.step()` を次のように置き換えます。
```
xm.optimizer_step(optimizer)
```
1. 分散データローダーを使用する場合は、データローダーを PyTorch/XLA の `ParallelLoader` クラスにラップします。
```
import torch_xla.distributed.parallel_loader as pl
parallel_loader=pl.ParallelLoader(dataloader, [device]).per_device_loader(device)
```
1. `parallel_loader` を使用しない場合は、トレーニングループの最後に `mark_step` を追加します。
```
xm.mark_step()
```
1. トレーニングをチェックポイントするには、Pytorch/XLA のモデルチェックポイントメソッドを使用します。
```
xm.save(model.state_dict(), path_to_save)
```
トレーニングスクリプトの調整が完了したら、「[SageMaker Training Compiler を使用して PyTorch トレーニングジョブを実行する](training-compiler-enable-pytorch.md)」に進みます。
#### 分散トレーニングの場合
前記 [シングル GPU のトレーニングの場合](#training-compiler-pytorch-models-non-trainer-single-gpu) のセクションで記載した変更点に加え、GPU 間にワークロードを適切に配分するには、次の変更を追加します。
1. AMP を使用する場合は、`all_reduce` を `scaler.scale(loss).backward()` の後に追加します。
```
gradients=xm._fetch_gradients(optimizer)
xm.all_reduce('sum', gradients, scale=1.0/xm.xrt_world_size())
```
1. `local_ranks` および `world_size` に対して変数を設定する必要がある場合、次と同様のコードを使用します。
```
local_rank=xm.get_local_ordinal()
world_size=xm.xrt_world_size()
```
1. `1` より大きな `world_size` (`num_gpus_per_node*num_nodes`) については、トレーニングサンプラーを定義する必要があります。これは次のようなものです。
```
import torch_xla.core.xla_model as xm
if xm.xrt_world_size() > 1:
train_sampler=torch.utils.data.distributed.DistributedSampler(
train_dataset,
num_replicas=xm.xrt_world_size(),
rank=xm.get_ordinal(),
shuffle=True
)
train_loader=torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
sampler=train_sampler,
drop_last=args.drop_last,
shuffle=False if train_sampler else True,
num_workers=args.num_workers
)
```
1. `torch_xla distributed` モジュールによって提供される `parallel_loader` を確実に使用するには、次の変更を加えます。
```
import torch_xla.distributed.parallel_loader as pl
train_device_loader=pl.MpDeviceLoader(train_loader, device)
```
`train_device_loader` は、次に示すように、通常の PyTorch ローダーのように機能します。
```
for step, (data, target) in enumerate(train_device_loader):
optimizer.zero_grad()
output=model(data)
loss=torch.nn.NLLLoss(output, target)
loss.backward()
```
これらのすべての変更により、Transformer Trainer API を使用せずに、どの PyTorch モデルでも分散トレーニングを開始できます。これらの手順は、シングルノードマルチ GPU とマルチノードマルチ GPU の両方に使用できます。
1. **PyTorch v1.11.0 以降の場合**
SageMaker Training Compiler で分散トレーニングを実行するには、トレーニングスクリプトに次の `_mp_fn()` 関数を追加し、`main()` 関数をラップする必要があります。これにより、`_mp_fn(index)` 関数の呼び出しは PyTorch (`pytorchxla`) 用の SageMaker AI 分散ランタイムからトレーニングスクリプトの `main()` 関数にリダイレクトされます。
```
def _mp_fn(index):
main()
```
この関数は、分散トレーニング用のクラスター内にある現在の GPU のランクを示す `index` 引数を受け入れます。サンプルスクリプトをさらに見つけるには、「[Hugging Face Transformers language modeling example scripts](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling)」を参照してください。
**PyTorch v1.10.2 以前を使用する v4.17 以前の Transformers の場合**
SageMaker Training Compiler では、分散トレーニングジョブを起動する代替メカニズムを使用しているため、SageMaker AI 分散トレーニングランチャースクリプトを `entry_point` 引数に渡し、トレーニングスクリプトを SageMaker AI Hugging Face 推定器の `hyperparameters` 引数に渡す必要があります。
トレーニングスクリプトの調整が完了したら、「[SageMaker Training Compiler を使用して PyTorch トレーニングジョブを実行する](training-compiler-enable-pytorch.md)」に進みます。
#### PyTorch/XLA を用いた SageMaker Training Compiler の使用のベストプラクティス
ネイティブの PyTorch トレーニングスクリプトで SageMaker Training Compiler を利用するには、まず、[XLAデバイス上のPyTorch](https://pytorch.org/xla/release/1.9/index.html) に習熟することが望まれます。以下のセクションでは、PyTorch 用に XLA を有効化するためのベストプラクティスをいくつか示します。
**注記**
ベストプラクティスに関するこのセクションでは、次の PyTorch/XLA モジュールを使用していることを前提としています。
```
import torch_xla.core.xla_model as xm
import torch_xla.distributed.parallel_loader as pl
```
##### Pytorch/XLA の lazy モードを理解する
Pytorch/XLA とネイティブ PyTorch の大きな違いは、Pytorch/XLA システムが lazy モードで実行されるのに対し、ネイティブ PyTorch は eager モードで実行される点です。lazy モードのテンソルは、コンパイルと評価が完了した後それらがマテリアライズされるまで計算グラフを構築するためのプレースホルダーです。PyTorch/XLA システムは、テンソルと演算子を使用する計算の構築のために PyTorch API が呼び出されたときに、その場で計算グラフを構築します。計算グラフは、`xm.mark_step()` が `pl.MpDeviceLoader/pl.ParallelLoader` によって明示的または暗黙的に呼び出されたとき、または、`loss.item()` や `print(loss)` を呼び出すなどテンソルの値が明示的にリクエストされたときに、コンパイルされ、実行されます。
##### コンパイル・実行の数を `pl.MpDeviceLoader/pl.ParallelLoader` および `xm.step_closure` を使用して最小限に抑える**
最高のパフォーマンスを得るには、[Pytorch/XLA の lazy モードを理解する](#training-compiler-pytorch-models-best-practices-lazy-mode)の説明のように、コンパイル・実行を開始するために可能な方法を念頭に置き、コンパイル・実行の数を最小限に抑えるようにしてください。**理想的には、トレーニングの反復ごとに必要なコンパイル・実行は 1 つだけであり、`pl.MpDeviceLoader/pl.ParallelLoader` によって自動的に開始されます。`MpDeviceLoader` は XLA 用に最適化されており、最高のパフォーマンスを得るために可能な限り常に使用してください。トレーニング中に、損失値などの中間結果をいくつか調べることもできます。そのような場合、lazy テンソルの印刷は、不要なコンパイル・実行を避けるため、`xm.add_step_closure()` を使用してラップしてください。
##### AMP および `syncfree` オプティマイザを使用する
自動混合精度 (AMP) モードでのトレーニングは、NVIDIA GPU のテンソルコアを活用することで、トレーニング速度を大幅に高めます。SageMaker Training Compiler は、XLA 用に最適化された `syncfree` オプティマイザを備えており、AMP のパフォーマンスを向上させます。現在、以下の 3 つの `syncfree`オプティマイザが利用可能で、最高のパフォーマンスを得るために可能な限り使用してください。
```
torch_xla.amp.syncfree.SGD
torch_xla.amp.syncfree.Adam
torch_xla.amp.syncfree.AdamW
```
これら `syncfree` オプティマイザは、グラデーションのスケーリング/スケーリング解除のために `torch_xla.amp.GradScaler` と組み合わせます。
**ヒント**
PyTorch 1.13.1 以降、SageMaker Training Compiler により、PyTorch/XLA が `torch.optim` または `torch_xla.amp.syncfree` (`torch_xla.amp.syncfree.SGD`、`torch_xla.amp.syncfree.Adam`、`torch_xla.amp.syncfree.AdamW` など) の syncfree バージョンを使用する `transformers.optimization` オプティマイザ (SGD、Adam、AdamW など) を自動的にオーバーライドすることにより、パフォーマンスが向上しています。トレーニングスクリプト内でオプティマイザを定義しているコード行を変更する必要はありません。
# TensorFlow
独自の TensorFlow モデルを SageMaker AI に持ち込み、SageMaker Training Compiler を使用してトレーニングジョブを実行します。
## TensorFlow モデル
SageMaker Training Compiler は、ネイティブ TensorFlow API または高レベルの Keras API の上に構築されたモデルトレーニングワークロードを自動的に最適化します。
**ヒント**
入力データセットを前処理する場合は、必ず静的な入力形状を使用してください。動的入力形状は、モデルの再コンパイルを開始し、合計トレーニング時間が長くなる可能性があります。
### Keras の使用 (推奨)
最良のコンパイラアクセラレーションを行うには、TensorFlow Keras のサブクラスであるモデル ([tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model))を使用することを推奨します。
#### シングル GPU のトレーニングの場合
トレーニングスクリプトに追加が必要な変更はありません。
### Keras を使用しない
SageMaker Training Compiler は TensorFlow での eager execution をサポートしていません。したがって、コンパイラアクセラレーションを活用するには、モデルとトレーニングループを TensorFlow 関数デコレータ (`@tf.function`) でラップする必要があります。
SageMaker Training Compiler は、グラフレベルの最適化を実行し、デコレータを使用して確実に TensorFlow 関数が[グラフモード](https://www.tensorflow.org/guide/intro_to_graphs)で実行されるよう設定します。
#### 単一 GPU のトレーニングの場合
TensorFlow 2.0 以降では、デフォルトで eager execution がオンになっているため、`@tf.function` デコレータを TensorFlow モデルの構築に使用するすべての関数の前に追加してください。
## Hugging Face Transformer を使用する TensorFlow モデル
[Hugging Face Transformers](https://huggingface.co/docs/transformers/index) を使用する TensorFlow モデルは、TensorFlow の [tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) API に基づいています。Hugging Face Transformers は、自然言語処理 (NLP) モデルの構成にかかる労力を軽減するために、TensorFlow に事前学習済みのモデルクラスも提供します。トランスフォーマーライブラリを使用して独自のトレーニングスクリプトを作成した後、前のトピックの [SageMaker トレーニングコンパイラを使用して TensorFlow トレーニングジョブを実行する](training-compiler-enable-tensorflow.md) で示したように、SageMaker Training Compiler 設定クラスで、SageMaker AI `HuggingFace` 推定器を使用してトレーニングスクリプトを実行できます。
SageMaker Training Compiler は、TensorFlow transformer モデルなど、ネイティブ TensorFlow API または高レベルの Keras API の上に構築されたモデルトレーニングワークロードを自動的に最適化します。
**ヒント**
トレーニングスクリプトで Transformers を使用して NLP モデルのトークナイザを作成する場合は、必ず `padding='max_length'` を指定して静的な入力テンソル形状を使用してください。バッチ内の最長シーケンスにパディングすると、各トレーニングバッチのテンソル形状が変化する可能性があるため、`padding='longest'` は使用しないでください。動的入力形状はモデルの再コンパイルを開始し、合計トレーニング時間が長くなる可能性があります。Transformer トークナイザのパディングオプションの詳細については、Hugging Face Transformers ドキュメントの「[Padding and truncation](https://huggingface.co/docs/transformers/pad_truncation)」を参照してください。
**Topics**
+ [Keras を使用する](#training-compiler-tensorflow-models-transformers-keras)
+ [Keras を使用しない](#training-compiler-tensorflow-models-transformers-no-keras)
### Keras を使用する
最良のコンパイラアクセラレーションを行うには、TensorFlow Keras のサブクラスであるモデル ([tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model))を使用することを推奨します。*Hugging Face Transformer のドキュメント*に含まれる[「クイックツアー」](https://huggingface.co/docs/transformers/quicktour)ページ内で述べられているように、それらのモデルを通常の TensorFlow Keras モデルとして使用できます。
#### 単一 GPU のトレーニングの場合
トレーニングスクリプトに追加が必要な変更はありません。
#### 分散トレーニングの場合
SageMaker Training Compiler アクセラレーションは、[https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy) 呼び出しのスコープ内で Keras API を使用してモデルを構築およびトレーニングする場合、マルチ GPU のワークロードに対して透過的に機能します。
1. 適切な分散トレーニング戦略を選択します。
1. シングルノードマルチ GPU の場合は、`tf.distribute.MirroredStrategy` を使用して戦略を設定します。
```
strategy = tf.distribute.MirroredStrategy()
```
1. マルチノードマルチ GPU の場合は、戦略を作成する前に、次のコードを追加して TensorFlow 分散トレーニング設定を適切に設定します。
```
def set_sm_dist_config():
DEFAULT_PORT = '8890'
DEFAULT_CONFIG_FILE = '/opt/ml/input/config/resourceconfig.json'
with open(DEFAULT_CONFIG_FILE) as f:
config = json.loads(f.read())
current_host = config['current_host']
tf_config = {
'cluster': {
'worker': []
},
'task': {'type': 'worker', 'index': -1}
}
for i, host in enumerate(config['hosts']):
tf_config['cluster']['worker'].append("%s:%s" % (host, DEFAULT_PORT))
if current_host == host:
tf_config['task']['index'] = i
os.environ['TF_CONFIG'] = json.dumps(tf_config)
set_sm_dist_config()
```
`tf.distribute.MultiWorkerMirroredStrategy` を使用して戦略を設定します。
```
strategy = tf.distribute.MultiWorkerMirroredStrategy()
```
1. 選択した戦略を使用して、モデルをラップします。
```
with strategy.scope():
# create a model and do fit
```
### Keras を使用しない
Keras を使用せずに TensorFlow を使用してカスタムトレーニングループを持つカスタムモデルを持ち込む場合は、モデルとトレーニングループを TensorFlow 関数デコレータ (`@tf.function`) でラップして、コンパイラアクセラレーションを活用します。
SageMaker Training Compiler は、グラフレベルの最適化を実行し、デコレータを使用して TensorFlow 関数がグラフモードで実行されるよう確実に設定します。
#### 単一 GPU のトレーニングの場合
TensorFlow 2.0 以降では、デフォルトで eager execution がオンになっているため、`@tf.function` デコレータを TensorFlow モデルの構築に使用するすべての関数の前に追加してください。
#### 分散トレーニングの場合
[分散トレーニングに Keras を使用する](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-tensorflow-models.html#training-compiler-tensorflow-models-transformers-keras)ために必要な変更に加えて、各 GPU で実行される関数に `@tf.function` のアノテーションが付加されるようにする必要があります。一方、クロス GPU 通信機能にはアノテーションは付加されません。トレーニングコードの例は、次ようになります。
```
@tf.function()
def compiled_step(inputs, outputs):
with tf.GradientTape() as tape:
pred=model(inputs, training=True)
total_loss=loss_object(outputs, pred)/args.batch_size
gradients=tape.gradient(total_loss, model.trainable_variables)
return total_loss, pred, gradients
def train_step(inputs, outputs):
total_loss, pred, gradients=compiled_step(inputs, outputs)
if args.weight_decay > 0.:
gradients=[g+v*args.weight_decay for g,v in zip(gradients, model.trainable_variables)]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss.update_state(total_loss)
train_accuracy.update_state(outputs, pred)
@tf.function()
def train_step_dist(inputs, outputs):
strategy.run(train_step, args= (inputs, outputs))
```
この手順は、シングルノードマルチ GPU とマルチノードマルチ GPU の両方に使用できます。