Merge pull request #45 from chengduoZH/feature/mnist_enable_gpu

make mnist.py enable running in GPU

Author: chengduo

fluid/mnist.py

@@ -123,32 +123,32 @@ def run_benchmark(model, args):
     train_reader = paddle.batch(
         paddle.dataset.mnist.train(), batch_size=args.batch_size)
 
-    place = core.CPUPlace()
+    place = core.CPUPlace() if args.device == 'CPU' else core.CUDAPlace(0)
     exe = fluid.Executor(place)
 
     exe.run(fluid.default_startup_program())
 
     for pass_id in range(args.pass_num):
         accuracy.reset(exe)
-        pass_start = time.clock()
+        pass_start = time.time()
         for batch_id, data in enumerate(train_reader()):
             img_data = np.array(
                 map(lambda x: x[0].reshape([1, 28, 28]), data)).astype(DTYPE)
             y_data = np.array(map(lambda x: x[1], data)).astype("int64")
             y_data = y_data.reshape([len(y_data), 1])
 
-            start = time.clock()
+            start = time.time()
             outs = exe.run(fluid.default_main_program(),
                            feed={"pixel": img_data,
                                  "label": y_data},
                            fetch_list=[avg_cost] + accuracy.metrics)
-            end = time.clock()
+            end = time.time()
             loss = np.array(outs[0])
             acc = np.array(outs[1])
             print("pass=%d, batch=%d, loss=%f, error=%f, elapse=%f" %
                   (pass_id, batch_id, loss, 1 - acc, (end - start) / 1000))
 
-        pass_end = time.clock()
+        pass_end = time.time()
         test_avg_acc = eval_test(exe, accuracy, avg_cost)
         pass_acc = accuracy.eval(exe)
         print("pass=%d, test_avg_acc=%f, test_avg_acc=%f, elapse=%f" %

fluid/stacked_dynamic_lstm.py

@@ -2,6 +2,7 @@
 import cPickle
 import os
 import random
+import time
 
 import numpy
 import paddle.v2.dataset.imdb as imdb
@@ -122,6 +123,8 @@ def train_loop(pass_num, crop_size):
             crop_sentence(imdb.train(word_dict), crop_size), clean=args.clean)
         for pass_id in range(pass_num):
             train_reader = batch(cache, batch_size=args.batch_size)
+
+            pass_start_time = time.time()
             for batch_id, data in enumerate(train_reader()):
                 tensor_words = to_lodtensor([x[0] for x in data], place)
                 label = numpy.array([x[1] for x in data]).astype("int64")
@@ -131,7 +134,10 @@ def train_loop(pass_num, crop_size):
                                         "label": label},
                                   fetch_list=[loss])[0]
                 print 'Pass', pass_id, 'Batch', batch_id, 'loss', loss_np
-            print 'Pass', pass_id, 'Done'
+
+            pass_end_time = time.time()
+            time_consumed = pass_end_time - pass_start_time
+            print("pass_id=%d, sec/pass: %f" % (pass_id, time_consumed))
 
     train_loop(args.pass_num, args.crop_size)
 

tensorflow/mnist.py

@@ -129,21 +129,21 @@ def eval_test():
     sess.run(init_g)
     sess.run(init_l)
     for pass_id in range(PASS_NUM):
-        pass_start = time.clock()
+        pass_start = time.time()
         for batch_id, data in enumerate(train_reader()):
             images_data = np.array(
                 map(lambda x: np.transpose(x[0].reshape([1, 28, 28]), axes=[1,2,0]), data)).astype("float32")
             labels_data = np.array(map(lambda x: x[1], data)).astype("int64")
-            start = time.clock()
+            start = time.time()
             _, loss, acc, g_acc = sess.run(
                 [train_op, avg_cost, accuracy, g_accuracy],
                 feed_dict={images: images_data,
                            labels: labels_data})
-            end = time.clock()
+            end = time.time()
 
             print("pass=%d, batch=%d, loss=%f, error=%f, elapse=%f" %
                   (pass_id, batch_id, loss, 1 - acc, (end - start) / 1000))
-        pass_end = time.clock()
+        pass_end = time.time()
         test_avg_acc = eval_test()
         print("pass=%d, training_avg_accuracy=%f, test_avg_acc=%f, elapse=%f" %
               (pass_id, g_acc[1], test_avg_acc, (pass_end - pass_start) / 1000))