Platform For AI:Quick start: Distributed training with DLC

3,1 Veri kümesi oluşturma

Bir veri kümesi, eğitim kodlarınızı, verilerinizi ve model yapıtlarınızı depolar. Bu bölümde, Alibaba Cloud Object Storage Service (OSS) tabanlı bir veri kümesinin nasıl kullanılacağı açıklanmaktadır.

1. PAI konsolunun sol gezinme bölmesinde Datasets > Custom Dataset > Create datasets seçeneklerini belirleyin.

2. Aşağıdaki temel parametreleri yapılandırın ve diğerleri için varsayılan değerleri koruyun.

   • Name: Örneğin, dataset_mnist girin.

   • Storage Type: OSS seçeneğini belirleyin.

   • OSS Path: Klasör simgesine tıklayın, bir paket seçin ve dlc_mnist gibi yeni bir dizin oluşturun.

     OSS'i henüz etkinleştirmediyseniz veya mevcut bölgede kullanılabilir bir paketiniz yoksa OSS'i etkinleştirmek ve bir paket oluşturmak için şu adımları izleyin:

     (İsteğe bağlı) OSS'i etkinleştirin ve bir paket oluşturun

     1. OSS'i Etkinleştir.

     2. OSS konsoluna oturum açın, Create Bucket seçeneğine tıklayın, bir Bucket name girin ve PAI ile aynı Region değerini seçin. Diğer parametreler için varsayılan değerleri koruyun ve Create seçeneğine tıklayın.

   Veri kümesini oluşturmak için Confirm seçeneğine tıklayın.

3. Eğitim kodunu ve verilerini yükleyin.

   1. Sağlanan eğitim betiğini indirin: mnist_train.py. Süreci basitleştirmek için betik, çalışma zamanında eğitim verilerini otomatik olarak veri kümenizin dataSet dizinine indirir.

      Kendi projeleriniz için kodlarınızı ve eğitim verilerinizi önceden bir PAI veri kümesine yükleyebilirsiniz.

      Tek düğümlü, tek GPU eğitim kodu örneği: 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  # Batch size for each training iteration
      learning_rate = 0.01  # Learning rate
      num_epochs = 20  # Number of training epochs
      # Check if a GPU is available
      device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
      # Data preprocessing
      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)
      # Define a simple neural network
      class SimpleCNN(nn.Module):
          def __init__(self):
              super(SimpleCNN, self).__init__()
              # First convolutional layer: 1 input channel (grayscale image), 10 output channels, 5x5 kernel
              self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
              # Second convolutional layer: 10 input channels, 20 output channels, 3x3 kernel
              self.conv2 = nn.Conv2d(10, 20, kernel_size=3)
              # Fully connected layer: Input is 20 * 5 * 5 (feature map size after convolution and pooling), output is 128
              self.fc1 = nn.Linear(20 * 5 * 5, 128)
              # Output layer: 128 -> 10 (for 10 digit classes)
              self.fc2 = nn.Linear(128, 10)
          def forward(self, x):
              # Input x shape: [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)  # Flatten to [batch, 500]
              x = F.relu(self.fc1(x))      # [batch, 128]
              x = self.fc2(x)              # [batch, 10]
              return x
      # Instantiate the model and move it to the GPU if available
      model = SimpleCNN().to(device)
      criterion = nn.CrossEntropyLoss()
      optimizer = optim.SGD(model.parameters(), lr=learning_rate)
      # Create a TensorBoard SummaryWriter to visualize the model training process
      writer = SummaryWriter('/mnt/data/output/runs/mnist_experiment')
      # Variable to save the model with the highest accuracy
      best_val_accuracy = 0.0
      # Train the model and log loss and accuracy
      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)  # Move data and target to the GPU
              # Zero the gradients
              optimizer.zero_grad()
              # Forward pass
              output = model(data)
              # Calculate loss
              loss = criterion(output, target)
              # Backward pass
              loss.backward()
              # Update parameters
              optimizer.step()
              # Log training loss to TensorBoard
              if batch_idx % 100 == 0:  # Log every 100 batches
                  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}')
          # Validate the model and log validation loss and accuracy
          model.eval()
          val_loss = 0
          correct = 0
          with torch.no_grad():  # Do not calculate gradients
              for data, target in val_loader:
                  data, target = data.to(device), target.to(device)  # Move data and target to the GPU
                  output = model(data)
                  val_loss += criterion(output, target).item()  # Accumulate validation loss
                  pred = output.argmax(dim=1, keepdim=True)  # Get predicted label
                  correct += pred.eq(target.view_as(pred)).sum().item()  # Accumulate number of correct predictions
          val_loss /= len(val_loader)  # Calculate average validation loss
          val_accuracy = 100. * correct / len(val_loader.dataset)  # Calculate validation accuracy
          print(f'Validation Loss: {val_loss:.4f}, Accuracy: {correct}/{len(val_loader.dataset)} ({val_accuracy:.0f}%)')
          # Log validation loss and accuracy to TensorBoard
          writer.add_scalar('Loss/validation', val_loss, epoch)
          writer.add_scalar('Accuracy/validation', val_accuracy, epoch)
          # Save the model with the highest validation accuracy
          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}%')
      # Close the SummaryWriter
      writer.close()
      print('Training complete. writer.close()')

   2. Kodu yükleyin. Veri kümesi ayrıntıları sayfasında, OSS konsoluna gitmek için View Data seçeneğine tıklayın. Ardından, eğitim betiğini OSS'e yüklemek için Upload Object >Select Files > Upload Object seçeneklerini belirleyin.

