AI 助理
文档备案控制台
开发者社区 人工智能 文章 正文

MNN createFromBuffer（一）

2024-08-27 470
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： MNN createFromBuffer（一）

一、MNN 资料

    MNN 是一个轻量级的深度神经网络推理引擎，在端侧加载深度神经网络模型进行推理预测。目前，MNN已经在阿里巴巴的手机淘宝、手机天猫、优酷等20多个App中使用，覆盖直播、短视频、搜索推荐、商品图像搜索、互动营销、权益发放、安全风控等场景。此外，IoT等场景下也有若干应用。

MNN GitHub

MNN 工作台产品手册

中文文档

MNN框架学习与分析

深入浅出 FlatBuffers 之 Schema

1、架构设计

    MNN 可以分为 Converter 和 Interpreter 两部分。

   Converter 由 Frontends 和 Graph Optimize 构成。前者负责支持不同的训练框架，MNN 当前支持 Tensorflow(Lite)、Caffe 和 ONNX(PyTorch/MXNet 的模型可先转为 ONNX 模型再转到 MNN )；后者通过算子融合、算子替代、布局调整等方式优化图。


   Interpreter 由 Engine 和 Backends 构成。前者负责模型的加载、计算图的调度；后者包含各计算设备下的内存分配、Op 实现。在 Engine 和 Backends 中，MNN 应用了多种优化方案，包括在卷积和反卷积中应用 Winograd 算法、在矩阵乘法中应用 Strassen 算法、低精度计算、Neon 优化、手写汇编、多线程优化、内存复用、异构计算等。

二、使用示例

  // 创建解释器 Interpreter
  auto net_ = Interpreter* createFromFile(const char* file);
  
  // 创建运行时 Runtime
  ScheduleConfig config;
  config.numberThread = 4;
  auto runtimeInfo = Interpreter::createRuntime({config});    

  // 创建会话 Session
  auto session = net_->createSession(config, runtimeInfo);

  // 执行推理
  net_->runSession(session1);

三、源码分析

1、createFromFile、createFromBuffer

    createFromFile、createFromBuffer 把模型读入，并放置在结构体 Content 的 buffer 中。

// source/core/Interpreter.cpp
Interpreter* Interpreter::createFromFile(const char* file) {
    Content* net = loadModelFile(file);
    if (nullptr == net) {
        return nullptr;
    }

    return createFromBufferInternal(net, true);
}

Interpreter* Interpreter::createFromBuffer(const void* buffer, size_t size) {
    if (nullptr == buffer || 0 == size) {
        MNN_PRINT("Buffer is null for create interpreter\n");
        return nullptr;
    }
    auto net = new Content;
    net->buffer.reset((int)size);
    if (nullptr == net->buffer.get()) {
        MNN_ERROR("Memory not enought!\n");
        return nullptr;
    }
    ::memcpy(net->buffer.get(), buffer, size);

    return createFromBufferInternal(net, true);
}

1.1 Content

// source/core/Interpreter.cpp
struct Content {
    AutoStorage<uint8_t> buffer;
    const Net* net = nullptr;
    std::vector<std::unique_ptr<Session>> sessions;
    std::map<Tensor*, const Session*> tensorMap;
    Session::ModeGroup modes;
    AutoStorage<uint8_t> cacheBuffer;
    std::string cacheFile;
    std::mutex lock;
    size_t lastCacheSize = 0;
    std::string bizCode;
    std::string uuid;
    std::string externalFile;
#ifdef MNN_INTERNAL_ENABLED
    std::map<std::string, std::string> basicLogginData;
    std::map<const Session*, std::tuple<int, int>> sessionInfo;
#endif
};

1.2 createFromBufferInternal

