remove Accuracys in model repo

fluid/adversarial/fluid_mnist.py

@@ -47,7 +47,9 @@ def main():
     optimizer = fluid.optimizer.Adam(learning_rate=0.01)
     optimizer.minimize(avg_cost)
 
-    accuracy = fluid.evaluator.Accuracy(input=logits, label=label)
+    batch_size = fluid.layers.create_tensor(dtype='int64')
+    batch_acc = fluid.layers.accuracy(
+        input=logits, label=label, total=batch_size)
 
     BATCH_SIZE = 50
     PASS_NUM = 3
@@ -63,20 +65,21 @@ def main():
     feeder = fluid.DataFeeder(feed_list=[img, label], place=place)
     exe.run(fluid.default_startup_program())
 
+    pass_acc = fluid.average.WeightedAverage()
     for pass_id in range(PASS_NUM):
-        accuracy.reset(exe)
+        pass_acc.reset()
         for data in train_reader():
-            loss, acc = exe.run(fluid.default_main_program(),
-                                feed=feeder.feed(data),
-                                fetch_list=[avg_cost] + accuracy.metrics)
-            pass_acc = accuracy.eval(exe)
-            print("pass_id=" + str(pass_id) + " acc=" + str(acc) + " pass_acc="
-                  + str(pass_acc))
+            loss, acc, b_size = exe.run(fluid.default_main_program(),
+                                        feed=feeder.feed(data),
+                                        fetch_list=[avg_cost, batch_acc, batch_size])
+            pass_acc.add(value=acc, weight=b_size)
+            print("pass_id=" + str(pass_id) + " acc=" + str(acc[0]) + " pass_acc="
+                  + str(pass_acc.eval()[0]))
             if loss < LOSS_THRESHOLD and pass_acc > ACC_THRESHOLD:
                 break
 
-        pass_acc = accuracy.eval(exe)
-        print("pass_id=" + str(pass_id) + " pass_acc=" + str(pass_acc))
+        print("pass_id=" + str(pass_id) +
+              " pass_acc=" + str(pass_acc.eval()[0]))
     fluid.io.save_params(
         exe, dirname='./mnist', main_program=fluid.default_main_program())
     print('train mnist done')

fluid/image_classification/mobilenet.py

@@ -173,14 +173,15 @@ def train(learning_rate, batch_size, num_passes, model_save_dir='model'):
         regularization=fluid.regularizer.L2Decay(5 * 1e-5))
     opts = optimizer.minimize(avg_cost)
 
-    b_size = fluid.layers.create_tensor(dtype='int64')
-    b_acc = fluid.layers.accuracy(input=out, label=label, total=b_size)
+    b_size_var = fluid.layers.create_tensor(dtype='int64')
+    b_acc_var = fluid.layers.accuracy(input=out, label=label, total=b_size_var)
 
     inference_program = fluid.default_main_program().clone()
     with fluid.program_guard(inference_program):
-        inference_program = fluid.io.get_inference_program(b_acc)
+        inference_program = fluid.io.get_inference_program(
+            target_vars=[b_acc_var, b_size_var])
 
-    place = fluid.CUDAPlace(0)
+    place = fluid.CPUPlace()
     exe = fluid.Executor(place)
     exe.run(fluid.default_startup_program())
 
@@ -190,26 +191,26 @@ def train(learning_rate, batch_size, num_passes, model_save_dir='model'):
         paddle.dataset.flowers.test(), batch_size=batch_size)
     feeder = fluid.DataFeeder(place=place, feed_list=[image, label])
 
-    train_pass_acc = fluid.average.WeightedAverage()
-    test_pass_acc = fluid.average.WeightedAverage()
+    train_pass_acc_evaluator = fluid.average.WeightedAverage()
+    test_pass_acc_evaluator = fluid.average.WeightedAverage()
     for pass_id in range(num_passes):
-        train_pass_acc.reset()
+        train_pass_acc_evaluator.reset()
         for batch_id, data in enumerate(train_reader()):
             loss, acc, size = exe.run(fluid.default_main_program(),
                                       feed=feeder.feed(data),
-                                      fetch_list=[avg_cost, b_acc, b_size])
-            train_pass_acc.add(value=acc, weight=size)
+                                      fetch_list=[avg_cost, b_acc_var, b_size_var])
+            train_pass_acc_evaluator.add(value=acc, weight=size)
             print("Pass {0}, batch {1}, loss {2}, acc {3}".format(
                 pass_id, batch_id, loss[0], acc[0]))
 