3,2 Bir DLC işi oluşturma

1. PAI konsolunun sol gezinme bölmesinde Deep Learning Containers (DLC) > Create Job seçeneklerini belirleyin.

2. Aşağıdaki temel parametreleri yapılandırın ve diğerleri için varsayılan değerleri koruyun. Parametrelerin tam listesi için bkz. Eğitim işi oluşturma.

   • Image Configuration: Image Address seçeneğini belirleyin ve ardından Region değeriniz için uygun görüntü adresini girin.

     Konsolun üst gezinme çubuğunda, Region seçicisini kullanarak mevcut bölgenizi onaylayın (örneğin 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	Bölge Kimliğinizi bulma ve tam URL'yi almak için görüntü adresindeki <Region ID> değerini değiştirme: dsw-registry-vpc.<Region ID>.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04

     Bu görüntü, DSW Etkileşimli Modellemeye Giriş konusundaki doğrulanmış ortamı kullanır. PAI ile modelleme yaparken tipik bir iş akışı, önce DSW'de ortamı doğrulamak ve kod geliştirmek, ardından eğitim için DLC kullanmaktır.

   • Dataset Mount: Custom Dataset seçeneğini belirleyin ve önceki adımda oluşturduğunuz veri kümesini seçin. Varsayılan Mount Path değeri /mnt/data şeklindedir.

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

     Başlatma komutu, kodu DSW'de veya yerel olarak çalıştırdığınız durumla aynıdır. Ancak, mnist_train.py artık /mnt/data/ konumuna bağlandığından, kod yolunu yalnızca /mnt/data/mnist_train.py olarak değiştirmeniz gerekir.

   • Source: Public Resources seçeneğini belirleyin ve ardından Resource Type için ecs.gn7i-c8g1.2xlarge değerini seçin.

     Bu örnek türü stokta yoksa başka bir GPU örnek türü seçebilirsiniz.

   İşi oluşturmak için OK seçeneğine tıklayın. İşin çalışması yaklaşık 15 dakika sürer. Çalışma sırasında günlükleri tıklayarak eğitim ilerlemesini görüntüleyebilirsiniz.

   Eğitim günlüğü, MNIST modelinin 18. Epoch'ta 9886/10000 (yaklaşık %99) doğrulama doğruluğuna ulaştığını gösterir. İş durumu Succeeded olarak değiştiğinde, günlük son çıktıyı görüntüler: Training complete. writer.close().

   İş tamamlandıktan sonra DLC, en iyi model kontrol noktasını ve TensorBoard günlüğünü bağlanan veri kümesinin output yoluna kaydeder.

   OSS paketinizdeki dlc_mnist/ dizini artık eğitim verileri için bir dataSet/ alt dizini, model yapıtları için bir output/ alt dizini ve mnist_train.py betiğini içerir.

3,3 (İsteğe bağlı) TensorBoard'da görüntüleme

Kayıp eğrisini görüntülemek ve eğitim sürecini daha iyi anlamak için TensorBoard görselleştirme aracını kullanabilirsiniz.

1. DLC işinin ayrıntılar sayfasında Tensorboard sekmesine tıklayın ve ardından Create TensorBoard seçeneğine tıklayın.

2. Configuration Type değerini By Task olarak ayarlayın. Summary Path için, eğitim kodunda SummaryWriter'ın verileri kaydettiği yolu girin: /mnt/data/output/runs/. Başlatmak için OK seçeneğine tıklayın.

   Bu, aşağıdaki kod parçasına karşılık gelir: writer = SummaryWriter('/mnt/data/output/runs/mnist_experiment')

3. train_loss eğrisini (eğitim kümesi kaybı) ve validation_loss eğrisini (doğrulama kümesi kaybı) görmek için View TensorBoard seçeneğine tıklayın.

   

   (İsteğe bağlı) Model performansını iyileştirmek için hiperparametreleri ayarlama

   Kayıp değerlerindeki eğilimleri gözlemleyerek modelinizin performansını değerlendirebilirsiniz:

   • Eğitim tamamlanmadan önce train_loss ve validation_loss hala düşüş eğilimi gösteriyorsa (yetersiz uyum).

     Eğitim verilerine daha iyi uyum sağlamak için num_epochs (eğitim dönem sayısı) değerini artırabilir veya learning_rate değerini biraz artırabilir ve ardından modeli yeniden eğitebilirsiniz.

   • train_loss sürekli azalırken, eğitim tamamlanmadan önce validation_loss artmaya başlıyorsa (aşırı uyum).

     Aşırı uymayı önlemek için num_epochs değerini azaltabilir veya learning_rate değerini biraz düşürebilir ve ardından modeli yeniden eğitebilirsiniz.

   • Eğitim tamamlanmadan önce hem train_loss hem de validation_loss stabilsse (iyi uyum).

     Model bu durumdaysa sonraki adımlara geçebilirsiniz.

3,4 Eğitilen modeli dağıtma

Daha fazla bilgi için bkz. V. EAS kullanarak model hizmetlerini dağıtma.

4,1 Veri kümesini ve betiği hazırlama

3. Tek düğümlü, tek GPU eğitimi bölümünde zaten bir veri kümesi oluşturduysanız mnist_train_distributed.py dosyasını indirip yüklemeniz yeterlidir. Aksi takdirde önce 3,1 Veri kümesi oluşturma adımını uygulayın ve ardından kodu yükleyin.

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,))
    ])
    # Only the main process (rank=0) needs to download; other processes must wait for it.
    # Make processes with rank != 0 wait at the barrier.
    if rank != 0:
        dist.barrier()
    # All processes create the dataset.
    # However, only the rank 0 process actually performs the download.
    train_dataset = datasets.MNIST(root='/mnt/data/dataSet', train=True, download=(rank == 0), transform=transform)
    # After the rank 0 process finishes downloading, it also reaches the barrier, releasing all processes.
    if rank == 0:
        dist.barrier()
    # At this point, all processes are synchronized and can continue.
    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:
                # Each rank and local_rank prints its own loss.
                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)
        # Validation
        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()

