Deep Learning Containers (DLC) のクイックスタート - Platform For AI

説明

MNIST の手書き数字認識タスクは、深層学習で最も古典的な入門タスクの 1 つです。目標は、10 種類の手書き数字 (0 から 9) を認識するための機械学習モデルを構築することです。

前提条件

Alibaba Cloud アカウントを使用して PAI を有効化し、ワークスペースを作成します。PAI コンソールにログインし、左上隅でリージョンを選択し、プロンプトに従って権限を付与し、製品を有効化します。

課金

このチュートリアルの例では、パブリックリソースを使用して DLC ジョブを作成します。これらのジョブは従量課金制で請求されます。課金ルールの詳細については、「Deep Learning Containers (DLC) の課金」をご参照ください。

シングルノード、シングル GPU トレーニング

データセットの作成

データセットには、コード、データ、およびトレーニング結果が格納されます。このチュートリアルでは、Object Storage Service (OSS) のデータセットを例として使用します。

PAI コンソールの左側メニューで、Datasets > Custom Dataset > Create datasets を選択します。
データセットのパラメータを設定します。以下は主要なパラメータです。他のパラメータはデフォルト値のままでかまいません。
- Name：例：dataset_mnist。
- Storage Type：OSS。
- OSS Path：アイコンをクリックし、バケットを選択して、dlc_mnist などのディレクトリを作成します。
  
  OSS を有効化していない場合、または現在のリージョンで利用可能なバケットがない場合は、次の手順に従って OSS を有効化し、バケットを作成します。
  (オプション) OSS の有効化とバケットの作成
  1. OSS サービスを有効化します。
  2. OSS コンソールにログインし、バケットの作成 をクリックします。[Bucket Name] を入力します。Region には、PAI と同じリージョンを選択します。他のパラメータはデフォルト値のままにして、[Create] をクリックします。
[OK] をクリックしてデータセットを作成します。

トレーニングコードとデータをアップロードします。

コードをダウンロードします。このチュートリアルでは、必要なトレーニングスクリプトを提供しています。mnist_train.py をクリックしてダウンロードします。手作業を減らすため、スクリプトは実行時にトレーニングデータをデータセットの dataSet ディレクトリに自動的にダウンロードします。

本番環境で使用する場合は、事前にコードとトレーニングデータを PAI データセットにアップロードすることを推奨します。

シングルノード、シングル GPU トレーニングのコード例：mnist_train.py

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torch.utils.tensorboard import SummaryWriter

# ハイパーパラメータ
batch_size = 64  # 各トレーニングバッチのデータ量。
learning_rate = 0.01  # 学習率。
num_epochs = 20  # トレーニングエポック数。

# GPU が利用可能かどうかを確認します。
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# データを前処理します。
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
train_dataset = datasets.MNIST(root='/mnt/data/dataSet', train=True, download=True, transform=transform)
val_dataset = datasets.MNIST(root='/mnt/data/dataSet', train=False, download=False, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)

# シンプルなニューラルネットワークを定義します。
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 最初の畳み込み層：1 入力チャネル (グレースケール画像)、10 出力チャネル、5x5 カーネル。
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        # 2番目の畳み込み層：10 入力チャネル、20 出力チャネル、3x3 カーネル。
        self.conv2 = nn.Conv2d(10, 20, kernel_size=3)
        # 全結合層：入力は 20*5*5 (畳み込みとプーリング後の特徴マップサイズ)、出力は 128。
        self.fc1 = nn.Linear(20 * 5 * 5, 128)
        # 出力層：128 -> 10 (10 個の数字クラスに対応)。
        self.fc2 = nn.Linear(128, 10)
    def forward(self, x):
        # 入力 x の形状：[batch, 1, 28, 28]
        x = F.max_pool2d(F.relu(self.conv1(x)), 2)  # [batch, 10, 12, 12]
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)  # [batch, 20, 5, 5]
        x = x.view(-1, 20 * 5 * 5)  # [batch, 500] にフラット化します。
        x = F.relu(self.fc1(x))      # [batch, 128]
        x = self.fc2(x)              # [batch, 10]
        return x

# モデルをインスタンス化し、利用可能であれば GPU に移動します。
model = SimpleCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

# TensorBoard の SummaryWriter を作成して、モデルのトレーニングプロセスを可視化します。
writer = SummaryWriter('/mnt/data/output/runs/mnist_experiment')

