当前位置：首页 > news >正文

C++部署Segment Anything模型：从ONNX转换到推理实现全流程

news 2026/7/26 22:21:12

1. 项目概述与核心价值

最近在搞一些图像处理相关的项目，发现Meta开源的Segment Anything Model（SAM）确实是个神器，它能对图像中的任何物体进行“一键分割”，效果相当惊艳。不过，官方主要提供了Python的接口和Demo，对于像我这样主要工作在C++环境，或者需要将模型集成到C++原生应用（比如一些客户端软件、嵌入式视觉系统或者对Python依赖有洁癖的项目）的开发者来说，直接调用Python总感觉隔了一层，部署起来也麻烦。

所以，我就琢磨着怎么在纯C++环境下把SAM给跑起来。网上相关的资料比较零散，要么是讲Python怎么用，要么就是C++部分一笔带过，对于环境配置、依赖处理、模型转换这些关键步骤，踩坑的细节很少。这次，我就把我从零开始，在本地Windows系统上，用C++成功跑通SAM模型的全过程，以及中间遇到的各种“坑”和解决方案，毫无保留地分享出来。目标就一个：让你照着做，一定能成功跑起来。

这个“Part1”，我们聚焦在最核心的目标上：在本地Windows系统上，配置好所有环境，并运行一个C++程序，使用ONNX格式的SAM模型完成对一张图片的分割推理。我们会用到ONNX Runtime作为推理引擎，OpenCV来处理图像，整个流程会涉及模型下载与转换、C++工程配置、代码编写与调试。只要你有一点C++基础，跟着步骤走，绝对没问题。

2. 环境准备与工具选型

在开始写代码之前，把“地基”打好至关重要。C++项目对环境依赖比较敏感，尤其是涉及到深度学习推理时。下面是我经过多次尝试后，确定的一套稳定、高效的工具组合。

2.1 核心工具清单与安装

开发环境：Visual Studio 2022
- 为什么选它？在Windows上进行C++开发，VS依然是生态最完善、对Windows特性支持最好的IDE。社区版免费，完全够用。它的MSVC编译器、调试器和项目管理系统，能极大降低我们配置复杂项目的难度。
- 安装要点：安装时，在“工作负载”中务必勾选“使用C++的桌面开发”。在右侧的“安装详细信息”中，确保包含了“用于Windows的C++ CMake工具”和“MSVC v143 - VS 2022 C++ x64/x86生成工具”。CMake工具对我们后续编译第三方库很有用。
包管理器：vcpkg
- 为什么选它？管理C++的第三方库（如OpenCV, ONNX Runtime）是件头疼事，编译选项、依赖关系、版本冲突能让人崩溃。vcpkg是微软官方的C++库管理工具，可以自动从源码编译或安装预编译的库，并集成到VS中，堪称“救命稻草”。
- 安装方法：
```
# 打开PowerShell或CMD，找一个你喜欢的目录，比如 D:\Dev git clone https://github.com/microsoft/vcpkg.git cd vcpkg .\bootstrap-vcpkg.bat # 将vcpkg添加到系统环境变量PATH中，方便全局调用 .\vcpkg integrate install
```
推理引擎：ONNX Runtime
- 为什么选它？SAM的官方PyTorch模型需要转换成ONNX格式才能在C++中使用。ONNX Runtime是微软推出的高性能推理引擎，对ONNX模型支持最好，且提供了简洁的C++ API。我们通过vcpkg来安装它的C++版本。
- 安装命令：
```
# 在vcpkg目录下执行 .\vcpkg install onnxruntime:x64-windows
```
  x64-windows表示安装64位Windows版本。安装过程会自动处理所有依赖，并编译安装。
图像处理库：OpenCV
- 为什么选它？我们需要用它来加载图片、转换颜色空间、绘制结果等。它是计算机视觉领域的事实标准，功能强大，同样通过vcpkg安装。
- 安装命令：
```
.\vcpkg install opencv4:x64-windows
```
模型与Python环境（用于转换）
- Python环境：你需要一个Python环境（Anaconda或官方Python均可），用于运行官方的SAM代码和模型转换脚本。确保安装了PyTorch和SAM相关的库。
- SAM模型：从Meta官方仓库（https://github.com/facebookresearch/segment-anything）下载模型检查点，例如sam_vit_b_01ec64.pth（ViT-Base模型）。我们最终需要的是转换后的ONNX模型。

