一个AI应用的开发、上线流程解析

終不似少年遊*

于 2025-02-12 21:01:11 发布

阅读量1k

点赞数 36

文章标签：人工智能 ai应用 ckpt onnx 模型文件部署推理

本文链接：https://blog.youkuaiyun.com/yuange1666/article/details/145599577

版权

1. 模型文件格式

1.1 CheckPoint (ckpt) 文件格式

2.1.pth (PyTorch模型格式)

2.2 .mindir (MindSpore模型格式)

2.3.onnx (开放神经网络交换格式)

2.4实际例子：自动驾驶系统中的推理模块

3. APP与网页

4. 运维中心与本地部署SDK

5. RAG（Retrieval-Augmented Generation）

6. 模型支持与硬件适配

7. 模型转换与迁移

1. 模型文件格式

ckpt：通常指TensorFlow模型的检查点文件，用于保存模型的权重和优化器状态。
.pth：PyTorch模型的文件格式，用于保存模型的参数。
.mindir：MindSpore框架的模型文件格式，支持高效的模型推理。
.onnx：开放神经网络交换格式，支持不同框架之间的模型转换。
实际例子：在医疗影像诊断中，模型可能以多种格式保存，以便在不同的硬件和框架上进行部署。例如，使用ONNX格式可以在NVIDIA GPU和国产硬件之间无缝迁移。

1.1 CheckPoint (ckpt) 文件格式

特点：ckpt文件格式通常用于保存TensorFlow模型的权重和优化器状态。它能够记录模型训练过程中的参数和优化器的状态，方便训练的中断和恢复。
应用场景：在训练大型深度学习模型时，如图像识别、自然语言处理等，ckpt文件可以用于保存训练过程中的中间结果，防止训练过程中断导致的损失。例如，在训练一个复杂的医疗影像诊断模型时，ckpt文件可以保存模型的权重和优化器状态，方便后续继续训练或进行模型评估。
实际例子：在医疗影像诊断中，使用TensorFlow训练的模型可以保存为ckpt文件，以便在不同的硬件和框架上进行部署。例如，在NVIDIA GPU上训练的模型可以保存为ckpt文件，然后在国产硬件上进行推理。

1.2 .pth 文件格式

特点：.pth是PyTorch模型的文件格式，用于保存模型的参数。它能够保存模型的权重和参数，方便模型的加载和推理。
应用场景：在使用PyTorch框架进行深度学习模型开发时，.pth文件格式常用于保存训练好的模型参数。例如，在自然语言处理任务中，训练好的情感分析模型可以保存为.pth文件，方便在不同的设备上进行推理。
实际例子：在医疗影像诊断中，使用PyTorch训练的模型可以保存为.pth文件，然后在不同的硬件平台上进行部署。例如，在国产硬件上进行推理时，可以加载.pth文件进行模型推理。

1.3 .mindir 文件格式

特点：.mindir是MindSpore框架的模型文件格式，支持高效的模型推理。它能够保存模型的结构和参数，方便在MindSpore框架下进行模型的加载和推理。
应用场景：在使用MindSpore框架进行深度学习模型开发时，.mindir文件格式常用于保存训练好的模型。例如，在图像分类任务中，训练好的ResNet模型可以保存为.mindir文件，方便在MindSpore框架下进行高效的模型推理。
实际例子：在医疗影像诊断中，使用MindSpore训练的模型可以保存为.mindir文件，然后在昇腾AI处理器上进行高效的模型推理。

1.4 .onnx 文件格式

特点：.onnx是开放神经网络交换格式，支持不同框架之间的模型转换。它能够保存模型的结构和参数，方便在不同的框架和硬件上进行模型的加载和推理。
应用场景：在需要将模型从一个框架转换到另一个框架进行推理时，.onnx文件格式非常有用。例如，在使用TensorFlow训练的模型需要在PyTorch框架下进行推理时，可以将模型转换为.onnx文件，然后在PyTorch中加载.onnx文件进行推理。
实际例子：在医疗影像诊断中，使用ONNX格式可以在NVIDIA GPU和国产硬件之间无缝迁移。例如，训练好的模型可以保存为.onnx文件，然后在NVIDIA GPU上进行高效的模型推理，也可以在国产硬件上进行推理。

2. 推理（Inference）

推理模块负责将模型应用于实际数据，生成预测结果。
支持多种模型格式（如.pth、.mindir、.onnx），确保兼容性和灵活性。
实际例子：在自动驾驶系统中，推理模块会实时处理摄像头和传感器数据，生成驾驶决策。

