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

MNN createFromBuffer（一）

2024-08-27 80
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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
目录
相关文章
Deephub
|
机器学习/深度学习 人工智能 API
使用TensorRT-LLM进行高性能推理
LLM的火爆之后，英伟达(NVIDIA)也发布了其相关的推理加速引擎TensorRT-LLM。TensorRT是nvidia家的一款高性能深度学习推理SDK。此SDK包含深度学习推理优化器和运行环境,可为深度学习推理应用提供低延迟和高吞吐量。而TensorRT-LLM是在TensorRT基础上针对大模型进一步优化的加速推理库，它号称可以增加4倍的推理速度。
Deephub
572 0
魔搭ModelScope社区小助手
|
3月前
|
存储 缓存 物联网
MNN推理框架将大模型放进移动端设备，并达到SOTA推理性能！
随着移动端（手机/平板等）算力、内存、磁盘空间的不断增长，在移动端部署大模型逐渐成为可能。在端侧运行大模型，可以有一系列好处：去除网络延迟，加快响应速度；降低算力成本，便于大规模应用；不需数据上传，保护用户稳私。
魔搭ModelScope社区小助手
777 13
MNN推理框架将大模型放进移动端设备，并达到SOTA推理性能！
Liuqz2009
|
7月前
|
缓存
MNN 执行推理（九）
MNN 执行推理（九）
Liuqz2009
69 1
游客s4romfez57yym
|
2月前
|
数据采集 JSON 数据处理
变色龙chameleon模型适配昇腾做训练开发
变色龙chameleon模型的官方仓库(https://github.com/facebookresearch/chameleon)并未开源训练的源代码，需要做训练代码的开发。
游客s4romfez57yym
62 14
技术员阿伟
|
3月前
|
机器学习/深度学习 人工智能 算法
《C++与 ONNX：构建跨平台推理引擎的智慧融合》
本文探讨了如何在 C++ 中整合 ONNX 格式模型，实现跨平台部署。首先介绍了 ONNX 的重要性和跨平台部署的意义，然后详细阐述了整合 ONNX 模型到 C++ 推理引擎的步骤，包括模型解析、计算图构建、节点计算功能实现、内存管理和跨平台适配。最后讨论了性能优化、模型兼容性和开发复杂性等挑战及解决方案，并展望了未来的发展前景。
技术员阿伟
79 9
阿里云云原生
|
10月前
|
机器学习/深度学习 人工智能 Cloud Native
大语言模型推理提速，TensorRT-LLM 高性能推理实践
大型语言模型（Large language models,LLM）是基于大量数据进行预训练的超大型深度学习模型，本文主要讲述TensorRT-LLM利用量化、In-Flight Batching、Attention、Graph Rewriting提升 LLM 模型推理效率。
阿里云云原生
101931 2
Liuqz2009
|
7月前
|
并行计算
MNN createRuntime（二）
MNN createRuntime（二）
Liuqz2009
65 2
技术君
|
10月前
|
存储 机器学习/深度学习 测试技术
mnn-llm: 大语言模型端侧CPU推理优化
mnn-llm: 大语言模型端侧CPU推理优化
技术君
1331 1
弹性计算-小弹
|
10月前
|
机器学习/深度学习 人工智能 前端开发
【Hello AI】计算优化编译器AIACC-AGSpeed
AIACC-AGSpeed（AIACC 2.0-AIACC Graph Speeding）是阿里云推出的一个基于PyTorch深度学习框架研发的计算优化编译器，用于优化PyTorch深度学习模型在阿里云GPU异构计算实例上的计算性能，相比原始的神龙AI加速引擎AIACC，AIACC-AGSpeed是AIACC 2.0产品的实现，是完全独立的产品形态，可以实现无感的计算优化功能。
弹性计算-小弹
338 0
极智视界
|
10月前
|
人工智能 并行计算 PyTorch
极智AI | 教你tensorrt实现mish算子
本文介绍了使用 tensorrt 实现 mish 算子的方法。
极智视界
167 1

热门文章

最新文章

  • 1
    域名ICP备案时网站备注到底该怎么写？全网最全教程来了
  • 2
    网络安全-反弹shell详解（攻击，检测与防御）
  • 3
    上海ACE同城会演讲实录|云原生分布式数据库PolarDB-X
  • 4
    4.[研磨设计模式笔记]适配器模式
  • 5
    ORA-12514: TNS: 监听程序当前无法识别连接描述符中请求的服务
  • 6
    基于Windows 7中的 Ribbon开发技术应用
  • 7
    LVS+keepalived负载均衡兼高可用集群配置
  • 8
    移动应用图片的福音--七牛云存储
  • 9
    oracle与sql server大批量存储过程可以替换部分
  • 10
    lxde 桌面环境使用compiz-gtk
  • 1
    阿里云认证全新发布【Apsara Clouder云计算专项技能认证：云服务器ECS入门】
    13
  • 2
    阿里云云计算ACA、大数据ACA、人工智能ACA三门认证升级调整公告
    12
  • 3
    阿里云新版ACE考试通关经历回顾
    13
  • 4
    算法系列之排序算法-堆排序
    15
  • 5
    认证故事|阿里云新版ACE全球第五人考试经历回顾
    11
  • 6
    阿里云新版ACE考试通关经历回顾
    25
  • 7
    2024阿里云天池大学生竞赛正式开赛，全网招募高校最强大脑！
    12
  • 8
    「阿里云认证」年度标杆企业奖揭晓
    12
  • 9
    对话阿里云CIO蒋林泉：AI时代，企业如何做好智能化系统建设？
    12
  • 10
    基于惯性加权PSO优化的目标函数最小值求解matlab仿真
    12

    • 相关课程

    更多
  • 云原生AI套件：一键训练大模型及部署GPU共享推理服务

    • 相关电子书

    更多
  • 《DeepRec：大规模稀疏模型训练引擎》
  • 端到端GPU性能优化 在深度学习场景下的应用实践
  • 函数计算让 AIGC 应用开发更简单

    • 相关实验场景

    更多
  • 【玩转ComfyUI】基于函数计算一键部署AI生图平台 ComfyUI
  • 基于函数计算实现AI推理
    • 下一篇
    通义万相：视觉生成大模型再进化