注意：版本兼容性是最大的坑！我强烈建议你记录下所有工具的版本号。我成功跑通的环境是：VS2022 (17.9.7), vcpkg (2024-07-16), ONNX Runtime (1.17.1), OpenCV (4.9.0), PyTorch (2.2.2), SAM (官方main分支)。如果未来版本更新导致问题，可以尝试回退到相近版本。

2.2 创建Visual Studio项目

打开VS2022，创建新项目。

选择“控制台应用”，项目名称比如SegmentAnythingCPPDemo，位置自选。
解决方案和项目创建好后，第一件重要的事是设置项目为x64 Release模式。因为vcpkg默认安装的是x64的库，Debug版的库可能需要单独安装，为了避免麻烦，我们统一用Release。
右键项目 -> “属性”，我们需要配置vcpkg的库路径。
- C/C++ -> 常规 -> 附加包含目录：添加你的vcpkg目录下的installed\x64-windows\include。例如D:\Dev\vcpkg\installed\x64-windows\include。
- 链接器 -> 常规 -> 附加库目录：添加installed\x64-windows\lib。例如D:\Dev\vcpkg\installed\x64-windows\lib。
- 链接器 -> 输入 -> 附加依赖项：这里添加我们需要链接的库文件的名字（不带路径，不带.lib后缀）。至少需要：
```
onnxruntime.lib opencv_world490.lib
```
  opencv_world490中的490对应OpenCV 4.9.0版本，请根据你实际安装的版本修改。onnxruntime.lib是ONNX Runtime的导入库。

3. SAM模型转换：从PyTorch到ONNX

这是整个流程中最关键、也最容易出错的一步。SAM模型结构比较特殊，包含图像编码器（Image Encoder）和掩码解码器（Mask Decoder）。官方提供了导出ONNX模型的脚本scripts/export_onnx_model.py，但直接使用可能会遇到问题。

3.1 标准转换流程

准备环境：在你的Python环境中，确保安装了segment-anything库（pip install git+https://github.com/facebookresearch/segment-anything.git）以及onnx和onnxruntime。
运行转换脚本：
```
python scripts/export_onnx_model.py --checkpoint ./sam_vit_b_01ec64.pth --model-type vit_b --output ./sam_onnx_model.onnx
```
这个命令会尝试导出一个包含编码器和解码器的完整模型。但根据我的经验，直接导出完整的、动态的解码器ONNX模型，在C++端用ONNX Runtime加载推理时，很容易出现输入输出维度不匹配或运行错误。

3.2 更可靠的分离转换法

一个更稳定、也是社区更常用的做法，是将图像编码器和掩码解码器分开导出为两个独立的ONNX模型。这样结构清晰，在C++端也更容易控制。

导出图像编码器：你需要稍微修改一下官方的导出脚本，或者使用社区提供的脚本。核心思想是只运行编码器部分，将输入图像转换为图像嵌入（Image Embedding）。这个模型是固定的：输入[1, 3, 1024, 1024]的归一化图像，输出图像嵌入。
导出掩码解码器：解码器需要多个输入：图像嵌入、点坐标和标签、掩码输入等。导出一个能接受这些动态输入的解码器模型。

由于修改脚本涉及代码，这里我提供一个经过验证的思路和关键点：

对于编码器：在export_onnx_model.py中，找到模型前向传播的部分，只保留编码器路径，用一个示例输入（如torch.randn(1,3,1024,1024)）进行torch.onnx.export。
对于解码器：需要构造解码器需要的所有输入（image_embedding, point_coords, point_labels, mask_input, has_mask_input等），注意这些输入的维度和类型。point_coords和point_labels需要是动态的（第二维可变），在导出时使用dynamic_axes参数指定。

实操心得：我强烈建议你直接寻找社区已经整理好的、可直接导出分离模型的脚本。在GitHub上搜索 “segment anything onnx export separate” 通常能找到。这能节省大量调试时间。我最终使用的是两个独立的ONNX模型：sam_encoder.onnx和sam_decoder.onnx。

转换后的关键产出：

sam_encoder.onnx：图像编码器模型。
sam_decoder.onnx：掩码解码器模型。
记住编码器输入的图像尺寸要求（默认是1024x1024），以及需要的预处理（归一化到[0,1]再按指定均值和标准差归一化）。

4. C++核心代码实现

环境好了，模型也有了，现在我们来编写C++代码。整个过程分为三步：加载模型、预处理图像并运行编码器、准备提示信息并运行解码器。

4.1 项目结构与头文件

在VS项目中，我们主要会修改main.cpp。首先包含必要的头文件：

