add cross-entropy-op (#2965)

* add cross-entropy-op

* add infershape and compute

* implement Infershape and compute of onehotcrossentropy op

paddle/operators/CMakeLists.txt

@@ -48,6 +48,7 @@ op_library(mul_op SRCS mul_op.cc mul_op.cu)
 op_library(rowwise_add_op SRCS rowwise_add_op.cu rowwise_add_op.cc)
 op_library(sigmoid_op SRCS sigmoid_op.cu sigmoid_op.cc)
 op_library(softmax_op SRCS softmax_op.cc softmax_op.cu)
+op_library(cross_entropy_op SRCS cross_entropy_op.cc cross_entropy_op.cu)
 
 op_library(fc_op SRCS fc_op.cc DEPS mul_op rowwise_add_op sigmoid_op
         softmax_op net)

paddle/operators/cross_entropy_op.cc

+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+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/operators/cross_entropy_op.h"
+#include "paddle/framework/op_registry.h"
+#include "paddle/framework/tensor.h"
+
+namespace paddle {
+namespace operators {
+
+class OnehotCrossEntropyOp : public framework::OperatorWithKernel {
+protected:
+  void InferShape(
+      const std::vector<const framework::Tensor *> &inputs,
+      const std::vector<framework::Tensor *> &outputs) const override {
+    PADDLE_ENFORCE(inputs.size() == 2,
+                   "Input size of OnehotCrossEntropyOp must be two");
+    PADDLE_ENFORCE(outputs.size() == 1,
+                   "Output size of OnehotCrossEntropyOp must be one");
+    PADDLE_ENFORCE(inputs[0] != nullptr && inputs[1] != nullptr,
+                   "Inputs of OnehotCrossEntropyOp must all be set");
+    PADDLE_ENFORCE(outputs[0] != nullptr,
+                   "Outputs of OnehotCrossEntropyOp must all be set");
+    PADDLE_ENFORCE(inputs[0]->dims().size() == 2, "X's dimension must be 2.");
+    PADDLE_ENFORCE(outputs[0]->dims().size() == 1,
+                   "label's dimension must be 1.");
+    outputs[0]->set_dims(framework::make_ddim({inputs[0]->dims()[0]}));
+  }
+};
+
+class OnehotCrossEntropyOpMaker : public framework::OpProtoAndCheckerMaker {
+public:
+  OnehotCrossEntropyOpMaker(framework::OpProto *proto,
+                            framework::OpAttrChecker *op_checker)
+      : framework::OpProtoAndCheckerMaker(proto, op_checker) {
+    AddInput("X", "The first input of OnehotCrossEntropyOp");
+    AddInput("label", "The second input of OnehotCrossEntropyOp");
+    AddOutput("Y", "The output of OnehotCrossEntropyOp");
+    AddComment(R"DOC(
+OnehotCrossEntropy Operator.
+
+                Y[i] = -log(X[i][j])
+
+)DOC");
+  }
+};
+}  // namespace operators
+}  // namespace paddle
+
+REGISTER_OP(onehot_cross_entropy,
+            paddle::operators::OnehotCrossEntropyOp,
+            paddle::operators::OnehotCrossEntropyOpMaker);
+REGISTER_OP_CPU_KERNEL(
+    onehot_cross_entropy,
+    paddle::operators::OnehotCrossEntropyOpKernel<::paddle::platform::CPUPlace,
+                                                  float>);

paddle/operators/cross_entropy_op.cu

+#include "paddle/operators/cross_entropy_op.h"
+#include "paddle/framework/op_registry.h"
+
+REGISTER_OP_GPU_KERNEL(onehot_cross_entropy,
+                       paddle::operators::OnehotCrossEntropyOpKernel<
+                            ::paddle::platform::GPUPlace, float>);
\ No newline at end of file

paddle/operators/cross_entropy_op.h

+/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
+
+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. */
+
+#pragma once
+#include "glog/logging.h"
+#include "paddle/framework/operator.h"
+
+namespace paddle {
+namespace operators {
+
+template <typename Place, typename T>
+class OnehotCrossEntropyOpKernel : public framework::OpKernel {
+public:
+  constexpr T LOG_THRESHOLD() const { return static_cast<T>(1e-20); }
+
+  void Compute(const framework::KernelContext& context) const override {
+    auto X = context.Input(0)->Get<framework::Tensor>();
+    const T* X_data = X.data<T>();
+    const int* label_data =
+        context.Input(1)->Get<framework::Tensor>().data<int>();
+    auto* Y = context.Output(0)->GetMutable<framework::Tensor>();
+
+    Y->mutable_data<T>(context.GetPlace());
+
+    T* Y_data = Y->data<T>();
+
+    int batch_size = X.dims()[0];
+    int class_num = X.dims()[1];
+
+    // Y[i] = -log(X[i][j])
+    for (int i = 0; i < batch_size; ++i) {
+      Y_data[i] = -std::log(
+          std::max(X_data[i * class_num + label_data[i]], LOG_THRESHOLD()));
+    }
+  }
+};
+
+}  // namespace operators
+}  // namespace paddle

paddle/pybind/CMakeLists.txt

 cc_library(paddle_pybind SHARED SRCS pybind.cc DEPS pybind python
-        add_op fc_op sgd_op)
+        add_op fc_op sgd_op cross_entropy_op)

paddle/pybind/pybind.cc

@@ -27,6 +27,7 @@ namespace py = pybind11;
 namespace pd = paddle::framework;
 
 USE_OP(add_two);
+USE_OP(onehot_cross_entropy);
 USE_OP_WITHOUT_KERNEL(fc);
 USE_OP(sgd);
 

python/paddle/v2/framework/tests/CMakeLists.txt

 add_python_test(test_framework test_protobuf.py test_scope.py
     test_default_scope_funcs.py test_op_creation_methods.py
-    test_tensor.py test_fc_op.py test_add_two_op.py test_sgd_op.py)
+    test_tensor.py test_fc_op.py test_add_two_op.py test_sgd_op.py test_cross_entropy_op.py)

python/paddle/v2/framework/tests/test_cross_entropy_op.py

+import unittest
+import numpy
+from op_test_util import OpTestMeta
+
+
+class TestSGD(unittest.TestCase):
+    __metaclass__ = OpTestMeta
+
+    def setUp(self):
+        self.type = "onehot_cross_entropy"
+        batch_size = 100
+        class_num = 10
+        self.X = numpy.random.random((batch_size, class_num)).astype("float32")
+        self.label = 5 * numpy.ones(batch_size).astype("int32")
+        Y = []
+        for i in range(0, batch_size):
+            Y.append(-numpy.log(self.X[i][self.label[i]]))
+        self.Y = numpy.array(Y).astype("float32")
+
+
+if __name__ == "__main__":
+    unittest.main()