免费体验:一键完成商超商品识别模型部署
一、工作准备
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.在“预测”页签,单击“上传”,上传一个测试图片,单击“预测”查看预测结果。此处提供一个样例图片供预测使用。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wwziUuh1-1688053129069)(…/zh-cn_image_0000001449294477.jpg)]
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。
- 是否自动停止:为了避免资源浪费,建议您打开该开关,根据您的需求,选择自动停止时间。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f2q27d3q-1688053129075)(https://s2.loli.net/2023/06/29/D62UOMWctQoLymK.png)]
4.参数填写完毕之后,单击运行状况右边的“继续运行”,单击确认弹窗中的“确定”即可继续完成工作流的运行。
六、预测分析
运行完成的工作流会自动部署相应的在线服务,您只需要在相应的服务详情页面进行预测即可。
1.在服务部署节点单击“实例详情”或者在管理控制台,选择“部署上线>在线服务”即可进入在线服务详情页。
2.在服务详情页,单击选择“预测”页签。
3.上传一张需要预测的图片,单击预测,即可在右边的预测结果显示区查看您的预测结果。
七、清除相应资源
在完成预测之后,建议关闭服务,以免产生不必要的计费。
1.停止运行服务
返回在线服务,在对应的服务名称,单击选择操作列的“更多>停止”,停止该服务
2.清除OBS中的数据
- 在控制台左侧导航栏的服务列表
,选择“对象存储服务OBS”,进入OBS服务详情页面。
- 在左侧导航栏选择“桶列表”,在列表详情,找到自己创建的OBS桶,进入OBS桶详情。
- 在桶的详情页,左侧导航栏选择“对象”,在右侧“名称”列选中不需要的存储对象,单击上方的“删除”或者在操作列单击“更多”,选择“删除”,即可删除相应的存储对象。
使用自定义算法构建模型(手写数字识别)
一、前提条件
已注册华为帐号并开通华为云,且在使用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 桶及文件夹,以及文件夹的文件。
”页面,单击“创建”。