华为云 ModelArts 产品体验

免费体验：一键完成商超商品识别模型部署

一、工作准备

1.1 注册账号、实名认证

已注册华为帐号并开通华为云，进行了实名认证，且在使用 ModelArts 前检查帐号状态，帐号不能处于欠费或冻结状态。

1.2 配置委托访问授权

ModelArts 使用过程中涉及到 OBS、SWR、IEF 等服务交互，首次使用 ModelArts 需要用户配置委托授权，允许访问这些依赖服务

1. 使用华为云帐号登录 ModelArts 管理控制台，在左侧导航栏单击 “全局配置”，进入 “全局配置” 页面，单击 “添加授权”。

2. 在 “访问授权” 页面，选择需要授权的 “用户名”，选择新增委托及其对应的权限 “普通用户”，并勾选 “我已经详细阅读并同意《ModelArts 服务声明》”，然后单击 “创建”。

二、订阅模型

商超商品识别的模型共享在 AI Gallery 中。您可以前往 AI Gallery，免费订阅此模型。

2.1 在 AI Gallery 搜索模型。

方式一：单击商超商品识别模型链接，进入模型详情页。

方式二：在 ModelArts 管理控制台的左侧菜单栏，单击 **“AI Gallery”** 进入 AI Gallery。选择 “资产集市 > 模型”，搜索 “商超商品识别”，单击名称进入模型详情页。

2.2 完成模型订阅。

在模型详情页，单击 “订阅”，阅读并勾选同意《数据安全与隐私风险承担条款》 和 《华为云 AI Gallery 服务协议》，单击 “继续订阅”。

订阅模型完成后，页面的 “订阅” 按钮显示为 “已订阅”。

3.3 进入 ModelArts 控制台的订阅列表。

在模型详情页，单击 “前往控制台”。在弹出的 “选择云服务区域” 页面选择 ModelArts 所在的云服务区域，单击 “确定” 跳转至 ModelArts 控制台的 “AI 应用管理 > AI 应用 > 我的订阅” 页面。

在 “我的订阅” 列表，单击模型名称前面的，当订阅模型的版本列表的状态显示为 “就绪” 时表示模型可以使用。

三、使用订阅模型部署在线服务

模型订阅成功后，可将此模型部署为在线服务。

1. 在 “AI 应用管理> AI 应用 > 我的订阅” 页面，单击模型名称前面的，在展开的版本列表中单击 “部署> 在线服务” 跳转至部署页面。

2. 在部署页面，参考如下说明填写关键参数。

• “名称”：自定义一个在线服务的名称，也可以使用默认值，此处以 “商超商品识别服务” 为例。
• “资源池”：选择 “公共资源池”。
• “AI 应用来源” 和 “选择 AI 应用及版本”：会自动选择订阅模型。
• “计算节点规格”：在下拉框中选择 “限时免费” 资源，勾选并阅读免费规格说明。
• 其他参数可使用默认值。

3. 参数配置完成后，单击 “下一步”，确认规格参数后，单击 “提交” 启动在线服务的部署。

4. 进入 “部署上线> 在线服务” 页面，等待服务服务状态变为 “运行中” 时，表示服务部署成功。预计时长 4 分钟左右

四、预测结果

1. 在线服务部署完成后，单击服务名称进入服务详情。

2. 在 “预测” 页签，单击 “上传”，上传一个测试图片，单击 “预测” 查看预测结果。此处提供一个样例图片供预测使用。

3. 预测结果

五、清理资源

体验结束后，建议暂停或删除服务，避免占用资源，造成资源浪费。

• 停止在线服务：在在线服务列表，单击对应服务操作列的 “更多> 停止”。
• 删除在线服务：在在线服务列表，单击对应服务操作列的 “更多> 删除”。

一键运行 Notebook 实现工地钢筋盘点

一、工作准备

同上，略

二、一键运行 Notebook

1. 单击案例链接基于计算机视觉的钢筋条数检测，进入案例详情页。

2. 单击详情页右侧的 “Run in ModelArts”。

3. 系统自动进入 ModelArts 的 JupyterLab 页面，如果未登录华为云，根据提示登录。

4. 登录后在页面右上角会提示正在与 ModelArts 连接中，请等待连接完成。

5. 在右侧的资源管理窗口，推荐切换为限时免费的 GPU 规格进行训练，可以提升训练效率。

