KuiperInfer深度学习推理框架-源码阅读和二次开发(1):算子开发流程之算子注册

前言:KuiperInfer是一个从零实现一个高性能的深度学习推理库,中文教程已经非常完善了。本系列博客主要是自己学习的一点笔记和二次开发的教程,欢迎更多的AI推理爱好者一起来玩。这篇写一下算子开发流程,重点是算子注册机制和背后的知识点,并和其他的深度学习框架(如AI编译器CINN、paddle推理inference等)对比,总结其中的异同点。

目录

算子注册

设计模式

算子注册表

算子开发模板

后记

参考


算子注册

设计模式

kuiper中的算子注册实现主要是由工厂模式和单例模式实现的,当中的细节讲解请看博客:自制深度学习推理框架-第五课-起飞!框架中的算子注册机制 - 知乎

工厂模型的简介:https://www.cnblogs.com/horacle/p/15494358.html

工厂模式概念:用一个简单的类来创建实例的过程便称为工厂,用工厂方式代替外部new操作的一种设计模式称为工厂模式。这是一种创建型模式,它提供了一个创建对象的最佳方式。在工厂模式中,我们创建对象时不会对上层暴露创建逻辑,而是通过使用一个共同结构来指向新创建的对象。

工厂模式分类:简单工厂模式、工厂方法模式、抽象工厂模式。

意图:定义一个常见对象的接口,让子类自己决定实例化哪个工厂类,工厂模式使其创建过程延迟到子类进行。

问题解决:主要解决接口选择问题。

解决方法:让其子类实现工厂接口,返回的是一个抽象的产品。

使用前提:1、编码时不能预见需要创建哪种类的实例(不同的条件下发创建不同实例);2、系统不应依赖于产品类实例如何被创建、组合和表达的细节。

关键代码:子类执行创建过程。

优点:1、使代码结构清晰,有效地封装变化,提高拓展性;2、屏蔽产品的具体实现,调用者只关心产品的接口;3、降低耦合度

单例模式的细节可看:【C++】C++ 单例模式总结(5种单例实现方法)_单例模式c++实现_unonoi的博客-CSDN博客

单例模式是指在整个系统生命周期内,保证一个类只能产生一个实例,确保该类的唯一性,并提供一个访问它的全局访问点。

一般的单例模式结构如下:

class Singleton {
public:
    static Singleton* GetInstance(); //供用户获取单例的全局访问点
protected:
    Singleton();  //方便继承,同时保证类的用户无法直接构造该类的实例
    Singleton(const Singleton&);
private:
    //class members
};

保证唯一的全局访问点的能力是通过全局静态变量实现的,全局静态变量能够实现对象的全局访问,但这不能防止你实例化多个类实例。为了实现上述要求,我们需要加强类的设计,让类自身保证其实例仅有一个。也就是说,“这个类可以保证没有其它实例可以被创建,并且它可以提供一个访问该实例的方法。"

例如所有的op都是单例模式实现的,因为要确保这个op的唯一性,以relu算子为例:

class ReluLayer : public Layer {
 public:
  ReluLayer() : Layer("Relu") {

  }
  InferStatus Forward(const std::vector>> &inputs,
                      std::vector>> &outputs) override;

  static ParseParameterAttrStatus GetInstance(const std::shared_ptr &op,
                                              std::shared_ptr &relu_layer);
};
}
#endif //KUIPER_INFER_SOURCE_LAYER_BINOCULAR_RELU_HPP_

在GetInstance()方法中实现实例化这个类:

ParseParameterAttrStatus ReluLayer::GetInstance(
    const std::shared_ptr &op,
    std::shared_ptr &relu_layer) {
  CHECK(op != nullptr) << "Relu operator is nullptr";
  relu_layer = std::make_shared();
  return ParseParameterAttrStatus::kParameterAttrParseSuccess;
}

然后需要注意到的是这里的注册表也是要用单例模式实现的,一切的一切实现关键都是static,因为static存放在静态区,这是一个全局的,可以复习一下C++的内存结构:

堆区:是由程序员手动申请(new)与释放(delete)的内存区域。从低地址向高地址申请;内存空间大、存储地址不连续,一般是链式的;速度较慢。
栈区:由编译器自动分配和释放,主要存储 函数的参数值、函数内部的变量的值、函数调用的空间。从高地址向低地址申请;容量有限;速度较快;存储地址连续,会溢出。
代码区:又叫文本段(.text),存放着程序的机器代码,可执行指令就是存储在这里的,这里的代码是只读的。
全局区(静态区):全局变量和静态变量是存储在这里的。初始化的全局变量和静态变量在一块区域(.data),未初始化的全局变量和未初始化的静态变量在相邻的另一块区域(.bbs)。系统结束后由系统释放。
常量区:常量字符串放在这里,程序结束后,由系统进行释放。