4,2 Dağıtılmış bir DLC işi oluşturma

1. PAI konsolunun sol gezinme bölmesinde Deep Learning Containers (DLC) > Create Job seçeneklerini belirleyin.

2. Aşağıdaki temel parametreleri yapılandırın ve diğerleri için varsayılan değerleri koruyun. Parametrelerin tam listesi için bkz. Eğitim işi oluşturma.

   • Image Configuration: Image Address seçeneğini belirleyin ve ardından Region değeriniz için uygun görüntü adresini girin.

     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	Bölge Kimliğinizi bulma ve tam URL'yi almak için görüntü adresindeki <Region ID> değerini değiştirme: dsw-registry-vpc.<Region ID>.cr.aliyuncs.com/pai/modelscope:1.28.0-pytorch2.3.1tensorflow2.16.1-gpu-py311-cu121-ubuntu22.04

     Bu görüntü, DSW Etkileşimli Modellemeye Giriş konusundaki doğrulanmış ortamı kullanır. PAI ile modelleme yaparken tipik bir iş akışı, önce DSW'de ortamı doğrulamak ve kod geliştirmek, ardından eğitim için DLC kullanmaktır.

   • Dataset Mount: Custom Dataset seçeneğini belirleyin ve oluşturduğunuz veri kümesini seçin. Varsayılan Mount Path değeri /mnt/data şeklindedir.

   • 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, ortam değişkenleri gibi yaygın değişkenleri otomatik olarak enjekte eder (örneğin MASTER_ADDR ve WORLD_SIZE). Bu değişkenlere $VARIABLE_NAME sözdizimiyle erişebilirsiniz.

   • Source: Public Resources seçeneğini belirleyin, Number of Nodes değerini 2 olarak ayarlayın ve Resource Type için ecs.gn7i-c8g1.2xlarge değerini seçin.

     Bu örnek türü stokta yoksa başka bir GPU örnek türü seçebilirsiniz.

   İşi oluşturmak için Confirm seçeneğine tıklayın. İşin çalışması yaklaşık 10 dakika sürer. Çalışma sırasında, Overview sayfasında her iki örnek için de eğitim Log değerlerini görüntüleyebilirsiniz.

   İş tamamlandıktan sonra DLC, en iyi model kontrol noktasını ve TensorBoard günlüğünü bağlanan veri kümesinin output_distributed yoluna kaydeder.