6. 资源切换完成后，即可以了解该案例的内容步骤并运行。

7. 单击 ipynb 文件右侧的 “No Kernel”, 在弹出的 “Select Kernel” 页面选择 AI 框架。

8. 反复单击导航栏的，逐步运行每个步骤；也可以一键运行该案例的所有步骤

单步运行按钮

一键运行所有步骤

运行时，右上角圆圈的空心圆表示未开始或者运行完成，实心圆表示代码正在运行。

9. 在第 9 步的训练环节，共迭代训练 25 次，每次耗时 60 秒，共 25 分钟，请耐心等待。

垃圾分类（使用新版自动学习实现图像分类）

一、准备工作

1. 注册华为帐号并开通华为云、实名认证

2. 创建 OBS 桶

登录 OBS 管理控制台，在桶列表页面右上角单击 “创建桶”，创建 OBS 桶。例如，创建名称为 “c-flowers” 的 OBS 桶。

在 ModelArts 中选择 OBS 路径时，找不到已创建的 OBS 桶？

原因是已创建的 OBS 桶和使用的 ModelArts 服务不在同一个区域。

注意下图中的区域要和 ModelArts 一致

二、准备训练数据集

1. 进入 AI Gallery，在 “资产集市”>“数据” 中的 “数据集” 页面找到 8 类常见生活垃圾图片数据集，单击右侧 “下载”。

2. 选择对应的云服务区域例如：华北 - 北京四，需要确保您选择的区域与您的管理控制台所在的区域一致。

3. 进入 “下载详情” 页面，填写下述参数。

• 下载方式：ModelArts 数据集。
• 目标区域：华北 - 北京四。
• 数据类型：图片。
• 数据集输出位置：选择您的 OBS 路径的空目录
• 数据集输入位置：选择您的 OBS 路径
• 名称：自定义

4. 完成参数填写，单击 “确定”，自动跳转至 AI Gallery 个人中心 “我的下载” 页签，等待 5 分钟左右下载完成，进入 “目标位置” 可以在对象存储服务（OBS）中查看数据集储存位置。

三、配置委托访问授权

ModelArts 使用过程中涉及到 OBS、SWR、IEF 等服务交互，首次使用 ModelArts 需要用户配置委托授权，允许访问这些依赖服务。

这个之前已经配置过了，所以只需要将已有委托加入即可

四、创建新版自动学习图像分类项目

1. 进入 ModelArts 管理控制台，在左侧导航栏选择 “自动学习”

2. 进入新版自动学习页面后，单击选择 “图像分类” 创建项目。完成参数填写：

• 计费模式：按需计费。
• 名称：自定义您的项目名称。
• 描述：自定义描述您的项目详情。
• 数据集：单击下拉框选择从 AI Gallery 下载好的数据集（下拉框展示的数据集为您名下按照时间顺序创建的的所有数据集，此处选择您最近创建的数据集即为从 AI Gallery 下载好的数据集）。
• 输出路径：选择您的 OBS 文件夹下的路径。
• 训练规格：单击下拉框选择训练规格。

3. 参数填写完成，单击 “创建项目”，即可跳转到新版自动学习的运行总览页面。

五、运行工作流

项目完成创建之后，会自动跳转到新版自动学习的运行总览页面。同时您的工作流会自动从数据标注节点开始运行。

1. 在数据标注节点，待数据标注节点变为橘色即为 “等待操作” 状态。

2. 单击 “继续运行” 工作流会自动从数据标注节点依次运行到服务部署节点。该段时间不需要用户做任何操作。

3. 当工作流运行到 “服务部署” 节点，状态会变为 “等待输入”，您需要填写您的输入参数：

• AI 应用：默认为您的自动学习项目名称。
• 选择 AI 应用版本：系统默认，无需再选择。
• 资源池：默认选择 “公共资源池”，您也可以根据您的需求选择相应的专属资源池。
• 计算节点规格：根据您的实际需求选择相应的规格，不同规格的配置费用不同，本案例使用的规格为 [限时免费] CPU：1 核 4GB。
• 分流（100%）：默认为 100。
• 节点个数：默认为 1。
• 是否自动停止：为了避免资源浪费，建议您打开该开关，根据您的需求，选择自动停止时间。

4. 参数填写完毕之后，单击运行状况右边的 “继续运行”，单击确认弹窗中的 “确定” 即可继续完成工作流的运行。

