print_op.cc 9.1 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
Y
Yan Chunwei 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15

   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 <algorithm>
Y
Yi Wang 已提交
16
#include "paddle/fluid/framework/op_registry.h"
S
sneaxiy 已提交
17
#include "paddle/fluid/framework/var_type.h"
18
#include "paddle/fluid/operators/assign_op.h"
Y
Yan Chunwei 已提交
19 20 21

namespace paddle {
namespace operators {
Y
Yu Yang 已提交
22
using framework::GradVarName;
Y
Yan Chunwei 已提交
23 24 25

#define CLOG std::cout

26 27 28
const char kForward[] = "FORWARD";
const char kBackward[] = "BACKWARD";
const char kBoth[] = "BOTH";
Y
yangyaming 已提交
29

C
chengduo 已提交
30 31 32 33 34 35 36 37 38 39 40 41 42
class LogGuard {
 public:
  inline LogGuard() { LogMutex().lock(); }

  inline ~LogGuard() { LogMutex().unlock(); }

 private:
  static std::mutex &LogMutex() {
    static std::mutex mtx;
    return mtx;
  }
};

Y
Yan Chunwei 已提交
43 44 45 46
struct Formater {
  std::string message;
  std::string name;
  std::vector<int> dims;
47
  std::type_index dtype{typeid(const char)};
Y
Yan Chunwei 已提交
48 49
  framework::LoD lod;
  int summarize;
Y
Yu Yang 已提交
50
  void *data{nullptr};
C
chengduo 已提交
51 52
  platform::Place place;
  std::stringstream logs;
Y
Yan Chunwei 已提交
53 54 55

  void operator()(size_t size) {
    PrintMessage();
C
chengduo 已提交
56
    PrintPlaceInfo();
Y
Yan Chunwei 已提交
57 58 59 60 61
    PrintName();
    PrintDims();
    PrintDtype();
    PrintLod();
    PrintData(size);
C
chengduo 已提交
62 63
    LogGuard guard;
    CLOG << logs.str();
Y
Yan Chunwei 已提交
64 65 66
  }

 private:
C
chengduo 已提交
67 68
  void PrintPlaceInfo() { logs << "The place is:" << place << std::endl; }
  void PrintMessage() { logs << std::time(nullptr) << "\t" << message << "\t"; }
Y
Yan Chunwei 已提交
69 70
  void PrintName() {
    if (!name.empty()) {
C
chengduo 已提交
71
      logs << "Tensor[" << name << "]" << std::endl;
Y
Yan Chunwei 已提交
72 73 74 75
    }
  }
  void PrintDims() {
    if (!dims.empty()) {
C
chengduo 已提交
76
      logs << "\tshape: [";
Y
Yan Chunwei 已提交
77
      for (auto i : dims) {
C
chengduo 已提交
78
        logs << i << ",";
Y
Yan Chunwei 已提交
79
      }
C
chengduo 已提交
80
      logs << "]" << std::endl;
Y
Yan Chunwei 已提交
81 82 83
    }
  }
  void PrintDtype() {
S
sneaxiy 已提交
84
    if (!framework::IsType<const char>(dtype)) {
C
chengduo 已提交
85
      logs << "\tdtype: " << dtype.name() << std::endl;
Y
Yan Chunwei 已提交
86 87 88 89
    }
  }
  void PrintLod() {
    if (!lod.empty()) {
C
chengduo 已提交
90
      logs << "\tLoD: [";
Y
Yan Chunwei 已提交
91
      for (auto level : lod) {
C
chengduo 已提交
92
        logs << "[ ";
Y
Yan Chunwei 已提交
93
        for (auto i : level) {
C
chengduo 已提交
94
          logs << i << ",";
Y
Yan Chunwei 已提交
95
        }
C
chengduo 已提交
96
        logs << " ]";
Y
Yan Chunwei 已提交
97
      }
C
chengduo 已提交
98
      logs << "]" << std::endl;
Y
Yan Chunwei 已提交
99 100 101 102 103 104
    }
  }

  void PrintData(size_t size) {
    PADDLE_ENFORCE_NOT_NULL(data);
    // print float
S
sneaxiy 已提交
105
    if (framework::IsType<const float>(dtype)) {
Y
Yan Chunwei 已提交
106
      Display<float>(size);
S
sneaxiy 已提交
107
    } else if (framework::IsType<const double>(dtype)) {
Y
Yan Chunwei 已提交
108
      Display<double>(size);
S
sneaxiy 已提交
109
    } else if (framework::IsType<const int>(dtype)) {
Y
Yan Chunwei 已提交
110
      Display<int>(size);
S
sneaxiy 已提交
111
    } else if (framework::IsType<const int64_t>(dtype)) {
Y
Yan Chunwei 已提交
112
      Display<int64_t>(size);
S
sneaxiy 已提交
113
    } else if (framework::IsType<const bool>(dtype)) {
114 115
      Display<bool>(size);
    } else {
C
chengduo 已提交
116
      logs << "\tdata: unprintable type: " << dtype.name() << std::endl;
Y
Yan Chunwei 已提交
117 118 119 120 121
    }
  }

