2. 程式人生 > >mxnet程式碼解析之mshadow

mxnet程式碼解析之mshadow

阿新 • • 發佈：2019-02-18

mshadow採用了表示式模板的技巧增強了c++矩陣庫的效能。
mshadow用於資料儲存結構的主要繼承脈絡如下：
Tensor->TRValue->RValueExp->Exp
繼承鏈的頂端是所有表示式的基類Exp：

template<typename SubType, typename DType, int exp_type>
struct Exp {
 public:
  /*! \return  subtype instance of current class */
  inline const SubType& self(void) const
 
 {
    return *static_cast<const SubType*>(this);
  }
  /*! \return reference of subtype instance of current class */
  inline SubType* ptrself(void) {
    return static_cast<SubType*>(this);
  }
};

這裡Exp定義的精髓就是通過self或ptrself可以獲得SubType的引用或指標，這為後面將SubType表示式作為模板引數傳遞後再獲得SubType提供了途徑。
RValueExp繼承於Exp，是所有右值的基類：

template<typename Container, typename DType>
class RValueExp: public Exp<Container, DType, type::kRValue> {
 public:
  inline const TransposeExp<Container, DType> T(void) const {
    return TransposeExp<Container, DType>(this->self());
  }
  /*! \brief operator overload */
 

  inline Container &operator+=(DType s) {
    ExpEngine<sv::plusto, Container, DType>::Eval(this->ptrself(), scalar<DType>(s));
    return *(this->ptrself());
  }
  /*! \brief operator overload */
  inline Container &operator-=(DType s) {......}
  /*! \brief operator overload */
  inline Container &operator*=(DType s) {......}
  /*! \brief operator overload */
  inline Container &operator/=(DType s) {......}

  /*! \brief operator overload */
  inline Container &__assign(DType s) {
    ExpEngine<sv::saveto, Container, DType>::Eval(this->ptrself(), scalar<DType>(s));
    return *(this->ptrself());
  }
  /*! \brief  we can not define container = container */
  template<typename E, int etype>
  inline Container &__assign(const Exp<E, DType, etype> &exp) {
    ExpEngine<sv::saveto, Container, DType>::Eval(this->ptrself(), exp.self());
    return *(this->ptrself());
  }
  /*! \brief operator overload, assign */
  inline Container &__assign(const Exp<Container, DType, type::kRValue> &exp);

  /*! \brief implementation of operator+= */
  template<typename E, int etype>
  inline Container &operator+=(const Exp<E, DType, etype> &exp) {
    ExpEngine<sv::plusto, Container, DType>::Eval(this->ptrself(), exp.self());
    return *(this->ptrself());
  }
  /*! \brief implementation of operator-= */
  template<typename E, int etype>
  inline Container &operator-=(const Exp<E, DType, etype> &exp) {......}
  /*! \brief implementation of operator*= */
  template<typename E, int etype>
  inline Container &operator*=(const Exp<E, DType, etype> &exp) {......}
  /*! \brief implementation of operator/= */
  template<typename E, int etype>
  inline Container &operator/=(const Exp<E, DType, etype> &exp) {......}
};

RValueExp類中的ExpEngine類過載了四種表示式型別(kMapper、kChainer、kRValue、kComplex)的Eval函式 :

template<typename SV, typename RV, typename DType>
struct ExpEngine {
  template<typename E>
  inline static void Eval(RV *dst,const Exp<E, DType, type::kMapper> &exp) {
    MapExp<SV>(dst, exp);
  }
  template<typename E>
  inline static void Eval(RV *dst,const Exp<E, DType, type::kChainer> &exp) {
    MapExp<SV>(dst, exp);
  }
  template<typename E>
  inline static void Eval(RV *dst,const Exp<E, DType, type::kRValue> &exp) {
    MapExp<SV>(dst, exp);
  }
  //用於dot
  template<typename E>
  inline static void Eval(RV *dst,const Exp<E, DType, type::kComplex> &exp) {
    ExpComplexEngine<SV, RV, E, DType>::Eval(dst->ptrself(), exp.self());
  }
};

TRValue是所有可能的tensor的超類