#include <opencv2/opencv.hpp> #include <onnxruntime_cxx_api.h> #include <iostream> #include <vector> #include <chrono> // 定义一些常量，方便修改 const int ENCODER_INPUT_SIZE = 1024; // SAM编码器默认输入尺寸 const std::string ENCODER_MODEL_PATH = “./models/sam_encoder.onnx”; const std::string DECODER_MODEL_PATH = “./models/sam_decoder.onnx”; // 图像归一化参数 (来自SAM训练配置) const cv::Scalar MEAN(123.675, 116.28, 103.53); const cv::Scalar STD(58.395, 57.12, 57.375);

4.2 初始化ONNX Runtime会话

我们需要创建两个Ort::Session，分别对应编码器和解码器。

Ort::Env env(ORT_LOGGING_LEVEL_WARNING, “SAM_CPP”); Ort::SessionOptions session_options; session_options.SetIntraOpNumThreads(1); // 设置线程数，根据情况调整 session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL); // 加载编码器模型 Ort::Session encoder_session(env, ENCODER_MODEL_PATH.c_str(), session_options); // 加载解码器模型 Ort::Session decoder_session(env, DECODER_MODEL_PATH.c_str(), session_options); // 获取模型输入输出信息 auto encoder_input_info = encoder_session.GetInputTypeInfo(0); auto encoder_output_info = encoder_session.GetOutputTypeInfo(0); // 解码器有多个输入输出，需要逐个获取

注意：SetIntraOpNumThreads控制并行计算的线程数。对于CPU推理，设置为0让ORT自己决定，或者设置为你的CPU核心数。如果后续发现推理速度慢，可以在这里调整。另外，如果模型较大，可以尝试启用ORT_ENABLE_EXTENDED等优化选项，但可能牺牲一些兼容性。

4.3 图像预处理与编码器推理

这一步的目标是将任意大小的输入图片，处理成编码器需要的[1,3,1024,1024]的Tensor。

cv::Mat image = cv::imread(“./input_image.jpg”); if (image.empty()) { std::cerr << “Failed to load image!” << std::endl; return -1; } // 1. 调整大小并填充到1024x1024，保持长宽比 cv::Mat resized_image; int old_h = image.rows, old_w = image.cols; float scale = std::min(1024.0f / old_w, 1024.0f / old_h); int new_w = int(old_w * scale), new_h = int(old_h * scale); cv::resize(image, resized_image, cv::Size(new_w, new_h)); cv::Mat padded_image = cv::Mat::zeros(ENCODER_INPUT_SIZE, ENCODER_INPUT_SIZE, CV_8UC3); cv::Rect roi(0, 0, new_w, new_h); resized_image.copyTo(padded_image(roi)); // 2. 转换为float，并归一化 (这里与Python端预处理保持一致是关键！) cv::Mat float_image; padded_image.convertTo(float_image, CV_32FC3, 1.0 / 255.0); // 先转到[0,1] // 按通道减去均值，除以标准差 cv::Mat channels[3]; cv::split(float_image, channels); for (int i = 0; i < 3; ++i) { channels[i] = (channels[i] - MEAN[i]) / STD[i]; } cv::merge(channels, 3, float_image); // 3. 调整维度顺序 HWC -> CHW，并添加Batch维度 // OpenCV是HWC，PyTorch/Tensor是NCHW std::vector<float> input_tensor_values; input_tensor_values.reserve(1 * 3 * ENCODER_INPUT_SIZE * ENCODER_INPUT_SIZE); for (int c = 0; c < 3; ++c) { for (int h = 0; h < ENCODER_INPUT_SIZE; ++h) { for (int w = 0; w < ENCODER_INPUT_SIZE; ++w) { input_tensor_values.push_back(float_image.at<cv::Vec3f>(h, w)[c]); } } } // 4. 创建ORT Tensor并运行编码器 std::vector<int64_t> input_shape = {1, 3, ENCODER_INPUT_SIZE, ENCODER_INPUT_SIZE}; Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault); Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_values.size(), input_shape.data(), input_shape.size()); auto encoder_output_tensors = encoder_session.Run(Ort::RunOptions{nullptr}, encoder_input_names.data(), // 需要提前从session获取输入输出名 &input_tensor, 1, encoder_output_names.data(), 1); // 5. 提取图像嵌入 (image_embedding) float* image_embedding_data = encoder_output_tensors[0].GetTensorMutableData<float>(); std::vector<int64_t> embedding_shape = encoder_output_tensors[0].GetTensorTypeAndShapeInfo().GetShape(); // embedding_shape 应该是 [1, 256, 64, 64] 对于ViT-B模型