  template <typename T>
  void Display(size_t size) {
Y
Yu Yang 已提交
122
    auto *d = reinterpret_cast<T *>(data);
C
chengduo 已提交
123
    logs << "\tdata: ";
Y
Yan Chunwei 已提交
124 125 126
    if (summarize != -1) {
      summarize = std::min(size, (size_t)summarize);
      for (int i = 0; i < summarize; i++) {
C
chengduo 已提交
127
        logs << d[i] << ",";
Y
Yan Chunwei 已提交
128 129 130
      }
    } else {
      for (size_t i = 0; i < size; i++) {
C
chengduo 已提交
131
        logs << d[i] << ",";
Y
Yan Chunwei 已提交
132 133
      }
    }
C
chengduo 已提交
134
    logs << std::endl;
Y
Yan Chunwei 已提交
135 136 137 138
  }
};

// TODO(ChunweiYan) there should be some other printers for TensorArray
139
class PrintOp : public framework::OperatorBase {
Y
Yan Chunwei 已提交
140
 public:
141 142 143
  PrintOp(const std::string &type, const framework::VariableNameMap &inputs,
          const framework::VariableNameMap &outputs,
          const framework::AttributeMap &attrs)
Y
Yan Chunwei 已提交
144 145
      : OperatorBase(type, inputs, outputs, attrs) {}

146
 private:
Y
Yu Yang 已提交
147 148
  void RunImpl(const framework::Scope &scope,
               const platform::Place &place) const override {
149 150 151 152 153 154 155 156 157 158 159 160 161 162
    const auto in_var = scope.FindVar(Input("In"));
    auto out_var = scope.FindVar(Output("Out"));
    PADDLE_ENFORCE_NOT_NULL(in_var, "The input should not be found in scope",
                            Input("In"));
    PADDLE_ENFORCE_NOT_NULL(out_var, "The output should not be found in scope",
                            Output("Out"));
    auto &in_tensor = in_var->Get<framework::LoDTensor>();
    framework::LoDTensor *out_tensor =
        out_var->GetMutable<framework::LoDTensor>();

    PrintValue(place, Inputs("In").front(), in_tensor);
    framework::TensorCopy(in_tensor, place, out_tensor);
    out_tensor->set_lod(in_tensor.lod());
  }
Y
yangyaming 已提交
163

164 165 166
  void PrintValue(const platform::Place &place,
                  const std::string &printed_var_name,
                  const framework::LoDTensor &in_tensor) const {
Y
yangyaming 已提交
167
    std::string print_phase = Attr<std::string>("print_phase");
Y
Yu Yang 已提交
168 169 170 171
    bool is_forward = Attr<bool>("is_forward");

    if ((is_forward && print_phase == kBackward) ||
        (!is_forward && print_phase == kForward)) {
Y
yangyaming 已提交
172 173 174
      return;
    }

Y
Yan Chunwei 已提交
175 176 177
    int first_n = Attr<int>("first_n");
    if (first_n > 0 && ++times_ > first_n) return;

Y
yangyaming 已提交
178 179 180
    framework::LoDTensor printed_tensor;
    printed_tensor.set_lod(in_tensor.lod());
    printed_tensor.Resize(in_tensor.dims());
Y
Yan Chunwei 已提交
181

182
    if (is_cpu_place(in_tensor.place())) {
Y
yangyaming 已提交
183 184 185 186
      printed_tensor.ShareDataWith(in_tensor);
    } else {
      // copy data to cpu to print
      platform::CPUPlace place;
187
      TensorCopy(in_tensor, place, &printed_tensor);
Y
yangyaming 已提交
188
    }
Y
Yan Chunwei 已提交
189 190

    Formater formater;
C
chengduo 已提交
191
    formater.place = place;
192
    formater.message = Attr<std::string>("message");
Y
Yan Chunwei 已提交
193
    if (Attr<bool>("print_tensor_name")) {
Y
yangyaming 已提交
194
      formater.name = printed_var_name;
Y
Yan Chunwei 已提交
195 196
    }
    if (Attr<bool>("print_tensor_type")) {
Y
Yu Yang 已提交
197
      formater.dtype = framework::ToTypeIndex(printed_tensor.type());
Y
Yan Chunwei 已提交
198 199
    }
    if (Attr<bool>("print_tensor_shape")) {
Y
Yu Yang 已提交
200
      auto &dims = printed_tensor.dims();
Y
yangyaming 已提交
201 202
      formater.dims.resize(dims.size());
      for (int i = 0; i < dims.size(); ++i) formater.dims[i] = dims[i];
Y
Yan Chunwei 已提交
203 204
    }
    if (Attr<bool>("print_tensor_lod")) {
Y
yangyaming 已提交
205
      formater.lod = printed_tensor.lod();
Y
Yan Chunwei 已提交
206 207
    }
    formater.summarize = Attr<int>("summarize");
Y
Yu Yang 已提交
208
    formater.data = reinterpret_cast<void *>(printed_tensor.data<void>());
Y
yangyaming 已提交
209
    formater(printed_tensor.numel());
Y
Yan Chunwei 已提交
210 211 212 213 214 215 216 217
  }