template<typename Container, typename Device, int dimension, typename DType>
struct TRValue: public expr::RValueExp<Container, DType> {
};

終於到了Tensor類的定義：

template<typename Device, int dimension,
         typename DType MSHADOW_DEFAULT_DTYPE>
struct Tensor: public TRValue<Tensor<Device, dimension, DType>,
                              Device, dimension, DType> {
 public:
  static const bool kDevCPU = Device::kDevCPU;
  static const int  kSubdim = dimension - 1;

  /*! \brief pointer to the data */
  DType *dptr_;
  /*! \brief shape of the tensor */
  Shape<dimension> shape_;
  /*!
   * \brief storing the stride information in x dimension
   *    this is used to deal with pitch allocation in gpu or sse(align x dimension to 64bit) for efficiency
   */
  index_t stride_;

  Stream<Device> *stream_;

  //各種建構函式
  ......
  /*! 從 data pointer 和shape構造Tensor  */
  MSHADOW_XINLINE Tensor(DType *dptr,
                         const Shape<dimension> &shape,
                         index_t stride, Stream<Device> *stream)
      : dptr_(dptr), shape_(shape), stride_(stride), stream_(stream) {}
  ......
  ......

  MSHADOW_XINLINE Tensor<Device, dimension, DType>
  Slice(index_t begin, index_t end) const {
    Shape<dimension> s = this->shape_;
    s[0] = end - begin;
    return Tensor<Device, dimension, DType>(dptr_ + this->MemSize<1>() * begin,
                                            s, stride_, stream_);
  }
  /*!\brief implement the assignment of same type */
  inline Tensor<Device, dimension, DType> &
  operator=(const Tensor<Device, dimension, DType> &exp) {
    dptr_ = exp.dptr_;
    shape_ = exp.shape_;
    stride_ = exp.stride_;
    stream_ = exp.stream_;
    return *this;
  }
  /*!\brief functions to fit expression template */
  template<typename E, int etype>
  inline Tensor<Device, dimension, DType> &
  operator=(const expr::Exp<E, DType, etype> &exp) {
    return this->__assign(exp);
  }
  /*!\brief functions to fit expression template */
  inline Tensor<Device, dimension, DType> &operator=(const DType &exp) {
    return this->__assign(exp);
  }
};

Tensor的shape與numpy.shape不一樣，最低維度從shape_[0]開始，過載操作符“=”除了拷貝已有Tensor，還可賦值中間運算結果表示式Exp，以及賦值標量。這裡對operator =的過載將運算操作延遲到了賦值階段，實現了Lazy Evaluation，避免了臨時記憶體分配。特別地，DotExp在operator =中實行lazily evaluate， 將矩陣的乘法重定向到了blas庫。

mshadow用於表示式操作的類（DotExp、BinaryMapExp、UnaryMapExp）同樣繼承於Exp基類，其特點是該表示式操作類自身也作為模板引數傳遞給Exp，以BinaryMapExp為例：

template<typename OP, typename TA, typename TB, typename DType, int etype>
struct BinaryMapExp: public Exp<BinaryMapExp<OP, TA, TB, DType, etype>,
                                DType, etype> {
  /*! \brief left operand */
  const TA &lhs_;
  /*! \brief right operand */
  const TB &rhs_;
  /*! \brief constructor */
  explicit BinaryMapExp(const TA &lhs, const TB &rhs)
      :lhs_(lhs), rhs_(rhs) {}
};

template<typename OP, typename TA, typename TB, typename DType, int ta, int tb>
inline BinaryMapExp<OP, TA, TB, DType, (ta|tb|type::kMapper)>
MakeExp(const Exp<TA, DType, ta> &lhs, const Exp<TB, DType, tb> &rhs) {
  return BinaryMapExp<OP, TA, TB, DType,
                      (ta|tb|type::kMapper)>(lhs.self(), rhs.self());
}

template<typename OP, typename TA, typename TB, typename DType, int ta, int tb>
inline BinaryMapExp<OP, TA, TB, DType, (ta|tb|type::kMapper)>
F(const Exp<TA, DType, ta> &lhs, const Exp<TB, DType, tb> &rhs) {
  return MakeExp<OP>(lhs, rhs);
}