这里有几个极易出错的细节：

归一化参数：必须和SAM训练时一致（MEAN和STD）。用错了模型效果会很差。
维度顺序：OpenCV (HWC) 到 PyTorch/ONNX (NCHW) 的转换是经典坑点，顺序错了颜色通道就乱了。
填充策略：SAM编码器要求固定输入。简单的直接拉伸会变形，影响分割效果。这里采用保持长宽比的填充（pad），填充区域通常用0（黑色），这需要与模型训练时的处理方式对齐。有些实现会填充一个统一的颜色（如114/255的灰色）。

4.4 准备提示信息与解码器推理

假设我们想分割图片中心的一个点。我们需要为解码器准备输入。

// 1. 准备点坐标和标签 // 原始图片上的点坐标 (假设是图片中心) int original_point_x = old_w / 2; int original_point_y = old_h / 2; // 转换到预处理后（padded_image）的坐标系统 float transformed_x = (original_point_x * scale) / ENCODER_INPUT_SIZE; float transformed_y = (original_point_y * scale) / ENCODER_INPUT_SIZE; // SAM解码器期望的坐标范围是 [0,1]，且是 (x, y) 顺序 std::vector<float> point_coords = {transformed_x, transformed_y}; // 标签：1表示前景点，0表示背景点。这里我们指定一个前景点。 std::vector<float> point_labels = {1.0f}; // 2. 构建解码器输入 // 解码器通常需要：image_embedding, point_coords, point_labels, mask_input, has_mask_input // 我们需要根据导出的解码器ONNX模型的输入顺序和形状来组织数据。 // 假设输入顺序为：image_embedding, point_coords, point_labels, mask_input, has_mask_input std::vector<Ort::Value> decoder_inputs; // a. image_embedding (来自编码器输出) decoder_inputs.push_back(std::move(encoder_output_tensors[0])); // b. point_coords & point_labels // 需要添加一个batch维度，并调整形状。例如 point_coords 形状为 [1, 1, 2] std::vector<int64_t> point_coords_shape = {1, 1, 2}; std::vector<float> point_coords_data = {transformed_x, transformed_y}; Ort::Value point_coords_tensor = Ort::Value::CreateTensor<float>(memory_info, point_coords_data.data(), point_coords_data.size(), point_coords_shape.data(), point_coords_shape.size()); decoder_inputs.push_back(std::move(point_coords_tensor)); std::vector<int64_t> point_labels_shape = {1, 1}; Ort::Value point_labels_tensor = Ort::Value::CreateTensor<float>(memory_info, point_labels.data(), point_labels.size(), point_labels_shape.data(), point_labels_shape.size()); decoder_inputs.push_back(std::move(point_labels_tensor)); // c. mask_input (初始掩码，全零) std::vector<int64_t> mask_input_shape = {1, 1, 256, 256}; std::vector<float> mask_input_data(1*1*256*256, 0.0f); Ort::Value mask_input_tensor = Ort::Value::CreateTensor<float>(memory_info, mask_input_data.data(), mask_input_data.size(), mask_input_shape.data(), mask_input_shape.size()); decoder_inputs.push_back(std::move(mask_input_tensor)); // d. has_mask_input (一个标量，float类型，1.0表示有掩码输入，我们这里是初始掩码，所以为1.0？这里需要根据模型定义来) // 有些模型定义has_mask_input为float，1.0或0.0。有些可能是int64。 std::vector<int64_t> has_mask_shape = {1}; std::vector<float> has_mask_data = {1.0f}; // 或 {0.0f}，取决于模型 Ort::Value has_mask_tensor = Ort::Value::CreateTensor<float>(memory_info, has_mask_data.data(), has_mask_data.size(), has_mask_shape.data(), has_mask_shape.size()); decoder_inputs.push_back(std::move(has_mask_tensor)); // 3. 运行解码器 auto decoder_output_tensors = decoder_session.Run(Ort::RunOptions{nullptr}, decoder_input_names.data(), // 解码器输入名 decoder_inputs.data(), decoder_inputs.size(), decoder_output_names.data(), // 解码器输出名 decoder_output_names.size()); // 4. 解析输出 // 解码器通常输出 masks, scores, low_res_logits // 我们需要 masks (形状可能是 [1, 3, 256, 256]) 和对应的 scores auto& masks_tensor = decoder_output_tensors[0]; auto& scores_tensor = decoder_output_tensors[1]; float* masks_data = masks_tensor.GetTensorMutableData<float>(); float* scores_data = scores_tensor.GetTensorMutableData<float>(); auto masks_shape = masks_tensor.GetTensorTypeAndShapeInfo().GetShape(); // masks_shape 可能是 [1, 3, 256, 256]，表示模型输出了3个候选掩码 int num_masks = masks_shape[1]; int mask_size = masks_shape[2] * masks_shape[3]; // 256 * 256 // 选择分数最高的掩码 int best_mask_idx = 0; float best_score = scores_data[0]; for (int i = 1; i < num_masks; ++i) { if (scores_data[i] > best_score) { best_score = scores_data[i]; best_mask_idx = i; } } // 提取最佳掩码数据 std::vector<float> best_mask_data(mask_size); for (int i = 0; i < mask_size; ++i) { best_mask_data[i] = masks_data[best_mask_idx * mask_size + i]; }

