"add elementwise_add more type"

paddle/operators/accuracy_op.h

@@ -45,9 +45,9 @@ class AccuracyKernel : public framework::OpKernel<T> {
     auto* correct = ctx.Output<Tensor>("Correct");
     auto* total = ctx.Output<Tensor>("Total");
 
-    float* correct_data = correct->mutable_data<float>(ctx.GetPlace());
-    int* accuracy_data = accuracy->mutable_data<int>(ctx.GetPlace());
+    int* correct_data = correct->mutable_data<int>(ctx.GetPlace());
     int* total_data = total->mutable_data<int>(ctx.GetPlace());
+    float* accuracy_data = accuracy->mutable_data<float>(ctx.GetPlace());
 
     const int64_t* indices_data = indices->data<int64_t>();
     const int64_t* label_data = label->data<int64_t>();

paddle/operators/elementwise_add_op.cc

@@ -34,7 +34,13 @@ REGISTER_OP(elementwise_add, ops::ElementwiseOp, ops::ElementwiseAddOpMaker,
             elementwise_add_grad, ops::ElementwiseOpGrad);
 REGISTER_OP_CPU_KERNEL(
     elementwise_add,
-    ops::ElementwiseAddKernel<paddle::platform::CPUPlace, float>);
+    ops::ElementwiseAddKernel<paddle::platform::CPUPlace, float>,
+    ops::ElementwiseAddKernel<paddle::platform::CPUPlace, double>,
+    ops::ElementwiseAddKernel<paddle::platform::CPUPlace, int>,
+    ops::ElementwiseAddKernel<paddle::platform::CPUPlace, int64_t>);
 REGISTER_OP_CPU_KERNEL(
     elementwise_add_grad,
-    ops::ElementwiseAddGradKernel<paddle::platform::CPUPlace, float>);
+    ops::ElementwiseAddGradKernel<paddle::platform::CPUPlace, float>,
+    ops::ElementwiseAddGradKernel<paddle::platform::CPUPlace, double>,
+    ops::ElementwiseAddGradKernel<paddle::platform::CPUPlace, int>,
+    ops::ElementwiseAddGradKernel<paddle::platform::CPUPlace, int64_t>);

python/paddle/v2/framework/framework.py

@@ -550,7 +550,7 @@ class Parameter(Variable):
                 raise ValueError("Parameter shape should not be related with "
                                  "batch-size")
 
-        super(Parameter, self).__init__(
+        Variable.__init__(
             self, block, persistable=True, shape=shape, dtype=dtype, **kwargs)
         self.trainable = kwargs.get('trainable', True)
 

python/paddle/v2/framework/layers.py

@@ -263,7 +263,9 @@ def accuracy(input, label, k=1, **kwargs):
                  "Indices": [topk_indices]},
         attrs={"k": k})
     acc_out_dtype = kwargs.get("out_dtype", "float32")
-    acc_out = helper.create_tmp_variable(dtype=acc_out_dtype)
+    acc_out = helper.create_tmp_variable(dtype="float32")
+    correct = helper.create_tmp_variable(dtype="int64")
+    total = helper.create_tmp_variable(dtype="int64")
     helper.append_op(
         type="accuracy",
         inputs={
@@ -271,7 +273,11 @@ def accuracy(input, label, k=1, **kwargs):
             "Indices": [topk_indices],
             "Label": [label]
         },
-        outputs={"Accuracy": [acc_out]})
+        outputs={
+            "Accuracy": [acc_out],
+            "Correct": [correct],
+            "Total": [total],
+        })
     return acc_out
 
 

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

@@ -19,7 +19,8 @@ class TestAccuracyOp(OpTest):
                     break
         self.outputs = {
             'Accuracy': np.array([num_correct / float(n)]).astype("float32"),
-            'Correct': np.array([num_correct]).astype("int32")
+            'Correct': np.array([num_correct]).astype("int32"),
+            'Total': np.array([n]).astype("int32")
         }
 
     def test_check_output(self):
@@ -27,5 +28,4 @@ class TestAccuracyOp(OpTest):
 
 
 if __name__ == '__main__':
-    exit(0)
     unittest.main()

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

@@ -3,6 +3,7 @@ import paddle.v2.framework.layers as layers
 import paddle.v2.framework.nets as nets
 import paddle.v2.framework.core as core
 import paddle.v2.framework.optimizer as optimizer
+import paddle.v2.framework.evaluator as evaluator
 
 from paddle.v2.framework.framework import Program, g_main_program
 from paddle.v2.framework.executor import Executor
@@ -54,17 +55,24 @@ cost = layers.cross_entropy(
     main_program=main_program,
     startup_program=startup_program)
 avg_cost = layers.mean(x=cost, main_program=main_program)
-accuracy = layers.accuracy(
-    input=predict,
-    label=label,
-    main_program=main_program,
-    startup_program=startup_program)
-
+# accuracy = layers.accuracy(
+#     input=predict,
+#     label=label,
+#     main_program=main_program,
+#     startup_program=startup_program)
 # optimizer = optimizer.MomentumOptimizer(learning_rate=0.1 / 128.0,
 # momentum=0.9)
 optimizer = optimizer.AdamOptimizer(learning_rate=0.01, beta1=0.9, beta2=0.999)
 opts = optimizer.minimize(avg_cost, startup_program)
 
+accuracy = evaluator.accuracy(
+    input=predict,
+    label=label,
+    main_program=main_program,
+    startup_program=startup_program)
+acc_out = accuracy._update_ops(
+    input=predict, label=label, main_program=main_program)
+
 BATCH_SIZE = 50
 PASS_NUM = 3
 train_reader = paddle.batch(
@@ -79,6 +87,7 @@ exe.run(startup_program, feed={}, fetch_list=[])
 
 for pass_id in range(PASS_NUM):
     count = 0
+    accuracy.reset(exe)
     for data in train_reader():
         img_data = np.array(map(lambda x: x[0].reshape([1, 28, 28]),
                                 data)).astype("float32")
@@ -93,11 +102,14 @@ for pass_id in range(PASS_NUM):
         outs = exe.run(main_program,
                        feed={"pixel": tensor_img,
                              "label": tensor_y},
-                       fetch_list=[avg_cost, accuracy])
+                       fetch_list=[avg_cost, acc_out])
         loss = np.array(outs[0])
         acc = np.array(outs[1])
+        # pass_acc = accuracy.eval(exe)
+        # print pass_acc
+        print loss, acc
 
-        if loss < 10.0 and acc > 0.9:
-            # if avg cost less than 10.0 and accuracy is larger than 0.9, we think our code is good.
-            exit(0)
+        # if loss < 10.0 and acc > 0.9:
+        #     # if avg cost less than 10.0 and accuracy is larger than 0.9, we think our code is good.
+        #     exit(0)
 exit(1)