template<typename TA, typename TB, typename DType, int ta, int tb>
inline BinaryMapExp<op::plus, TA, TB, DType, (ta|tb|type::kMapper)>
operator+(const Exp<TA, DType, ta> &lhs, const Exp<TB, DType, tb> &rhs) {
  return MakeExp<op::plus>(lhs, rhs);
}
......
......

BinaryMapExp是雙目運算的表示式類，MakeExp是用來生成BinaryMapExp類物件的函式，F是自定義操作的函式，F< OP >(lhs, rhs)描述了一個新的雙目運算，除此以外，+-*/等操作符過載函式也呼叫MakeExp建立BinaryMapExp。
這些用於表示式操作的類（DotExp、BinaryMapExp、UnaryMapExp）表示一個運算操作的中間結果，且可以遞迴表示（由Plan的Eval函式完成），實現了lengthy equations的解析。

真正用於遞迴呼叫eval的是Plan類：

template<typename ExpType, typename DType>
class Plan {
 public:
  /*!
   * \brief evaluate the expression at index [y][x]
   *  to be implemented by SubType, for RValue, the return type will be DType &
   */
  MSHADOW_XINLINE DType Eval(index_t y, index_t x) const;
};

// tensor的plan函式
template <typename Device, int dim, typename DType>
class Plan<Tensor<Device, dim, DType>, DType> {
 public:
  explicit Plan(const Tensor<Device, dim, DType> &t)
      : dptr_(t.dptr_), stride_(t.stride_) {}
  // for RValue, the return type should be reference
  MSHADOW_XINLINE DType &REval(index_t y, index_t x) {
    return dptr_[y * stride_ + x];
  }
  // const evaluation
  MSHADOW_XINLINE const DType &Eval(index_t y, index_t x) const {
    return dptr_[y * stride_ + x];
  }

 private:
  DType  *dptr_;
  index_t stride_;
};
......
......
// 雙目表示式的plan
template<typename OP, typename TA, typename TB, int etype, typename DType>
class Plan<BinaryMapExp<OP, TA, TB, DType, etype>, DType> {
 public:
  explicit Plan(const Plan<TA, DType> &lhs, const Plan<TB, DType> &rhs)
      : lhs_(lhs), rhs_(rhs) {}
  MSHADOW_XINLINE DType Eval(index_t y, index_t x) const {
    return OP::Map(lhs_.Eval(y, x), rhs_.Eval(y, x));
  }

 private:
  Plan<TA, DType> lhs_;
  Plan<TB, DType> rhs_;
};

呼叫模板函式MakePlan從表示式生成Plan，再以BinaryMapExp表示式為例：

template<typename T, typename DType>
inline Plan<T, DType> MakePlan(const RValueExp<T, DType> &e) {
  return Plan<T, DType>(e.self());
}

template<typename OP, typename TA, typename TB, typename DType, int etype>
inline Plan<BinaryMapExp<OP, TA, TB, DType, etype>, DType>
MakePlan(const BinaryMapExp<OP, TA, TB, DType, etype> &e) {
  return Plan<BinaryMapExp<OP, TA, TB, DType, etype>,
              DType>(MakePlan(e.lhs_), MakePlan(e.rhs_));
}

已知ExpEngine中過載的eval中呼叫了MapExp來實現將Plan的結果傳遞給目標Exp的作用，MapExp又通過直接或間接（為處理sse優化而加入一箇中間類MapExpCPUEngine）呼叫MapPlan實現上述作用。

Tensor的維數在定義後就固定了，因此在圖模型中需要一個更為抽象靈活的資料結構，這就是TBlob：

class TBlob {
 public:
  /*! \brief pointer to the data */
  void *dptr_;
  /*! \brief shape of the tensor */
  TShape shape_;
  /*!
   * \brief storing the stride information in x dimension
   */
  index_t stride_;
  /*! \brief device mask of the corresponding device */
  int dev_mask_;
  /*! \brief type flag of the tensor blob */
  int type_flag_;
  ......
  template<typename Device, int dim, typename DType>
  inline Tensor<Device, dim, DType> get(Stream<Device> *stream = NULL) const {...}

