rename LOD to LoD for short of "Level of Details" (#3936)

paddle/framework/lod_tensor.cc

@@ -19,8 +19,8 @@
 namespace paddle {
 namespace framework {
 
-LOD SliceLevels(const LOD& in, size_t level_begin, size_t level_end) {
-  LOD new_lod;
+LoD SliceLevels(const LoD& in, size_t level_begin, size_t level_end) {
+  LoD new_lod;
   new_lod.reserve(level_end - level_begin);
   for (size_t i = level_begin; i < level_end; i++) {
     new_lod.emplace_back(in.at(i));
@@ -28,10 +28,10 @@ LOD SliceLevels(const LOD& in, size_t level_begin, size_t level_end) {
   return new_lod;
 }
 
-LOD SliceInLevel(const LOD& in, size_t level, size_t elem_begin,
+LoD SliceInLevel(const LoD& in, size_t level, size_t elem_begin,
                  size_t elem_end) {
   // slice the lod.
-  LOD new_lod;
+  LoD new_lod;
   new_lod.reserve(in.size() - level);
   auto start = in.at(level)[elem_begin];
   auto end = in.at(level)[elem_end];
@@ -46,13 +46,13 @@ LOD SliceInLevel(const LOD& in, size_t level, size_t elem_begin,
     std::transform(new_lod.back().begin(), new_lod.back().end(),
                    new_lod.back().begin(),
                    [start](int v) { return v - start; });
-    PADDLE_ENFORCE_EQ(new_lod.back().front(), 0, "error in slice LOD");
+    PADDLE_ENFORCE_EQ(new_lod.back().front(), 0, "error in slice LoD");
   }
   PADDLE_ENFORCE_LE(new_lod.size(), in.size());
   return new_lod;
 }
 
-bool operator==(const LOD& a, const LOD& b) {
+bool operator==(const LoD& a, const LoD& b) {
   if (a.size() != b.size()) {
     return false;
   }
@@ -72,12 +72,12 @@ bool operator==(const LOD& a, const LOD& b) {
   return true;
 }
 
-void LODTensor::SliceLevels(size_t level_begin, size_t level_end) {
+void LoDTensor::SliceLevels(size_t level_begin, size_t level_end) {
   auto new_lod = framework::SliceLevels(lod_, level_begin, level_end);
   lod_ = new_lod;
 }
 
-void LODTensor::SliceInLevel(size_t level, size_t elem_begin, size_t elem_end) {
+void LoDTensor::SliceInLevel(size_t level, size_t elem_begin, size_t elem_end) {
   PADDLE_ENFORCE(level < NumLevels(), "level [%d] out of range [%d]", level,
                  NumLevels());
   PADDLE_ENFORCE(elem_begin < NumElements(level),

paddle/framework/lod_tensor.h

@@ -35,34 +35,34 @@ template <typename T>
 using Vector = thrust::host_vector<T>;
 #endif
 
-using LOD = std::vector<Vector<size_t>>;
+using LoD = std::vector<Vector<size_t>>;
 
-LOD SliceLevels(const LOD& in, size_t level_begin, size_t level_end);
+LoD SliceLevels(const LoD& in, size_t level_begin, size_t level_end);
 
-LOD SliceInLevel(const LOD& in, size_t level, size_t elem_begin,
+LoD SliceInLevel(const LoD& in, size_t level, size_t elem_begin,
                  size_t elem_end);
 
-bool operator==(const LOD& a, const LOD& b);
+bool operator==(const LoD& a, const LoD& b);
 
 /*
- * LODTensor (Level of details Tensor)
+ * LoDTensor (Level of details Tensor)
  * see https://en.wikipedia.org/wiki/Level_of_details for reference.
  */
-class LODTensor {
+class LoDTensor {
  public:
-  LODTensor() {}
-  LODTensor(const LOD& lod, Tensor* t) : lod_(lod), tensor_(t) {}
+  LoDTensor() {}
+  LoDTensor(const LoD& lod, Tensor* t) : lod_(lod), tensor_(t) {}
 
-  void set_lod(const LOD& lod) { lod_ = lod; }
+  void set_lod(const LoD& lod) { lod_ = lod; }
 
   void set_tensor(Tensor* tensor) { tensor_ = tensor; }
 
   Tensor& tensor() { return *tensor_; }
 
-  LOD lod() { return lod_; }
+  LoD lod() { return lod_; }
 
   /*
-   * Get a element from LOD.
+   * Get a element from LoD.
    */
   size_t lod_element(size_t level, size_t elem) const {
     PADDLE_ENFORCE(level < NumLevels(), "level [%d] out of range [%d]", level,
@@ -74,7 +74,7 @@ class LODTensor {
   }
 
   /*
-   * Number of LODTensor's levels, each level has units of data, for example,
+   * Number of LoDTensor's levels, each level has units of data, for example,
    * in the sentence's view, article, paragraph, sentence are 3 levels.
    */
   size_t NumLevels() const { return lod_.size(); }
@@ -100,7 +100,7 @@ class LODTensor {
   void SliceInLevel(size_t level, size_t elem_begin, size_t elem_end);
 
  private:
-  LOD lod_;
+  LoD lod_;
   Tensor* tensor_;  // not owned
 };
 }  // namespace framework

paddle/framework/lod_tensor_test.cc

@@ -21,7 +21,7 @@
 namespace paddle {
 namespace framework {
 
-class LODTensorTester : public ::testing::Test {
+class LoDTensorTester : public ::testing::Test {
  public:
   virtual void SetUp() override {
     // tensor's batch_size: 30
@@ -29,7 +29,7 @@ class LODTensorTester : public ::testing::Test {
     // 0 10 20
     // 0 5 10 15 20
     // 0 2 5 7 10 12 15 20
-    LOD lod;
+    LoD lod;
     lod.push_back(std::vector<size_t>{0, 10, 20});
     lod.push_back(std::vector<size_t>{0, 5, 10, 15, 20});
     lod.push_back(std::vector<size_t>{0, 2, 5, 7, 10, 12, 15, 17, 20});
@@ -47,21 +47,21 @@ class LODTensorTester : public ::testing::Test {
  protected:
   platform::CPUPlace place;
   Tensor tensor;
-  LODTensor lod_tensor;
+  LoDTensor lod_tensor;
 };
 
-TEST_F(LODTensorTester, NumLevels) { ASSERT_EQ(lod_tensor.NumLevels(), 3UL); }
+TEST_F(LoDTensorTester, NumLevels) { ASSERT_EQ(lod_tensor.NumLevels(), 3UL); }
 
-TEST_F(LODTensorTester, NumElements) {
+TEST_F(LoDTensorTester, NumElements) {
   ASSERT_EQ(lod_tensor.NumElements(0), 2UL);
   ASSERT_EQ(lod_tensor.NumElements(1), 4UL);
   ASSERT_EQ(lod_tensor.NumElements(2), 8UL);
 }
 
-TEST_F(LODTensorTester, SliceLevels) {
+TEST_F(LoDTensorTester, SliceLevels) {
   // slice 1 level
   for (size_t level = 0; level < 3UL; ++level) {
-    LODTensor new_lod_tensor = lod_tensor;
+    LoDTensor new_lod_tensor = lod_tensor;
     new_lod_tensor.SliceLevels(level, level + 1);
     ASSERT_EQ(new_lod_tensor.NumLevels(), 1UL);
     ASSERT_EQ(new_lod_tensor.NumElements(0), lod_tensor.NumElements(level));
@@ -70,7 +70,7 @@ TEST_F(LODTensorTester, SliceLevels) {
   }
   // slice 2 level
   for (size_t level = 0; level < 2UL; ++level) {
-    LODTensor new_lod_tensor = lod_tensor;
+    LoDTensor new_lod_tensor = lod_tensor;
     new_lod_tensor.SliceLevels(level, level + 2);
     ASSERT_EQ(new_lod_tensor.NumLevels(), 2UL);
     ASSERT_EQ(new_lod_tensor.NumElements(0), lod_tensor.NumElements(level));
@@ -80,9 +80,9 @@ TEST_F(LODTensorTester, SliceLevels) {
   }
 }
 
-TEST_F(LODTensorTester, SliceInLevel) {
+TEST_F(LoDTensorTester, SliceInLevel) {
   size_t level = 0;
-  LODTensor new_lod_tensor = lod_tensor;
+  LoDTensor new_lod_tensor = lod_tensor;
   new_lod_tensor.SliceInLevel(level, 0, 2);
   EXPECT_EQ(new_lod_tensor.NumLevels(), 3UL);
   EXPECT_EQ(new_lod_tensor.NumElements(0), 2UL);