Mulai dengan OSS Connector untuk AI/ML - Object Storage Service

Topik ini menjelaskan cara menggunakan OSS Connector untuk AI/ML untuk membuat dan melatih model data secara efisien.

Lingkungan penyebaran

Sistem Operasi: Linux x86-64
glibc: >=2.17
Python: 3.8-3.12
PyTorch: >=2.0
Untuk menggunakan fitur OSS Checkpoint, kernel Linux harus mendukung userfaultfd.
Catatan
Sebagai contoh, pada sistem Ubuntu, Anda dapat menjalankan perintah sudo grep CONFIG_USERFAULTFD /boot/config-$(uname -r) untuk memeriksa apakah kernel Linux mendukung userfaultfd. Jika perintah mengembalikan CONFIG_USERFAULTFD=y, kernel mendukungnya. Jika perintah mengembalikan CONFIG_USERFAULTFD=n, kernel tidak mendukungnya, sehingga fitur OSS Checkpoint tidak dapat digunakan.

Instalasi cepat

Contoh berikut menjelaskan cara menginstal OSS Connector untuk AI/ML untuk Python 3.12.

Pada sistem operasi Linux atau dalam kontainer yang dibuat dari image berbasis Linux, jalankan perintah pip3.12 install osstorchconnector untuk menginstal OSS Connector untuk AI/ML.
```
pip3.12 install osstorchconnector
```
Jalankan perintah pip3.12 show osstorchconnector untuk memeriksa apakah instalasi berhasil.
```
pip3.12 show osstorchconnector
```
Jika informasi versi untuk osstorchconnector ditampilkan, instalasi berhasil.

Konfigurasi

Buat file konfigurasi untuk kredensial akses.

mkdir -p /root/.alibabacloud && touch /root/.alibabacloud/credentials

Tambahkan konfigurasi kredensial akses dan simpan file tersebut.
Ganti <Access-key-id> dan <Access-key-secret> dalam contoh dengan ID AccessKey dan Rahasia AccessKey dari Pengguna Resource Access Management (RAM). Untuk informasi lebih lanjut tentang cara membuat ID AccessKey dan Rahasia AccessKey, lihat Buat AccessKey. Untuk informasi lebih lanjut tentang item konfigurasi dan penggunaan kredensial akses sementara, lihat Konfigurasikan Kredensial Akses.
```
{
  "AccessKeyId": "LTAI************************",
  "AccessKeySecret": "At32************************"
}
```

Buat file konfigurasi OSS Connector.

mkdir -p /etc/oss-connector/ && touch /etc/oss-connector/config.json

Tambahkan konfigurasi OSS Connector dan simpan file tersebut. Untuk informasi lebih lanjut tentang item konfigurasi, lihat Konfigurasikan OSS Connector.

Dalam kebanyakan kasus, Anda dapat menggunakan konfigurasi default berikut.

{
    "logLevel": 1,
    "logPath": "/var/log/oss-connector/connector.log",
    "auditPath": "/var/log/oss-connector/audit.log",
    "datasetConfig": {
        "prefetchConcurrency": 24,
        "prefetchWorker": 2
    },
    "checkpointConfig": {
        "prefetchConcurrency": 24,
        "prefetchWorker": 4,
        "uploadConcurrency": 64
    }
}

Contoh

Contoh berikut menunjukkan cara membuat model pengenalan tulisan tangan menggunakan PyTorch. Model ini menggunakan dataset MNIST yang dibangun dengan OssMapDataset dan menyimpan serta memuat checkpoint model menggunakan OssCheckpoint.

import io
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from PIL import Image
from torch.utils.data import DataLoader
from osstorchconnector import OssMapDataset
from osstorchconnector import OssCheckpoint

