Panduan Cepat Deep Learning Containers (DLC) - Platform For AI

Deep Learning Containers (DLC) memungkinkan Anda membuat pekerjaan pelatihan terdistribusi atau single-node dengan cepat. Dibangun di atas Kubernetes, DLC menghilangkan kebutuhan untuk membeli mesin secara manual dan mengonfigurasi lingkungan runtime, sehingga Anda dapat menggunakannya tanpa mengubah alur kerja yang sudah ada. Topik ini menggunakan tugas pengenalan tulisan tangan MNIST sebagai contoh untuk menunjukkan cara menggunakan DLC dalam pelatihan single-node single-GPU dan pelatihan terdistribusi multi-node multi-GPU.

Catatan

Pengenalan tulisan tangan MNIST adalah tugas pengantar klasik dalam pembelajaran mendalam. Tujuannya adalah membangun model pembelajaran mesin untuk mengenali 10 digit tulisan tangan (0 hingga 9).

Prasyarat

Aktifkan PAI dan buat ruang kerja menggunakan Akun Alibaba Cloud Anda. Masuk ke Konsol PAI. Di pojok kiri atas, pilih Wilayah. Kemudian, berikan izin yang diperlukan dan aktifkan Produk tersebut.

Billing

Contoh dalam topik ini menggunakan Sumber daya publik untuk membuat Pekerjaan DLC. Metode penagihannya adalah pay-as-you-go. Untuk informasi selengkapnya tentang aturan penagihan, lihat Penagihan Deep Learning Containers (DLC).

Pelatihan single-node, single-GPU

Buat dataset

Dataset menyimpan kode, data, dan hasil untuk pelatihan model. Topik ini menggunakan dataset Object Storage Service (OSS) sebagai contoh.

Di panel navigasi sebelah kiri Konsol PAI, klik Datasets > Custom Datasets > Create Dataset.
Konfigurasikan parameter dataset. Parameter utama dijelaskan di bawah ini. Anda dapat menggunakan nilai default untuk parameter lainnya.
- Name: Misalnya, dataset_mnist.
- Storage Type: Alibaba Cloud Object Storage Service (OSS).
- OSS Path: Klik ikon , pilih Bucket, lalu buat folder baru, misalnya dlc_mnist.
  Jika Anda belum mengaktifkan OSS atau tidak tersedia bucket di wilayah saat ini, ikuti langkah-langkah berikut untuk mengaktifkan OSS dan membuat bucket:
  (Opsional) Aktifkan OSS dan buat bucket
  1. Aktifkan OSS.
  2. Masuk ke Konsol OSS. Klik Create Bucket. Masukkan Bucket Name. Untuk Region, pilih wilayah yang sama dengan PAI. Gunakan nilai default untuk parameter lainnya. Lalu, klik Create.
Klik Confirm untuk membuat dataset.

Unggah kode dan data pelatihan.

Unduh kode pelatihan yang disediakan dengan mengklik mnist_train.py. Untuk menyederhanakan proses, kode dikonfigurasi agar secara otomatis mengunduh data pelatihan ke folder dataSet dataset saat waktu proses.

Untuk penggunaan produksi, Anda dapat mengunggah kode dan data pelatihan ke dataset PAI terlebih dahulu.

Contoh kode pelatihan single-node, single-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

# Hiperparameter
batch_size = 64  # Jumlah data untuk setiap batch pelatihan
learning_rate = 0.01  # Laju pembelajaran
num_epochs = 20  # Jumlah epoch pelatihan

# Periksa apakah GPU tersedia
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# Pra-pemrosesan data
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)


# Definisikan jaringan saraf sederhana
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # Lapisan konvolusi pertama: 1 channel input (citra grayscale), 10 channel output, kernel 5x5
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        # Lapisan konvolusi kedua: 10 channel input, 20 channel output, kernel 3x3
        self.conv2 = nn.Conv2d(10, 20, kernel_size=3)
        # Lapisan fully connected: Input berupa 20 × 5 × 5 (ukuran feature map setelah konvolusi dan pooling), output 128
        self.fc1 = nn.Linear(20 * 5 * 5, 128)
        # Lapisan output: 128 -> 10 (sesuai dengan 10 kelas digit)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        # Bentuk input 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)  # Ratakan menjadi [batch, 500]
        x = F.relu(self.fc1(x))      # [batch, 128]
        x = self.fc2(x)              # [batch, 10]
        return x


# Buat instance model dan pindahkan ke GPU jika tersedia
model = SimpleCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

# Buat TensorBoard SummaryWriter untuk memvisualisasikan proses pelatihan model
writer = SummaryWriter('/mnt/data/output/runs/mnist_experiment')

# Variabel untuk menyimpan model dengan akurasi tertinggi
best_val_accuracy = 0.0