// source/core/Interpreter.cpp
Interpreter* Interpreter::createFromBufferInternal(Content* net, bool enforceAuth) {
    if (nullptr == net) {
        MNN_PRINT("Buffer is null for create interpreter\n");
        return nullptr;
    }
#ifndef MNN_BUILD_MINI
  // 验证模型
    flatbuffers::Verifier verify((const uint8_t*)(net->buffer.get()), net->buffer.size());
    if (false == VerifyNetBuffer(verify)) {
        MNN_PRINT("Invalidate buffer to create interpreter\n");
        delete net;
        return nullptr;
    }
#endif
  // 获取网络
    net->net = GetNet(net->buffer.get());
    if (nullptr == net->net->oplists()) {
        MNN_ERROR("Model has no oplist\n");
        delete net;
        return nullptr;
    }
    // 验证模型算子
    int opSize = net->net->oplists()->size();
    for (int i = 0; i < opSize; ++i) {
        auto op = net->net->oplists()->GetAs<Op>(i);
        if (nullptr == op || nullptr == op->outputIndexes()) {
            MNN_ERROR("Invalid Model, the %d op is empty\n", i);
            delete net;
            return nullptr;
        }
    }
    // 新建解释器
    return new Interpreter(net);
}

1.3 Net

// schema/current/MNN_generated.h
struct Net FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NetT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return NetTypeTable();
  }
  const flatbuffers::String *bizCode() const {
    return GetPointer<const flatbuffers::String *>(4);
  }
  const flatbuffers::Vector<flatbuffers::Offset<TensorDescribe>> *extraTensorDescribe() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TensorDescribe>> *>(6);
  }
  const ExtraInfo *extraInfo() const {
    return GetPointer<const ExtraInfo *>(8);
  }
  const flatbuffers::Vector<flatbuffers::Offset<Op>> *oplists() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Op>> *>(10);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputName() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(12);
  }
  ForwardType preferForwardType() const {
    return static_cast<ForwardType>(GetField<int8_t>(14, 0));
  }
  NetSource sourceType() const {
    return static_cast<NetSource>(GetField<int8_t>(16, 0));
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *tensorName() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(18);
  }
  int32_t tensorNumber() const {
    return GetField<int32_t>(20, 0);
  }
  Usage usage() const {
    return static_cast<Usage>(GetField<int8_t>(22, 0));
  }
  const flatbuffers::Vector<flatbuffers::Offset<SubGraphProto>> *subgraphs() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<SubGraphProto>> *>(24);
  }
  const flatbuffers::String *mnn_uuid() const {
    return GetPointer<const flatbuffers::String *>(26);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, 4) &&
           verifier.VerifyString(bizCode()) &&
           VerifyOffset(verifier, 6) &&
           verifier.VerifyVector(extraTensorDescribe()) &&
           verifier.VerifyVectorOfTables(extraTensorDescribe()) &&
           VerifyOffset(verifier, 8) &&
           verifier.VerifyTable(extraInfo()) &&
           VerifyOffset(verifier, 10) &&
           verifier.VerifyVector(oplists()) &&
           verifier.VerifyVectorOfTables(oplists()) &&
           VerifyOffset(verifier, 12) &&
           verifier.VerifyVector(outputName()) &&
           verifier.VerifyVectorOfStrings(outputName()) &&
           VerifyField<int8_t>(verifier, 14) &&
           VerifyField<int8_t>(verifier, 16) &&
           VerifyOffset(verifier, 18) &&
           verifier.VerifyVector(tensorName()) &&
           verifier.VerifyVectorOfStrings(tensorName()) &&
           VerifyField<int32_t>(verifier, 20) &&
           VerifyField<int8_t>(verifier, 22) &&
           VerifyOffset(verifier, 24) &&
           verifier.VerifyVector(subgraphs()) &&
           verifier.VerifyVectorOfTables(subgraphs()) &&
           VerifyOffset(verifier, 26) &&
           verifier.VerifyString(mnn_uuid()) &&
           verifier.EndTable();
  }
  NetT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NetT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Net> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NetT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

1.4 Interpreter

/** net data holder. multiple sessions could share same net. */
class MNN_PUBLIC Interpreter {
public:
    /**
     * @brief create net from file.
     * @param file  given file.
     * @return created net if success, NULL otherwise.
     */
    static Interpreter* createFromFile(const char* file);
    /**
     * @brief create net from buffer.
     * @param buffer    given data buffer.
     * @param size      size of data buffer.
     * @return created net if success, NULL otherwise.
     */
    static Interpreter* createFromBuffer(const void* buffer, size_t size);
    ~Interpreter();

public:
    /**
     * @brief create session with schedule config. created session will be managed in net.
     * @param config session schedule config.
     * @return created session if success, NULL otherwise.
     */
    Session* createSession(const ScheduleConfig& config);

