accumulation_node.cc 5.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// 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
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// 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.

#include "paddle/fluid/eager/accumulation/accumulation_node.h"
16 17

#include "glog/logging.h"
18
#include "paddle/fluid/eager/eager_tensor.h"
19
#include "paddle/fluid/imperative/gradient_accumulator.h"
20 21 22
#include "paddle/fluid/platform/device_context.h"
#include "paddle/fluid/platform/enforce.h"
#include "paddle/fluid/platform/errors.h"
23 24
#include "paddle/phi/api/all.h"
#include "paddle/phi/core/dense_tensor.h"
25
#include "paddle/phi/core/sparse_coo_tensor.h"
26

27 28
namespace egr {

29
static void CopyOrAddTensor(paddle::experimental::Tensor* tensor,
J
Jiabin Yang 已提交
30 31 32
                            const paddle::experimental::Tensor& t,
                            bool is_fake_empty) {
  if (is_fake_empty) {
33 34
    *tensor = t;
  } else {
J
Jiabin Yang 已提交
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
    if (!tensor->defined() || !tensor->initialized()) {
      // Simply copy tensor->impl
      *tensor = t;
    } else {
      // Accumulation
      if (LIKELY(t.is_dense_tensor())) {
        if (LIKELY(tensor->is_dense_tensor())) {
          paddle::imperative::TensorAdd<paddle::experimental::Tensor>(t,
                                                                      tensor);
        } else {
          // TODO(jiabin): Support Other TensorBase later
          // TODO(zhanlve): Replace SelectedRowsAddTensor with
          // add_dygraph_function once it's supported
          paddle::experimental::Tensor new_buffer(
              std::make_shared<phi::DenseTensor>(), "tmp_accumulator");
          paddle::imperative::SelectedRowsAddTensor(*tensor, t, &new_buffer);
          tensor->set_impl(new_buffer.impl());
        }
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
      } else if (LIKELY(t.is_sparse_coo_tensor())) {
        // In fact, the gradient of SparseTensor is still a SparseTensor
        if (LIKELY(tensor->is_sparse_coo_tensor())) {
          auto t_sparse =
              std::dynamic_pointer_cast<phi::SparseCooTensor>(t.impl());
          paddle::experimental::Tensor t_values(
              std::make_shared<phi::DenseTensor>(
                  t_sparse->non_zero_elements()));
          auto tensor_sparse =
              std::dynamic_pointer_cast<phi::SparseCooTensor>(tensor->impl());
          paddle::experimental::Tensor tensor_values(
              std::make_shared<phi::DenseTensor>(
                  tensor_sparse->non_zero_elements()));
          paddle::imperative::TensorAdd<paddle::experimental::Tensor>(
              t_values, &tensor_values);
        }
69 70 71
      } else {
        // TODO(jiabin): Support Other TensorBase later
        // TODO(zhanlve): Replace SelectedRowsAddTensor with
J
Jiabin Yang 已提交
72 73 74 75 76 77 78 79
        // add_dygraph_function
        // once it's supported
        if (tensor->is_dense_tensor()) {
          paddle::imperative::SelectedRowsAddToTensor(t, tensor);
        } else {
          *tensor = std::move(*paddle::imperative::SelectedRowsMerge<
                              paddle::experimental::Tensor>(t, *tensor));
        }
80 81
      }
    }
82 83 84
  }
}

85 86 87 88 89
paddle::small_vector<std::vector<paddle::experimental::Tensor>,
                     kSlotSmallVectorSize>
GradNodeAccumulation::operator()(
    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
                         kSlotSmallVectorSize>& grads,  // NOLINT
90 91
    bool create_graph,
    bool is_new_grad) {
92
  VLOG(3) << "Running Eager Backward Node: GradNodeAccumulation";
93 94 95 96 97 98 99 100 101
  PADDLE_ENFORCE(grads.size() == 1,
                 paddle::platform::errors::Fatal(
                     "GradNodeAccumulation should take exactly 1 grad tensor"
                     "However received: %d slot.",
                     grads.size()));
  PADDLE_ENFORCE(grads[0].size() == 1,
                 paddle::platform::errors::Fatal(
                     "GradNodeAccumulation should take exactly 1 grad tensor"
                     "However received: %d in slot %d .",
102 103
                     grads[0].size(),
                     0));
104
  // Apply Gradient Hooks
105
  paddle::experimental::Tensor grad_out;
106
  if (GradientHooksRegistered()) {
107 108 109
    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
                         kSlotSmallVectorSize>
        hooked_grads = ApplyGradientHooks(grads);
110
    grad_out = hooked_grads[0][0];
111
  } else {
112
    grad_out = grads[0][0];
113 114
  }

115
  if (!weak_grad_.expired() && !is_new_grad) {
116
    auto grad = weak_grad_.lock();
J
Jiabin Yang 已提交
117 118
    CopyOrAddTensor(grad.get(), grad_out, is_fake_empty_);
    is_fake_empty_ = false;
119 120 121 122 123 124 125
  }

  // Apply Reduce Hooks
  if (ReduceHooksRegistered()) {
    ApplyReduceHooks();
  }

126
  return {{grad_out}};
127 128
}

129
void GradNodeAccumulation::RegisterReduceHook(
130
    std::shared_ptr<VoidHook>&& hook) {
131
  reduce_hooks_.emplace_back(std::move(hook));
132 133 134 135
}

void GradNodeAccumulation::ApplyReduceHooks() {
  for (auto& hook : reduce_hooks_) {
136
    (*hook)();
137 138
  }
}
139
}  // namespace egr