从零开始山寨Caffe·玖：BlobFlow
听说Google出了TensorFlow，那么Caffe应该叫什么？
——BlobFlow
神经网络时代的传播数据结构
我的代码
我最早手写神经网络的时候，Flow结构是这样的：
struct Data { vector<double> feature; int y; Data(vector<double> feature,int y):feature(feature),y(y) {} }; vector<double> u_i,v_i,u_j,v_j;
很简陋的结构，主要功能就是利用vector存一下每层正向传播的值。
Word2Vec
后来我看了Google的Mikolov大神的Word2Vec的源码，它的Flow结构是这样的:
real *neu1 = (real *)calloc(doc->layer1_size, sizeof(real));
然后我吐槽了一下，这功能不是比我还弱么，vector起码还能提供STL的基础功能。
(注：Word2Vec源码是以CPU多线程和内存操作快而著称的，简陋但速度快）
Theano
再后来，我学习了Theano，它的Flow结构是这样的:
input=theano.tensor.matrix('x') class DataLayer(object): def __init__(self,input,batch_size,size): self.batch_size=batch_size self.size=size self.input=input self.params=None def get_output(self): output=self.input if type(self.size) is tuple: #Mode: 2D output=output.reshape((self.batch_size,self.size[2],self.size[1],self.size[0])) else: #Mode: 1D output=output.reshape((self.batch_size,self.size)) return output
Bengio组模仿物理学的张量(Tensor)的概念，创建了Theano的Tensor系统。
Dim为0的叫常量，Dim为1的叫向量，Dim=2的叫矩阵，Dim>2就没名字了，且Dim可以无限扩大。
Tensor的出现，很好地规避了机器学习研究者不会写代码的问题（比如上节出现的简陋结构）。
同时，随着mini-batch、conv等方法在深度学习中的大规模使用，我们的Flow结构显然需要多维化。
由于是操作多维空间，经常需要维度切换，reshape函数自然成了Tensor的核心函数。
(reshape的概念最早应该来自Python的科学计算库numpy，Theano的Tensor系统，很大程度上在重写numpy）
TensorFlow
再后来，Google把Andrew Ng开发的一代深度学习框架DistBelief给换掉了，第二代叫TensorFlow。
按照官方的说法，取名TensorFlow(2015)的原因是因为系统里主要是Tensor在Flow。
推测一下DistBelief(2011)和Theano(NIPS2012)的公布时间，我们大概推测，DistBelief的Flow结构估计相当Low。
按照Caffe(2013)作者贾大神的说法，他参与了TensorFlow的主体开发。
所以，TensorFlow里的Tensor结构，不难看出来，是借鉴了Theano(2012)和Caffe(2013)的综合体。
符号系统
尽管Caffe(2013)具有类似Tensor的Blob结构，但是和Theano(2012)、TensorFlow(2015)的Tensor相比，
还是比较弱的。核心原因是，Tensor的出发点是建立在符号系统上的，而Caffe(2013)只是最暴力的执行代码。
按照MXNet的陈天奇大神在MS研究院内部的讲座说法：
Caffe(2013)属于Imperative Programme(命令程序)
Theano(2012)、TensorFlow(2015)、MXNet(2015)属于Declaretive Programme(声明程序)
符号系统需要内建一套数学式语法解析结构，针对原始的命令语句做一个深度的Wrapper，从白盒变成黑盒。
其难度和代码量还是有的。与之相比，Blob读起来，还是要比Tensor要简单地多的。
浅析Blob设计原理
存储性质
无论是正向传播的输出，还是反向传播的残差，还是神经元参数，这些都需要不同的结构去存储。
Blob广义上极力规避设计多种结构的问题，这点上是参考Tensor的。
你可以自由规划1D、2D、3D、4D甚至nD的多维数组存储空间，这种存储具有相当不错的灵活性。
功能性质
不幸的是，操作多维数组在编程中是件麻烦事。
朴素C语言提供的多维数组，功能很弱，比如你想获知大小(size)就是一件难事。
使用STL是一个不错的注意，嵌套STL，从数据结构角度就变成了广义表。
尽管广义表的功能较朴素C语言多维数组要多，不过看起来也不尽如人意。
——————————————————————————————————————————————————
另外，最恼人的是CUDA不推荐GPU操作多维数组，最多可以申请到3维数组的显存优化。
如果不使用CUDA提供的多维数组内存对齐优化，那么IO指令取址将会非常频繁，导致IO速度严重退化。
从内存角度理解，显然线性内存空间访问便捷，nD内存空间就十分糟糕了。
——————————————————————————————————————————————————
从SyncedMemory的设计中，几乎就可以推测，Caffe为了速度，完全使用线性内存/显存。
因而，为使线性内存模拟出nD内存，就需要在内存访问上做点偏移(Offset)计算。
Blob的大部分功能，便是扩展线性SyncedMemory的逻辑功能，使其变成逻辑上的多维数组。
张量·轴设计
在早期神经网络编程中，通常采用的是1D空间，每个样本拥有一个输入向量。
上个世纪末，LeCun等人倡导在SGD中，替代单样本为mini-batch，才使得轴设计得以派上用场。
axis=0用于batch_size，batch中每个样本的向量移到axis=1。
这种空间在今天的神经网络NLP（NNNLP）任务中，仍然是主要采用的。
上个世纪90年代初，LeCun将Fukushima的神经机结合导师Hinton的BP算法，演化成可以训练的CNN，使得轴进一步扩展。
CNN所扩展的轴，称之为空间轴(spatial axes)，放置于axis=2,....之后。
原神经网络的axis=1轴，结合图像文件的通道(channels)概念、CNN的特征图概念，被替换成channels axis。
这样，在Blob中，就构成了使用最频繁的4轴空间(batch_size，channels，height，width）。
在Caffe中，batch_size用num替代，这个名字理解起来更泛性一点。
各轴都具有一定的轴长，描述轴空间需要shape功能，轴空间变形则需要reshape功能。
代码实战
从Blob开始，为了便于阅读，代码将在不同章逐步扩展，以下仅提供适用于本章的精简代码。
完整代码见本章最后的Github链接。
建立blob.hpp
数据结构
template <typename Dtype> class Blob{ public: Blob():data_(),diff_(),count_(0), capacity_(0) {} Blob(const vector<int>& shape) :count_(0),capacity_(0) { reshape(shape); } void reshape(int num, int channels, int height, int width); void reshape(vector<int> shape); void reshape(const BlobShape& blob_shape); void reshapeLike(const Blob& blob); const Dtype* cpu_data() const;
const Dtype *gpu_data() const;
const Dtype* cpu_diff() const; const Dtype* gpu_diff() const; Dtype *mutable_cpu_data(); Dtype *mutable_gpu_data(); Dtype *mutable_cpu_diff(); Dtype *mutable_gpu_diff(); int num() const { return shape(0); } int channels() const { return shape(1); } int height() const { return shape(2); } int width() const { return shape(3); } int count() const{ return count_; } int count(int start_axis, int end_axis) const { CHECK_GE(start_axis, 0); CHECK_LE(start_axis, end_axis); CHECK_LE(start_axis, num_axes()); CHECK_LE(end_axis, num_axes()); int cnt = 1; for (int i = start_axis; i < end_axis; i++) cnt *= shape(i); return cnt; } int count(int start_axis) const{ return count(start_axis, num_axes()); } const vector<int> &shape() const{ return shape_; } int shape(int axis) const{ return shape_[canonicalAxisIndex(axis)]; } int offset(const int n, const int c = 0, const int h = 0, const int w = 0){ CHECK_GE(n, 0); CHECK_LE(n, num()); CHECK_GE(channels(), 0); CHECK_LE(c, channels()); CHECK_GE(height(), 0); CHECK_LE(h, height()); CHECK_GE(width(), 0); CHECK_LE(w, width()); return ((n * channels() + c) * height() + h) * width() + w; } int num_axes() const { return shape_.size(); } // idx ranges [-axes,axes) // idx(-1) means the last axis int canonicalAxisIndex(int axis) const{ CHECK_GE(axis, -num_axes()); CHECK_LT(axis, num_axes()); if (axis < 0) return axis + num_axes(); else return axis; } const boost::shared_ptr<SyncedMemory>& data() const { return data_; } const boost::shared_ptr<SyncedMemory>& diff() const { return diff_; } // change the shared_ptr object and will recycle the memory if need void shareData(const Blob& blob) { CHECK_EQ(count(), blob.count()); data_ = blob.data(); } void shareDiff(const Blob& blob) { CHECK_EQ(count(), blob.count()); diff_ = blob.diff(); }void FromProto(const BlobProto& proto, bool need_reshape = true); void ToProto(BlobProto* proto, bool write_diff = false); protected: boost::shared_ptr<SyncedMemory> data_, diff_; vector<int> shape_; int count_, capacity_; };
先说说几个成员变量：
count、capacity用于reshape中的计算，前者是新reshape的大小，后者是历史reshape大小。
Blob的任何构造函数中，一定要将这个两个值置0，否则reshape会失败。
线性内存空间以shared_ptr绑定，因此Blob不需要析构函数，Blob销毁后，指针空间会被自动回收。
默认有2个线性内存空间，data、diff，分别用于存储数据/残差。
vector<int> shape用于存各个轴的轴长。
——————————————————————————————————————————————————
然后看轴相关函数：
num、channels、height、width、count、shape都是简单的封装，注意设成常成员函数。
由于Blob会作为const引用的参数，比如sharedData/shareDiff，这些访问接口必须保证this指针一致。
这点在第壹章时，略微提醒过。
count和shape都是重载函数，提供不同的访问方式。
轴访问canonicalAxisIndex函数上，借鉴了Python的负轴访问方式，如果你没有Python的习惯，可以写简单点。
——————————————————————————————————————————————————
对SyncedMemory的封装，主要目的是将void*型内存转换为计算类型的内存。
void*型内存以数组下标方式访问时，每个单元占用8Bit（1字节），这种单元内存是不能直接使用的。
因为一个int/float单元占用32Bit(4字节)，一个double单元占用64Bit(8字节)。
C/C++通过对数组首元素指针的强制转换，可以改变下标索引的单元访问模式。
——————————————————————————————————————————————————
reshape函数看起来重载了很多，实际上主体设在 void reshape(vector<int> shape)里。
其它都是简单的封装。
——————————————————————————————————————————————————
offset函数是非常重要的，它目的是计算相对偏移量，形成逻辑上的多维空间结构。
在DataLayer中，由Datum组织Blob一个例子如下：
for (int i = 0; i < batch_size; i++){ // must refer use '&' to keep data vaild(!!!important) Datum &datum = *(reader.full().pop("Waiting for Datum data")); int offset = batch->data.offset(i); // share a part of a blob memory transformed_data.set_cpu_data(base_data + offset); // transform datum and copy its value to the part of blob memory if (has_labels) base_label[i] = datum.label(); ptr_transformer->transform(datum, &transformed_data); //let the reader to read new datum reader.free().push(&datum); }
在这里，对batch里的每一个样本，每次偏移channels*height*width个单位，立刻跳转到下一张图的首元素。
更一般的，令base_data+=data.offset(0,1)，就跳转到了下一个channel的首元素。
由于线性空间是连续的，这种偏移仅仅需要加法器一次运算，就能模拟出多维空间，十分廉价。
——————————————————————————————————————————————————
两个share函数用于直接替换掉data_,diff_，由于使用了shared_ptr，SyncedMemory会自动释放。
当神经网络需要交叉验证时，从训练网络copy参数到测试网络是没有必要的。
此时，只要将训练网络的全部参数Blob，一一对应share给测试网络即可。
——————————————————————————————————————————————————
FromProto和ToProto用于反序列化/序列化至protobuff格式。
唯一用处是对神经网络的参数Blob进行snapshot(截图)，以便继续训练或者离线测试。
实现
给出几个比较重要的实现。
template<typename Dtype> void Blob<Dtype>::reshape(vector<int> shape){ count_ = 1; shape_.resize(shape.size()); for (int i = 0; i < shape.size(); ++i) { count_ *= shape[i]; shape_[i] = shape[i]; } if (count_ > capacity_) { capacity_ = count_; data_.reset(new SyncedMemory(capacity_ * sizeof(Dtype))); diff_.reset(new SyncedMemory(capacity_ * sizeof(Dtype))); } }
可以看到，reshape为SyncedMemory准备了capacity*sizeof(Dtype)个字节单元。
同时，你需要回忆一下，SyncedMemory(size)并不会立刻启动状态转移自动机申请内存/显存。
只有执行Blob:: cpu_data/gpu_data/mutable_cpu_data/mutable_gpu_data，才会申请。
这有点像函数式编程里的Lazy思想，胡乱写Blob其实问题不大，只要该Blob没有使用，就不会有内存空间损耗。
template<typename Dtype> void Blob<Dtype>::ToProto(BlobProto* proto, bool write_diff){ proto->clear_shape(); proto->clear_data(); proto->clear_diff(); //do not use proto->shape() cause it is a const method for (int i = 0; i < shape_.size(); i++) proto->mutable_shape()->add_dim(shape_[i]); const Dtype *data = cpu_data(); const Dtype *diff = cpu_diff(); for (int i = 0; i < count_; i++) proto->add_data(data[i]); if (write_diff) for (int i = 0; i < count_; i++) proto->add_diff(diff[i]); }
ToProto里，首次出现了如何向protobuff结构写数据的例子。
以proto->mutable_shape()为例，切记不要写成proto->shape()，因为proto->shape()是常成员函数。
其内部不能修改，这点上，同Blob::cpu_data/mutable_cpu_data的原理是一致的。
对于message的repeated类型，使用add_name函数可以填充数组数据。
针对Caffe的精简
- 移除SyncedMemory形式的shape_data，与vector<int> shape_作用重复
- 移除基本没什么用的CopyFrom函数
完整代码
注：关于Blob中的update等在底层计算的函数会在后期补充讲解。
blob.hpp
https://github.com/neopenx/Dragon/blob/master/Dragon/include/blob.hpp
https://github.com/neopenx/Dragon/blob/master/Dragon/src/blob.cpp