# Latih model dan catat loss serta akurasi
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)  # Pindahkan data dan target ke GPU

        # Nolkan gradien
        optimizer.zero_grad()
        # Propagasi maju
        output = model(data)
        # Hitung loss
        loss = criterion(output, target)
        # Propagasi mundur
        loss.backward()
        # Perbarui parameter
        optimizer.step()

        # Catat loss pelatihan ke TensorBoard
        if batch_idx % 100 == 0:  # Catat setiap 100 batch
            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}')

    # Validasi model dan catat loss serta akurasi validasi
    model.eval()
    val_loss = 0
    correct = 0
    with torch.no_grad():  # Jangan hitung gradien
        for data, target in val_loader:
            data, target = data.to(device), target.to(device)  # Pindahkan data dan target ke GPU
            output = model(data)
            val_loss += criterion(output, target).item()  # Akumulasikan loss validasi
            pred = output.argmax(dim=1, keepdim=True)  # Dapatkan label prediksi
            correct += pred.eq(target.view_as(pred)).sum().item()  # Akumulasikan jumlah prediksi benar

    val_loss /= len(val_loader)  # Hitung rata-rata loss validasi
    val_accuracy = 100. * correct / len(val_loader.dataset)  # Hitung akurasi validasi
    print(f'Validation Loss: {val_loss:.4f}, Accuracy: {correct}/{len(val_loader.dataset)} ({val_accuracy:.0f}%)')

    # Catat loss dan akurasi validasi ke TensorBoard
    writer.add_scalar('Loss/validation', val_loss, epoch)
    writer.add_scalar('Accuracy/validation', val_accuracy, epoch)

    # Simpan model dengan akurasi validasi tertinggi
    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}%')

# Tutup SummaryWriter
writer.close()
print('Training complete. writer.close()')

Unggah kode. Di halaman detail dataset, klik View Data untuk membuka Konsol OSS. Lalu, klik Upload Object > Select Files > Upload Object untuk mengunggah kode pelatihan ke OSS.

Buat Pekerjaan DLC

Di panel navigasi sebelah kiri Konsol PAI, klik Deep Learning Containers (DLC) > Create Job.

Konfigurasikan parameter Pekerjaan DLC. Parameter utama dijelaskan di bawah ini. Anda dapat menggunakan nilai default untuk parameter lainnya. Untuk informasi selengkapnya tentang semua parameter, lihat Buat pekerjaan pelatihan.

Image config: Pilih Image Address dan masukkan URL citra untuk Region Anda.

Wilayah	URL Gambar
China (Beijing)	dsw-registry-vpc.cn-beijing.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
China (Shanghai)	dsw-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
China (Hangzhou)	dsw-registry-vpc.cn-hangzhou.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
Wilayah lain	Temukan ID wilayah Anda dan ganti <Region ID> dalam URL citra untuk mendapatkan tautan lengkap: dsw-registry-vpc.<Region ID>.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04

Citra ini telah diverifikasi kompatibel dengan lingkungan di Panduan Cepat Pemodelan Interaktif (DSW). Alur kerja tipikal untuk pemodelan dengan PAI adalah terlebih dahulu memverifikasi lingkungan dan mengembangkan kode di DSW, lalu menggunakan DLC untuk pelatihan.

Mount dataset: Pilih Custom Dataset dan pilih dataset yang Anda buat pada langkah sebelumnya. Mount Path default adalah /mnt/data.
Startup Command: python /mnt/data/mnist_train.py
Perintah mulai ini sama dengan yang digunakan saat menjalankan di DSW atau lokal. Namun, karena mnist_train.py dipasang ke /mnt/data/, jalur kode harus diperbarui menjadi /mnt/data/mnist_train.py.
Source: Pilih Public Resources. Untuk Resource Type, pilih ecs.gn7i-c8g1.2xlarge.
Jika spesifikasi instans ini habis stoknya, Anda dapat memilih instans GPU-accelerated lainnya.

Klik Confirm untuk membuat pekerjaan. Pekerjaan memerlukan waktu sekitar 15 menit untuk selesai. Anda dapat memantau proses pelatihan dengan mengklik Logs.

Setelah pekerjaan selesai, checkpoint model terbaik dan log TensorBoard disimpan ke path output dari dataset yang dipasang.

(Opsional) Tampilkan TensorBoard

Anda dapat menggunakan alat visualisasi TensorBoard untuk melihat kurva loss dan memahami detail pelatihan.

Penting

Untuk menggunakan TensorBoard pada Pekerjaan DLC, Anda harus mengonfigurasi dataset.

Di halaman detail Pekerjaan DLC, klik tab TensorBoard lalu klik Create TensorBoard.
Atur Configuration Type ke By Task. Untuk Summary Path, masukkan path tempat ringkasan disimpan dalam kode pelatihan: /mnt/data/output/runs/. Klik Confirm untuk memulai.
Ini sesuai dengan potongan kode: writer = SummaryWriter('/mnt/data/output/runs/mnist_experiment')
Klik View TensorBoard untuk melihat kurva loss untuk dataset pelatihan (train_loss) dan set validasi (validation_loss).
(Opsional) Sesuaikan hiperparameter berdasarkan grafik loss untuk meningkatkan performa model
Anda dapat mengevaluasi performa pelatihan model dengan mengamati tren nilai loss:
- Jika train_loss dan validation_loss masih menurun saat pelatihan berakhir, ini menunjukkan underfitting.
  Untuk mengatasinya, Anda dapat menambah `num_epochs` (jumlah epoch pelatihan, yang berkorelasi positif dengan kedalaman pelatihan) atau sedikit menaikkan `learning_rate`, lalu melatih ulang model.
