lod_tensor.h 6.8 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
2

L
Luo Tao 已提交
3 4 5
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
6

L
Luo Tao 已提交
7
    http://www.apache.org/licenses/LICENSE-2.0
8

L
Luo Tao 已提交
9 10 11 12 13
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. */
14 15 16 17

#pragma once

#include <memory>
18
#ifdef PADDLE_WITH_CUDA
19 20 21 22
#include <thrust/device_vector.h>
#include <thrust/host_vector.h>
#endif

23
#include <glog/logging.h>
Y
Yi Wang 已提交
24 25 26 27 28 29
#include "paddle/fluid/framework/ddim.h"
#include "paddle/fluid/framework/mixed_vector.h"
#include "paddle/fluid/framework/tensor.h"
#include "paddle/fluid/framework/tensor_util.h"
#include "paddle/fluid/platform/enforce.h"
#include "paddle/fluid/platform/place.h"
30 31

namespace paddle {
Y
Yu Yang 已提交
32 33 34 35 36 37

namespace recordio {
class Writer;
class Scanner;
}

38 39
namespace framework {

40
/*
41
 * LoD is short for Level of Details.
42
 *
43
 * - in a level, each element indicates relative offset of the lower level
44 45 46
 * - the first element should be 0 and that indicates that this sequence start
 * from 0
 * - each sequence's begin and end(no-inclusive) is level[id, id+1]
47 48 49 50 51 52 53
 *
 * For example:
 *    3-level LoD stores
 *
 *    0 2 3
 *    0 2 4 7
 *    0 2 5 7 10 12 15 20
54
 */
Y
Yu Yang 已提交
55
using LoD = std::vector<Vector<size_t>>;
Q
qijun 已提交
56

57
std::ostream& operator<<(std::ostream& os, const LoD& lod);
Y
Yang Yang 已提交
58
std::ostream& operator<<(std::ostream& os, const LoDTensor& t);
59

Q
Qiao Longfei 已提交
60 61
std::string LoDToString(const LoD& lod);

62
LoD SliceInLevel(const LoD& in, size_t level, size_t elem_begin,
Q
qijun 已提交
63
                 size_t elem_end);
64 65 66 67
/*
 * Transform an LoD from relative offsets to absolute offsets.
 */
LoD ToAbsOffset(const LoD& in);
Q
qijun 已提交
68

69
bool operator==(const LoD& a, const LoD& b);
Q
qijun 已提交
70

Y
Yan Chunwei 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
/*
 * Check whether this lod's format is valid.
 *
 * ATTENTION:
 *   - Empty lod is treated as valid.
 *
 * It will check two things:
 *
 *  1. all the offsets in a level should be ascending(no same items allows).
 *  2. there should be more than 2 offsets existing in each level.
 *  3. the higher level's last offset should equals the lower level's size-1.
 *  4. the first offset(the begin offset) of each level should be 0.
 *  5. the lowest level's last offset should equals `tensor_height` if
 * tensor_height>0.
 */

bool CheckLoD(const LoD& in, int tensor_height = -1);
/*
 * Check whether this absolute lod's format is valid.
 *
 * ATTENTION:
 *   - Empty lod is treated as valid.
 *
 * It will check two things:
 *  1. all the offsets in a level should be ascending(no same items allows)
 *  2. there should be more than 2 offsets existing in each level.
 *  3. the first offset of each level should be 0, and the last should be the
 *     same(the height of underlying tensor) or `tensor_height` if
 *     tensor_height>0.
 */
bool CheckAbsLoD(const LoD& in, int tensor_height = -1);

103
/*
104
 * LoDTensor (Level of details Tensor)
105 106
 * see https://en.wikipedia.org/wiki/Level_of_details for reference.
 */
107
class LoDTensor : public Tensor {
108
 public:
D
dzhwinter 已提交
109 110 111 112
  LoDTensor() : Tensor() {}

  /* Constructor with place should only be used in pybind */
  explicit LoDTensor(const platform::Place& place) : Tensor(place) {}
113

114
  explicit LoDTensor(const LoD& lod) : lod_(lod) {}
Q
qijun 已提交
115

D
dzhwinter 已提交
116
  void set_lod(const LoD& lod) { lod_ = lod; }
Q
qijun 已提交
117

Y
Yu Yang 已提交
118 119 120
  const LoD& lod() const { return lod_; }