六、预测分析

运行完成的工作流会自动部署相应的在线服务，您只需要在相应的服务详情页面进行预测即可。

1. 在服务部署节点单击 “实例详情” 或者在管理控制台，选择 “部署上线 > 在线服务” 即可进入在线服务详情页。

2. 在服务详情页，单击选择 “预测” 页签。

3. 上传一张需要预测的图片，单击预测，即可在右边的预测结果显示区查看您的预测结果。

七、清除相应资源

在完成预测之后，建议关闭服务，以免产生不必要的计费。

1. 停止运行服务

返回在线服务，在对应的服务名称，单击选择操作列的 “更多> 停止”，停止该服务

2. 清除 OBS 中的数据

1. 在控制台左侧导航栏的服务列表，选择 “对象存储服务 OBS”, 进入 OBS 服务详情页面。
2. 在左侧导航栏选择 “桶列表”，在列表详情，找到自己创建的 OBS 桶，进入 OBS 桶详情。
   
3. 在桶的详情页，左侧导航栏选择 “对象”，在右侧 “名称” 列选中不需要的存储对象，单击上方的 “删除” 或者在操作列单击 “更多”, 选择 “删除”，即可删除相应的存储对象。
   
   

使用自定义算法构建模型（手写数字识别）

一、前提条件

已注册华为帐号并开通华为云，且在使用 ModelArts 前检查帐号状态，帐号不能处于欠费或冻结状态。

二、准备训练数据

本案例使用的数据是 MNIST 数据集，您可以从 MNIST 官网下载数据集至本地，以下 4 个文件均要下载。（需要翻出去）

链接：https://pan.baidu.com/s/1jhfLx3PRU1c9zqZX74tJmQ?pwd=o261
提取码：o261

“train-images-idx3-ubyte.gz”：训练集的压缩包文件。训练集，共包含 60000 个样本。
“train-labels-idx1-ubyte.gz”：训练集标签的压缩包文件。训练集标签，共包含 60000 个样本的类别标签。
“t10k-images-idx3-ubyte.gz”：验证集的压缩包文件。验证集，共包含 10000 个样本。
“t10k-labels-idx1-ubyte.gz”：验证集标签的压缩包文件。验证集标签，共包含 10000 个样本的类别标签。

三、准备训练文件和推理文件

三个文件：train.py、customize_service.py、config.json

文件类型改为 UTF-8

train.py

# base on https://github.com/pytorch/examples/blob/main/mnist/main.py

from __future__ import print_function

import os
import gzip
import codecs
import argparse
from typing import IO, Union

import numpy as np

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms    
from torch.optim.lr_scheduler import StepLR

import shutil


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.eval()
    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()
            pred = output.argmax(dim=1, keepdim=True)
            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)))


# pytorch mnist
# https://github.com/pytorch/vision/blob/v0.9.0/torchvision/datasets/mnist.py
def get_int(b: bytes) -> int:
    return int(codecs.encode(b, 'hex'), 16)


def open_maybe_compressed_file(path: Union[str, IO]) -> Union[IO, gzip.GzipFile]:
    """Return a file object that possibly decompresses 'path' on the fly.
       Decompression occurs when argument `path` is a string and ends with '.gz' or '.xz'.
    """
    if not isinstance(path, torch._six.string_classes):
        return path
    if path.endswith('.gz'):
        return gzip.open(path, 'rb')
    if path.endswith('.xz'):
        return lzma.open(path, 'rb')
    return open(path, 'rb')


SN3_PASCALVINCENT_TYPEMAP = {
    8: (torch.uint8, np.uint8, np.uint8),
    9: (torch.int8, np.int8, np.int8),
    11: (torch.int16, np.dtype('>i2'), 'i2'),
    12: (torch.int32, np.dtype('>i4'), 'i4'),
    13: (torch.float32, np.dtype('>f4'), 'f4'),
    14: (torch.float64, np.dtype('>f8'), 'f8')
}