    /**
     * @brief create multi-path session with schedule configs. created session will be managed in net.
     * @param configs session schedule configs.
     * @return created session if success, NULL otherwise.
     */
    Session* createMultiPathSession(const std::vector<ScheduleConfig>& configs);

    /**
     * @brief release session.
     * @param session   given session.
     * @return true if given session is held by net and is freed.
     */
    bool releaseSession(Session* session);

    /**
     * @brief call this function to get tensors ready. output tensor buffer (host or deviceId) should be retrieved
     *        after resize of any input tensor.
     * @param session given session.
     */
    void resizeSession(Session* session);

    /**
     * @brief call this function if don't need resize or create session any more, it will save a few memory that equal
     * to the size of model buffer
     */
    void releaseModel();

    /**
     * @brief Get the model buffer for user to save
     * @return std::make_pair(modelBuffer, modelSize).
     * @example:
     * std::ofstream output("trainResult.alinn")
     * auto buffer = net->getModelBuffer();
     * output.write((const char*)buffer.first, buffer.second);
     */
    std::pair<const void*, size_t> getModelBuffer() const;

    /**
     * @brief update Session's Tensor to model's Const Op
     * @param session   given session.
     * @return result of running.
     */
    ErrorCode updateSessionToModel(Session* session);

    /**
     * @brief run session.
     * @param session   given session.
     * @return result of running.
     */
    ErrorCode runSession(Session* session) const;

    /*
     * @brief run session.
     * @param session   given session.
     * @param before    callback before each op. return true to run the op; return false to skip the op.
     * @param after     callback after each op. return true to continue running; return false to interrupt the session.
     * @param sync      synchronously wait for finish of execution or not.
     * @return result of running.
     */
    ErrorCode runSessionWithCallBack(const Session* session, const TensorCallBack& before, const TensorCallBack& end,
                                     bool sync = false) const;

    /*
     * @brief run session.
     * @param session   given session.
     * @param before    callback before each op. return true to run the op; return false to skip the op.
     * @param after     callback after each op. return true to continue running; return false to interrupt the session.
     * @param sync      synchronously wait for finish of execution or not.
     * @return result of running.
     */
    ErrorCode runSessionWithCallBackInfo(const Session* session, const TensorCallBackWithInfo& before,
                                         const TensorCallBackWithInfo& end, bool sync = false) const;

    /**
     * @brief get input tensor for given name.
     * @param session   given session.
     * @param name      given name. if NULL, return first input.
     * @return tensor if found, NULL otherwise.
     */
    Tensor* getSessionInput(const Session* session, const char* name);
    /**
     * @brief get output tensor for given name.
     * @param session   given session.
     * @param name      given name. if NULL, return first output.
     * @return tensor if found, NULL otherwise.
     */
    Tensor* getSessionOutput(const Session* session, const char* name);

    /**
     * @brief get all input tensors.
     * @param session   given session.
     * @return all input tensors mapped with name.
     */
    const std::map<std::string, Tensor*>& getSessionOutputAll(const Session* session) const;
    /**
     * @brief get all output tensors.
     * @param session   given session.
     * @return all output tensors mapped with name.
     */
    const std::map<std::string, Tensor*>& getSessionInputAll(const Session* session) const;

public:
    /**
     * @brief resize given tensor.
     * @param tensor    given tensor.
     * @param dims      new dims. at most 6 dims.
     */
    void resizeTensor(Tensor* tensor, const std::vector<int>& dims);

    /**
     * @brief resize given tensor by nchw.
     * @param batch  / N.
     * @param channel   / C.
     * @param height / H.
     * @param width / W
     */
    void resizeTensor(Tensor* tensor, int batch, int channel, int height, int width);

    /**
     * @brief get backend used to create given tensor.
     * @param session   given session.
     * @param tensor    given tensor.
     * @return backend used to create given tensor, may be NULL.
     */
    const Backend* getBackend(const Session* session, const Tensor* tensor) const;

