Platform For AI:Memulai: Pelatihan terdistribusi dengan DLC

3.1 Membuat dataset

Dataset menyimpan kode pelatihan, data, dan artefak model Anda. Bagian ini menjelaskan cara menggunakan dataset berbasis Alibaba Cloud Object Storage Service (OSS).

1. Di panel navigasi sebelah kiri Konsol PAI, pilih Datasets > Custom Dataset > Create datasets.

2. Konfigurasikan parameter utama berikut dan gunakan nilai default untuk parameter lainnya.

   • Name: Misalnya, masukkan dataset_mnist.

   • Storage Type: Pilih OSS.

   • OSS Path: Klik ikon folder , pilih bucket, lalu buat direktori 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, dan pilih Region yang sama dengan PAI. Gunakan nilai default untuk parameter lainnya, lalu klik Create.

   Klik Confirm untuk membuat dataset.

3. Unggah kode dan data pelatihan.

   1. Unduh skrip pelatihan yang disediakan: mnist_train.py. Untuk menyederhanakan proses, skrip ini secara otomatis mengunduh data pelatihan ke direktori dataSet dataset Anda selama waktu proses.

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

      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
      # Hyperparameters
      batch_size = 64  # Ukuran batch untuk setiap iterasi 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 (gambar 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 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 (untuk 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()
              # Forward pass
              output = model(data)
              # Hitung loss
              loss = criterion(output, target)
              # Backward pass
              loss.backward()
              # Perbarui parameter
              optimizer.step()
              # Catat training loss 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 validation loss serta akurasi
          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()  # Akumulasi validation loss
                  pred = output.argmax(dim=1, keepdim=True)  # Dapatkan label prediksi
                  correct += pred.eq(target.view_as(pred)).sum().item()  # Akumulasi jumlah prediksi benar
          val_loss /= len(val_loader)  # Hitung rata-rata validation loss
          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 validation loss dan akurasi 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 disimpan dengan akurasi: {best_val_accuracy:.2f}%')
      # Tutup SummaryWriter
      writer.close()
      print('Pelatihan selesai. writer.close()')

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

3.2 Membuat Pekerjaan DLC

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

2. Konfigurasikan parameter utama berikut dan gunakan nilai default untuk parameter lainnya. Untuk daftar lengkap parameter, lihat Buat pekerjaan pelatihan.

   • Image Configuration: Pilih Image Address, lalu masukkan alamat image yang sesuai untuk Region Anda.

     Di bilah navigasi atas konsol, gunakan pemilih Region untuk memastikan wilayah saat ini, misalnya China (Hangzhou).

     Region	Image address
     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
     Other	Temukan ID wilayah Anda dan ganti <Region ID> pada alamat image 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

     Image ini menggunakan lingkungan terverifikasi yang sama dari topik Memulai Pemodelan Interaktif DSW. Saat melakukan pemodelan dengan PAI, alur kerja tipikal adalah 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 adalah /mnt/data.

   • Startup Command: python /mnt/data/mnist_train.py

     Perintah startup sama seperti saat Anda menjalankan kode di DSW atau lokal. Namun, karena mnist_train.py  kini dipasang di /mnt/data/, Anda hanya perlu mengubah path kode menjadi /mnt/data/mnist_train.py. 

   • Source: Pilih Public Resources, lalu pilih ecs.gn7i-c8g1.2xlarge untuk Resource Type.

     Jika tipe instans ini kehabisan stok, Anda dapat memilih tipe instans GPU lainnya.

   Klik OK untuk membuat pekerjaan. Pekerjaan memerlukan waktu sekitar 15 menit untuk dijalankan. Selama eksekusi, Anda dapat mengklik Logs untuk melihat progres pelatihan.

   Log pelatihan menunjukkan bahwa model MNIST mencapai akurasi validasi 9.886/10.000 (sekitar 99%) pada Epoch 18. Saat status pekerjaan berubah menjadi Succeeded, log menampilkan output akhir: Pelatihan selesai. writer.close().

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

   Direktori dlc_mnist/ di bucket OSS Anda kini berisi subdirektori dataSet/ untuk data pelatihan, subdirektori output/ untuk artefak model, dan skrip mnist_train.py.

3.3 (Opsional) tampilkan di TensorBoard

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

1. Di halaman detail Pekerjaan DLC, klik tab Tensorboard, lalu klik Create TensorBoard.

2. Atur Configuration Type menjadi By Task. Untuk Summary Path, masukkan path tempat SummaryWriter menyimpan data dalam kode pelatihan: /mnt/data/output/runs/. Klik OK untuk memulai.

   Ini sesuai dengan potongan kode: writer = SummaryWriter('/mnt/data/output/runs/mnist_experiment')