# 最高精度でモデルを保存するための変数。
best_val_accuracy = 0.0

# モデルをトレーニングし、損失と精度を記録します。
for epoch in range(num_epochs):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)  # データとターゲットを GPU に移動します。
        
        # 勾配をゼロにします。
        optimizer.zero_grad()
        # 順伝播。
        output = model(data)
        # 損失を計算します。
        loss = criterion(output, target)
        # 逆伝播。
        loss.backward()
        # パラメータを更新します。
        optimizer.step()
        
        # トレーニングの損失を TensorBoard に記録します。
        if batch_idx % 100 == 0:  # 100 バッチごとに記録します。
            writer.add_scalar('Loss/train', loss.item(), epoch * len(train_loader) + batch_idx)
            print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} ({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}')

# モデルを検証し、検証の損失と精度を記録します。
    model.eval()
    val_loss = 0
    correct = 0
    with torch.no_grad():  # 勾配を計算しません。
        for data, target in val_loader:
            data, target = data.to(device), target.to(device)  # データとターゲットを GPU に移動します。
            output = model(data)
            val_loss += criterion(output, target).item()  # 検証の損失を累積します。
            pred = output.argmax(dim=1, keepdim=True)  # 予測されたラベルを取得します。
            correct += pred.eq(target.view_as(pred)).sum().item()  # 正しい予測の数を累積します。
            
    val_loss /= len(val_loader)  # 平均検証損失を計算します。
    val_accuracy = 100. * correct / len(val_loader.dataset)  # 検証の精度を計算します。
    print(f'Validation Loss: {val_loss:.4f}, Accuracy: {correct}/{len(val_loader.dataset)} ({val_accuracy:.0f}%)')
    
    # 検証の損失と精度を TensorBoard に記録します。
    writer.add_scalar('Loss/validation', val_loss, epoch)
    writer.add_scalar('Accuracy/validation', val_accuracy, epoch)
    
    # 最高の検証精度でモデルを保存します。
    if val_accuracy > best_val_accuracy:
        best_val_accuracy = val_accuracy
        torch.save(model.state_dict(), '/mnt/data/output/best_model.pth')
        print(f'Model saved with accuracy: {best_val_accuracy:.2f}%')
        
# SummaryWriter を閉じます。
writer.close()
print('Training complete. writer.close()')

コードをアップロードします。データセットの詳細ページで、View Data をクリックして OSS コンソールに移動します。次に、オブジェクト >ファイルの選択 > アップロード をクリックして、トレーニングスクリプトを OSS にアップロードします。

DLC ジョブの作成

PAI コンソールの左側メニューで、Deep Learning Containers (DLC) > Create Job を選択します。

DLC ジョブのパラメータを設定します。以下は主要なパラメータです。残りのパラメータはデフォルト値のままでかまいません。パラメータの完全なリストについては、「トレーニングジョブの作成」をご参照ください。

Image Configuration：Image Address を選択し、現在の Region に対応するイメージ URL を入力します。

コンソールの上部メニューの [Region] セレクターで、現在のリージョン (例：中国 (杭州)) を確認します。

リージョン	イメージ URL
中国 (北京)	dsw-registry-vpc.cn-beijing.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
中国 (上海)	dsw-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
中国 (杭州)	dsw-registry-vpc.cn-hangzhou.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
その他	リージョンIDを検索し、イメージ URL の <リージョンID> を置き換えて、完全な URL を取得してください。 dsw-registry-vpc.<リージョンID>.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04

このイメージは、「PAI-DSW を使用したインタラクティブモデリングのクイックスタート」で検証済みです。一般的な PAI ワークフローとして、PAI-DSW でコードを開発・検証してから、DLC を使用してトレーニングを行います。

Dataset Mount：Custom Dataset を選択し、前の手順で作成したデータセットを選択します。デフォルトの Mount Path は /mnt/data です。
Startup Command：python /mnt/data/mnist_train.py

この起動コマンドは、PAI-DSW やローカルで実行する場合と同じです。しかし、mnist_train.py が /mnt/data/ にマウントされるようになったため、コマンド内のスクリリプトパスはマウント先を反映して /mnt/data/mnist_train.py に更新されます。
Source：Public Resources を選択します。Resource Type には、ecs.gn7i-c8g1.2xlarge を選択します。

このインスタンスタイプが在庫切れの場合は、別の GPU インスタンスタイプを選択できます。

OK をクリックしてジョブを作成します。ジョブの完了には約 15 分かかります。実行中に、[Logs] をクリックしてトレーニングの進捗状況を確認できます。

トレーニングログでは、MNIST モデルはエポック 18 で 9886/10000 (約 99%) の検証精度を達成しました。ジョブのステータスは [Succeeded] で、最終的な出力は Training complete. writer.close() です。

ジョブが完了すると、最適なモデルチェックポイントと TensorBoard ログは、マウントされたデータセットの output パスに保存されます。

OSS バケット内の dlc_mnist/ ディレクトリには、dataSet/ サブディレクトリ (トレーニングデータ)、output/ サブディレクトリ (モデル出力)、および mnist_train.py トレーニングスクリプトが含まれています。

TensorBoard の表示 (オプション)

TensorBoard 可視化ツールを使用して損失曲線を表示し、トレーニングプロセスの詳細を確認できます。

重要

DLC ジョブで TensorBoard を使用するには、データセットを設定する必要があります。

DLC ジョブの詳細ページで、Tensorboard タブをクリックし、Create TensorBoard をクリックします。
Configuration Type を By Task に設定します。Summary Path には、トレーニングコードで指定されたサマリーパス /mnt/data/output/runs/ を入力します。OK をクリックして開始します。

これは、コードスニペット writer = SummaryWriter('/mnt/data/output/runs/mnist_experiment') に相当します。
View TensorBoard をクリックして、Loss/train 曲線 (トレーニングセットの損失を示す) と Loss/validation 曲線 (検証セットの損失を示す) を表示します。
(オプション) 損失グラフに基づいてハイパーパラメータを調整し、モデルのパフォーマンスを向上させる
損失の傾向に基づいて、モデルのトレーニングパフォーマンスを評価できます。
- Loss/train と Loss/validation の両方がトレーニング終了時にもまだ減少している場合 (学習不足)：
  
  num_epochs (トレーニングエポック数) を増やすか、learning_rate をわずかに上げてモデルを再トレーニングし、トレーニングデータにより適合させることができます。
- Loss/train は減少し続けているのに、Loss/validation が増加し始めた場合 (過学習)：
  
  num_epochs を減らすか、learning_rate をわずかに下げてモデルを再トレーニングし、過学習を防ぐことができます。
- Loss/train と Loss/validation の両方がトレーニング終了前に安定した場合 (良好な適合)：
  
  モデルが良好な適合を示している場合は、次のステップに進むことができます。

トレーニング済みモデルのデプロイ

詳細については、「PAI-EAS を使用してモデルをサービスとしてデプロイする」をご参照ください。

分散トレーニング

シングル GPU のビデオメモリではトレーニング要件に対して不十分な場合、またはトレーニングプロセスを高速化したい場合は、シングルノード、マルチ GPU またはマルチノード、マルチ GPU の分散トレーニングジョブを作成できます。

このチュートリアルでは、それぞれが 1 つの GPU を持つ 2 つのインスタンスの例を使用します。この例は、他のシングルノード、マルチ GPU またはマルチノード、マルチ GPU のトレーニング設定にも適用されます。

データセットの作成

シングルノード、シングル GPU トレーニング用にすでにデータセットを作成している場合は、mnist_train_distributed.py スクリプトをダウンロードしてアップロードするだけです。それ以外の場合は、まずデータセットを作成してからスクリプトをアップロードしてください。

シングルノード、マルチ GPU またはマルチノード、マルチ GPU トレーニングのコード例：mnist_train_distributed.py

import os
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torch.utils.data.distributed import DistributedSampler
from torchvision import datasets, transforms
from torch.utils.tensorboard import SummaryWriter
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=3)
        self.fc1 = nn.Linear(20 * 5 * 5, 128)
        self.fc2 = nn.Linear(128, 10)
    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), 2)
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, 20 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x
def main():
    rank = int(os.environ["RANK"])
    world_size = int(os.environ["WORLD_SIZE"])
    local_rank = int(os.environ["LOCAL_RANK"])
    dist.init_process_group(backend='nccl')
    torch.cuda.set_device(local_rank)
    device = torch.device('cuda', local_rank)
    batch_size = 64
    learning_rate = 0.01
    num_epochs = 20
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5,), (0.5,))
    ])
    # メインプロセス (rank = 0) のみがダウンロードを行い、他のプロセスは完了するまで待機する必要があります。
    # rank != 0 のプロセスをバリアで待機させます。
    if rank != 0:
        dist.barrier()
    # すべてのプロセスがデータセットの作成を実行します。
    # ただし、実際にダウンロードを実行するのは rank = 0 のプロセスのみです。
    train_dataset = datasets.MNIST(root='/mnt/data/dataSet', train=True, download=(rank == 0), transform=transform)
    # rank = 0 のプロセスがダウンロードを完了すると、バリアに到達してすべてのプロセスを解放します。
    if rank == 0:
        dist.barrier()
    # この時点で、すべてのプロセスが同期され、後続のコードを継続できます。
    val_dataset = datasets.MNIST(root='/mnt/data/dataSet', train=False, download=False, transform=transform)
    train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank, shuffle=True)
    train_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=train_sampler, num_workers=4, pin_memory=True)
    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=4, pin_memory=True)
    model = SimpleCNN().to(device)
    model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[local_rank])
    criterion = nn.CrossEntropyLoss().to(device)
    optimizer = optim.SGD(model.parameters(), lr=learning_rate)
    if rank == 0:
        writer = SummaryWriter('/mnt/data/output_distributed/runs/mnist_experiment')
    best_val_accuracy = 0.0
    for epoch in range(num_epochs):
        train_sampler.set_epoch(epoch)
        model.train()
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data.to(device, non_blocking=True), target.to(device, non_blocking=True)
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            if batch_idx % 100 == 0:
                # 各 rank と local_rank が、それぞれの損失を出力します。
                print(f"Rank: {rank}, Local_Rank: {local_rank} -- Train Epoch: {epoch} "
                      f"[{batch_idx * len(data) * world_size}/{len(train_loader.dataset)} "
                      f"({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}")
                if rank == 0:
                    writer.add_scalar('Loss/train', loss.item(), epoch * len(train_loader) + batch_idx)
        # 検証
        model.eval()
        val_loss = 0
        correct = 0
        total = 0
        with torch.no_grad():
            for data, target in val_loader:
                data, target = data.to(device, non_blocking=True), target.to(device, non_blocking=True)
                output = model(data)
                val_loss += criterion(output, target).item() * data.size(0)
                pred = output.argmax(dim=1, keepdim=True)
                correct += pred.eq(target.view_as(pred)).sum().item()
                total += target.size(0)
        val_loss_tensor = torch.tensor([val_loss], dtype=torch.float32, device=device)
        correct_tensor = torch.tensor([correct], dtype=torch.float32, device=device)
        total_tensor = torch.tensor([total], dtype=torch.float32, device=device)
        dist.all_reduce(val_loss_tensor, op=dist.ReduceOp.SUM)
        dist.all_reduce(correct_tensor, op=dist.ReduceOp.SUM)
        dist.all_reduce(total_tensor, op=dist.ReduceOp.SUM)
        val_loss = val_loss_tensor.item() / total_tensor.item()
        val_accuracy = 100. * correct_tensor.item() / total_tensor.item()
        if rank == 0:
            print(f'Validation Loss: {val_loss:.4f}, Accuracy: {int(correct_tensor.item())}/{int(total_tensor.item())} ({val_accuracy:.0f}%)')
            writer.add_scalar('Loss/validation', val_loss, epoch)
            writer.add_scalar('Accuracy/validation', val_accuracy, epoch)
            if val_accuracy > best_val_accuracy:
                best_val_accuracy = val_accuracy
                torch.save(model.module.state_dict(), '/mnt/data/output_distributed/best_model.pth')
                print(f'Model saved with accuracy: {best_val_accuracy:.2f}%')
    if rank == 0:
        writer.close()
    dist.destroy_process_group()
    if rank == 0:
        print('Training complete. writer.close()')
