引言

科研助手【科研版】提供并行計算功能模塊，您可以基于該能力模塊運行分布式作業。我們提供多種運行引擎的支持，您可以根據自己的需要使用不同的訓練引擎。同時，我們也提供多個區域不同種類的算力，您可以根據需要按需選購。

場景描述

本文將通過使用 PyTorch框架訓練手寫數字識別 MNIST 模型來講述如何在科研助手并行計算模塊中訓練模型。

手寫數字MNIST 數據集是一個經典的手寫數字圖像數據集，廣泛用于機器學習和深度學習領域的模型訓練與評估。它包含60,000 張訓練圖像和 10,000 張測試圖像，每張圖像為 28×28 的灰度圖，涵蓋手寫數字 0 到 9。MNIST數據集因其簡單性和代表性，成為算法驗證和教學的經典工具，支持多種機器學習方法和深度學習模型的開發與測試。

本場景的整體流程如下：

準備工作

準備工作包括如下幾步：

• 準備數據：準備訓練代碼、訓練數據、訓練環境
• 創建科研文件：科研文件是科研助手提供的文件管理服務，并行計算需要依賴科研文件將數據掛載到訓練任務中
• 上傳數據：將準備好的數據上傳到科研文件實例

數據準備

數據包括訓練代碼、訓練數據和訓練環境。

1、訓練代碼

本示例的訓練代碼包括兩部分，如下所述：

（1）啟動腳本

本示例提供一個啟動腳本start.sh，可以簡化創建任務填寫的啟動命令內容。內容如下：

sudo /opt/conda/bin/python3 /storage/mnist/bc_mnist.py

您可以按照實際情況調整啟動腳本的內容。

（2）模型訓練代碼

本示例的訓練代碼包括訓練和驗證兩部分內容，參考官方提供的示例代碼進行改寫。bc_mnist.py 內容如下：

from __future__ import print_function
import argparse
import os
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.onnx
from torchvision import datasets, transforms
from torch.optim.lr_scheduler import StepLR
 
 
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.dropout1 = nn.Dropout(0.25)
        self.dropout2 = nn.Dropout(0.5)
        self.fc1 = nn.Linear(9216, 128)
        self.fc2 = nn.Linear(128, 10)
 
    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, 2)
        x = self.dropout1(x)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        output = F.log_softmax(x, dim=1)
        return output
 
 
def train(args, model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % args.log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))
            if args.dry_run:
                break
 
 
def test(model, device, test_loader):
    model.
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss
            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
            correct += pred.eq(target.view_as(pred)).sum().item()
 
    test_loss /= len(test_loader.dataset)
 
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))
 
 
def main():
    # Training settings
    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
    parser.add_argument('--batch-size', type=int, default=64, metavar='N',
                        help='input batch size for training (default: 64)')
    parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
                        help='input batch size for testing (default: 1000)')
    parser.add_argument('--epochs', type=int, default=5, metavar='N',
                        help='number of epochs to train (default: 5)')
    parser.add_argument('--lr', type=float, default=1.0, metavar='LR',
                        help='learning rate (default: 1.0)')
    parser.add_argument('--gamma', type=float, default=0.7, metavar='M',
                        help='Learning rate step gamma (default: 0.7)')
    parser.add_argument('--no-cuda', action='store_true', default=False,
                        help='disables CUDA training')
    parser.add_argument('--dry-run', action='store_true', default=False,
                        help='quickly check a single pass')
    parser.add_argument('--seed', type=int, default=1, metavar='S',
                        help='random seed (default: 1)')
    parser.add_argument('--log-interval', type=int, default=10, metavar='N',
                        help='how many batches to wait before logging training status')
    parser.add_argument('--save-model', action='store_true', default=True,
                        help='For Saving the current Model')
    args = parser.parse_args()
    use_cuda = not args.no_cuda and torch.cuda.is_available()
    print("use_cuda: {}".format(use_cuda))
 
    torch.manual_seed(args.seed)
 
    device = torch.device("cuda" if use_cuda else "cpu")
 
    train_kwargs = {'batch_size': args.batch_size}
    test_kwargs = {'batch_size': args.test_batch_size}
    if use_cuda:
        cuda_kwargs = {'num_workers': 1,
                       'pin_memory': True,
                       'shuffle': True}
        train_kwargs.update(cuda_kwargs)
        test_kwargs.update(cuda_kwargs)
 
    transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
        ])
    dataset1 = datasets.MNIST('/storage/mnist/data', train=True, download=True,
                       transform=transform)
    dataset2 = datasets.MNIST('/storage/mnist/data', train=False,
                       transform=transform)
    train_loader = torch.utils.data.DataLoader(dataset1,**train_kwargs)
    test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)
    print("Dataloader done")
 
    model = Net().to(device)
    optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
    print("modeldone")
 
    scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
    for epoch in range(1, args.epochs + 1):
        train(args, model, device, train_loader, optimizer, epoch)
        test(model, device, test_loader)
        scheduler.step()
    print("train done")
 
    if args.save_model:
        out_dir = "/storage/mnist/model/m/1/"
        if not os.path.isdir(out_dir):
            os.makedirs(out_dir)
        # 保存模型
        model_path = out_dir + "mnist_model.pth"
        torch.save(model.state_dict(), model_path)
        print("模型已保存到 {}".format(model_path))
 
    # 加載模型
    print("加載模型...")
    model = Net()  # 創建新的模型實例
    model.load_state_dict(torch.load(model_path))  # 加載保存的權重
    model.  # 設置為評估模式
   
    # 測試模型
    print("開始測試...")
    with torch.no_grad():
        for images, labels in test_loader:
            # 獲取第一批數據中的第一張圖片和標簽
            image = images[0].unsqueeze(0)  # 添加一個批次維度
            true_label = labels[0].item()
 
            # 進行預測
            output = model(image)
            _, predicted_label = torch.max(output, 1)
            predicted_label = predicted_label.item()
 
            # 打印結果
            print(f"真實標簽: {true_label}")
            print(f"預測標簽: {predicted_label}")
            break  # 只處理一張圖片
 