4,3 (İsteğe bağlı) TensorBoard'da görüntüleme

Kayıp eğrisini görüntülemek ve eğitim sürecini daha iyi anlamak için TensorBoard görselleştirme aracını kullanabilirsiniz.

1. DLC işinin ayrıntılar sayfasında TensorBoard sekmesine tıklayın ve ardından Create TensorBoard seçeneğine tıklayın.

2. Configuration Type değerini By Task olarak ayarlayın. Summary Path için, eğitim kodunun özet dosyalarını kaydettiği yolu girin: /mnt/data/output_distributed/runs. Başlatmak için OK seçeneğine tıklayın.

   Bu, aşağıdaki kod parçasına karşılık gelir: writer = SummaryWriter('/mnt/data/output_distributed/runs/mnist_experiment')

3. train_loss eğrisini (eğitim kümesi kaybı) ve validation_loss eğrisini (doğrulama kümesi kaybı) görmek için View TensorBoard seçeneğine tıklayın.

   

   (İsteğe bağlı) Model performansını iyileştirmek için hiperparametreleri ayarlama

   Kayıp değerlerindeki eğilimleri gözlemleyerek modelinizin performansını değerlendirebilirsiniz:

   • Eğitim sona ermeden önce train_loss ve validation_loss hala azalıyorsa (yetersiz uyum).

     Eğitim verilerine daha iyi uyum sağlamak için num_epochs (eğitim dönem sayısı) değerini artırabilir veya learning_rate değerini biraz artırabilir ve ardından modeli yeniden eğitebilirsiniz.

   • train_loss sürekli azalırken, eğitim sona ermeden önce validation_loss artmaya başlıyorsa (aşırı uyum).

     Aşırı uymayı önlemek için num_epochs değerini azaltabilir veya learning_rate değerini biraz düşürebilir ve ardından modeli yeniden eğitebilirsiniz.

   • Eğitim sona ermeden önce hem train_loss hem de validation_loss stabilsse (iyi uyum).

     Model bu durumdaysa sonraki adımlara geçebilirsiniz.

4,4 Eğitilen modeli dağıtma

Daha fazla bilgi için bkz. V. EAS kullanarak model hizmetlerini dağıtma.