RNN变长输入设计

[Superjomn]

No description provided.

[emailweixu]

Op的unittest需要保证这点。

[Superjomn]

嗯，现在准备在 Op 的基类里做这个事情，以实现自动复制/传递的效果。

如果当前 Op 需要修改 Seq 的信息，则另外在继承的 InferShape 里自己改下。

基类会有 unittest check Seq信息的复制是否正常。
@emailweixu

[luotao1]

不只RecurrentLayerGroup，其他的LSTM/GRU也是无padding的变成序列支持。

[luotao1]

就行-》进行

[luotao1]

sorted:
xxxx
xxx
xx

[luotao1]

125-140行和上面的重复了

[luotao1]

将序列折叠，在batch维度上展开是什么意思呢？

[luotao1]

还要考虑memory boot layer的序列变化。是根据input序列的拆分变化来进行拆分的。可参考RecurrentGradientMachine::createMemoryFrameInfo函数。

[Superjomn]

下面 InitMemories 有对应的逻辑 @luotao1

[wangkuiyi]

I am afraid that a Tensor with some extensions is simply no longer a "tensor" at all. And it looks that this variable-lengths inputs are simply not tensor. So why not design a brand new data structure for this kind of brand new value?

For example, it seems that we can design a new data type, in addition to Tensor, let's call it class Array:

typedef std::vector<shared_ptr<Variable>> Array;

and we can create a multi-dimensional Array:

Variable article;
article.GetMutable<Array>()/*an array of paragraphs*/
  ->GetMutable<Array>()/*an array of sentences*/
  ->GetMutable<Array>()/*an array of words*/
  ->GetMutable<Tensor>()/*a tensor representing a word*/

By simply assuming that a RNNOp consumes an Array, we can assume that its step-net knows the element type of that Array, so we don't even need to record the type of elements in class Array.

[wangkuiyi]

I got it that the very basic element of a sequence has a fixed size, so it is reasonable for us to pack a sequence into a tensor and record the boundaries in additional data fields. So please ignore my above comment.

[Superjomn]

的确，对应 RNNOp 这样设计很自然。 但考虑到 RNNOp 的inputs/outputs 需要直接跟计算网络里其他的op做交互， RNNOp 的inputs/outputs 就需要框架做很多工作了。

SeqPos 有一些特殊的地方：

• SeqPos 只要出现，就需要沿着调用的顺序一直传递下去
  • 比如 data_reader -> fc0 -> rnn0 -> fc1
    • data_reader 输出 SeqPos
    • rnn0 读取 SeqPos
    • 目前的设计是让所有的 Tensor 变成 TensorWithSequence ，这样 fc0 甚至 fc1 都会很自然地把 SeqPos 传递下去，因为后面可能有 op 会继续使用 SeqPos