if __name__ == '__main__':
    main()

您可以根據實際情況調整模型訓練代碼。

2、數據準備

本示例使用的是官方提供的MNIST 數據集。

【注意】訓練代碼中有配置自動下載代碼的選項，如果沒有提前下載數據，也支持自動下載。您可以按照實際情況上傳模型訓練需要的數據。

創建科研文件

【科研文件】是科研助手提供的文件管理服務模塊，您可以通過【科研文件】來管理自己的數據。并行計算需要依賴【科研文件】提供訓練所需數據，因此需要提前創建科研文件。

進入科研助手，選擇【數據存儲】>【科研文件管理】，點擊【創建科研文件】按鈕

請根據你所需要的可用區進行選擇。科研文件默認最小容量為10G，您可以按需調整所需容量。

配置后，點擊【確認訂單】，等待科研文件狀態變為【創建成功】

上傳數據

選擇剛剛創建好的科研文件，點擊【查看】，進入文件管理界面。

新建一個目錄，本示例命名為mnist。進入目錄上傳準備好的訓練腳本、訓練數據。

【注意】

• 數據上傳過程中，請保持網絡暢通
• 數據上傳過程中，不要刷新頁面，否則會導致上傳文件丟失

MNIST 手寫識別模型訓練

準備工作做完后，進入【并行計算】頁面，點擊【創建計算任務】按鈕，進入任務配置頁面。

【注意】并行計算內置了一些可以直接使用的模板，您可以按需使用。

在任務配置頁面，本示例的配置如下：

• 選擇 PyTorch 訓練框架
• 鏡像地址：本示例使用科研助手公共的 PyTorch 鏡像（該鏡像需要使用本示例啟動腳本對應的 python 命令），地址為：
• 啟動執行命令：sh /storage/mnist/start.sh
• 可用區：需要與科研文件在同一個可用區：廈門4，請按照實際選擇
• 實例規格：可以按照實際需求選擇
• 容器掛載路徑，需要與訓練腳本中使用的路徑相對應：/storage

配置后，點【立即創建】

可以點擊右側的【詳情】按鈕查看任務運行情況。

并行計算提供多種能力來跟蹤任務運行情況，包括：

• 作業日志：可以查看任務運行過程中產生的訓練日志
• 實例終端：可以登錄任務運行容器查看訓練過程中產生的中間數據
• 運行監控：可以查看任務運行過程的資源占用情況
• 實例事件：可以查看任務運行過程中所產生的事件列表

作業日志如下：

實例終端如下：

運行監控如下：

實例事件如下：

最終運行效果，模型成功訓練，將模型保存到科研文件。通過保存的模型文件，能夠正確識別手寫識別數字。效果如下：

保存到科研文件的模型文件如下：