1. 项目概述与核心价值

最近在做一个桌面端工具，核心需求是能对用户输入的中文文本进行语法润色和优化。市面上虽然有不少在线工具，但考虑到数据隐私、离线可用性以及想深度集成到自己的C++工作流里，我决定自己动手撸一个。最终方案敲定为：用 Qt 做GUI框架， C++ 作为主力开发语言，通过 ONNX Runtime 来加载和运行 Qwen-2-0.5B 这个轻量级大语言模型，专门处理中文文本的润色任务。

这个组合听起来有点“混搭”，但实际跑下来，效果和效率都远超预期。Qt保证了跨平台且美观的界面，C++提供了接近硬件的执行效率，而ONNX Runtime则让我们能无缝对接PyTorch等框架训练好的模型，避免了繁琐的模型转换和C++推理框架二次开发。Qwen-2-0.5B作为通义千问家族的最小成员，在语法纠错、句式优化、书面语润色上表现相当不错，而且模型尺寸小，在消费级GPU甚至纯CPU上都能流畅运行。

如果你也在寻找一种将前沿AI能力“固化”到本地C++应用程序中的方法，特别是处理文本、图像等任务的场景，那么这个Qt + C++ + ONNX Runtime + 轻量化大模型的技术栈，绝对值得你深入了解一下。它不仅解决了云端服务的延迟和隐私顾虑，更能让你对模型的输入、输出和整个处理流程拥有百分百的控制权。

2. 技术选型与架构设计思路

为什么是这“四件套”？每一个选择背后都有具体的考量，并非随意堆砌技术名词。

2.1 为什么选择Qt和C++？

首先，项目的目标是做一个 桌面端工具 。Qt几乎是C++领域桌面GUI开发的事实标准，它成熟、稳定、跨平台（Windows、macOS、Linux一套代码搞定），并且拥有丰富的控件和良好的文档。对于需要长期维护、可能涉及复杂交互的工具类软件，Qt是可靠的选择。

其次，选择C++而非Python，主要出于 性能 和 部署便利性 的考虑。模型推理，尤其是神经网络的前向传播，涉及大量的矩阵运算。C++能更好地利用硬件资源，减少推理时的延迟。最终打包发布的软件是一个独立的可执行文件，用户无需安装庞大的Python环境或一堆依赖库，真正做到“开箱即用”，极大降低了用户的使用门槛。

2.2 为什么是ONNX Runtime？

这是连接AI模型和C++应用的关键桥梁。ONNX（Open Neural Network Exchange）是一个开放的模型格式标准，几乎所有主流训练框架（PyTorch, TensorFlow等）都能将模型导出为 .onnx 格式。而ONNX Runtime是由微软维护的高性能推理引擎，专门用于运行ONNX模型。

它的优势在于：

  • 标准化 ：一次导出，多处运行。我们可以在PyTorch环境下用Python方便地验证和调试模型，然后导出为ONNX，在C++中加载。
  • 高性能 ：ONNX Runtime内部做了大量优化，支持CPU、GPU（CUDA, DirectML等），能自动进行算子融合、图优化等，推理速度有保障。
  • 接口友好 ：提供了清晰的C++ API，虽然需要一些学习成本，但文档齐全，社区活跃。

2.3 为什么是Qwen-2-0.5B？

大模型千千万，为什么挑这个“小个子”？

  • 轻量化 ：0.5B（5亿）参数对于大模型来说非常小巧。经过量化后（如INT8），模型文件可以压缩到几百MB，内存占用小，在无独立显卡的电脑上仅用CPU也能在可接受的时间内完成推理。
  • 中文能力强 ：Qwen系列模型对中文的理解和生成能力有目共睹。Qwen-2-0.5B虽然在创意写作、复杂推理上不如它的“大哥们”，但完成语法检查、词语替换、句式调整这类“精修”任务，已经绰绰有余。
  • 易于获取与转换 ：模型在Hugging Face等平台公开，并且官方提供了完善的脚本，可以轻松地将PyTorch模型转换为ONNX格式，为我们的C++集成铺平了道路。