def read_sn3_pascalvincent_tensor(path: Union[str, IO], strict: bool = True) -> torch.Tensor:
    """Read a SN3 file in "Pascal Vincent" format (Lush file 'libidx/idx-io.lsh').
       Argument may be a filename, compressed filename, or file object.
    """
    # read
    with open_maybe_compressed_file(path) as f:
        data = f.read()
    # parse
    magic = get_int(data[0:4])
    nd = magic % 256
    ty = magic // 256
    assert 1 <= nd <= 3
    assert 8 <= ty <= 14
    m = SN3_PASCALVINCENT_TYPEMAP[ty]
    s = [get_int(data[4 * (i + 1): 4 * (i + 2)]) for i in range(nd)]
    parsed = np.frombuffer(data, dtype=m[1], offset=(4 * (nd + 1)))
    assert parsed.shape[0] == np.prod(s) or not strict
    return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)


def read_label_file(path: str) -> torch.Tensor:
    with open(path, 'rb') as f:
        x = read_sn3_pascalvincent_tensor(f, strict=False)
    assert(x.dtype == torch.uint8)
    assert(x.ndimension() == 1)
    return x.long()


def read_image_file(path: str) -> torch.Tensor:
    with open(path, 'rb') as f:
        x = read_sn3_pascalvincent_tensor(f, strict=False)
    assert(x.dtype == torch.uint8)
    assert(x.ndimension() == 3)
    return x


def extract_archive(from_path, to_path):
    to_path = os.path.join(to_path, os.path.splitext(os.path.basename(from_path))[0])
    with open(to_path, "wb") as out_f, gzip.GzipFile(from_path) as zip_f:
        out_f.write(zip_f.read())
# --- pytorch mnist
# --- end


# raw mnist 数据处理
def convert_raw_mnist_dataset_to_pytorch_mnist_dataset(data_url):
    """
    raw

    {data_url}/
        train-images-idx3-ubyte.gz
        train-labels-idx1-ubyte.gz
        t10k-images-idx3-ubyte.gz
        t10k-labels-idx1-ubyte.gz

    processed

    {data_url}/
        train-images-idx3-ubyte.gz
        train-labels-idx1-ubyte.gz
        t10k-images-idx3-ubyte.gz
        t10k-labels-idx1-ubyte.gz
        MNIST/raw
            train-images-idx3-ubyte
            train-labels-idx1-ubyte
            t10k-images-idx3-ubyte
            t10k-labels-idx1-ubyte
        MNIST/processed
            training.pt
            test.pt
    """
    resources = [
        "train-images-idx3-ubyte.gz",
        "train-labels-idx1-ubyte.gz",
        "t10k-images-idx3-ubyte.gz",
        "t10k-labels-idx1-ubyte.gz"
    ]

    pytorch_mnist_dataset = os.path.join(data_url, 'MNIST')

    raw_folder = os.path.join(pytorch_mnist_dataset, 'raw')
    processed_folder = os.path.join(pytorch_mnist_dataset, 'processed')

    os.makedirs(raw_folder, exist_ok=True)
    os.makedirs(processed_folder, exist_ok=True)

    print('Processing...')

    for f in resources:
        extract_archive(os.path.join(data_url, f), raw_folder)

    training_set = (
        read_image_file(os.path.join(raw_folder, 'train-images-idx3-ubyte')),
        read_label_file(os.path.join(raw_folder, 'train-labels-idx1-ubyte'))
    )
    test_set = (
        read_image_file(os.path.join(raw_folder, 't10k-images-idx3-ubyte')),
        read_label_file(os.path.join(raw_folder, 't10k-labels-idx1-ubyte'))
    )
    with open(os.path.join(processed_folder, 'training.pt'), 'wb') as f:
        torch.save(training_set, f)
    with open(os.path.join(processed_folder, 'test.pt'), 'wb') as f:
        torch.save(test_set, f)

    print('Done!')