if __name__ == "__main__":
    main()

DLC ジョブの作成

PAI コンソールの左側メニューで、Deep Learning Containers (DLC) > Create Job を選択します。

DLC ジョブのパラメータを設定します。以下は主要なパラメータです。残りのパラメータはデフォルト値のままでかまいません。パラメータの完全なリストについては、「トレーニングジョブの作成」をご参照ください。

Image Configuration：Image Address を選択し、現在の Region に対応するイメージ URL を入力します。

リージョン	イメージ URL
中国 (北京)	dsw-registry-vpc.cn-beijing.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
中国 (上海)	dsw-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
中国 (杭州)	dsw-registry-vpc.cn-hangzhou.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
その他	リージョンIDを検索し、イメージ URL の <リージョンID> を置き換えて、完全な URL を取得してください。 dsw-registry-vpc.<リージョンID>.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04

このイメージは、「PAI-DSW を使用したインタラクティブモデリングのクイックスタート」で検証済みです。一般的な PAI ワークフローとして、PAI-DSW でコードを開発・検証してから、DLC を使用してトレーニングを行います。

Dataset Mount：Custom Dataset を選択し、前の手順で作成したデータセットを選択します。デフォルトの Mount Path は /mnt/data です。
Startup Command：torchrun --nproc_per_node=1 --nnodes=${WORLD_SIZE} --node_rank=${RANK} --master_addr=${MASTER_ADDR} --master_port=${MASTER_PORT} /mnt/data/mnist_train_distributed.py