3. Klik View TensorBoard untuk melihat kurva train_loss (loss set pelatihan) dan kurva validation_loss (loss set validasi).

   

   (Opsional) Sesuaikan hiperparameter untuk meningkatkan performa model

   Anda dapat mengevaluasi performa model dengan mengamati tren nilai loss:

   • train_loss dan validation_loss masih menunjukkan tren menurun sebelum pelatihan selesai (underfitting).

     Anda dapat menambah num_epochs (jumlah epoch pelatihan) atau sedikit menaikkan learning_rate, lalu melatih ulang model agar lebih sesuai dengan data pelatihan.

   • train_loss terus menurun, tetapi validation_loss mulai meningkat sebelum pelatihan selesai (overfitting).

     Anda dapat mengurangi num_epochs atau sedikit menurunkan learning_rate, lalu melatih ulang model untuk mencegah overfitting.

   • Kedua train_loss dan validation_loss sudah stabil sebelum pelatihan selesai (good fit).

     Saat model berada dalam kondisi ini, Anda dapat melanjutkan ke langkah berikutnya.

3.4 Deploy model yang telah dilatih

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

4.1 Persiapkan dataset dan skrip

Jika Anda telah membuat dataset di bagian 3. Pelatihan single-node, single-GPU, cukup unduh mnist_train_distributed.py dan unggah. Jika belum, pertama-tama 3.1 Buat dataset, lalu unggah kode tersebut.

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.
    # Proses dengan rank != 0 menunggu di barrier.
    if rank != 0:
        dist.barrier()
    # Semua proses membuat dataset.
    # Namun, hanya proses rank 0 yang benar-benar melakukan pengunduhan.
    train_dataset = datasets.MNIST(root='/mnt/data/dataSet', train=True, download=(rank == 0), transform=transform)
    # Setelah proses 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.
    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 disimpan dengan akurasi: {best_val_accuracy:.2f}%')
    if rank == 0:
        writer.close()
    dist.destroy_process_group()
    if rank == 0:
        print('Pelatihan selesai. writer.close()')
if __name__ == "__main__":
    main()

4.2 Membuat Pekerjaan DLC terdistribusi

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

2. Konfigurasikan parameter utama berikut dan gunakan nilai default untuk parameter lainnya. Untuk daftar lengkap parameter, lihat Buat pekerjaan pelatihan.

   • Image Configuration: Pilih Image Address, lalu masukkan alamat image yang sesuai untuk Region Anda.

     Region	Image address
     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
     Other	Temukan ID wilayah Anda dan ganti <Region ID> pada alamat image 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

     Image ini menggunakan lingkungan terverifikasi yang sama dari topik Memulai Pemodelan Interaktif DSW. Saat melakukan pemodelan dengan PAI, alur kerja tipikal adalah 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. 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 dan WORLD_SIZE, yang dapat Anda akses dengan sintaks $VARIABLE_NAME.

   • Source: Pilih Public Resources, atur Number of Nodes menjadi 2, lalu pilih ecs.gn7i-c8g1.2xlarge untuk Resource Type.

     Jika tipe instans ini kehabisan stok, Anda dapat memilih tipe instans GPU lainnya.

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

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

4.3 (Opsional) tampilkan di TensorBoard

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

1. Di halaman detail Pekerjaan DLC, klik tab TensorBoard, lalu klik Create TensorBoard.

2. Atur Configuration Type menjadi By Task. Untuk Summary Path, masukkan path tempat kode pelatihan menyimpan file ringkasan: /mnt/data/output_distributed/runs. Klik OK untuk memulai.

   Ini sesuai dengan potongan kode: writer = SummaryWriter('/mnt/data/output_distributed/runs/mnist_experiment')

3. Klik View TensorBoard untuk melihat kurva train_loss (loss set pelatihan) dan kurva validation_loss (loss set validasi).

   

   (Opsional) Sesuaikan hiperparameter untuk meningkatkan performa model

   Anda dapat mengevaluasi performa model dengan mengamati tren nilai loss:

   • Sebelum pelatihan berakhir, train_loss dan validation_loss masih menurun (underfitting).

     Anda dapat menambah num_epochs (jumlah epoch pelatihan) atau sedikit menaikkan learning_rate, lalu melatih ulang model agar lebih sesuai dengan data pelatihan.

   • train_loss terus menurun, sementara validation_loss mulai meningkat sebelum pelatihan berakhir (overfitting).

     Anda dapat mengurangi num_epochs atau sedikit menurunkan learning_rate, lalu melatih ulang model untuk mencegah overfitting.

   • Kedua train_loss dan validation_loss sudah stabil sebelum pelatihan berakhir (good fit).

     Saat model berada dalam kondisi ini, Anda dapat melanjutkan ke langkah berikutnya.

4.4 Deploy model yang telah dilatih

Untuk informasi selengkapnya, lihat V. Deploy layanan model menggunakan EAS.