整个架构的流程可以概括为： Qt界面捕获用户输入 -> C++业务逻辑层预处理文本 -> 调用ONNX Runtime C++ API，将文本送入Qwen-2-0.5B模型 -> 获取模型生成的润色后文本 -> 返回给Qt界面进行展示 。清晰的分层，让每一部分各司其职。

3. 环境搭建与核心依赖部署

工欲善其事，必先利其器。这一步是基础，也是最容易踩坑的地方。我会详细列出每一步，特别是Windows下的操作。

3.1 Qt开发环境搭建

对于Qt，我推荐使用官方在线安装器，它允许你自由选择组件和版本。

  1. 下载安装器 ：访问Qt官网，下载对应操作系统的在线安装程序。
  2. 选择组件 ：安装时，务必勾选你需要的Qt版本（如Qt 6.5 LTS）和对应的 MSVC编译器套件 （例如，MSVC 2019 64-bit）。如果你计划用MinGW，就选择MinGW套件。 记住你的选择，后续编译ONNX Runtime时必须匹配 。
  3. 集成开发环境 ：你可以使用Qt Creator，它开箱即用。但我个人更喜欢使用 Visual Studio ，因为它对C++的调试支持更强大。在VS中安装“Qt VS Tools”扩展，即可在VS内创建和管理Qt项目。

3.2 ONNX Runtime C++库的编译与集成

这是最关键也最复杂的一步。ONNX Runtime提供了预编译的二进制包，但为了获得最佳性能和兼容性（尤其是启用GPU支持时），我强烈建议从源码编译。

核心步骤：

  1. 获取源码 ：从ONNX Runtime的GitHub仓库克隆或下载稳定版源码。
  2. 安装依赖 ：
    • CMake ：版本需符合ONNX Runtime的要求。
    • Python ：用于运行编译配置脚本。
    • 对应编译器 ：如果你在Qt中选择了MSVC，那么这里也必须使用相同版本的Visual Studio开发者命令行（如 x64 Native Tools Command Prompt for VS 2019 ）来执行编译命令。
  3. 使用 build.bat 编译 ： 在源码根目录下，运行以下命令是一个典型的配置（Windows示例）： 
    .\build.bat --config RelWithDebInfo --build_shared_lib --parallel --use_cuda --cuda_home "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8" --cudnn_home "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8"
    • --config RelWithDebInfo ：生成带调试信息的发布版，便于排查问题。
    • --build_shared_lib ：生成动态链接库（DLL），方便部署。
    • --use_cuda ：如果你有NVIDIA GPU并希望启用CUDA加速，则加上此参数及后续的CUDA路径。 纯CPU运行则去掉这些参数 。
    • --parallel ：启用并行编译，加快速度。
  4. 获取编译产物 ： 编译完成后，在 build\Windows\[你的配置] 目录下，找到：
    • onnxruntime.dll （动态库）或 onnxruntime.lib （静态库）
    • 头文件位于源码的 include 目录。
  5. 集成到Qt项目 ： 在你的Qt项目文件（ .pro ）中，添加库路径和链接库。例如： 
    # 添加包含目录
INCLUDEPATH += $$PWD/third_party/onnxruntime/include
# 添加库目录
LIBS += -L$$PWD/third_party/onnxruntime/lib
# 链接库
LIBS += -lonnxruntime
    并将 onnxruntime.dll 复制到你的可执行文件同级目录。

注意 ：编译环境（特别是MSVC版本）必须与你的Qt项目编译环境严格一致，否则会导致链接错误或运行时崩溃。如果只使用CPU，编译过程会简单很多。