  template<typename Device, int dim, typename DType>
  inline Tensor<Device, dim, DType> get_with_shape(const Shape<dim> &shape,
                                                   Stream<Device> *stream = NULL) const
  {
    CHECK(Device::kDevMask == dev_mask_)
      << "TBlob.get: device type do not match specified type";
    CHECK(DataType<DType>::kFlag == type_flag_)
      << "TBlob.get_with_shape: data type do not match specified type."
      << "Expected: " << type_flag_ << " v.s. given " << DataType<DType>::kFlag;
    CHECK_EQ(this->CheckContiguous(), true) << "TBlob.get_reshape: must be contiguous";
    CHECK_EQ(this->shape_.Size(), shape.Size())
      << "TBlob.get_with_shape: new and old shape do not match total elements";
    return Tensor<Device, dim, DType>(static_cast<DType*>(dptr_),
                                      shape,
                                      shape[dim - 1],
                                      stream);
  }
  ......
  template<typename Device, typename DType>
  inline Tensor<Device, 2, DType> FlatTo2D(Stream<Device> *stream = NULL) const {}
  ......
  template<typename Device, typename DType>
  inline Tensor<Device, 3, DType> FlatTo3D(int axis, Stream<Device> *stream = NULL)  
  const {}
  ......                           
}

TBlob不涉及任何算數運算，也沒有隱式的記憶體分配與釋放，它就像一個指標類，在需要的時候呼叫get、get_with_shape、FlatTo2D、FlatTo3D等獲得固定維數的Tensor來做更多的操作。Tshape與TBlob類似，在需要的時候呼叫get、FlatTo2D等獲得Tensor對應的Shape。

相關推薦

mxnet程式碼解析之mshadow

mshadow採用了表示式模板的技巧增強了c++矩陣庫的效能。 mshadow用於資料儲存結構的主要繼承脈絡如下： Tensor->TRValue->RValueExp->Exp 繼承鏈的頂端是所有表示式的基類Exp： templa

Jquery 萬行程式碼解析之路(一)—jquery物件

從今天開始讀Jquery原始碼，並開始解析原始碼的思路，記下來備忘。後邊會整理出一個完整的。 Write less,Do more！—Jquery理念 想必只要是學過前端，學過html+css+js這一套用來寫網頁的技術的人必然不能不知道大名鼎鼎的J

MXnet程式碼實戰之多類邏輯迴歸

多類邏輯迴歸 在談多類邏輯迴歸之前，我們先要認識邏輯迴歸。邏輯迴歸（Logistic Regression）是機器學習中的一種分類模型，雖然它的名字有個迴歸，其實它是做分類的。說簡單點，就是線上性迴歸的輸出加入了sigmoid 函式，使得結果輸出變成了二分類。

Android Design: 九種常見Activity及程式碼解析之"Navigation Drawer Activity"

Navigation Drawer Activity 如果我們是直接new一個“Navigation Drawer Activity”,自動生成的程式碼如下： NavigationDrawerActivity.java public class NavigationDra

MXnet程式碼實戰之多層感知機

多層感知機介紹 多層感知器（MLP，Multilayer Perceptron）是一種前饋人工神經網路模型。與上文提到的多類邏輯迴歸非常相似，主要區別在：輸入層和輸出層之間插入了一個到多個隱含層。 如下圖，黃色的點為輸入層，中間為隱含層，綠色的點為輸出層：

程式碼解析之grid_map庫grid_map_core工程（二）——move功能

         grid_map庫的說明中，強調了因為該庫採用了circular buffer的資料結構，使得地圖移動時無需重新分配記憶體空間、無需移動和複製記憶體資料，即可儲存新的地圖資料，大大提高了效率。本文主要分析該功能的實現原理——move。標頭檔案中宣告如下：

程式碼解析之range_sensor_layer中costmap更新的方法和模型（二）

         隔了一段時間回頭再看costmap的更新，結合自己使用gridmap的經歷，發現costmap中那麼多程式碼無非是做2件事情，一是限定感測器探測掃描過的區域大小和邊界（即後續要更新的區域），二是根據感測器模型和貝葉斯方法計算上述區域中所有柵格的更新後的被佔據

TP5.1的核心程式碼解析之Facade