DLC は、一般的な環境変数 (たとえば MASTER_ADDR や WORLD_SIZE) を自動的に注入します。これらにアクセスするには、$VARIABLE_NAME 形式を使用します。
Source には、Public Resources を選択します。Number of Nodes を 2 に設定します。Resource Type には、ecs.gn7i-c8g1.2xlarge を選択します。

このインスタンスタイプが在庫切れの場合は、別の GPU インスタンスタイプを選択できます。

Confirm をクリックしてジョブを作成します。ジョブの完了には約 10 分かかります。実行中に、Overview ページで両方のインスタンスの Log を表示できます。

ジョブが完了すると、最適なモデルチェックポイントと TensorBoard ログが、マウントされたデータセットの output_distributed パスに保存されます。

TensorBoard の表示 (オプション)

TensorBoard 可視化ツールを使用して損失曲線を表示し、トレーニングプロセスの詳細を確認できます。

重要

DLC ジョブで TensorBoard を使用するには、データセットを設定する必要があります。

DLC ジョブの詳細ページで、TensorBoard タブをクリックし、Create TensorBoard をクリックします。
Configuration Type を By Task に設定します。Summary Path に、トレーニングコードで指定されたサマリーパス /mnt/data/output_distributed/runs を入力します。OK をクリックして開始します。