3.3 获取并转换Qwen-2-0.5B模型

  1. 下载模型 ：从Hugging Face的 Qwen/Qwen2-0.5B-Instruct 仓库下载PyTorch格式的模型文件（包括 pytorch_model.bin , config.json , tokenizer.json 等）。
  2. 转换为ONNX格式 ：使用Hugging Face的 transformers 库和 optimum 库可以方便地导出。你需要编写一个简单的Python脚本，核心是利用 optimum.onnxruntime 提供的 ORTModelForCausalLM 进行转换。转换时需要注意指定正确的输入输出名称和动态轴（dynamic axes），以支持可变长度的文本输入。 
    from optimum.onnxruntime import ORTModelForCausalLM
from transformers import AutoTokenizer

model_id = "Qwen/Qwen2-0.5B-Instruct"
onnx_path = "./qwen2-0.5b-onnx"

# 导出模型
model = ORTModelForCausalLM.from_pretrained(model_id, export=True)
model.save_pretrained(onnx_path)
# 保存分词器
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.save_pretrained(onnx_path)
    转换后，你会得到 .onnx 模型文件和一些配置文件。

4. 核心实现：C++中集成ONNX Runtime运行模型

环境准备好后，就到了最核心的编码环节。我们将创建一个 ModelInferencer 类来封装所有模型相关的操作。

4.1 初始化ONNX Runtime环境与会话

首先，需要包含必要的头文件并初始化全局环境。

#include <onnxruntime_cxx_api.h>
#include <vector>
#include <string>

class ModelInferencer {
public:
    ModelInferencer(const std::string& model_path) {
        // 1. 创建环境，一个应用通常只需要一个环境实例
        env_ = std::make_unique<Ort::Env>(ORT_LOGGING_LEVEL_WARNING, "QwenTextPolish");

        // 2. 创建会话选项
        Ort::SessionOptions session_options;
        session_options.SetIntraOpNumThreads(4); // 设置线程数，根据CPU核心调整
        session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL);

        // 3. 可选：配置CUDA Provider（如果编译时支持且希望用GPU）
        #ifdef USE_CUDA
            OrtCUDAProviderOptions cuda_options;
            cuda_options.device_id = 0;
            session_options.AppendExecutionProvider_CUDA(cuda_options);
        #endif

        // 4. 创建会话，加载模型
        session_ = std::make_unique<Ort::Session>(*env_, model_path.c_str(), session_options);

        // 5. 获取模型输入输出信息
        Ort::AllocatorWithDefaultOptions allocator;
        size_t num_input_nodes = session_->GetInputCount();
        for(size_t i=0; i<num_input_nodes; i++) {
            auto input_name = session_->GetInputName(i, allocator);
            input_names_.push_back(input_name);
            allocator.Free(input_name); // 注意释放内存
        }
        // 类似地获取输出信息...
    }

private:
    std::unique_ptr<Ort::Env> env_;
    std::unique_ptr<Ort::Session> session_;
    std::vector<const char*> input_names_;
    std::vector<const char*> output_names_;
    // ... 其他成员，如输出名称等
};

4.2 文本预处理：分词与Tensor构造

大模型不能直接处理字符串，需要将文本转换为模型能理解的数字ID序列（Token IDs）。我们需要集成Qwen的分词器（Tokenizer）。这里有两种思路：

  1. 使用Hugging Face的 tokenizers 库C++版本 ：这是最准确的方式，但需要额外编译和集成一个C++库。
  2. 实现一个简化的分词逻辑 ：对于Qwen这类基于BPE的分词器，我们可以将其 vocab.json （词表）和 merges.txt （合并规则）加载到内存，在C++中实现一个基础的分词函数。这对于0.5B这种词汇量相对固定的模型是可行的，但实现起来较复杂。

为了项目快速推进，我采用了第一种方式的变体： 在Python端预处理 。即，在将文本送入C++推理器之前，先用一个轻量级的Python脚本（或服务）调用 transformers 的 AutoTokenizer 进行分词，然后将Token IDs序列通过某种方式（如文件、管道、网络）传递给C++程序。这虽然引入了Python依赖，但在原型阶段极大地简化了开发。