坐标转换的逻辑是重中之重，也是最容易晕的地方：

用户给的坐标是相对于原始图片的。
图片经过缩放和填充，变成了1024x1024。我们需要将原始坐标映射到这个预处理后的坐标系中。
映射后的坐标还需要归一化到[0, 1]区间，这才是SAM解码器期望的输入。
顺序是(x, y)，不是(行, 列)。

4.5 后处理与结果可视化

解码器输出的掩码是256x256的低分辨率掩码，并且值在(-∞, +∞)范围（logits）。我们需要将其上采样到原始图像大小，并转换为二值掩码。

// 1. 将低分辨率掩码 (256x256) reshape 并上采样到原始图片大小 (old_h, old_w) cv::Mat low_res_mask(256, 256, CV_32FC1, best_mask_data.data()); cv::Mat resized_mask; // 上采样到预处理后的尺寸 (new_h, new_w)，注意这里不是直接到old_h, old_w cv::resize(low_res_mask, resized_mask, cv::Size(new_w, new_h), 0, 0, cv::INTER_LINEAR); // 2. 将logits通过sigmoid转换为概率，并二值化 (阈值通常取0.0，因为logits>0对应概率>0.5) cv::Mat prob_mask; cv::exp(-resized_mask, prob_mask); // 先计算 exp(-x) prob_mask = 1.0 / (1.0 + prob_mask); // sigmoid(x) = 1/(1+exp(-x)) cv::Mat binary_mask = prob_mask > 0.5; // 阈值化 // 3. 由于我们之前填充了黑边，需要将掩码裁剪到有效图像区域 (roi)，并缩放到原始图像大小 cv::Mat final_mask = cv::Mat::zeros(old_h, old_w, CV_8UC1); cv::Mat roi_mask = binary_mask(cv::Rect(0, 0, new_w, new_h)); // 裁剪出非填充区域 cv::resize(roi_mask, final_mask, cv::Size(old_w, old_h), 0, 0, cv::INTER_NEAREST); // 用最近邻插值保持二值性 // 4. 可视化：将掩码叠加到原图上 cv::Mat colored_mask(old_h, old_w, CV_8UC3, cv::Scalar(0, 255, 0)); // 绿色掩码 cv::Mat result_image = image.clone(); colored_mask.copyTo(result_image, final_mask); // 仅在有掩码的区域着色 cv::imshow(“Segmentation Result”, result_image); cv::waitKey(0); cv::imwrite(“./output_result.jpg”, result_image);

实操心得：掩码上采样到原始尺寸时，插值方法的选择有讲究。从256x256上采样到new_h x new_w可以用线性插值(INTER_LINEAR)。但从new_h x new_w缩放到最终的old_h x old_w时，由于已经是二值掩码了，最好用最近邻插值(INTER_NEAREST)，避免边缘产生模糊的灰度值。另外，sigmoid操作也可以直接用cv::compare(resized_mask, 0.0, binary_mask, cv::CMP_GT)，因为logits>0即概率>0.5。

5. 编译、运行与问题排查

代码写完了，最后一步就是编译运行。

5.1 编译配置与运行

确保依赖库路径正确：如前所述，在项目属性中正确设置了包含目录、库目录和附加依赖项。
将模型文件放入正确位置：将转换好的sam_encoder.onnx和sam_decoder.onnx放在项目目录下的models文件夹中（或者你在代码中指定的路径）。
准备输入图片：将一张测试图片（如input_image.jpg）放在项目目录下。
编译运行：在VS中按Ctrl+F5（开始执行不调试）或F5（调试）。如果一切配置正确，程序会运行并弹窗显示分割结果。