• SeqPos 可能会被修改，修改后的 SeqPos 需要沿着依赖传递下去
  • 比如 rnn0 -> max0 -> fc0 (max 指按序列求最大），每个序列长度会被压缩成 1 ，fc0 接到的会是新的 SeqPos

所以，其实也是有两个设计思路

1. 有强大的依赖分析，可以把 SeqPos 作为 input/output 加到分析里
   • 每个 Op 的输入需要的不同元信息，都可以通过额外的数据（比如 SeqPos）解开来
   • 最灵活的方式，但需要框架非常健壮
2. 简单的把 SeqPos 塞入到 Tensor 里作为 Variable 存储的内容，Op默认把 input的 SeqPos 复制给 output，以达到传递SeqPos的效果，这也就是目前的设计, TensorWithSequence
   • 无需依赖分析，强制复制，按需修改
   • 应该是最简单的方式

@wangkuiyi

[luotao1]

@wangkuiyi 目前paddle使用的是第二个设计思路：

• 如果一个op没有修改seqPos，则output的seqPos和input的seqPos共享一个内存地址；
• 如果一个op需要修改seqPos，则output的seqPos重新分配一块内存地址，来存储新的seqPos.

[wangkuiyi]

这里的“维”应该改成“层”，因为对应的是网络里有几层RNN吧?

[Superjomn]

对，应该是这个说法

[wangkuiyi]

我理解，这里的

struct SeqPos {
  int dim{1};
  std::vector<std::shared_ptr<std::vector<int>> startPoses;
};

struct TensorWithSequence {
  Tensor* tensor;
  std::shared_ptr<SeqPos> seq_pos;
}

可以简化为

class RNNInput : public Tensor {
 public:
  size_t Elements() const { return this->dims()[0]; }
  size_t Levels() const { return start_positions_per_level_.size(); }
  const Tensor Element(size_t level, size_t element) const { 
    size_t pos = (*start_positions_per_level_)[level][element];
    return this->Slice(pos, pos+1); 
  }
 private:
  std::vector<std::share_ptr<std::vector<size_t>>> start_positions_per_level_;
};

请看是这样吗？

[luotao1]

1. Elements() 返回 this->dims()[0]，就是返回RNNInput中所有元素的个数。没问题。
2. Levels() 返回有多少层RNN. 没问题。
3. Tensor Element表示取第几层RNN的第几个元素。但应该修改成下面的形式，不然每次取出的Tensor->dims()[0]都为1。按照下面的形式，可以取出一句话的Tensor.

size_t pos_start = (*start_positions_per_level_)[level][element];
size_t pos_end = (*start_positions_per_level_)[level][element+1];
returen this->Slice(pos_start, pos_end);

[wangkuiyi]

@Superjom @luotao1 An additional question is -- should we make RNNInput represent a whole minibatch of data?

If so, the first dimension of the tensor should indicate instances, the second and thereafter are levels.

[luotao1]

If so, the first dimension of the tensor should indicate instances, the second and thereafter are levels.

可以这样存。目前Paddle中，就是按照minibatch的格式存的，这样方便加速。

[Superjomn]

现在就是这样想的，第一维存mini-batch信息，后面一层一层解开，一个金字塔的感觉，压缩到二维的 vector 里存储。

是支持 mini-batch 的，和 @qingqing01 刚推了一下格式。

但的确有点绕，需要封装成您上面的接口才直观一些。 @wangkuiyi

[luotao1]

getElement?

[luotao1]

shareDataFrom, ShareSeqPosFrom, CopySeqPosFrom会在哪儿用到呢？

[luotao1]

这段注释是附录里的解释更加清楚。

[luotao1]

个人觉得反过来比较好，level越小，粒度越小。因为seq_start_positions会伴随着所有op，在这些op中，用单层序列的情况会明显多于双层的。因此，如果反过来存储，使用会更加方便。即一般的op只要拿sentences level的信息就够了。

[luotao1]

我认为：
seq_start_positions_[0]存：0,3,7,9,14,17
seq_start_positions_[1]存：0,9,17

原因：

1. 考虑mini-batch的情况，所以都存在一起。
2. 在使用多层序列的情况下，单层序列的Op也会多于多层的，因此level越小，粒度越小，可以符合单测序列的Op
3. 需要存储一个总长度。

[wangkuiyi]

有道理哦。这样每经过一级RNN，只需

std::vector<std::share_ptr<std::vector<size_t>>> start_positions_per_level_;

忽略这里的vector的最后一个元素。

[reyoung]

We need to consider how to share sequence position between GPU and CPU. If we want to copy from host to device every time, it could be very slow.

Maybe, we can use thrust here?

#ifdef PADDLE_ONLY_CPU
using level_t = std::vector<int>;
#else
using level_t = thrust::device_vector<int>;
#endif

[reyoung]

可能是我理解的问题，我不确定使用继承创建新的LODTensor是一个好主意。

因为显然这会让我们产生很多Tensor类型，至少SparseTensor就是另一种类型了。并且，SparseLODTensor是什么类型呢？难道使用菱形的继承关系么？

        Tensor
          +
          |
    +--------------+
    |              |
    +              +
LODTensor   SparseTensor
    +              +
    |              |
    +--------------+
          |
          +
    SparseLODTensor

[reyoung]

也许类似于golang的class类型，使用组合而不是继承，对这个类型更好?

示例代码:

#include <iostream>
#include <memory>
#include <vector>

class Tensor {
public:
  void FunctionA() { std::cout << "FunctionA in Tensor" << std::endl; }
};

using Level = std::vector<int>;

struct LODTensor {
  Tensor tensor_;
  std::shared_ptr<std::vector<Level>> lod_;
};

struct SparseTensor {
  Tensor tensor_;
  std::vector<int> rows_;
  std::vector<int> cols_;
};

struct SparseLODTensor {
  Tensor tensor_;
  std::shared_ptr<std::vector<Level>> lod_;
  std::vector<int> rows_;
  std::vector<int> cols_;
};

template <typename T> void FunctionA(T *self) { self->tensor_.FunctionA(); }

template <> void FunctionA<Tensor>(Tensor *self) { self->FunctionA(); }

template <typename T> size_t LODLevels(T *self) {
  return self->lod_ == nullptr ? 0UL : self->lod_->size();
}

template <typename T> std::vector<Level> &LODMutableLevels(T *self) {
  if (self->lod_ == nullptr) {
    self->lod_.reset(new std::vector<Level>);
  }
  return *self->lod_;
}

int main() {
  LODTensor lod;
  FunctionA(&lod);
  LODMutableLevels(&lod).resize(10);
  std::cout << "LOD Tensor Levels" << LODLevels(&lod);
  return 0;
}

[reyoung]

或者，如果觉得模板实现比较麻烦，可以使用如下实现方式

#include <iostream>
#include <memory>
#include <vector>

class Tensor {
public:
  void FunctionA() { std::cout << "FunctionA in Tensor" << std::endl; }
};

using Level = std::vector<int>;

struct LODTensor {
  std::shared_ptr<Tensor> tensor_;
  std::shared_ptr<std::vector<Level>> lod_;

  LODTensor() : tensor_(new Tensor()), lod_(new std::vector<Level>) {}

  Tensor &tensor() { return *tensor_; }

  size_t Levels() const { return lod_->size(); }
};

struct SparseTensor {
  std::shared_ptr<Tensor> tensor_;
  std::shared_ptr<std::vector<int>> rows_;
  std::shared_ptr<std::vector<int>> cols_;

  SparseTensor()
      : tensor_(new Tensor()), rows_(new std::vector<int>),
        cols_(new std::vector<int>) {}

  Tensor &tensor() { return *tensor_; }
  const Tensor &tensor() const { return *tensor_; }

  size_t NNZ() const { return cols_->size(); }
};

struct SparseLODTensor {
  std::shared_ptr<Tensor> tensor_;
  std::shared_ptr<std::vector<Level>> lod_;
  std::shared_ptr<std::vector<int>> rows_;
  std::shared_ptr<std::vector<int>> cols_;

  SparseLODTensor()
      : tensor_(new Tensor), lod_(new std::vector<Level>),
        rows_(new std::vector<int>), cols_(new std::vector<int>) {}

  Tensor &tensor() { return *tensor_; }

  LODTensor &lod_tensor() { return LODTensor{tensor_, lod_}; }

  SparseTensor &sparse_tensor() { return SparseTensor{tensor_, rows_, cols_}; }
};

int main() {
  SparseLODTensor tensor;
  tensor.tensor().FunctionA();
  tensor.lod_tensor().Levels();
  tensor.sparse_tensor().NNZ();
  return 0;
}

[wangkuiyi]

Because the polymorphism of Variable is via template, in particular, Variable::Get<T>(), not via inheritance, it looks to me that both inheritance and embedding work from this perspective.

Also, SparseTensor differs significantly from Tensor, that they don't have to share the same base class.

I agree embedding could be a better choice as it makes the logic cleaner:

class LODTesnor {
 public:
  typedef vector<vector<int>> LOD;
 private:
  Tensor elements_;
  LOD index_;
};

[reyoung]

seq_start_positions并不存在，下面的代码也得改一下

[reyoung]

这个实现里就不是『几乎完全兼容』Tensor。继承的语意是LODTensor is a Tensor