-        test_pass_acc.reset()
+        test_pass_acc_evaluator.reset()
         for data in test_reader():
             loss, acc, size = exe.run(inference_program,
                                       feed=feeder.feed(data),
-                                      fetch_list=[avg_cost, b_acc, b_size])
-            test_pass_acc.add(value=acc, weight=size)
+                                      fetch_list=[avg_cost, b_acc_var, b_size_var])
+            test_pass_acc_evaluator.add(value=acc, weight=size)
         print("End pass {0}, train_acc {1}, test_acc {2}".format(
-            pass_id, train_pass_acc.eval(), test_pass_acc.eval()))
+            pass_id, train_pass_acc_evaluator.eval(), test_pass_acc_evaluator.eval()))
         if pass_id % 10 == 0:
             model_path = os.path.join(model_save_dir, str(pass_id))
             print 'save models to %s' % (model_path)

fluid/text_classification/train.py

@@ -89,12 +89,14 @@ def main(dict_path):
     sgd_optimizer = fluid.optimizer.SGD(learning_rate=conf.learning_rate)
     sgd_optimizer.minimize(avg_cost)
 
-    accuracy = fluid.evaluator.Accuracy(input=prediction, label=label)
+    batch_size_var = fluid.layers.create_tensor(dtype='int64')
+    batch_acc_var = fluid.layers.accuracy(
+        input=prediction, label=label, total=batch_size_var)
 
     inference_program = fluid.default_main_program().clone()
     with fluid.program_guard(inference_program):
-        test_target = accuracy.metrics + accuracy.states
-        inference_program = fluid.io.get_inference_program(test_target)
+        inference_program = fluid.io.get_inference_program(
+            target_vars=[batch_acc_var, batch_size_var])
 
     # The training data set.
     train_reader = paddle.batch(
@@ -119,31 +121,36 @@ def main(dict_path):
 
     exe.run(fluid.default_startup_program())
 
+    train_pass_acc_evaluator = fluid.average.WeightedAverage()
+    test_pass_acc_evaluator = fluid.average.WeightedAverage()
+
     def test(exe):
-        accuracy.reset(exe)
+        test_pass_acc_evaluator.reset()
         for batch_id, data in enumerate(test_reader()):
             input_seq = to_lodtensor(map(lambda x: x[0], data), place)
             y_data = np.array(map(lambda x: x[1], data)).astype("int64")
             y_data = y_data.reshape([-1, 1])
-            acc = exe.run(inference_program,
-                          feed={"words": input_seq,
-                                "label": y_data})
-        test_acc = accuracy.eval(exe)
+            b_acc, b_size = exe.run(inference_program,
+                                    feed={"words": input_seq,
+                                          "label": y_data},
+                                    fetch_list=[batch_acc_var, batch_size_var])
+            test_pass_acc_evaluator.add(value=b_acc, weight=b_size)
+        test_acc = test_pass_acc_evaluator.eval()
         return test_acc
 
     total_time = 0.
     for pass_id in xrange(conf.num_passes):
-        accuracy.reset(exe)
+        train_pass_acc_evaluator.reset()
         start_time = time.time()
         for batch_id, data in enumerate(train_reader()):
-            cost_val, acc_val = exe.run(
+            cost_val, acc_val, size_val = exe.run(
                 fluid.default_main_program(),
                 feed=feeder.feed(data),
-                fetch_list=[avg_cost, accuracy.metrics[0]])
-            pass_acc = accuracy.eval(exe)
+                fetch_list=[avg_cost, batch_acc_var, batch_size_var])
+            train_pass_acc_evaluator.add(value=acc_val, weight=size_val)
             if batch_id and batch_id % conf.log_period == 0:
-                print("Pass id: %d, batch id: %d, cost: %f, pass_acc %f" %
-                      (pass_id, batch_id, cost_val, pass_acc))
+                print("Pass id: %d, batch id: %d, cost: %f, pass_acc: %f" %
+                      (pass_id, batch_id, cost_val, train_pass_acc_evaluator.eval()))
         end_time = time.time()
         total_time += (end_time - start_time)
         pass_test_acc = test(exe)