假设我们已经获得了 std::vector<int64_t> input_ids ，接下来需要构造ONNX Runtime需要的 Ort::Value 张量。

std::vector<Ort::Value> ModelInferencer::createModelInput(const std::vector<int64_t>& input_ids) {
    // 输入形状: [batch_size, sequence_length]
    std::vector<int64_t> input_shape = {1, static_cast<int64_t>(input_ids.size())};

    // 创建内存信息（在CPU上）
    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);

    // 创建输入Tensor
    Ort::Value input_tensor = Ort::Value::CreateTensor<int64_t>(
        memory_info,
        const_cast<int64_t*>(input_ids.data()), // 注意：这里需要非const指针，但API设计如此
        input_ids.size(),
        input_shape.data(),
        input_shape.size()
    );

    // 通常语言模型还需要attention_mask等输入，这里为简化只演示input_ids
    // 实际需要根据模型的具体输入节点来构造
    std::vector<Ort::Value> inputs;
    inputs.push_back(std::move(input_tensor));
    return inputs;
}

4.3 执行推理与后处理

构造好输入后，就可以运行模型了。

std::string ModelInferencer::infer(const std::vector<int64_t>& input_ids) {
    // 1. 准备输入
    std::vector<Ort::Value> inputs = createModelInput(input_ids);

    // 2. 准备输出容器
    // 首先获取输出节点名称（通常在初始化时完成）
    // output_names_ 已在构造函数中填充
    std::vector<Ort::Value> outputs;

    // 3. 运行推理
    try {
        outputs = session_->Run(Ort::RunOptions{nullptr},
                                input_names_.data(), inputs.data(), inputs.size(),
                                output_names_.data(), output_names_.size());
    } catch (const Ort::Exception& e) {
        std::cerr << "推理失败: " << e.what() << std::endl;
        return "";
    }

    // 4. 解析输出
    // 假设第一个输出是logits，形状为 [batch_size, seq_len, vocab_size]
    auto& output_tensor = outputs[0];
    int64_t* logits_data = output_tensor.GetTensorMutableData<int64_t>(); // 注意数据类型，可能是float
    auto output_shape = output_tensor.GetTensorTypeAndShapeInfo().GetShape();
    // batch_size = output_shape[0], seq_len = output_shape[1], vocab_size = output_shape[2]

    // 5. 后处理：这里需要实现文本生成逻辑
    // 例如，使用贪心搜索（Greedy Search）或集束搜索（Beam Search）从logits中生成下一个token。
    // 这是一个简化的贪心解码示例（仅生成一个token）：
    int64_t vocab_size = output_shape[2];
    int64_t last_token_logits_start = (output_shape[1] - 1) * vocab_size; // 取最后一个位置的logits
    int64_t next_token_id = 0;
    int64_t max_logit = logits_data[last_token_logits_start];
    for (int64_t i = 1; i < vocab_size; ++i) {
        if (logits_data[last_token_logits_start + i] > max_logit) {
            max_logit = logits_data[last_token_logits_start + i];
            next_token_id = i;
        }
    }

    // 6. 将生成的token id转换回文本（需要分词器的解码功能）
    // 同样，这里需要分词器的decode函数。简化起见，我们假设有一个`decode`函数。
    std::vector<int64_t> all_generated_ids = input_ids;
    all_generated_ids.push_back(next_token_id);
    // 实际应用中，你需要一个循环，不断生成token直到遇到结束符（如<|endoftext|>）。
    
    std::string result = tokenizer_decode(all_generated_ids); // 伪代码，需要实现
    return result;
}