 private:
  mutable int times_{0};
};

class PrintOpProtoAndCheckMaker : public framework::OpProtoAndCheckerMaker {
 public:
Y
Yu Yang 已提交
218
  void Make() override {
Y
yangyaming 已提交
219
    AddInput("In", "Input tensor to be displayed.");
220
    AddOutput("Out", "The output tensor.");
Y
Yan Chunwei 已提交
221 222
    AddAttr<int>("first_n", "Only log `first_n` number of times.");
    AddAttr<std::string>("message", "A string message to print as a prefix.");
Y
yangyaming 已提交
223
    AddAttr<int>("summarize", "Number of elements printed.");
Y
Yan Chunwei 已提交
224 225 226 227
    AddAttr<bool>("print_tensor_name", "Whether to print the tensor name.");
    AddAttr<bool>("print_tensor_type", "Whether to print the tensor's dtype.");
    AddAttr<bool>("print_tensor_shape", "Whether to print the tensor's shape.");
    AddAttr<bool>("print_tensor_lod", "Whether to print the tensor's lod.");
Y
Yu Yang 已提交
228 229 230 231
    AddAttr<std::string>("print_phase",
                         "(string, default 'FORWARD') Which phase to display "
                         "including 'FORWARD' "
                         "'BACKWARD' and 'BOTH'.")
232 233 234
        .SetDefault(std::string(kBoth))
        .InEnum({std::string(kForward), std::string(kBackward),
                 std::string(kBoth)});
Y
Yu Yang 已提交
235
    AddAttr<bool>("is_forward", "Whether is forward or not").SetDefault(true);
Y
Yan Chunwei 已提交
236
    AddComment(R"DOC(
Y
yangyaming 已提交
237
Creates a print op that will print when a tensor is accessed.
Y
Yan Chunwei 已提交
238

Y
yangyaming 已提交
239 240 241
Wraps the tensor passed in so that whenever that a tensor is accessed,
the message `message` is printed, along with the current value of the
tensor `t`.)DOC");
Y
Yan Chunwei 已提交
242 243 244
  }
};

245 246 247 248 249 250 251 252 253 254 255 256
class PrintOpInferShape : public framework::InferShapeBase {
 public:
  void operator()(framework::InferShapeContext *ctx) const override {
    VLOG(10) << "PrintOpInferShape";
    PADDLE_ENFORCE(ctx->HasInput("In"), "Input(In) should not be null.");
    PADDLE_ENFORCE(ctx->HasOutput("Out"), "Output(Out) should not be null.");
    ctx->ShareDim("In", /*->*/ "Out");
    ctx->ShareLoD("In", /*->*/ "Out");
  }
};

class PrintOpVarTypeInference : public framework::VarTypeInference {
Y
Yan Chunwei 已提交
257
 public:
258 259 260 261
  void operator()(framework::InferVarTypeContext *ctx) const override {
    auto input_type = ctx->GetType(ctx->Input("In")[0]);
    auto out_name = ctx->Output("Out").front();
    ctx->SetType(out_name, input_type);
Y
Yan Chunwei 已提交
262 263 264
  }
};

H
hong 已提交
265 266
template <typename T>
class PrintOpGradientMaker : public framework::SingleGradOpMaker<T> {
Y
yangyaming 已提交
267
 public:
H
hong 已提交
268
  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
Y
yangyaming 已提交
269

270
  void Apply(GradOpPtr<T> op_desc_ptr) const override {
Y
Yu Yang 已提交
271
    op_desc_ptr->SetType("print");
H
hong 已提交
272 273 274
    op_desc_ptr->SetInput("In", this->OutputGrad("Out"));
    op_desc_ptr->SetOutput("Out", this->InputGrad("In"));
    op_desc_ptr->SetAttrMap(this->Attrs());
Y
Yu Yang 已提交
275
    op_desc_ptr->SetAttr("is_forward", false);
Y
yangyaming 已提交
276 277 278
  }
};

Y
Yan Chunwei 已提交
279 280 281
}  // namespace operators
}  // namespace paddle

Y
yangyaming 已提交
282 283
namespace ops = paddle::operators;

284
REGISTER_OPERATOR(print, ops::PrintOp, ops::PrintOpProtoAndCheckMaker,
H
hong 已提交
285 286 287
                  ops::PrintOpGradientMaker<paddle::framework::OpDesc>,
                  ops::PrintOpGradientMaker<paddle::imperative::OpBase>,
                  ops::PrintOpInferShape, ops::PrintOpVarTypeInference);