これは、以下のコードスニペットに対応します: writer = SummaryWriter('/mnt/data/output_distributed/runs/mnist_experiment')
View TensorBoard をクリックして、Loss/train 曲線 (トレーニングセットの損失を示す) と Loss/validation 曲線 (検証セットの損失を示す) を表示します。
(オプション) 損失グラフに基づいてハイパーパラメータを調整し、モデルのパフォーマンスを向上させる
損失の傾向に基づいて、モデルのトレーニングパフォーマンスを評価できます。
- Loss/train と Loss/validation の両方がトレーニング終了時にもまだ減少している場合 (学習不足)：
  
  num_epochs (トレーニングエポック数) を増やすか、learning_rate をわずかに上げてモデルを再トレーニングし、トレーニングデータにより適合させることができます。
- Loss/train は減少し続けているのに、Loss/validation が増加し始めた場合 (過学習)：
  
  num_epochs を減らすか、learning_rate をわずかに下げてモデルを再トレーニングし、過学習を防ぐことができます。
- Loss/train と Loss/validation の両方がトレーニング終了前に安定した場合 (良好な適合)：
  
  モデルが良好な適合を示している場合は、次のステップに進むことができます。

トレーニング済みモデルのデプロイ

詳細については、「PAI-EAS を使用してモデルをサービスとしてデプロイする」をご参照ください。

Platform For AI:Deep Learning Containers (DLC) のクイックスタート

前提条件

課金

シングルノード、シングル GPU トレーニング

データセットの作成

DLC ジョブの作成

TensorBoard の表示 (オプション)

トレーニング済みモデルのデプロイ

分散トレーニング

データセットの作成

DLC ジョブの作成

TensorBoard の表示 (オプション)

トレーニング済みモデルのデプロイ

関連ドキュメント