需调整经销商报错提示

USE [SOI_ADD]
GO
/****** Object:  StoredProcedure [dbo].[SP_BI_WSDealerPriceImport]    Script Date: 2025/12/18 11:14:18 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROC [dbo].[SP_BI_WSDealerPriceImport]
(
    @userid int,
    @TempTable NVARCHAR(100)
)
AS
BEGIN
    SET NOCOUNT ON;

    DECLARE @rows INT, @temp NVARCHAR(4000), @rows1 INT;
    DECLARE @t TABLE (x INT PRIMARY KEY, y NVARCHAR(1000) COLLATE Chinese_PRC_CI_AS);
    DECLARE @totalnum INT;
    DECLARE @count INT;

    CREATE TABLE #DataTemp
    (
        [PKID] int IDENTITY(1,1) NOT NULL,
        [省份] nvarchar(255) COLLATE Chinese_PRC_CI_AS NULL,
        [产品编码] nvarchar(255) COLLATE Chinese_PRC_CI_AS NULL,
        [产品名称] nvarchar(255) COLLATE Chinese_PRC_CI_AS NULL,
        [单价]  nvarchar(255) COLLATE Chinese_PRC_CI_AS NULL,
        [生效日期]  nvarchar(255) COLLATE Chinese_PRC_CI_AS NULL,
        [截止日期] nvarchar(255) COLLATE Chinese_PRC_CI_AS NULL,
        [FK_Province] int,
        [FK_Product] int
    );

    DECLARE @sql nvarchar(4000);
    SET @sql = 'insert #DataTemp select ltrim(rtrim([省份])),ltrim(rtrim([产品编码])),ltrim(rtrim([产品名称])),[单价],[生效日期],[截止日期],0,0 from ' + @TempTable;
    EXEC(@sql);

    SET @temp = '';

    -- 基本校验
    SELECT @rows = COUNT(*) FROM #DataTemp;
    IF (@rows = 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'临时表中没有数据,请确认Excel文档格式正确!');
        SELECT x,y FROM @t;
        RETURN;
    END

    SELECT @rows = COUNT(*) FROM #DataTemp WHERE [省份] IS NULL OR [省份] = '';
    IF (@rows > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'省份不能为空');
        SELECT x,y FROM @t;
        RETURN;
    END

    SELECT @rows = COUNT(*) FROM #DataTemp WHERE [产品编码] IS NULL OR [产品编码] = '';
    IF (@rows > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'产品编码不能为空');
        SELECT x,y FROM @t;
        RETURN;
    END

    SELECT @rows = COUNT(*) FROM #DataTemp WHERE [单价] IS NULL OR [单价] = '';
    IF (@rows > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'单价不能为空');
        SELECT x,y FROM @t;
        RETURN;
    END

    SELECT @rows = COUNT(*) FROM #DataTemp WHERE [生效日期] IS NULL OR [生效日期] = '';
    IF (@rows > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'生效日期不能为空');
        SELECT x,y FROM @t;
        RETURN;
    END

    SELECT @rows = COUNT(*) FROM #DataTemp WHERE [截止日期] IS NULL OR [截止日期] = '';
    IF (@rows > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'截止日期不能为空');
        SELECT x,y FROM @t;
        RETURN;
    END

    -- 产品映射
    UPDATE #DataTemp SET FK_Product = (
        SELECT TOP 1 PKID FROM UT_Product WHERE JDECode = #DataTemp.[产品编码] AND IsValid = 1 AND FK_Origin = 3
    );

    DECLARE @problemProductNum INT;
    SELECT @problemProductNum = COUNT(*) FROM #DataTemp WHERE FK_Product IS NULL OR FK_Product = 0;
    IF (@problemProductNum > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'产品在系统中不存在');
        SELECT x,y FROM @t;
        RETURN;
    END

    -- 单价 numeric 校验（保留原有 ISNUMERIC 校验）
    DECLARE @problemPriceNum INT;
    SELECT @problemPriceNum = COUNT(*) FROM #DataTemp WHERE ISNUMERIC([单价]) = 0;
    IF (@problemPriceNum > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'单价必须为数字');
        SELECT x,y FROM @t;
        RETURN;
    END

    -- 日期格式校验 (使用 IsDate)
    DECLARE @problemStartNum INT;
    SELECT @problemStartNum = COUNT(*) FROM #DataTemp WHERE IsDate([生效日期]) = 0;
    IF (@problemStartNum > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'生效日期不正确');
        SELECT x,y FROM @t;
        RETURN;
    END

    DECLARE @problemEndNum INT;
    SELECT @problemEndNum = COUNT(*) FROM #DataTemp WHERE IsDate([截止日期]) = 0;
    IF (@problemEndNum > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'截止日期不正确');
        SELECT x,y FROM @t;
        RETURN;
    END

    DECLARE @problemEffectNum INT;
    SELECT @problemEffectNum = COUNT(*) FROM #DataTemp WHERE CAST([截止日期] AS date) <= CAST([生效日期] AS date);
    IF (@problemEffectNum > 0)
    BEGIN
        INSERT INTO @t VALUES (1, N'生效日期必须小于截止日期');
        SELECT x,y FROM @t;
        RETURN;
    END

    -- 省份映射
    UPDATE #DataTemp SET FK_Province = (
        SELECT TOP(1) PKID FROM SOI_SmallRegion WHERE SmallRegionName = #DataTemp.[省份] AND IsValid = 1
    );

    -- 返回具体省份名
DECLARE @problemDealerNum INT;
SELECT @problemDealerNum = COUNT(*) FROM #DataTemp WHERE (FK_Province IS NULL OR FK_Province = 0);

IF (@problemDealerNum > 0)
BEGIN
    DECLARE @badProvinces NVARCHAR(MAX);

    SELECT @badProvinces = STUFF(
        (
            SELECT DISTINCT '，' + ISNULL([省份], N'（空）')
            FROM #DataTemp
            WHERE FK_Province IS NULL OR FK_Province = 0
            FOR XML PATH(''), TYPE
        ).value('.', 'NVARCHAR(MAX)')
    ,1,1,'');

    INSERT INTO @t VALUES (1, N'以下省份在系统中不存在：' + @badProvinces);
    SELECT x,y FROM @t;
    RETURN;
END

    -- 关键校验：若存在任意一条导入记录，其时间区间完全包含了系统中某条历史记录，则拒绝整个导入
    IF EXISTS (
        SELECT 1
        FROM #DataTemp dt
        JOIN BI_WSDealerPrice b ON b.IsValid = 1 AND b.[ProvinceName] = dt.省份 AND b.FK_Product = dt.FK_Product
        WHERE b.StartTime >= CAST(dt.[生效日期] AS date)
          AND b.EndTime <= CAST(dt.[截止日期] AS date)
          AND NOT (b.StartTime = CAST(dt.[生效日期] AS date) AND b.EndTime = CAST(dt.[截止日期] AS date))
    )
    BEGIN
        INSERT INTO @t VALUES (1, N'导入失败：存在历史记录完全包含在某条导入记录的时间区间内，系统不允许导入。请检查导入数据或历史数据。');
        SELECT x,y FROM @t;
        RETURN;
    END

    -- 开始事务并调整交叉的历史记录，然后 MERGE 导入
    BEGIN TRY
        BEGIN TRANSACTION;

        -- 左侧相交：历史 b.Start < S.Start and b.End between S.Start and S.End => b.End = S.Start -1
        UPDATE b
        SET b.EndTime = DATEADD(day, -1, CAST(dt.[生效日期] AS date))
        FROM BI_WSDealerPrice b
        JOIN #DataTemp dt ON b.[ProvinceName] = dt.省份 AND b.FK_Product = dt.FK_Product
        WHERE b.IsValid = 1
          AND b.StartTime < CAST(dt.[生效日期] AS date)
          AND b.EndTime >= CAST(dt.[生效日期] AS date)
          AND b.EndTime <= CAST(dt.[截止日期] AS date);

        -- 右侧相交：b.Start between S.Start and S.End and b.End > S.End => b.Start = S.End + 1
        UPDATE b
        SET b.StartTime = DATEADD(day, 1, CAST(dt.[截止日期] AS date))
        FROM BI_WSDealerPrice b
        JOIN #DataTemp dt ON b.[ProvinceName] = dt.省份 AND b.FK_Product = dt.FK_Product
        WHERE b.IsValid = 1
          AND b.StartTime >= CAST(dt.[生效日期] AS date)
          AND b.StartTime <= CAST(dt.[截止日期] AS date)
          AND b.EndTime > CAST(dt.[截止日期] AS date);

        -- 跨越导入区间（拆分右段）
        INSERT INTO BI_WSDealerPrice (
            [WS_DealerType],[WS_DealerCode],[WS_DealerName],[FK_BPCSDealer],
            [FK_SDDealer],[ProductCode],[ProductName],[FK_Product],
            [Price],[StartTime],[EndTime],[CreateTime],[FK_CreateUser],[ModifyTime],
            [FK_ModifyUser],[IsValid],[Memo],[ProvinceName]
        )
        SELECT
            b.WS_DealerType, b.WS_DealerCode, b.WS_DealerName, b.FK_BPCSDealer,
            b.FK_SDDealer, b.ProductCode, b.ProductName, b.FK_Product,
            b.Price, DATEADD(day, 1, CAST(dt.[截止日期] AS date)) AS StartTime, b.EndTime,
            GETDATE(), b.FK_CreateUser, GETDATE(), @userid, 1, b.Memo,b.[ProvinceName]
        FROM BI_WSDealerPrice b
        JOIN #DataTemp dt ON b.[ProvinceName] = dt.省份 AND b.FK_Product = dt.FK_Product
        WHERE b.IsValid = 1
          AND b.StartTime < CAST(dt.[生效日期] AS date)
          AND b.EndTime > CAST(dt.[截止日期] AS date);

        -- 左段更新 EndTime = S.Start -1
        UPDATE b
        SET b.EndTime = DATEADD(day, -1, CAST(dt.[生效日期] AS date))
        FROM BI_WSDealerPrice b
        JOIN #DataTemp dt ON b.[ProvinceName] = dt.省份 AND b.FK_Product = dt.FK_Product
        WHERE b.IsValid = 1
          AND b.StartTime < CAST(dt.[生效日期] AS date)
          AND b.EndTime > CAST(dt.[截止日期] AS date);

        -- MERGE 导入（明确列出 SOURCE 字段并使用 CAST 进行转换）
        MERGE INTO BI_WSDealerPrice AS TARGET
        USING (
            SELECT
                省份,
                FK_Product,
                [产品编码] AS ProductCode,
                [产品名称] AS ProductName,
                CAST([单价] AS decimal(18,4)) AS Price,
                CAST([生效日期] AS date) AS StartTime,
                CAST([截止日期] AS date) AS EndTime
            FROM #DataTemp
        ) AS SOURCE
        ON (TARGET.ProvinceName = SOURCE.省份
            AND TARGET.FK_Product = SOURCE.FK_Product
            AND TARGET.StartTime = SOURCE.StartTime
            AND TARGET.EndTime = SOURCE.EndTime)
        WHEN MATCHED THEN
            UPDATE SET
                TARGET.Price = SOURCE.Price,
                TARGET.CreateTime = GETDATE(),
                TARGET.FK_CreateUser = @userid,
                TARGET.ModifyTime = GETDATE(),
                TARGET.FK_ModifyUser = @userid,
                TARGET.IsValid = 1,
                TARGET.Memo = '导入'
        WHEN NOT MATCHED BY TARGET THEN
        INSERT (
            [WS_DealerType],[WS_DealerCode],[WS_DealerName],[FK_BPCSDealer],
            [FK_SDDealer],[ProductCode],[ProductName],[FK_Product],
            [Price],[StartTime],[EndTime],[CreateTime],[FK_CreateUser],[ModifyTime],
            [FK_ModifyUser],[IsValid],[Memo],[ProvinceName]
        )
        VALUES (
            NULL, NULL, NULL, NULL,
            NULL, SOURCE.ProductCode, SOURCE.ProductName, SOURCE.FK_Product,
            SOURCE.Price, SOURCE.StartTime, SOURCE.EndTime, GETDATE(), @userid, GETDATE(), @userid, 1, '导入', SOURCE.省份
        );

        COMMIT TRANSACTION;

        INSERT INTO @t VALUES (0, N'导入成功!');
        SELECT x,y FROM @t;
        RETURN;
    END TRY
    BEGIN CATCH
        DECLARE @ErrNum INT = ERROR_NUMBER();
        DECLARE @ErrSeverity INT = ERROR_SEVERITY();
        DECLARE @ErrState INT = ERROR_STATE();
        DECLARE @ErrProc NVARCHAR(128) = ISNULL(ERROR_PROCEDURE(), N'(NULL)');
        DECLARE @ErrLine INT = ERROR_LINE();
        DECLARE @ErrMsg NVARCHAR(4000) = ERROR_MESSAGE();
        DECLARE @FullMsg NVARCHAR(1000) = N'导入失败，发生异常: 错误号=' + CAST(@ErrNum AS NVARCHAR(20))
            + N', 严重性=' + CAST(@ErrSeverity AS NVARCHAR(10))
            + N', 状态=' + CAST(@ErrState AS NVARCHAR(10))
            + N', 存储过程=' + @ErrProc
            + N', 行=' + CAST(@ErrLine AS NVARCHAR(10))
            + N', 消息=' + LEFT(@ErrMsg, 900); -- 截断以适应 NVARCHAR(1000)

        IF XACT_STATE() <> 0
        BEGIN
            ROLLBACK TRANSACTION;
        END

        INSERT INTO @t VALUES (1, @FullMsg);
        SELECT x,y FROM @t;
        RETURN;
    END CATCH
END

https://www.python.org/downloads/windows/ 下载python 安装

pip install 库名 -i https://pypi.tuna.tsinghua.edu.cn/simple

pip install jupyter -i https://pypi.tuna.tsinghua.edu.cn/simple

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple

pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

pip install openpyxl -i https://pypi.tuna.tsinghua.edu.cn/simple

医院编号管理功能调整

经销商与医院关系管理功能调整

去除 DMS 系统自动创建经销商医院客户关系功能

退款审批逻辑调整

报表功能调整

SOI 相关报表（退款明细报表、开票明细报表、预提明细报表、预提汇总报表）

DMS 相关报表（开票明细报表、预提明细报表）

新增医院 VS 仪器关系报表

Python代码：

根据数据统计，用户在一天内不同时段的亮度与色温偏好如下：

• 上午（6–12点）： 平均亮度 51.7，色温 3689K

• 下午（12–18点）： 平均亮度 49.9，色温 3732K

• 晚上（18–24点）： 平均亮度 48.1，色温 3661K

二、功能使用频率分析（3）

• 使用最频繁场景： Relax Mode（273次）

• 使用适中场景： Reading Mode（264次），WorkMode（237次）

• 使用较少场景： Sleep Mode（226次）

三、响应时间分析（3）

• 平均响应时间为1.06秒

延迟瓶颈： 网络瓶颈，系统处理能力是可能的延迟原因

1. 用户界面设计：提供一个简洁直观的用户界面，方便用户上传图片和查看识别结果。
2. 模型加载：系统启动时预加载模型和标签，减少用户等待时间。
3. 图像上传与预处理：允许用户上传图片，并自动进行必要的预处理。
4. 图像识别：后台使用 “resnet.onnx” 模型处理预处理后的图片。
5. 结果展示：清晰展示识别结果，包括最可能的类别和概率。
6. 交互反馈：提供用户反馈选项，以改进模型性能。
7. 帮助与支持：内置帮助文档和客服支持，提升用户体验。
8. 性能优化：优化系统响应速度和模型处理能力。
9. 安全性考虑：确保用户数据安全和隐私保护。
10. 多语言支持：界面支持多语言，满足全球用户需求。

可访问性：确保 UI 无障碍，方便所有用户操作

import os

import time

import cv2

import numpy as np

import vision.utils.box_utils_numpy as box_utils

import onnxruntime as ort

# 定义预测函数，对模型输出的边界框和置信度进行后处理

def predict(width, height, confidences, boxes, prob_threshold, iou_threshold=0.3, top_k=-1):

    boxes = boxes[0]

    confidences = confidences[0]

    picked_box_probs = []

    picked_labels = []

    for class_index in range(1, confidences.shape[1]):

        probs = confidences[:, class_index]

        mask = probs > prob_threshold

        probs = probs[mask]

        if probs.shape[0] == 0:

            continue

        subset_boxes = boxes[mask, :]

        box_probs = np.concatenate([subset_boxes, probs.reshape(-1, 1)], axis=1)

        box_probs = box_utils.hard_nms(box_probs,

                                       iou_threshold=iou_threshold,

                                       top_k=top_k,

                                       )

        picked_box_probs.append(box_probs)

        picked_labels.extend([class_index] * box_probs.shape[0])

    if not picked_box_probs:

        return np.array([]), np.array([]), np.array([])

    picked_box_probs = np.concatenate(picked_box_probs)

    picked_box_probs[:, 0] *= width

    picked_box_probs[:, 1] *= height

    picked_box_probs[:, 2] *= width

    picked_box_probs[:, 3] *= height

    return picked_box_probs[:, :4].astype(np.int32), np.array(picked_labels), picked_box_probs[:, 4]

# 从标签文件中读取每一行，并去除行首尾的空白字符，得到类别名称列表 2分

class_names = [name.strip() for name in open('voc-model-labels.txt').readlines()]

# 创建 ONNX Runtime 的推理会话，用于运行模型进行推理 2分

ort_session = ort.InferenceSession('version-RFB-320.onnx')

# 获取模型输入的名称 2分

input_name = ort_session.get_inputs()[0].name

# 定义保存检测结果图像的目录路径

result_path = "./detect_imgs_results_onnx"

# 定义置信度阈值，用于筛选出置信度较高的检测结果

threshold = 0.7

# 定义存储待检测图像的目录路径

path = "imgs"

# 用于统计所有图像中检测到的目标框总数，初始化为 0

sum = 0

# 如果保存结果的目录不存在，则创建该目录 2分

if not os.path.exists(result_path):

    os.mkdir(result_path)

# 获取指定目录下的所有文件和文件夹名称列表

listdir = os.listdir(path)

# 遍历目录下的每个文件

for file_path in listdir:

    # 拼接图像文件的完整路径

    img_path = os.path.join(path, file_path)

    # 使用 OpenCV 读取图像文件 2分

    orig_image = cv2.imread(img_path)

    # 将图像从 BGR 颜色空间转换为 RGB 颜色空间（许多模型要求输入为 RGB 格式）

    image = cv2.cvtColor(orig_image, cv2.COLOR_BGR2RGB)

    # 将图像调整为 320x240 的尺寸（符合模型输入的尺寸要求） 2分

    image = cv2.resize(image, (320, 240))

    # 定义图像归一化的均值数组 2分

    image_mean = np.array([127, 127, 127])

    # 对图像进行归一化处理，减去均值并除以 128

    image = (image - image_mean) / 128

    # 将图像的维度从 (高度, 宽度, 通道数) 转换为 (通道数, 高度, 宽度)

    image = np.transpose(image, [2, 0, 1])

    # 在第一个维度上扩展一个维度，将图像变为 (1, 通道数, 高度, 宽度)，以符合模型输入的维度要求  1分

    image = np.expand_dims(image, axis=0)

    # 将图像数据类型转换为 float32 类型

    image = image.astype(np.float32)

    # 记录开始时间，用于计算模型推理的耗时

    time_time = time.time()

    # 使用 ONNX Runtime 运行模型，输入图像数据，得到模型输出的置信度和边界框  2分

    confidences, boxes = ort_session.run(None, {input_name: image})

    # 计算并打印模型推理的耗时

    print("cost time:{}".format(time.time() - time_time))

    # 调用 predict 函数对模型输出的边界框和置信度进行后处理，得到最终的边界框、类别标签和置信度

    boxes, labels, probs = predict(orig_image.shape[1], orig_image.shape[0], confidences, boxes, threshold)

    # 遍历每个检测到的目标框

    for i in range(boxes.shape[0]):

        # 获取当前目标框的坐标

        box = boxes[i, :]

        # 生成当前目标框的标签字符串，包含类别名称和置信度

        label = f"{class_names[labels[i]]}: {probs[i]:.2f}"

        # 在原始图像上绘制目标框，颜色为 (255, 255, 0)，线条粗细为 4

        cv2.rectangle(orig_image, (box[0], box[1]), (box[2], box[3]), (255, 255, 0), 4)

        # 将绘制了目标框的图像保存到结果目录中

        cv2.imwrite(os.path.join(result_path, file_path), orig_image)

    # 累加当前图像中检测到的目标框数量到总数中

    sum += boxes.shape[0]

# 打印所有图像中检测到的目标框总数

print("sum:{}".format(sum))

import onnxruntime as ort
import numpy as np
import scipy.special
from PIL import Image
# 预处理图像
def preprocess_image(image, resize_size=256, crop_size=224, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]):
    image = image.resize((resize_size, resize_size), Image.BILINEAR)
    w, h = image.size
    left = (w - crop_size) / 2
    top = (h - crop_size) / 2
    image = image.crop((left, top, left + crop_size, top + crop_size))
    image = np.array(image).astype(np.float32)
    image = image / 255.0
    image = (image - mean) / std
    image = np.transpose(image, (2, 0, 1))
    image = image.reshape((1,) + image.shape)
    return image
# 加载模型  2分
session = ort.InferenceSession('flower-detection.onnx')
# 加载类别标签 2分
with open('labels.txt') as f:
    labels = [line.strip() for line in f.readlines()]
# 获取模型输入和输出的名称
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name
# 加载图片  2分
image = Image.open('flower_test.png').convert('RGB')
# 预处理图片  2分
processed_image = preprocess_image(image)
# 确保输入数据是 float32 类型
processed_image = processed_image.astype(np.float32)
# 进行图片识别  2分
output = session.run([output_name], {input_name: processed_image})[0]
# 应用 softmax 函数获取识别分类后的准确率  2分
accuracy = scipy.special.softmax(output, axis=-1)
# 获取预测的类别索引
predicted_idx = np.argmax(accuracy)
# 获取预测的准确值（转换为百分比）
prob_percentage = accuracy[0, predicted_idx] * 100

# 获取预测的类别标签
predicted_label = labels[predicted_idx]
# 输出预测结果，包含百分比形式的概率
print(f"Predicted class: {predicted_label}, Accuracy: {prob_percentage:.2f}%")

import onnx
import numpy as np
from PIL import Image
import onnxruntime as ort
# 定义预处理函数，用于将图片转换为模型所需的输入格式
def preprocess(image_path):
    input_shape = (1, 1, 64, 64)    # 模型输入期望的形状，这里是 (N, C, H, W)，N=batch size, C=channels, H=height, W=width
    img = Image.open(image_path).convert('L')    # 打开图像文件并将其转换为灰度图  1分
    img = img.resize((64, 64), Image.Resampling.LANCZOS)    # 调整图像大小到模型输入所需的尺寸
    img_data = np.array(img, dtype=np.float32)    # 将PIL图像对象转换为numpy数组，并确保数据类型是float32
    # 调整数组的形状以匹配模型输入的形状
    img_data = np.expand_dims(img_data, axis=0)  # 添加 batch 维度
    img_data = np.expand_dims(img_data, axis=1)  # 添加 channel 维度
    assert img_data.shape == input_shape, f"Expected shape {input_shape}, but got {img_data.shape}"    # 确保最终的形状与模型输入要求的形状一致
    return img_data    # 返回预处理后的图像数据
# 定义情感类别与数字标签的映射表 2分
emotion_table = {'neutral':0, 'happiness':1, 'surprise':2, 'sadness':3, 'anger':4, 'disgust':5, 'fear':6, 'contempt':7}
# 加载模型 2分
ort_session = ort.InferenceSession('emotion-ferplus.onnx')    # 使用onnxruntime创建一个会话，用于加载并运行模型
# 加载本地图片并进行预处理 2分
input_data = preprocess('img_test.png')
# 准备输入数据，确保其符合模型输入的要求
ort_inputs = {ort_session.get_inputs()[0].name: input_data}    # ort_session.get_inputs()[0].name 是获取模型的第一个输入的名字
# 运行模型，进行预测 2分
ort_outs = ort_session.run(None, ort_inputs)
# 解码模型输出，找到预测概率最高的情感类别 2分
predicted_label = np.argmax(ort_outs[0])
print(predicted_label)
# 根据预测的标签找到对应的情感名称 2分
predicted_emotion = list(emotion_table.keys())[predicted_label]
# 输出预测的情感
print(f"Predicted emotion: {predicted_emotion}")

代码：

import onnxruntime

import numpy as np

from PIL import Image

# 加载ONNX模型  2分

ort_session = onnxruntime.InferenceSession("mnist.onnx")

# 加载图像 2分

image = Image.open("img_test.png").convert('L')  # 转为灰度图

# 图像预处理 4分

image = image.resize((28, 28))  # 调整大小为MNIST模型的输入尺寸1分

image_array = np.array(image, dtype=np.float32)  # 转为numpy数组1分

image_array = np.expand_dims(image_array, axis=0)  # 添加batch维度1分

image_array = np.expand_dims(image_array, axis=0)  # 添加通道维度1分

# 使用模型对图片进行识别 2分

ort_inputs = {ort_session.get_inputs()[0].name: image_array}

# 执行预测 2分

ort_outs = ort_session.run(None, ort_inputs)

# 获取预测结果 2分

predicted_class = np.argmax(ort_outs[0])

# 输出预测结果
print(f"Predicted class: {predicted_class}")