实操心得 ：模型推理的核心是正确构造输入张量和解析输出张量。务必使用 Netron 这样的工具打开你的 .onnx 模型文件，仔细核对输入/输出节点的名称、数据类型和维度。ONNX Runtime的 GetInputName 和 GetOutputName 返回的名称必须与模型文件中的完全一致，包括大小写。

5. Qt GUI设计与业务逻辑整合

模型推理引擎准备好后，我们需要一个友好的界面让用户使用。

5.1 设计简单的用户界面

使用Qt Designer拖拽一个简单的界面，包含：

  • 一个 QTextEdit 用于输入待润色的原文。
  • 一个 QPushButton ，点击后触发润色操作。
  • 另一个 QTextEdit 用于显示润色后的结果。
  • 一个 QLabel 或 QProgressBar 用于显示状态（如“推理中...”）。

将设计好的 .ui 文件集成到Qt项目中。

5.2 连接信号与槽，调用推理引擎

在主窗口类中，我们将界面控件与模型推理类连接起来。

// MainWindow.h
#include <QMainWindow>
#include "modelinferencer.h" // 我们之前封装的类

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow {
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
private slots:
    void on_polishButton_clicked(); // 按钮点击的槽函数
private:
    Ui::MainWindow *ui;
    std::unique_ptr<ModelInferencer> inferencer; // 模型推理器
    // 可能还需要一个分词器客户端或封装
};

// MainWindow.cpp
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QMessageBox>
#include <thread>
#include <future>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    inferencer(nullptr) {
    ui->setupUi(this);

    // 初始化模型（可以放在线程中，避免界面卡顿）
    try {
        inferencer = std::make_unique<ModelInferencer>("./models/qwen2-0.5b.onnx");
        // 初始化分词器...
        ui->statusLabel->setText("模型加载成功");
    } catch (const std::exception& e) {
        QMessageBox::critical(this, "错误", QString("模型加载失败: %1").arg(e.what()));
        ui->polishButton->setEnabled(false);
    }

    // 连接按钮信号到槽
    connect(ui->polishButton, &QPushButton::clicked, this, &MainWindow::on_polishButton_clicked);
}

void MainWindow::on_polishButton_clicked() {
    QString inputText = ui->inputTextEdit->toPlainText().trimmed();
    if (inputText.isEmpty()) {
        QMessageBox::information(this, "提示", "请输入待润色的文本");
        return;
    }

    ui->polishButton->setEnabled(false);
    ui->statusLabel->setText("正在润色...");
    ui->outputTextEdit->clear();
    QApplication::processEvents(); // 更新UI状态

    // 使用异步操作，防止界面冻结
    std::future<std::string> future = std::async(std::launch::async, [this, inputText]() {
        // 1. 文本预处理（分词）：这里调用分词器，将QString转为token ids
        // 假设有一个`tokenizer_encode`函数
        std::vector<int64_t> input_ids = tokenizer_encode(inputText.toStdString());

        // 2. 调用模型推理
        if (inferencer) {
            return inferencer->infer(input_ids);
        }
        return std::string("");
    });

    // 等待结果（可以设置超时）
    std::string result = future.get();

    // 更新UI
    ui->outputTextEdit->setPlainText(QString::fromStdString(result));
    ui->statusLabel->setText("润色完成");
    ui->polishButton->setEnabled(true);
}

注意事项 ：模型推理是计算密集型任务，会阻塞UI线程，导致界面卡住。上述代码使用了 std::async 进行简单的异步处理。对于更复杂的应用，应考虑使用Qt的 QThread 或 QtConcurrent 框架，并处理好线程间的通信和状态同步。

6. 性能优化与工程化实践

一个可用的原型和一個健壯的产品之间，隔着许多优化工作。

6.1 模型量化与加速

