OSS Connector for AI/MLを使用してデータトレーニングタスクを効率的に完了する - Object Storage Service

このトピックでは、OSS Connector for AI/MLを使用してデータモデルを効率的に作成およびトレーニングする方法について説明します。

デプロイ環境

オペレーティングシステム: 64ビットx86 Linux
glibc: 2.17以降
Python: 3.12する3.8
PyTorch: 2.0以降
OSSチェックポイント機能を使用するには、Linuxカーネルがuserfaultfdをサポートしている必要があります。
説明
この例では、Ubuntuが使用されています。 sudo grep CONFIG_USERFAULTFD /boot/config-$(uname -r) コマンドを実行して、Linuxカーネルがuserfaultfdをサポートしているかどうかを確認できます。 CONFIG_USERFAULTFD=yが返された場合、Linuxカーネルはuserfaultfdをサポートします。 CONFIG_USERFAULTFD=nが返された場合、Linuxカーネルはuserfaultfdをサポートしません。この場合、OSSチェックポイント機能は使用できません。

インストール

次の例では、OSS Connector for AI/ML for Python 3.12をインストールする方法を説明します。

pip3.12 install osstorchconnectorコマンドを実行して、LinuxまたはLinuxベースのイメージを使用して生成されたコンテナーにOSS Connector for AI/MLをインストールします。
```
pip3.12 install osstorchconnector
```
pip3.12 show osstorchconnectorコマンドを実行し、OSS Connector for AI/MLがインストールされているかどうかを確認します。
```
pip3.12 show osstorchconnector
```
osstorchconnectorのバージョン情報が返されると、OSS Connector for AI/MLがインストールされます。

設定

アクセス資格情報の設定ファイルを作成します。

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

アクセス資格情報を構成ファイルに追加し、構成ファイルを保存します。
例の <Access-key-id> および <Access-key-secret> を、RAMユーザーのAccessKey IDおよびAccessKey secretに置き換えます。 AccessKey IDとAccessKeyシークレットの作成方法の詳細については、「AccessKeyペアの作成」をご参照ください。設定項目と一時的なアクセス資格情報を使用した設定の詳細については、「アクセス資格情報の設定」をご参照ください。
```
{
  "AccessKeyId": "LTAI************************",
  "AccessKeySecret": "At32************************"
}
```

OSSコネクタの設定ファイルを作成します。

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

OSSコネクタの設定を設定ファイルに追加し、設定ファイルを保存します。設定項目の詳細については、「OSSコネクタの設定」をご参照ください。

ほとんどの場合、次のデフォルト設定を使用できます。

{
    "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
    }
}

例

次の例は、PyTorchを使用して手書き数字認識モデルを作成する方法を示しています。モデルに使用されるMNISTデータセットは、OssMapDatasetを使用して作成されます。チェックポイントは、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

# Specify the following hyperparameters:
EPOCHS = 1
BATCH_SIZE = 64
LEARNING_RATE = 0.001
CHECKPOINT_READ_URI = "oss://you_bucketname/epoch.ckpt"  # Read the URL of the checkpoint in OSS.
CHECKPOINT_WRITE_URI = "oss://you_bucketname/epoch.ckpt" # Specify the checkpoint write URL in OSS.
ENDPOINT = "oss-cn-hangzhou-internal.aliyuncs.com"       # Specify the endpoint of the region that is used to access OSS. To use this endpoint, the Elastic Compute Service (ECS) instance and the OSS bucket must be in the same region.
CONFIG_PATH = "/etc/oss-connector/config.json"           # Specify the path of the OSS connector configuration file.
CRED_PATH = "/root/.alibabacloud/credentials"            # Specify the path of the configuration file that is used to configure access credentials.
OSS_URI = "oss://you_bucketname/mninst/"                 # Specify the path of resources in the OSS bucket.

# Create an object by using OssCheckpoint for saving and reading checkpoints during the training process.
checkpoint = OssCheckpoint(endpoint=ENDPOINT, cred_path=CRED_PATH, config_path=CONFIG_PATH)

# Specify a simple convolutional neural network (CNN).
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)
        input_size = 224  
        after_conv1 = (input_size - 3 + 2*1) 
        after_pool1 = after_conv1 // 2  
        after_conv2 = (after_pool1 - 3 + 2*1) // 1 + 1  
        after_pool2 = after_conv2 // 2  
        flattened_size = 64 * after_pool2 * after_pool2
        self.fc1 = nn.Linear(flattened_size, 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 = x.view(x.size(0), -1)
        x = nn.ReLU()(self.fc1(x))
        x = self.fc2(x)
        return x

# Preprocess the 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
    label = 0
    return val, torch.tensor(label)

# Load the OssMapDataset dataset.
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)

# Initialize the model, loss function, and optimizer.
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()  
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)  

# Train the 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}], Step [{i + 1}/{len(train_loader)}], Loss: {loss.item():.4f}')
    # Store the checkpoint using the object created by using OssCheckpoint.
    with checkpoint.writer(CHECKPOINT_WRITE_URI) as writer:
        torch.save(model.state_dict(), writer)
        print("-------------------------")
        print(model.state_dict)

# Read the checkpoint using the object created by using OssCheckpoint.
with checkpoint.reader(CHECKPOINT_READ_URI) as reader:
   state_dict = torch.load(reader)

# Load the model.
model = SimpleCNN()
model.load_state_dict(state_dict)
model.eval()