- Jika train_loss terus menurun sementara validation_loss mulai meningkat, ini menunjukkan overfitting.
  Untuk mengatasinya, Anda dapat mengurangi `num_epochs` atau sedikit menurunkan `learning_rate`, lalu melatih ulang model.
- Jika train_loss dan validation_loss stabil sebelum pelatihan berakhir, ini menunjukkan fit yang baik.
  Jika model memiliki fit yang baik, Anda dapat melanjutkan ke langkah berikutnya.

Deploy model yang telah dilatih

Untuk informasi selengkapnya, lihat Gunakan EAS untuk deploy model sebagai layanan online.

Pelatihan terdistribusi single-node multi-GPU atau multi-node multi-GPU

Jika memori video GPU tunggal tidak mencukupi untuk kebutuhan pelatihan Anda, atau jika Anda ingin mempercepat proses pelatihan, Anda dapat membuat pekerjaan pelatihan terdistribusi single-node multi-GPU atau multi-node multi-GPU.

Topik ini menggunakan contoh dua instans, masing-masing dengan satu GPU. Contoh ini juga berlaku untuk konfigurasi lain untuk pelatihan single-node multi-GPU atau multi-node multi-GPU.

Buat dataset

Jika Anda telah membuat dataset selama pelatihan single-node, single-GPU, Anda hanya perlu mengunduh dan mengunggah kode mnist_train_distributed.py. Jika belum, Anda harus terlebih dahulu membuat dataset lalu mengunggah kode tersebut.

Contoh kode pelatihan single-node multi-GPU atau multi-node multi-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,))
    ])

    # Hanya proses utama (rank=0) yang perlu mengunduh. Proses lain harus menunggu hingga selesai.
    # Biarkan proses dengan rank!=0 menunggu di barrier terlebih dahulu.
    if rank != 0:
        dist.barrier()

    # Semua proses menjalankan pembuatan dataset.
    # Namun, hanya proses dengan rank=0 yang benar-benar melakukan pengunduhan.
    train_dataset = datasets.MNIST(root='/mnt/data/dataSet', train=True, download=(rank == 0), transform=transform)

    # Setelah proses dengan rank=0 selesai mengunduh, ia juga mencapai barrier, melepaskan semua proses.
    if rank == 0:
        dist.barrier()

    # Pada titik ini, semua proses telah disinkronkan dan dapat melanjutkan eksekusi kode berikutnya.
    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:
                # Setiap rank dan local_rank mencetak loss-nya sendiri.
                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)

        # Validasi
        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()

Buat Pekerjaan DLC

Di panel navigasi sebelah kiri Konsol PAI, klik Deep Learning Containers (DLC) > New Job.

Image config: Pilih Image Address dan masukkan URL citra untuk Region Anda.

Wilayah	URL Gambar
China (Beijing)	dsw-registry-vpc.cn-beijing.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
China (Shanghai)	dsw-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
China (Hangzhou)	dsw-registry-vpc.cn-hangzhou.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
Wilayah lain	Temukan ID wilayah Anda dan ganti <Region ID> dalam URL citra untuk mendapatkan tautan lengkap: dsw-registry-vpc.<Region ID>.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04

Citra ini telah diverifikasi kompatibel dengan lingkungan di Panduan Cepat Pemodelan Interaktif (DSW). Alur kerja tipikal untuk pemodelan dengan PAI adalah terlebih dahulu memverifikasi lingkungan dan kode di DSW, lalu menggunakan DLC untuk pelatihan.

Mount dataset: Pilih Custom Dataset dan pilih dataset yang Anda buat pada langkah sebelumnya. Mount Path default adalah /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 secara otomatis menyuntikkan variabel lingkungan umum seperti MASTER_ADDR, WORLD_SIZE$VARIABLE_NAME
Source: Pilih Public Resources. Atur Quantity menjadi 2. Untuk Resource Type, pilih ecs.gn7i-c8g1.2xlarge.
Jika spesifikasi instans ini habis stoknya, Anda dapat memilih instans GPU-accelerated lainnya.

Klik Confirm untuk membuat pekerjaan. Pekerjaan memerlukan waktu sekitar 10 menit untuk berjalan. Selama pekerjaan berjalan, Anda dapat melihat Log pelatihan untuk kedua instans di halaman Overview.

Setelah pekerjaan selesai, checkpoint model terbaik dan log TensorBoard disimpan ke path output_distributed dari dataset yang dipasang.