Qwen-2-0.5B的原始FP32模型大约2GB。量化可以大幅减少模型体积和内存占用，并提升推理速度。

  • 动态量化 ：在模型加载时进行，对精度影响小，实现简单。
  • 静态量化 ：需要校准数据，能获得更好的性能提升。
  • 使用ONNX Runtime的量化工具 ：ONNX Runtime提供了 quantize 模块，可以很方便地将FP32模型量化为INT8。量化后的模型体积可减少至原来的1/4左右，CPU推理速度能有显著提升。 
    from onnxruntime.quantization import quantize_dynamic, QuantType
quantize_dynamic("./qwen2-0.5b.onnx",
                 "./qwen2-0.5b_int8.onnx",
                 weight_type=QuantType.QInt8)
    在C++代码中，加载量化后的 .onnx 模型文件即可，ONNX Runtime会自动处理量化后的运算。

6.2 缓存与批处理优化

  • KV Cache ：对于自回归生成模型，每次生成下一个token时，前面token计算的Key和Value（K/V）是可以缓存的。ONNX Runtime的 GreedySearch 或 BeamSearch 实现内部已经包含了KV Cache的优化。我们需要确保使用支持这些功能的模型转换方式（如使用 optimum 导出时选择正确的配置）。
  • 批处理 ：虽然桌面工具通常是单条处理，但如果你需要处理大量文本，可以将多条文本拼成一个批次（batch）进行推理，能更充分地利用GPU/CPU的并行计算能力，大幅提升吞吐量。这需要调整输入张量的 batch_size 维度。

6.3 内存管理与错误处理

  • Ort::Value的生命周期 ：确保 Ort::Value 在离开作用域前不被意外释放，特别是在跨函数传递时。
  • 异常捕获 ：ONNX Runtime的API会抛出 Ort::Exception 。务必用 try-catch 块包裹关键的模型加载和运行代码，给用户友好的错误提示，而不是程序崩溃。
  • 资源释放 ： Ort::AllocatorWithDefaultOptions 分配的名字字符串需要手动调用 allocator.Free() 释放，否则会导致内存泄漏。

6.4 部署与打包

为了让用户无需配置复杂环境就能使用，我们需要打包发布。

  1. 依赖收集 ：将编译好的 onnxruntime.dll 、模型文件（ .onnx ）、以及可能需要的其他动态库（如CUDA的 cudart64_xxx.dll ，如果用了GPU）都放在可执行文件旁边。
  2. Qt运行时 ：使用 windeployqt （Windows）或类似的工具，自动收集你的程序所依赖的所有Qt库。
  3. 创建安装包 ：使用 Inno Setup 或 NSIS 等工具，制作一个专业的安装程序，可以方便地设置开始菜单、桌面快捷方式等。

7. 常见问题与排查技巧实录

在实际开发中，我遇到了不少坑，这里记录下最典型的几个及其解决方法。

7.1 编译与链接问题

  • 问题 ：链接时报告 LNK2001: 无法解析的外部符号 ，错误指向ONNX Runtime的函数。
    • 排查 ：检查你的编译配置（Debug/Release）是否与ONNX Runtime库的配置一致。检查是否链接了正确的库文件（ .lib ）。
    • 解决 ：确保项目属性中“附加库目录”和“附加依赖项”设置正确。 Debug模式必须链接带 d 后缀的库 （如 onnxruntime.lib 对应Release， onnxruntimed.lib 对应Debug），如果库名不对应，需要手动在代码中通过宏选择。
  • 问题 ：程序运行时崩溃，提示“找不到 onnxruntime.dll ”。
    • 解决 ：将 onnxruntime.dll 放到可执行文件的同一目录下，或者将其路径添加到系统的 PATH 环境变量中。