def main():
    # 定义可以接收的训练作业运行参数
    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')

    parser.add_argument('--data_url', type=str, default=False,
                        help='mnist dataset path')
    parser.add_argument('--train_url', type=str, default=False,
                        help='mnist model path')

    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=14, metavar='N',
                        help='number of epochs to train (default: 14)')
    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()

    torch.manual_seed(args.seed)

    # 设置使用 GPU 还是 CPU 来运行算法
    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,))
        ])

    # 将 raw mnist 数据集转换为 pytorch mnist 数据集
    convert_raw_mnist_dataset_to_pytorch_mnist_dataset(args.data_url)

    # 分别创建训练和验证数据集
    dataset1 = datasets.MNIST(args.data_url, train=True, download=False,
                       transform=transform)
    dataset2 = datasets.MNIST(args.data_url, train=False, download=False,
                       transform=transform)

    # 分别构建训练和验证数据迭代器
    train_loader = torch.utils.data.DataLoader(dataset1, **train_kwargs)
    test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)

    # 初始化神经网络模型并拷贝模型到计算设备上
    model = Net().to(device)
    # 定义训练优化器和学习率策略，用于梯度下降计算
    optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
    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()

    # 保存模型与适配 ModelArts 推理模型包规范
    if args.save_model:

        # 在 train_url 训练参数对应的路径内创建 model 目录
        model_path = os.path.join(args.train_url, 'model')
        os.makedirs(model_path, exist_ok = True)

        # 按 ModelArts 推理模型包规范，保存模型到 model 目录内
        torch.save(model.state_dict(), os.path.join(model_path, 'mnist_cnn.pt'))

        # 拷贝推理代码与配置文件到 model 目录内
        the_path_of_current_file = os.path.dirname(__file__)
        shutil.copyfile(os.path.join(the_path_of_current_file, 'infer/customize_service.py'), os.path.join(model_path, 'customize_service.py'))
        shutil.copyfile(os.path.join(the_path_of_current_file, 'infer/config.json'), os.path.join(model_path, 'config.json'))

if __name__ == '__main__':
    main()

customize_service.py

import os
import log
import json

import torch.nn.functional as F
import torch.nn as nn
import torch
import torchvision.transforms as transforms

import numpy as np
from PIL import Image

from model_service.pytorch_model_service import PTServingBaseService

logger = log.getLogger(__name__)

# 定义模型预处理
infer_transformation = transforms.Compose([
    transforms.Resize(28),
    transforms.CenterCrop(28),
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])


class PTVisionService(PTServingBaseService):

    def __init__(self, model_name, model_path):
        # 调用父类构造方法
        super(PTVisionService, self).__init__(model_name, model_path)

        # 调用自定义函数加载模型
        self.model = Mnist(model_path)

        # 加载标签
        self.label = [0,1,2,3,4,5,6,7,8,9]

    def _preprocess(self, data):
        preprocessed_data = {}
        for k, v in data.items():
            input_batch = []
            for file_name, file_content in v.items():
                with Image.open(file_content) as image1:
                    # 灰度处理
                    image1 = image1.convert("L")
                    if torch.cuda.is_available():
                        input_batch.append(infer_transformation(image1).cuda())
                    else:
                        input_batch.append(infer_transformation(image1))
            input_batch_var = torch.autograd.Variable(torch.stack(input_batch, dim=0), volatile=True)
            print(input_batch_var.shape)
            preprocessed_data[k] = input_batch_var

        return preprocessed_data

    def _postprocess(self, data):
        results = []
        for k, v in data.items():
            result = torch.argmax(v[0])
            result = {k: self.label[result]}
            results.append(result)
        return results

    def _inference(self, data):

        result = {}
        for k, v in data.items():
            result[k] = self.model(v)

        return result


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 Mnist(model_path, **kwargs):
    # 生成网络
    model = Net()

    # 加载模型
    if torch.cuda.is_available():
        device = torch.device('cuda')
        model.load_state_dict(torch.load(model_path, map_location="cuda:0"))
    else:
        device = torch.device('cpu')
        model.load_state_dict(torch.load(model_path, map_location=device))

    # CPU 或者 GPU 映射
    model.to(device)

    # 声明为推理模式
    model.eval()

    return model

config.json

{
    "model_algorithm": "image_classification",
    "model_type": "PyTorch",
    "runtime": "pytorch_1.8.0-cuda_10.2-py_3.7-ubuntu_18.04-x86_64"
}

四、创建 OBS 桶并上传文件

将训练使用的数据和代码文件、推理代码文件与推理配置文件，上传到 OBS 桶中。在 ModelArts 上运行训练作业时，需要从 OBS 桶中读取数据和代码文件。

1. 登录 OBS 管理控制台，按照如下示例创建 OBS 桶和文件夹。

{OBS桶}                     # OBS对象桶，用户可以自定义名称，例如：test-modelarts-xx
      -{OBS文件夹}          # OBS文件夹，自定义名称，此处举例为pytorch
          - mnist-data      # OBS文件夹，用于存放训练数据集，可以自定义名称，此处举例为mnist-data
          - mnist-code      # OBS文件夹，用于存放训练脚本train.py，可以自定义名称，此处举例为mnist-code
              - infer       # OBS文件夹，用于存放推理脚本customize_service.py和配置文件config.json
          - mnist-output    # OBS文件夹，用于存放训练输出模型，可以自定义名称，此处举例为mnist-output