    /**
     * @brief get business code (model identifier).
     * @return business code.
     */
    const char* bizCode() const;

private:
    static Interpreter* createFromBufferInternal(Content* net);

    Content* mNet = nullptr;
    Interpreter(Content* net);

    Interpreter(const Interpreter&)  = delete;
    Interpreter(const Interpreter&&) = delete;
    Interpreter& operator=(const Interpreter&) = delete;
    Interpreter& operator=(const Interpreter&&) = delete;
};
} // namespace MNN

1.5 Interpreter::Interpreter

    把 Content 放入到 Interpreter 中

Interpreter::Interpreter(Content* net) {
    MNN_ASSERT(nullptr != net);
    mNet = net;
    // Store bizcode and uuid because we need them even after `releaseModel` is called.
    mNet->bizCode = std::string(mNet->net->bizCode() ? mNet->net->bizCode()->c_str() : "");
    mNet->uuid = std::string(mNet->net->mnn_uuid() ? mNet->net->mnn_uuid()->c_str() : "");
#ifdef MNN_INTERNAL_ENABLED
    mNet->basicLogginData = getBasicLoggingData();
    mNet->basicLogginData.emplace("ModelVersion", getModelVersion());
#endif
}


文章标签：
算法框架/工具
机器学习/深度学习
算法
搜索推荐
安全
Liuqz2009
目录
相关文章
雪碧有白泡泡
|
数据采集 数据可视化 数据挖掘
Python数据挖掘项目实战——自动售货机销售数据分析
Python数据挖掘项目实战——自动售货机销售数据分析
雪碧有白泡泡
779 0
Clawdbot
|
4月前
|
人工智能 API 网络安全
新手零基础｜阿里云计算巢部署OpenClaw+WhatsApp集成+千问Qwen3.6-Plus保姆级全攻略
2026年，开源AI智能体框架OpenClaw（曾用名Clawdbot，因形象被称为“小龙虾”）凭借“本地优先、主动执行、多渠道接入”的核心特性，成为个人与中小企业搭建专属AI助手的首选方案。它不局限于传统对话交互，而是能通过自然语言理解完成任务规划、工具调用、自动化执行，覆盖办公提效、客户服务、内容创作等全场景。
Clawdbot
737 2
小凡晓宇
|
人工智能 前端开发 Java
autojs非常见函数1
牙叔教程 简单易懂
小凡晓宇
2789 0
游客vhylg5zno4ifs
|
8月前
|
机器学习/深度学习 算法 关系型数据库
强化学习
强化学习（RL）是一种通过智能体与环境交互，以最大化累积奖励为目标的学习方法。核心包括状态、动作、奖励、策略与价值函数，依赖试错和延迟奖励机制。常见算法如Q-learning、PPO、DPO等，广泛应用于游戏、机器人及大模型训练。结合人类反馈（RLHF），可实现对齐人类偏好的智能行为优化。（239字）
游客vhylg5zno4ifs
858 0
蚝油菜花
|
机器学习/深度学习 存储 人工智能
MNN：阿里开源的轻量级深度学习推理框架，支持在移动端等多种终端上运行，兼容主流的模型格式
MNN 是阿里巴巴开源的轻量级深度学习推理框架，支持多种设备和主流模型格式，具备高性能和易用性，适用于移动端、服务器和嵌入式设备。
蚝油菜花
4540 18
MNN：阿里开源的轻量级深度学习推理框架，支持在移动端等多种终端上运行，兼容主流的模型格式
bruce_xiaowei
|
搜索推荐 索引 Python
使用Python批量生成个性化奖状
本文介绍了如何使用Python结合Pandas和python-pptx库，根据Excel数据表自动批量生成个性化PowerPoint格式的奖状文件，详细步骤包括导入库、读取数据、替换模板占位符及保存文件，有效提升工作效率。
bruce_xiaowei
760 64
郑小健
|
机器学习/深度学习 自然语言处理 PyTorch
PyTorch 中的动态图与静态图：理解它们的区别及其应用场景
【8月更文第29天】深度学习框架中的计算图是构建和训练神经网络的基础。PyTorch 支持两种类型的计算图：动态图和静态图。本文旨在阐述这两种计算图的区别、各自的优缺点以及它们在不同场景下的应用。
郑小健
4298 0
蚝油菜花
|
机器学习/深度学习 人工智能 编解码
StereoCrafter：腾讯开源将任意2D视频转换为立体3D视频的框架，适用于Apple Vision Pro等多种显示设备
StereoCrafter 是腾讯开源的框架，能够将单目2D视频转换为高保真度的立体3D视频，适用于多种显示设备。
蚝油菜花
1617 8
StereoCrafter：腾讯开源将任意2D视频转换为立体3D视频的框架，适用于Apple Vision Pro等多种显示设备
梦笔生花伟
|
存储 监控 算法
基于YOLOv5和树莓派4B平台
目标检测在计算机视觉领域中具有重要意义。YOLOv5（You Only Look One-level）是目标检测算法中的一种代表性方法，以其高效性和准确性备受关注，并且在各种目标检测任务中都表现出卓越的性能。本文将详细介绍如何在性能更强的计算机上训练YOLOv5模型，并将训练好的模型部署到树莓派4B上，通过树莓派的摄像头进行实时动物目标检测。 一、在电脑上训练YOLOv5模型 1. 安装Anaconda 在性能更强的计算机上安装Anaconda，方便管理Python环境和依赖。 从Anaconda官网（https://www.anaconda.com/products/distribu
梦笔生花伟
1278 6
chnjames
|
机器学习/深度学习 前端开发 JavaScript
WebAssembly：让前端性能突破极限的秘密武器
WebAssembly（简称 WASM）作为前端开发的性能加速器，能够让代码像 C++ 一样在浏览器中高速运行，突破了 JavaScript 的性能瓶颈。本文详细介绍了 WebAssembly 的概念、工作原理以及其在前端性能提升中的关键作用。通过与 JavaScript 的配合，WASM 让复杂运算如图像处理、3D 渲染、机器学习等在浏览器中流畅运行。文章还探讨了如何逐步集成 WASM，展示其在网页游戏、高计算任务中的实际应用。WebAssembly 为前端开发者提供了新的可能性，是提升网页性能、优化用户体验的关键工具。
chnjames
8317 2
WebAssembly：让前端性能突破极限的秘密武器

