基于华为云ModelArts与OBS快速搭建图像分类模型训练及部署全流程
基于华为云 ModelArts 与 OBS 快速搭建图像分类模型训练及部署全流程
本文面向需要快速验证图像分类能力的开发者,完整演示从 OBS 数据准备、ModelArts 训练作业、模型注册到在线服务部署的端到端流程。文中给出可直接运行的关键脚本,包括训练循环、验证、模型保存与类别映射保存,便于按步骤复现。
一、方案概述
- 对象存储 OBS:存放原始图片数据集、训练输出与模型产物。
- ModelArts 训练作业:使用自定义脚本拉起训练容器,读取 OBS 挂载的数据目录,完成训练并输出模型。
- ModelArts 模型管理:将训练产出的模型注册为“模型”,并完成版本管理。
- 在线服务部署:基于注册模型创建在线服务,提供实时推理接口。
整体数据流:本地图片 → OBS 数据集桶 → ModelArts 训练作业(读取/训练/输出)→ OBS 模型目录 → 模型注册 → 在线服务 → 调用验证。
二、准备工作
2.1 华为云资源与权限
1. 已开通 OBS 与 ModelArts 服务。
2. 已创建 IAM 用户或使用主账号,具备 OBS Administrator(或指定桶读写权限)与 ModelArts FullAccess 权限。
3. 在 ModelArts 控制台完成全局配置中的 OBS 委托授权(首次使用训练作业通常需要)。
2.2 安装华为云 CLI(可选,用于脚本化创建桶与上传)
如希望通过命令行操作 OBS,请使用华为云官方工具,而非第三方 S3 SDK:
# 安装华为云 CLI(以 Linux x86_64 为例,版本号请以官网最新为准)
curl -LO https://cn-north-4-huaweicloud-cli.obs.cn-north-4.myhuaweicloud.com/hcloud_install.sh
bash hcloud_install.sh
# 配置访问密钥(AK/SK)
hcloud configure set --cli-access-key=<你的AK> --cli-secret-key=<你的SK> --cli-region=cn-north-4
如使用 Python 脚本操作 OBS,请安装华为云官方 SDK(esdk-obs-python),而非 boto3:
pip install esdk-obs-python --trusted-host pypi.org
> 说明:boto3 面向 AWS S3 接口,华为云 OBS 推荐使用 obsutil、esdk-obs-python 或华为云 CLI。本文示例以华为云 CLI 与 SDK 为主。
2.3 创建 OBS 桶与目录结构
在 cn-north-4 区域创建桶(示例名 my-image-cls-demo),并按如下结构组织:
my-image-cls-demo/
├── dataset/
│ ├── train/
│ │ ├── cat/
│ │ │ ├── 0001.jpg
│ │ │ └── ...
│ │ └── dog/
│ │ ├── 0001.jpg
│ │ └── ...
│ └── val/
│ ├── cat/
│ └── dog/
├── code/ # 训练脚本目录(可选,也可使用本地代码目录)
│ └── train.py
└── output/ # 训练输出(作业自动写入)
创建桶与上传示例:
hcloud obs mb obs://my-image-cls-demo
hcloud obs cp -r ./dataset obs://my-image-cls-demo/dataset/ -f
三、步骤一:准备训练脚本
训练脚本需满足 ModelArts 自定义脚本的约定:通过环境变量或命令行参数获取数据与输出路径。ModelArts 训练作业会将 OBS 路径挂载为容器内路径,常用环境变量包括 DLS_TRAIN_URL(数据输入路径)、DLS_TRAIN_OUTPUT_PATH(输出路径)等(以控制台实际配置为准)。为便于本地调试,脚本同时支持命令行参数覆盖。
创建 train.py:
# -*- coding: utf-8 -*-
"""
图像分类训练脚本(PyTorch)
支持 ModelArts 训练作业环境变量与本地命令行参数两种方式。
"""
import os
import argparse
import json
import random
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms, models
def parse_args():
parser = argparse.ArgumentParser(description="Image classification training")
# 优先使用命令行参数;ModelArts 场景下由启动参数或环境变量注入
parser.add_argument("--data-dir", type=str,
default=os.getenv("DLS_TRAIN_URL", "/opt/data"),
help="训练数据根目录,包含 train/ 与 val/ 子目录")
parser.add_argument("--output-dir", type=str,
default=os.getenv("DLS_TRAIN_OUTPUT_PATH", "/opt/output"),
help="模型与日志输出目录")
parser.add_argument("--epochs", type=int, default=5)
parser.add_argument("--batch-size", type=int, default=32)
parser.add_argument("--lr", type=float, default=1e-3)
parser.add_argument("--num-workers", type=int, default=4)
parser.add_argument("--seed", type=int, default=42)
return parser.parse_args()
def build_loaders(data_dir, batch_size, num_workers):
train_tf = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
val_tf = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
train_dir = os.path.join(data_dir, "train")
val_dir = os.path.join(data_dir, "val")
train_set = datasets.ImageFolder(train_dir, transform=train_tf)
val_set = datasets.ImageFolder(val_dir, transform=val_tf)
train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True,
num_workers=num_workers, pin_memory=True)
val_loader = DataLoader(val_set, batch_size=batch_size, shuffle=False,
num_workers=num_workers, pin_memory=True)
return train_set, val_set, train_loader, val_loader
def train_one_epoch(model, loader, criterion, optimizer, device):
model.train()
running_loss, correct, total = 0.0, 0, 0
for images, labels in loader:
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item() * images.size(0)
_, preds = torch.max(outputs, 1)
correct += (preds == labels).sum().item()
total += labels.size(0)
return running_loss / total, correct / total
@torch.no_grad()
def evaluate(model, loader, criterion, device):
model.eval()
running_loss, correct, total = 0.0, 0, 0
for images, labels in loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
loss = criterion(outputs, labels)
running_loss += loss.item() * images.size(0)
_, preds = torch.max(outputs, 1)
correct += (preds == labels).sum().item()
total += labels.size(0)
return running_loss / total, correct / total
def main():
args = parse_args()
random.seed(args.seed)
torch.manual_seed(args.seed)
os.makedirs(args.output_dir, exist_ok=True)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"[INFO] device = {device}")
print(f"[INFO] data_dir = {args.data_dir}")
print(f"[INFO] output_dir = {args.output_dir}")
train_set, val_set, train_loader, val_loader = build_loaders(
args.data_dir, args.batch_size, args.num_workers
)
num_classes = len(train_set.classes)
print(f"[INFO] classes = {train_set.classes}")
# 使用预训练 ResNet18,替换分类头以适配当前类别数
model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
model.fc = nn.Linear(model.fc.in_features, num_classes)
model = model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=args.lr)
best_acc = 0.0
best_path = os.path.join(args.output_dir, "best_model.pth")
history = []
for epoch in range(1, args.epochs + 1):
train_loss, train_acc = train_one_epoch(model, train_loader, criterion, optimizer, device)
val_loss, val_acc = evaluate(model, val_loader, criterion, device)
print(f"[EPOCH {epoch}/{args.epochs}] "
f"train_loss={train_loss:.4f} train_acc={train_acc:.4f} "
f"val_loss={val_loss:.4f} val_acc={val_acc:.4f}")
history.append({
"epoch": epoch,
"train_loss": train_loss,
"train_acc": train_acc,
"val_loss": val_loss,
"val_acc": val_acc,
})
if val_acc > best_acc:
best_acc = val_acc
torch.save(model.state_dict(), best_path)
print(f"[INFO] best model saved to {best_path} (val_acc={val_acc:.4f})")
# 保存类别映射,供推理服务还原标签
class_map = {str(idx): name for idx, name in enumerate(train_set.classes)}
class_map_path = os.path.join(args.output_dir, "class_indices.json")
with open(class_map_path, "w", encoding="utf-8") as f:
json.dump(class_map, f, ensure_ascii=False, indent=2)
print(f"[INFO] class map saved to {class_map_path}")
# 保存训练历史与最终指标
metrics = {
"num_classes": num_classes,
"best_val_acc": best_acc,
"history": history,
}
with open(os.path.join(args.output_dir, "metrics.json"), "w", encoding="utf-8") as f:
json.dump(metrics, f, ensure_ascii=False, indent=2)
# 保存最终权重(便于排查)
final_path = os.path.join(args.output_dir, "final_model.pth")
torch.save(model.state_dict(), final_path)
print(f"[INFO] training finished. best_val_acc={best_acc:.4f}")
if __name__ == "__main__":
main()
> 若在 ModelArts 上运行,请确认训练镜像内已安装 torch、torchvision。可使用 ModelArts 预置的 PyTorch 镜像,或自行构建镜像并在作业中指定。
四、步骤二:在 ModelArts 创建训练作业
4.1 创建训练作业
1. 进入 ModelArts 控制台 → 模型训练 → 训练作业 → 创建训练作业。
2. 基本信息:选择“自定义”算法,作业名称如 img-cls-train-demo。
3. 代码目录:选择存放 train.py 的 OBS 路径(例如 obs://my-image-cls-demo/code/),并上传 train.py 到该目录。
- 如代码目录上传不便,也可在“训练输入”中挂载代码目录后使用启动命令
python ${code_dir}/train.py。
4. 训练输入:添加数据输入,选择 obs://my-image-cls-demo/dataset/,挂载路径设为 /opt/data(与脚本 --data-dir 默认值一致)。
5. 训练输出:选择 obs://my-image-cls-demo/output/,挂载路径设为 /opt/output(与脚本 --output-dir 默认值一致)。
6. 运行参数:如使用自定义镜像或预置镜像,可在启动命令中追加参数,例如:
```bash
python train.py --epochs 5 --batch-size 32 --lr 0.001
```
若环境变量 DLS_TRAIN_URL、DLS_TRAIN_OUTPUT_PATH 已由平台注入,脚本默认值即可生效。
7. 规格与节点:选择单卡 GPU(如 1 * T4 或 1 * V100),节点数 1。
8. 镜像:选择预置 PyTorch 镜像(版本需包含 torchvision)。
9. 提交作业并等待运行完成。
4.2 校验训练输出
训练完成后,在 OBS 的 obs://my-image-cls-demo/output/ 下应看到:
best_model.pthfinal_model.pthclass_indices.jsonmetrics.json
可在 ModelArts 训练作业详情页查看训练日志中的 [EPOCH ...] 输出与最终 best_val_acc。
五、步骤三:注册模型
5.1 准备推理脚本(推理入口)
ModelArts 模型注册与在线服务需要推理入口脚本。以 PyTorch 为例,创建 customize_service.py(与模型文件同目录或通过“模型配置文件”指定),实现 initialize 与 inference:
# -*- coding: utf-8 -*-
import json
import os
import io
import torch
import torch.nn as nn
from torchvision import transforms, models
from PIL import Image
from modelarts.service import ModelService # ModelArts 推理框架基类
class ImageClassifier(ModelService):
def __init__(self, model_name, model_path):
super().__init__(model_name, model_path)
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.model = None
self.class_map = None
self.transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
def initialize(self, context):
# ModelArts 会将模型目录内文件放到 self.model_path 下
model_file = os.path.join(self.model_path, "best_model.pth")
class_file = os.path.join(self.model_path, "class_indices.json")
with open(class_file, "r", encoding="utf-8") as f:
self.class_map = json.load(f)
num_classes = len(self.class_map)
net = models.resnet18(weights=None)
net.fc = nn.Linear(net.fc.in_features, num_classes)
net.load_state_dict(torch.load(model_file, map_location=self.device))
net = net.to(self.device)
net.eval()
self.model = net
def preprocess(self, data):
# data 为原始请求体(bytes),按图片解码
if isinstance(data, (bytes, bytearray)):
images = [Image.open(io.BytesIO(data)).convert("RGB")]
else:
images = []
for item in data:
if hasattr(item, "read"):
images.append(Image.open(item).convert("RGB"))
else:
images.append(Image.open(io.BytesIO(item)).convert("RGB"))
return torch.stack([self.transform(img) for img in images])
@torch.no_grad()
def inference(self, inputs):
inputs = inputs.to(self.device)
logits = self.model(inputs)
probs = torch.softmax(logits, dim=1)
results = []
for p in probs:
idx = int(torch.argmax(p).item())
results.append({
"label": self.class_map[str(idx)],
"score": float(p[idx].item()),
})
return results
def postprocess(self, data):
return json.dumps(data, ensure_ascii=False)
> 上述 ModelService 接口基于 ModelArts 自定义推理框架;不同框架版本接口可能略有差异,请以控制台“模型配置文件”向导中的模板为准。若使用 modelarts-inference 模板,可将上述逻辑调整为对应的 _preprocess、_inference、_postprocess 方法名。
5.2 注册模型
1. 进入 ModelArts 控制台 → 模型管理 → 模型 → 导入。
2. 元模型:选择“从训练作业导入”或“从 OBS 导入”。选择“从 OBS 导入”,模型来源路径填 obs://my-image-cls-demo/output/。
3. 推理框架:选择 PyTorch(与训练镜像一致),并上传/指定 customize_service.py 作为推理入口(可在“模型配置文件”中指定)。
4. 运行用户:按镜像要求选择(例如 1000)。
5.
x
- 点赞
- 收藏
- 关注作者
评论(0)