2. 上传数据集到 “mnist-data” 文件夹中

3. 上传训练脚本 “train.py” 到 “mnist-code” 文件夹中。

4. 上传推理脚本 “customize_service.py” 和推理配置文件 “config.json” 到 “infer” 文件中。

五、创建训练作业

1. 登录 ModelArts 管理控制台，选择和 OBS 桶相同的区域。

2. 在 “全局配置” 中检查当前帐号是否已完成访问授权的配置。如未完成，请参考使用委托授权 **。** 针对之前使用访问密钥授权的用户，建议清空授权，然后使用委托进行授权。

3. 在左侧导航栏的 “训练管理”-> “训练作业” 中，单击 “创建训练作业”。填写创建训练作业相关信息。

• 创建方式：选择 “自定义算法”。
• 启动方式：选择 “预置框架”，下拉框中选择 PyTorch，pytorch_1.8.0-cuda_10.2-py_3.7-ubuntu_18.04-x86_64。
• 代码目录：选择已创建的代码目录路径 “/test-modelarts-xx/pytorch/mnist-code/”。
• 启动文件：选择代码目录下上传的训练脚本 “train.py”。
• 输入：单击 “添加”，设置训练输入的 **“参数名称”** 为 “data_url”。设置数据存储位置为 “/test-modelarts-xx/pytorch/mnist-data/”。
• 输出：单击 “添加”，设置训练输出的 **“参数名称”** 为 “train_url”。设置数据存储位置为 “/test-modelarts-xx/pytorch/mnist-output/”
• 资源类型：选择 GPU 单卡的规格，如 “GPU: 1*NVIDIA-V100 (16GB) | CPU: 8 核 64GB 780GB”。

4. 单击 “提交”，确认训练作业的参数信息，确认无误后单击 “确定”

5. 页面自动返回 “训练作业” 列表页，当训练作业状态变为 “已完成” 时，即完成了模型训练过程

6. 单击训练作业名称，进入作业详情界面查看训练作业日志信息，观察日志是否有明显的 Error 信息，如果有则表示训练失败，请根据日志提示定位原因并解决。

7. 在训练详情页左下方单击训练输出路径，跳转到 OBS 目录，查看是否存在 model 文件夹，且 model 文件夹中是否有生成训练模型。如果未生成 model 文件夹或者训练模型，可能是训练输入数据不完整导致，请检查训练数据上传是否完整，并重新训练。

六、推理部署

模型训练完成后，可以创建 AI 应用，将 AI 应用部署为在线服务。

1. 在 ModelArts 管理控制台，单击左侧导航栏中的 “AI 应用管理> AI 应用”，进入 “我的 AI 应用” 页面，单击 “创建”。

2. 在 “创建 AI 应用” 页面，填写相关参数，然后单击 “立即创建”。

在 AI 应用列表页面，当 AI 应用状态变为 “正常” 时，表示 AI 应用创建成功。

3. 单击 AI 应用名称左侧的小三角，打开此 AI 应用下的所有版本。在对应版本所在行，单击操作列 “部署> 在线服务”，将 AI 应用部署为在线服务。

4. 在 “部署” 页面，参考下图填写参数，然后根据界面提示完成在线服务创建。本案例适用于 CPU 规格，节点规格需选择 CPU

5. 完成服务部署后，返回在线服务页面列表页，等待服务部署完成，当服务状态显示为 “运行中”，表示服务已部署成功。

七、预测结果

1. 在 “在线服务” 页面，单击在线服务名称，进入服务详情页面。

2. 单击 “预测” 页签，请求类型选择 “multipart/form-data”，请求参数填写 “image”，单击 “上传” 按钮上传示例图片，然后单击 “预测”。

八、清除资源

如果不再需要使用此模型及在线服务，建议清除相关资源，避免产生不必要的费用。

在 “在线服务” 页面，“停止” 或 “删除” 刚创建的在线服务。

在 “AI 应用管理” 页面，“删除” 刚创建的 AI 应用。

在 “训练作业” 页面，“删除” 运行结束的训练作业。

进入 OBS，删除本示例使用的 OBS 桶及文件夹，以及文件夹的文件。