推理模块是AI系统中的关键组件，负责将训练好的模型应用于实际数据，生成预测结果。为了确保系统的兼容性和灵活性，推理模块通常需要支持多种模型格式，如.pth、.mindir、.onnx等。

2.1.pth (PyTorch模型格式)

import torch
from torchvision import models

# 加载预训练的ResNet50模型
model = models.resnet50(pretrained=True)
model.eval() # 设置模型为评估模式

# 加载.pth文件
model.load_state_dict(torch.load('model.pth'))

# 准备输入数据
input_data = torch.randn(1, 3, 224, 224)

# 进行推理
with torch.no_grad():
output = model(input_data)
print(output)

2.2 .mindir (MindSpore模型格式)

import mindspore
from mindspore import context, Tensor
from mindspore.train import inference

# 设置上下文
context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")

# 加载.mindir文件
network = mindspore.load('model.mindir')

# 准备输入数据
input_data = Tensor(np.random.randn(1, 3, 224, 224).astype(np.float32))

# 进行推理
output = network(input_data)
print(output)

2.3.onnx (开放神经网络交换格式)

import onnx
import onnxruntime as ort

# 加载.onnx文件
session = ort.InferenceSession('model.onnx')

# 准备输入数据
input_data = np.random.randn(1, 3, 224, 224).astype(np.float32)

# 进行推理
inputs = {session.get_inputs()[0].name: input_data}
outputs = session.run(None, inputs)
print(outputs)

2.4实际例子：自动驾驶系统中的推理模块

在自动驾驶系统中，推理模块负责实时处理摄像头和传感器数据，生成驾驶决策。以下进行非常简化的示例：

导出模型为ONNX格式：

import torch
import torchvision.models as models

# 加载预训练的ResNet-18模型
model = models.resnet18(pretrained=True).eval()

# 创建一个随机输入张量
dummy_input = torch.randn(1, 3, 224, 224)

# 导出模型为ONNX格式
torch.onnx.export(model, dummy_input, "resnet18.onnx", verbose=True)

使用TensorRT将ONNX模型转换为TensorRT引擎：

import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np

TRT_LOGGER = trt.Logger(trt.Logger.WARNING)

def build_engine(onnx_file_path, shape=(1, 3, 224, 224)):
with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.OnnxParser(network, TRT_LOGGER) as parser:
config = builder.create_builder_config()
config.max_workspace_size = 1 << 30 # 设置最大工作空间大小为1GB
builder.max_batch_size = 1 # 设置最大批处理大小为1

# 读取ONNX模型文件
with open(onnx_file_path, 'rb') as model:
if not parser.parse(model.read()):
print('Failed parsing ONNX file.')
for error in range(parser.num_errors):
print(parser.get_error(error))
return None

network.get_input(0).shape = shape # 设置输入形状
engine = builder.build_engine(network, config) # 构建TensorRT引擎
return engine

engine = build_engine("resnet18.onnx")

分配内存缓冲区：

def allocate_buffers(engine):
inputs = []
outputs = []
bindings = []
stream = cuda.Stream() # 创建CUDA流

for binding in engine:
size = trt.volume(engine.get_binding_shape(binding)) * engine.max_batch_size
dtype = trt.nptype(engine.get_binding_dtype(binding))
host_mem = cuda.pagelocked_empty(size, dtype)
dev_mem = cuda.mem_alloc(host_mem.nbytes)
bindings.append(int(dev_mem))

if engine.binding_is_input(binding):
inputs.append((host_mem, dev_mem))
else:
outputs.append((host_mem, dev_mem))

return inputs, outputs, bindings, stream

inputs, outputs, bindings, stream = allocate_buffers(engine)

创建执行上下文并进行推理：

context = engine.create_execution_context()

def infer(context, bindings, inputs, outputs, stream):
[cuda.memcpy_htod_async(inp[1], inp[0], stream) for inp in inputs]
context.execute_async(bindings=bindings, stream_handle=stream.handle)
[cuda.memcpy_dtoh_async(out[0], out[1], stream) for out in outputs]
stream.synchronize()
return [out[0] for out in outputs]

# 准备输入数据
input_data = np.random.random_sample((1, 3, 224, 224)).astype(np.float32)
np.copyto(inputs[0][0], input_data.ravel())

# 进行推理
trt_outputs = infer(context, bindings, inputs, outputs, stream)
print(trt_outputs)