5.2 常见问题与解决方案实录

在实际操作中，你几乎一定会遇到下面这些问题。我把我的踩坑记录分享出来：

问题1：编译时链接错误，提示无法打开包括文件: “onnxruntime_cxx_api.h”或无法解析的外部符号。

原因：这是最常见的环境配置问题。vcpkg安装的库路径没有正确添加到VS项目中。
排查：
- 检查项目属性中的“附加包含目录”和“附加库目录”路径是否正确指向了vcpkg\installed\x64-windows\include和lib。
- 检查“附加依赖项”中的库文件名是否正确，特别是OpenCV的版本号（如opencv_world490.lib）。
- 终极解决方案：使用vcpkg的集成命令。在vcpkg目录下运行.\vcpkg integrate project，它会为你的VS解决方案生成一个属性表。在你的VS解决方案资源管理器中，右键解决方案 -> “添加” -> “现有项”，找到生成的vcpkg.props文件并添加。这能确保所有vcpkg安装的库都被正确引用。

问题2：运行时崩溃，错误信息关于Ort::Session初始化失败或Run失败。

原因A：ONNX模型文件路径错误或模型损坏。
- 解决：检查模型路径是否正确，并用Netron（一个神经网络可视化工具）打开你的.onnx文件，确认模型结构正常，并记下输入输出的名称和形状，与你代码中的encoder_input_names等变量核对。输入输出名称必须完全一致，包括大小写。
原因B：输入Tensor的形状或数据类型与模型期望不匹配。
- 解决：这是最可能的原因。仔细核对编码器输入的shape是否为[1,3,1024,1024]，数据类型是否为float。核对解码器每个输入的shape和类型。使用GetTensorTypeAndShapeInfo()打印模型期望的shape进行对比。
原因C：解码器动态轴设置问题。
- 解决：如果你导出的解码器模型支持动态点坐标（第二维可变），在C++端创建Tensor时，point_coords_shape应为{1, num_points, 2}，其中num_points是你实际提供的点数。确保与导出模型时指定的dynamic_axes一致。

问题3：分割结果不对，要么全图都是掩码，要么什么都没有。

原因A：图像预处理错误。
- 解决：99%的问题出在这里！逐行检查你的预处理代码：BGR转RGB做了吗？（SAM训练用的是RGB，OpenCV默认加载是BGR）。归一化参数MEAN和STD用对了吗？是(123.675/255, 116.28/255, 103.53/255)这样的值吗？维度顺序HWC->CHW转换正确吗？建议将预处理后的第一个像素值打印出来，与用Python脚本处理同一张图片的结果进行对比，必须完全一致。
原因B：点坐标转换错误。
- 解决：在代码中打印出original_point_x/y,transformed_x/y的值。确保缩放因子scale计算正确。确保最终传给解码器的坐标在[0,1]范围内。可以尝试用一个非常明显的位置（比如图片左上角(10,10)）进行测试。
原因C：掩码后处理阈值问题。
- 解决：解码器输出的是logits。尝试调整二值化的阈值，不一定非要是0.0。可以先将logits通过sigmoid得到概率图，保存下来看看概率分布，再决定阈值。

问题4：推理速度很慢。

原因：在CPU上运行ViT模型本身就不快。
优化：
- 使用更小的SAM模型，如vit_t(Tiny) 或vit_s(Small)。
- 在session_options中尝试设置SetIntraOpNumThreads为你的CPU核心数。
- 如果支持，尝试使用ONNX Runtime的CUDA或TensorRT执行提供者（需要安装对应版本的ONNX Runtime并配置）。这需要GPU和额外的环境配置，是下一步优化的方向。

问题5：如何支持多点提示（正负点）或框提示？

原理：解码器的point_coords和point_labels输入支持多个点。只需将多个点的坐标和标签（1前景，0背景）拼接起来即可。例如，两个点：point_coords = {x1, y1, x2, y2}，point_labels = {1.0, 0.0}。对应的Tensor形状应为[1, 2, 2]。
框提示：一个框可以用两个点表示（左上角和右下角），并将这两个点的标签都设为2（在SAM中，标签2通常代表框）。具体需要查阅SAM的原始代码确定标签定义。然后在坐标数组中传入四个值[x1, y1, x2, y2]，标签数组为[2, 2]。同样，形状要调整为[1, 2, 2]。