  LoD* mutable_lod() { return &lod_; }
Q
qijun 已提交
121

122
  /*
W
wanghaoshuang 已提交
123
   * Get the start offset and end offset of an  element from LoD.
124
   */
W
wanghaoshuang 已提交
125
  std::pair<size_t, size_t> lod_element(size_t level, size_t elem) const {
126
    PADDLE_ENFORCE_LT(level, NumLevels());
W
wanghaoshuang 已提交
127 128
    PADDLE_ENFORCE_LT(elem, NumElements(level));
    return std::make_pair((lod_)[level][elem], (lod_)[level][elem + 1]);
129 130 131
  }

  /*
132
   * Number of LoDTensor's levels, each level has units of data, for example,
133 134
   * in the sentence's view, article, paragraph, sentence are 3 levels.
   */
135
  size_t NumLevels() const { return lod_.size(); }
136 137 138 139
  /*
   * Number of elements in a level.
   */
  size_t NumElements(size_t level = 0) const {
140
    PADDLE_ENFORCE_LT(level, NumLevels());
141
    // the last offset is the end of last element
Q
qijun 已提交
142
    return (lod_)[level].size() - 1;
143 144
  }

Y
Yang Yang 已提交
145 146 147
  std::vector<LoDTensor> SplitLoDTensor(
      const std::vector<platform::Place> places) const;

Y
Yang Yang 已提交
148 149 150
  void MergeLoDTensor(const std::vector<const LoDTensor*>& lod_tensors,
                      platform::Place place);

Q
qijun 已提交
151
 private:
152
  LoD lod_;
153
};
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182

/*
 * Expand the `source` to fit the LoD of `lod`. For example, a `source`
 * LoDTensor is
 *  - LoD: [0, 2]
 *  - tensor: [a0, a1]
 * a `lod` is
 *  - LoD: [0 3 5]
 * returns a new LoDTensor
 *  - [a0 a0 a0 a1 a1]
 */
template <typename T>
LoDTensor LodExpand(const LoDTensor& source, const LoD& lod, size_t level,
                    const platform::Place& place) {
  LoD abs_lod = ToAbsOffset(lod);
  const auto& lod_level = lod[level];
  size_t num_instances = source.dims()[0];

  // new tensor
  LoDTensor tensor;
  tensor.set_lod(lod);
  auto dims = source.dims();
  dims[0] = lod_level.back();
  tensor.Resize(dims);
  tensor.mutable_data<T>(place);

  PADDLE_ENFORCE_EQ(num_instances, lod_level.size() - 1);
  for (size_t ins = 0; ins < num_instances; ins++) {
    for (size_t elem = lod_level[ins]; elem < lod_level[ins + 1]; elem++) {
D
dzhwinter 已提交
183
      auto slice = tensor.Slice(elem, elem + 1);
Y
Yi Wang 已提交
184 185
      TensorCopy(source.Slice(ins, ins + 1), platform::CPUPlace(),
                 platform::CPUDeviceContext(), &slice);
186 187 188 189 190
    }
  }
  return tensor;
}

191 192 193 194 195 196 197 198 199 200 201 202
// Get the absolute offset of a lod[start_level][start_idx:end_idx] and
// relative length of details for every levels(i.e., [start_level: ]).
//
// For example,
//   lod = [[0, 3, 4, 8], [0, 9, 10, 11, 13, 17, 19, 22, 24]]
//   start_level = 0
//   start_idx = 1
//   end_idx = 3
//
// Returns:
//  LoD = [[1, 4], [2, 4, 2, 3, 2]]
//  pair<size_t, size_t> = {11, 24}
203 204
std::pair<LoD, std::pair<size_t, size_t>> GetSubLoDAndAbsoluteOffset(
    const LoD& lod, size_t start_idx, size_t end_idx, size_t start_level);
205

206
void AppendLoD(LoD* lod, const LoD& lod_length);
207

武毅 已提交
208 209 210 211 212 213 214
/*
 * Serialize/Desiralize LoDTensor to std::ostream
 * You can pass ofstream or ostringstream to serilize to file
 * or to a in memory string. GPU tensor will be copied to CPU.
 */
void SerializeToStream(std::ostream& os, const LoDTensor& tensor,
                       const platform::DeviceContext& dev_ctx);
Y
Yancey 已提交
215 216
void DeserializeFromStream(std::istream& is, LoDTensor* tensor,
                           const platform::DeviceContext& dev_ctx);
武毅 已提交
217

Y
Yu Yang 已提交
218 219 220 221 222 223 224
extern void WriteToRecordIO(recordio::Writer& writer,
                            const std::vector<LoDTensor>& tensor,
                            const platform::DeviceContext& dev_ctx);

extern std::vector<LoDTensor> ReadFromRecordIO(
    recordio::Scanner& scanner, const platform::DeviceContext& dev_ctx);

225 226
}  // namespace framework
}  // namespace paddle