所以要保证注册表唯一性,这里也得使用单例模式,在创建CreateRegistry的时候用static:

LayerRegisterer::CreateRegistry &LayerRegisterer::Registry() {
  static CreateRegistry *kRegistry = new CreateRegistry();
  CHECK(kRegistry != nullptr) << "Global layer register init failed!";
  return *kRegistry;
}

算子注册表

核心是操作和维护注册表,这是一组键值对,key是对应的OpType,用来查找对应的value,value是用于创建该层的对应方法(Creator)。

typedef std::map CreateRegistry;

注册creator就是向这个哈希表中插入键值对:

void LayerRegisterer::RegisterCreator(const std::string &layer_type,
                                      const Creator &creator) {
  CHECK(creator != nullptr);
  CreateRegistry ®istry = Registry();
  CHECK_EQ(registry.count(layer_type), 0)
      << "Layer type: " << layer_type << " has already registered!";
  registry.insert({layer_type, creator});
}

LayerRegisterer::CreateRegistry &LayerRegisterer::Registry() {
  static CreateRegistry *kRegistry = new CreateRegistry();
  CHECK(kRegistry != nullptr) << "Global layer register init failed!";
  return *kRegistry;
}

需要注意一下Creator的定义:

typedef ParseParameterAttrStatus (*Creator)(const std::shared_ptr &op, std::shared_ptr &layer);

这是一个typedef函数指针的语法糖,表示Creator是一个函数指针,每一个Creator表示一个工厂。返回值类型是ParseParameterAttrStatus,参数是const std::shared_ptr &op, std::shared_ptr &layer。关于这个语法的详细讲解请看:typedef 函数指针的用法_typedef函数指针_Rebirth_2017的博客-CSDN博客

算子开发模板

目前框架实现了二三十个算子,对比CINN实现80多个算子,总共需要实现的算子有一百多个。这些算子开发的方法都很有套路,这里简单的介绍一下:

hpp文件里需要声明一个Forward和一个用于实现单例模式的GetInstance,然后构造函数需要explicit修饰,表示不能发生相应的隐式类型转换,只能以显式的方式进行类型转换。

#ifndef KUIPER_INFER_SOURCE_LAYER_SIGMOID_HPP_
#define KUIPER_INFER_SOURCE_LAYER_SIGMOID_HPP_
#include "layer/abstract/layer.hpp"
namespace kuiper_infer {
class SigmoidLayer : public Layer {
 public:
  explicit SigmoidLayer(): Layer("Sigmoid"){

  }
  InferStatus Forward(const std::vector>> &inputs,
                      std::vector>> &outputs) override;

  static ParseParameterAttrStatus GetInstance(const std::shared_ptr &op,
                                                        std::shared_ptr &sigmoid_layer);
};
}

cpp文件里首先实现单例函数的GetInstance方法,这里需要复习一下智能指针的使用方法。

ParseParameterAttrStatus SigmoidLayer::GetInstance(const std::shared_ptr &op,
                                                   std::shared_ptr &sigmoid_layer) {
  CHECK(op != nullptr) << "Sigmoid operator is nullptr";
  sigmoid_layer = std::make_shared();
  return ParseParameterAttrStatus::kParameterAttrParseSuccess;
}

kuiper的尽可能地使用了智能指针管理内存,其实主要就是shared_ptr。

在 C++ 中没有垃圾回收机制,必须自己释放分配的内存,否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针(smart pointer)。智能指针是存储指向动态分配(堆)对象指针的类,用于生存期的控制,能够确保在离开指针所在作用域时,自动地销毁动态分配的对象,防止内存泄露。智能指针的核心实现技术是引用计数,每使用它一次,内部引用计数加1,每析构一次内部的引用计数减1,减为0时,删除所指向的堆内存。

关于只能指针强烈推荐复习一下大丙的文章!

共享智能指针 | 爱编程的大丙 共享智能指针 | 爱编程的大丙

这里还是用刚才的GetInstance当做例子吧,我们本来是要把

relu_layer = std::make_shared();

写作是

ReluLayer *relu_layer = new ReluLayer();

后记

本来是想讲完整个算子开发流程的,但是不知不觉写了6k+,还是分成几篇博客系列介绍吧~

这篇博客完全是自己的个人笔记,仅供自我参考!还是强烈建议去看up主的教程!

参考

  • 自制深度学习推理框架系列-手写第一个算子Relu - 知乎
  • 自制深度学习推理框架-第六课-MaxPooling算子的实现_哔哩哔哩_bilibili
  • 深度学习编器CINN(2):以reciprocal算子为例看算子开发方法_深度学习算子开发_沉迷单车的追风少年的博客-CSDN博客

你可能感兴趣的:(深度学习,人工智能,模型部署,深度学习编译器,编译器)