热门文章

最新文章

  • 1
    阿里云DTS踩坑经验分享系列｜如何使用DTS进行MySQL->ClickHouse同步
  • 2
    linux命令之ln
  • 3
    预测分析：R语言实现.
  • 4
    西门子S7-1200与S7-200的区别有哪些？
  • 5
    Halcon解决方案指南（18）OCR--字符识别
  • 6
    yolov5的完整部署（适合新人和懒人，一键安装）
  • 7
    创建SEO友好的内容让网站排名第一
  • 8
    IE浏览器Css选择的优先问题
  • 9
    Asp.net MVC 3 开发简单的企业系统开篇--数据库
  • 10
    【RAC】Creating a filesystem physical standby from ASM (RAC ) primary之一
  • 1
    阿里云 ESSD AutoPL 云盘完整指南：性能分层、计费规则与控制台操作
    272
  • 2
    同城O2O系统开发趋势分析：本地生活数字化下的新机会
    105
  • 3
    【AI】Agent 全栈进阶｜系统化学习路线专题
    920
  • 4
    创业团队开发聊天应用，需要解决哪些 IM 技术难题？
    158
  • 5
    互联网医院系统开发：HIS接口、电子病历与处方数据同步设计
    167
  • 6
    RAG系统测试实战：如何验证企业知识库AI助手是否可靠？
    161
  • 7
    风控系统如何从“管交易”延伸到“管IP”？IP风险画像落地指南
    147
  • 8
    LLM测试体系设计：从Prompt测试到模型质量评估的完整实践
    153
  • 9
    【AI时代软件项目管理系列】2. 从工具到数字员工：AI 在项目团队中的角色演进
    185
  • 10
    阿里云服务器弹性临时盘是什么？哪些ECS支持弹性临时盘？
    144

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！