optimize pyreader

paddle/fluid/API.spec

@@ -178,6 +178,7 @@ paddle.fluid.layers.batch ArgSpec(args=['reader', 'batch_size'], varargs=None, k
 paddle.fluid.layers.double_buffer ArgSpec(args=['reader', 'place', 'name'], varargs=None, keywords=None, defaults=(None, None))
 paddle.fluid.layers.random_data_generator ArgSpec(args=['low', 'high', 'shapes', 'lod_levels', 'for_parallel'], varargs=None, keywords=None, defaults=(True,))
 paddle.fluid.layers.py_reader ArgSpec(args=['capacity', 'shapes', 'dtypes', 'lod_levels', 'name', 'use_double_buffer'], varargs=None, keywords=None, defaults=(None, None, True))
+paddle.fluid.layers.create_py_reader_by_data ArgSpec(args=['capacity', 'feed_list', 'name', 'use_double_buffer'], varargs=None, keywords=None, defaults=(None, True))
 paddle.fluid.layers.Preprocessor.__init__ ArgSpec(args=['self', 'reader', 'name'], varargs=None, keywords=None, defaults=(None,))
 paddle.fluid.layers.Preprocessor.block ArgSpec(args=[], varargs='args', keywords='kwds', defaults=None)
 paddle.fluid.layers.Preprocessor.inputs ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)

paddle/fluid/CMakeLists.txt

@@ -12,6 +12,5 @@ endif(NOT WIN32)
 if(WITH_INFERENCE)
   # NOTE: please add subdirectory inference at last.
   add_subdirectory(inference)
+  add_subdirectory(train)
 endif()
-
-add_subdirectory(train)

python/paddle/fluid/tests/unittests/test_py_reader_using_executor.py

@@ -53,13 +53,22 @@ def simple_fc_net(in_size,
                   hidden_sizes,
                   batch_size,
                   queue_capacity,
-                  use_double_buffer=False):
+                  use_double_buffer=False,
-    reader = fluid.layers.py_reader(
+                  use_feed_list=True):
-        capacity=queue_capacity,
+    if use_feed_list:
-        shapes=[[-1, in_size], [-1, 1]],
+        data = fluid.layers.data(name="data", dtype='float32', shape=[in_size])
-        lod_levels=[0, 0],
+        label = fluid.layers.data(name='label', dtype='int64', shape=[1])
-        dtypes=['float32', 'int64'],
+        reader = fluid.layers.create_py_reader_by_data(
-        use_double_buffer=False)
+            capacity=queue_capacity,
+            use_double_buffer=False,
+            feed_list=[data, label])
+    else:
+        reader = fluid.layers.py_reader(
+            capacity=queue_capacity,
+            shapes=[[-1, in_size], [-1, 1]],
+            lod_levels=[0, 0],
+            dtypes=['float32', 'int64'],
+            use_double_buffer=False)
     feed_queue = reader.queue
     reader = fluid.layers.batch(reader, batch_size=batch_size)
     if use_double_buffer:
@@ -100,14 +109,16 @@ class TestPyReaderUsingExecutor(unittest.TestCase):
                          if core.is_compiled_with_cuda() else [False]):
             for use_parallel_executor in [False, True]:
                 for use_double_buffer in [False, True]:
-                    print('Test Parameters:'),
+                    for use_feed_list in [False, True]:
-                    print({
+                        print('Test Parameters:'),
-                        'use_cuda': use_cuda,
+                        print({
-                        'use_parallel_executor': use_parallel_executor,
+                            'use_cuda': use_cuda,
-                        'use_double_buffer': use_double_buffer
+                            'use_parallel_executor': use_parallel_executor,
-                    })
+                            'use_double_buffer': use_double_buffer,
-                    self.main(use_cuda, use_parallel_executor,
+                            'use_feed_list': use_feed_list
-                              use_double_buffer)
+                        })
+                        self.main(use_cuda, use_parallel_executor,
+                                  use_double_buffer, use_feed_list)
 
     def random_reader(self):
         def reader():
@@ -143,12 +154,14 @@ class TestPyReaderUsingExecutor(unittest.TestCase):
     def main(self,
              use_cuda=True,
              use_parallel_executor=False,
-             use_double_buffer=False):
+             use_double_buffer=False,
+             use_feed_list=False):
         assert not use_cuda or use_cuda and core.is_compiled_with_cuda()
 
         self.use_cuda = use_cuda
         self.use_parallel_executor = use_parallel_executor
         self.use_double_buffer = use_double_buffer
+        self.use_feed_list = use_feed_list
 
         startup_program = fluid.Program()
         main_program = fluid.Program()
@@ -160,7 +173,8 @@ class TestPyReaderUsingExecutor(unittest.TestCase):
                 hidden_sizes=self.hidden_sizes,
                 batch_size=self.batch_size,
                 queue_capacity=self.queue_capacity,
-                use_double_buffer=self.use_double_buffer)
+                use_double_buffer=self.use_double_buffer,
+                use_feed_list=self.use_feed_list)
 
             place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()