# Tentukan hiperparameter.
EPOCHS = 1
BATCH_SIZE = 64
LEARNING_RATE = 0.001
CHECKPOINT_READ_URI = "oss://you_bucketname/epoch.ckpt"  # URI untuk membaca checkpoint dari OSS.
CHECKPOINT_WRITE_URI = "oss://you_bucketname/epoch.ckpt" # URI untuk menyimpan checkpoint ke OSS.
ENDPOINT = "oss-cn-hangzhou-internal.aliyuncs.com"       # Titik akhir internal untuk mengakses OSS. Untuk menggunakan titik akhir ini, Instance ECS dan Bucket OSS harus berada di wilayah yang sama.
CONFIG_PATH = "/etc/oss-connector/config.json"           # Jalur ke file konfigurasi OSS Connector.
CRED_PATH = "/root/.alibabacloud/credentials"            # Jalur ke file konfigurasi kredensial akses.
OSS_URI = "oss://you_bucketname/mnist/"                  # URI sumber daya bucket di OSS.

# Buat objek OssCheckpoint untuk menyimpan checkpoint ke dan membaca checkpoint dari OSS selama pelatihan.
checkpoint = OssCheckpoint(endpoint=ENDPOINT, cred_path=CRED_PATH, config_path=CONFIG_PATH)

# Definisikan jaringan saraf konvolusional sederhana.
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        # Gunakan pooling adaptif untuk menyederhanakan pemrosesan ukuran.
        self.adaptive_pool = nn.AdaptiveAvgPool2d((7, 7))
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = nn.ReLU()(self.conv1(x)) 
        x = nn.MaxPool2d(2)(x)
        x = nn.ReLU()(self.conv2(x))
        x = nn.MaxPool2d(2)(x)
        x = self.adaptive_pool(x)
        x = x.view(x.size(0), -1)
        x = nn.ReLU()(self.fc1(x))
        x = self.fc2(x)
        return x

# Pra-proses data.
trans = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5], std=[0.5])
])

def transform(object):
    try:
        img = Image.open(io.BytesIO(object.read())).convert('L')
        val = trans(img)
    except Exception as e:
        raise e
    
    # Ekstrak label dari jalur objek. Asumsikan format jalur adalah oss://bucket/mnist/label/filename.
    # Sesuaikan logika ekstraksi label berdasarkan struktur dataset aktual.
    try:
        label = int(object.name.split('/')[-2])  # Ekstrak segmen kedua terakhir sebagai label.
    except (ValueError, IndexError):
        label = 0  # Label default. Sesuaikan ini berdasarkan struktur dataset Anda.
    
    return val, torch.tensor(label)

# Muat dataset OssMapDataset.
train_dataset = OssMapDataset.from_prefix(OSS_URI, endpoint=ENDPOINT, transform=transform, cred_path=CRED_PATH, config_path=CONFIG_PATH)
train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, num_workers=32, prefetch_factor=2, shuffle=True)

# Inisialisasi model, fungsi loss, dan pengoptimal.
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()  
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)  

# Latih model.
for epoch in range(EPOCHS):
    for i, (images, labels) in enumerate(train_loader):
        optimizer.zero_grad()  
        outputs = model(images)  
        loss = criterion(outputs, labels)  
        loss.backward()  
        optimizer.step()  
        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch + 1}/{EPOCHS}], Langkah [{i + 1}/{len(train_loader)}], Loss: {loss.item():.4f}')
    
    # Simpan checkpoint menggunakan objek OssCheckpoint.
    with checkpoint.writer(CHECKPOINT_WRITE_URI) as writer:
        torch.save(model.state_dict(), writer)
        print("-------------------------")
        print("Checkpoint disimpan")
        print(model.state_dict())

# Baca checkpoint menggunakan objek OssCheckpoint.
try:
    with checkpoint.reader(CHECKPOINT_READ_URI) as reader:
        state_dict = torch.load(reader)
    
    # Muat model.
    model = SimpleCNN()
    model.load_state_dict(state_dict)
    model.eval()
    print("Checkpoint dimuat dengan sukses")
except Exception as e:
    print(f"Gagal memuat checkpoint: {e}")
    # Anda dapat memilih untuk melatih dari awal atau menggunakan checkpoint lain.