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 atau mengonfigurasi lingkungan runtime secara manual. Anda dapat langsung menggunakan DLC tanpa mengubah alur kerja Anda. Topik ini menggunakan contoh pengenalan tulisan tangan MNIST untuk menunjukkan cara menggunakan DLC dalam pelatihan single-node single-GPU atau pelatihan terdistribusi multi-node multi-GPU.

Catatan

Pengenalan tulisan tangan MNIST adalah salah satu tugas pengantar paling 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 root. Masuk ke Konsol PAI. Di pojok kiri atas, pilih Wilayah untuk mengaktifkan layanan tersebut. Kemudian, gunakan otorisasi satu klik untuk mengaktifkan Produk.

Deskripsi penagihan

Contoh dalam topik ini menggunakan Sumber daya publik untuk membuat Pekerjaan DLC. Metode penagihannya adalah pay-as-you-go. Untuk informasi selengkapnya, 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, pilih Datasets > Custom Dataset > Create datasets.
Konfigurasikan parameter dataset. Parameter utama dijelaskan di bawah ini. Anda dapat menggunakan nilai default untuk parameter lainnya.
- Name: Misalnya, dataset_mnist
- Storage Type: OSS
- OSS Path: Klik ikon , pilih bucket, lalu buat folder baru, misalnya dlc_mnist.
  Jika Anda belum mengaktifkan OSS atau tidak memiliki bucket yang tersedia 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. Atur Region ke Wilayah yang sama dengan PAI. Pertahankan nilai default untuk parameter lainnya, lalu klik Create.
Klik OK untuk membuat dataset.

Unggah kode dan data pelatihan.

Unduh kode pelatihan yang disediakan dalam topik ini. Klik mnist_train.py untuk mengunduh file tersebut. Untuk menyederhanakan proses, kode ini secara otomatis mengunduh data pelatihan ke folder dataSet dataset selama waktu proses.

Untuk proyek Anda sendiri, Anda dapat mengunggah kode dan data pelatihan ke dataset PAI terlebih dahulu.

Kode contoh untuk 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 saluran input (gambar grayscale), 10 saluran output, kernel 5x5
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        # Lapisan konvolusi kedua: 10 saluran input, 20 saluran output, kernel 3x3
        self.conv2 = nn.Conv2d(10, 20, kernel_size=3)
        # Lapisan fully connected: Input adalah 20*5*5 (ukuran peta fitur setelah konvolusi dan pooling), output adalah 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 SummaryWriter untuk TensorBoard guna 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 menuju Konsol OSS. Lalu, klik Upload Object > Select Files > Upload Object untuk mengunggah kode pelatihan.

Buat Pekerjaan DLC

Di panel navigasi sebelah kiri Konsol PAI, pilih 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, lihat Buat pekerjaan pelatihan.

Image Configuration: Pilih Image Address. Lalu, masukkan alamat registri yang sesuai dengan Region Anda.

Region	Corresponding Registry Address
Beijing	dsw-registry-vpc.cn-beijing.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
Shanghai	dsw-registry-vpc.cn-shanghai.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
Hangzhou	dsw-registry-vpc.cn-hangzhou.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04
Other	Query the region ID dan ganti <Region ID> dalam alamat registri untuk mendapatkan URL 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 runtime ini telah diverifikasi kompatibel dengan lingkungan dalam Panduan Cepat Interactive Modelling (DSW). Biasanya, ketika Anda menggunakan PAI untuk pemodelan, Anda terlebih dahulu memverifikasi lingkungan dan mengembangkan kode di DSW, lalu menggunakan DLC untuk pelatihan.

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

Klik OK untuk membuat pekerjaan. Pekerjaan ini membutuhkan waktu sekitar 15 menit untuk dijalankan. Saat pekerjaan sedang berjalan, Anda dapat mengklik Logs untuk melihat proses pelatihan.

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

Lihat TensorBoard (Opsional)

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 Tensorboard > Create TensorBoard di bagian atas halaman.
Atur Configuration Type ke By Task. Di bidang Summary Path, masukkan path tempat ringkasan disimpan dalam kode pelatihan: /mnt/data/output/runs/. Klik OK untuk memulai.
Potongan kode yang sesuai: writer = SummaryWriter('/mnt/data/output/runs/mnist_experiment')
Klik View TensorBoard untuk melihat kurva train_loss, yang mencerminkan loss dataset pelatihan, dan kurva validation_loss, yang mencerminkan loss set validasi.
(Opsional) Sesuaikan hiperparameter berdasarkan kurva loss untuk meningkatkan performa model
Anda dapat mengevaluasi performa pelatihan model berdasarkan tren nilai loss:
- Sebelum pelatihan berakhir, train_loss dan validation_loss masih menurun (underfitting)
  Anda dapat menambah num_epochs (jumlah epoch pelatihan, yang berkorelasi positif dengan kedalaman pelatihan) atau sedikit menaikkan learning_rate lalu melatih ulang model untuk meningkatkan kesesuaian terhadap data pelatihan.
- Sebelum pelatihan berakhir, train_loss terus menurun sementara validation_loss mulai meningkat (overfitting)
  Anda dapat mengurangi num_epochs atau sedikit menurunkan learning_rate lalu melatih ulang model untuk mencegah overfitting.
- Sebelum pelatihan berakhir, train_loss dan validation_loss stabil (kesesuaian baik)
  Saat model berada dalam kondisi ini, Anda dapat melanjutkan ke langkah berikutnya.

Deploy model yang telah dilatih

Untuk informasi selengkapnya, lihat Deploy model sebagai layanan online menggunakan EAS.

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

Jika VRAM satu GPU 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 kode mnist_train_distributed.py dan mengunggahnya. Jika belum, Anda harus terlebih dahulu membuat dataset lalu mengunggah kode tersebut.

Kode contoh untuk 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, sehingga 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()