Facade是什麼呢，目前看是一個用來方便實現原有類（未定義靜態方法）的靜態方式呼叫對應的方法的類。 具體Facade的實現如下： 首先看核心檔案： \thinkphp\base.php 中的： // 註冊核心類的靜態代理 Facade::bind([

uvc攝像頭程式碼解析之描述符

module_init(uvc_init); //1.模組入口 2.初始化函式 static int __init uvc_init(void) // 2.初始化函式 { int result; result = usb_register(&uvc_driver.driver); // 3

Matlab程式設計之——卷積神經網路CNN程式碼解析

卷積神經網路CNN程式碼解析 deepLearnToolbox-master是一個深度學習matlab包，裡面含有很多機器學習演算法，如卷積神經網路CNN，深度信念網路DBN，自動編碼AutoE ncoder（堆疊SAE，卷積CAE）的作者是 RasmusBerg Palm 今天給介紹d

基於C語言的編碼器（光耦）程式設計之C程式碼解析（二）

程式碼需要一個.c文件和一個.h文件。 .h文件主要配置編碼器相關引數 #define OptoKnobNumber 2 /* 旋鈕個數配置 */ #define _01_SH

【原創】大資料基礎之Spark（4）RDD原理及程式碼解析

一 簡介 spark核心是RDD，官方文件地址：https://spark.apache.org/docs/latest/rdd-programming-guide.html#resilient-distributed-datasets-rdds官方描述如下：重點是可容錯，可並行處理 Spark r

【原創】大資料基礎之Spark（5）Shuffle實現原理及程式碼解析

一 簡介 Shuffle，簡而言之，就是對資料進行重新分割槽，其中會涉及大量的網路io和磁碟io，為什麼需要shuffle，以詞頻統計reduceByKey過程為例， serverA：partition1: (hello, 1), (word, 1)serverB：partition2: (hell

爬蟲解析之xls檔案處理（附錄甘肅省爬蟲解析程式碼）

用jxl檔案處理xls表格。突然發現if迴圈真的是感受到了溫暖 package test; import java.io.File; import java.io.FileInputStream; import java.io.FileWriter; import java.io.IOE

android程式碼混淆之Gson解析為null

自古英雄不問出處，奈何我卻不是英雄！ 如果你的專案中用到了Gson。並且你的程式在混淆之後執行後發現獲取了資料，但是在看解析成Gson的時候都是null，那麼你就要加上下面的程式碼。這裡要注意最後一行。這個是你javabean物件的路徑 -keepattrib

Deep Learning學習 之 CNN程式碼解析（MATLAB）

MATLAB實現CNN一般會用到deepLearnToolbox-master。但是根據Git上面的說明，現在已經停止更新了，而且有很多功能也不太能夠支援，具體的請大家自習看一看Git中的README。 deepLearnToolbox-master是一個深度

混淆程式碼問題之沒有jar包的解析Error:Execution failed for task ':app:transformClassesAndResourcesWithProguardForRel

Android Studio 混淆 Error:Execution failed for task ':app:transformClassesAndResourcesWithProguardForRelease'. > Java.io.IOException:

機器學習實戰之K-近鄰演算法總結和程式碼解析

            機器學習實戰是入手機器學習和python實戰的比較好的書，可惜我現在才開始練習程式碼！先宣告：本人菜鳥一枚，機器學習的理論知識剛看了一部分，python的知識也沒學很多，所以寫程式碼除錯的過程很痛可！但是還是挨個找出了問題所在，蠻開心的！看了很多大牛

caffe之Data_Layer層程式碼解析

一、 caffe的資料輸入層， 根據不同的輸入方式有不同的層， 因為本人最早接觸的是通過lmdb資料庫輸入資料，而lmdb對應這DataLayer層， 其實還有一個常用的就是ImageDataLayer層， 這個層 可以直接輸入圖片的路徑， 而不需轉換。     上面這張

CC2541之回撥函式程式碼解析

轉自：香瓜部落格回撥函式，解析程式碼： 一 、定義一個 “ 成員為函式指標 ” 的結構體 1 ）定義一個函式指標 /** * Central Event Callback Function */ typedef void (*pfnGapCentralRoleEventCB