7.2 模型推理错误

  • 问题 ： Ort::Exception ，错误信息包含 Invalid argument 或 Non-zero status code returned 。
    • 排查 ：这是最常见的问题。99%的原因是你的输入张量形状、数据类型或节点名称与模型期望的不匹配。
    • 解决 ：
      1. 用 Netron 打开你的 .onnx 模型，双击输入节点，记下它的 name 、 type （如 int64 ）、 shape （如 [1, -1] ，其中 -1 表示动态维度）。
      2. 在你的C++代码中，打印出你构造的 input_names_ 和 input_shape ，与Netron中的信息逐字对比。
      3. 确保 Ort::Value 创建时使用的数据类型（如 int64_t ）与模型要求的一致。
  • 问题 ：推理结果完全是乱码或重复的无效字符。
    • 排查 ：首先检查预处理（分词）和后处理（解码）是否正确。用一个非常短的句子（如“你好”），打印出 input_ids ，与你在Python中用相同分词器得到的结果对比。
    • 解决 ：分词不一致是罪魁祸首。确保C++端的分词逻辑与模型训练时使用的分词器完全一致。如果自己实现BPE分词有困难，前期强烈建议通过外部调用Python分词器来验证流程。

7.3 性能问题

  • 问题 ：第一次推理特别慢，后续变快。
    • 解释 ：ONNX Runtime在第一次运行时会对计算图进行优化和内核选择，这需要时间。属于正常现象。
  • 问题 ：CPU推理速度慢，无法接受。
    • 解决 ：
      1. 量化模型 ：这是提升CPU推理速度最有效的手段。
      2. 调整线程数 ：通过 session_options.SetIntraOpNumThreads() 和 SetInterOpNumThreads() 设置合适的线程数，通常设置为物理核心数。
      3. 使用更快的CPU后端 ：ONNX Runtime支持多种执行提供者（Execution Providers）。对于Intel CPU，可以尝试使用 OpenVINO EP；对于ARM CPU，可以使用 ACL （ARM Compute Library）EP。这需要在编译ONNX Runtime时启用相应选项。

7.4 内存占用过高

  • 问题 ：程序运行一段时间后内存持续增长。
    • 排查 ：检查是否有循环中持续创建 Ort::Env 或 Ort::Session 而未释放。整个应用应该只创建一次全局的 Ort::Env ，每个模型也只应加载一次 Ort::Session 。
    • 解决 ：确保 Ort::Value 等对象在不再使用时及时离开作用域被销毁。可以使用智能指针或确保它们在函数栈帧内创建。

开发这样一个将大模型嵌入本地C++应用的工具，最大的挑战不在于某个单一技术的深度，而在于对多个技术栈的整合能力。从Python的模型训练与转换，到C++的高效推理与内存管理，再到Qt的界面交互与跨平台部署，每一步都需要细致的考量。但一旦打通这个流程，其带来的优势是显而易见的：极致的性能、完全的隐私控制、以及脱离云服务的独立性。对于特定领域的垂直应用（如本文的文本润色），这种轻量化、本地化的AI集成方案，其实用价值会越来越突出。

Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

【无标题】

一开始觉得这样很偷懒，后来发现其实比手写还累。你得把需求描述得足够精确AI才能给对的东西，这个过程其实在逼你提升技术表达能力和代码审查能力。还有就是经常发现AI写的代码有隐藏bug，不仔细看根本看不出来。我会先在脑子里把功能逻辑想清楚，这步不能跳。然后用大白话描述给AI，尽量把边界条件和异常处理也说清楚。它生成之后我一行行读，看到不对的就标出来让它改，改完我再读，来回到我满意为止。大家用AI写代码

avatar AI编程社区

diansai-report-writer

AI助力电赛报告写作：开源工具diansai-report-writer问世 针对全国大学生电子设计竞赛中设计报告写作的痛点，开发者推出开源AI工具diansai-report-writer。该工具作为AI Skill文件，通过对话交互方式，按竞赛评分标准分8步生成完整报告框架，涵盖方案论证、理论计算、测试分析等核心内容，并内置10项防扣分检查机制。支持Claude Code/Codex CLI等

avatar AI编程社区
cover

Claude Code让普通人也能编程

avatar AI编程社区