Complete inferencer.

Author: reyoung

demo/mnist/api_train_v2.py

@@ -44,6 +44,19 @@ def event_handler(event):
             batch_size=32),
         event_handler=event_handler)
 
+    # output is a softmax layer. It returns probabilities.
+    # Shape should be (100, 10)
+    probs = paddle.infer(
+        output=inference,
+        parameters=parameters,
+        reader=paddle.reader.batched(
+            paddle.reader.limited(
+                paddle.reader.map_readers(lambda item: (item[0], ),
+                                          paddle.dataset.mnist.test()),
+                limit=100),
+            batch_size=32))
+    print probs.shape
+
 
 if __name__ == '__main__':
     main()

python/paddle/v2/dataset/mnist.py

@@ -35,24 +35,25 @@ def reader():
         l = subprocess.Popen([zcat_cmd, label_filename], stdout=subprocess.PIPE)
         l.stdout.read(8)  # skip some magic bytes
 
-        while True:
-            labels = numpy.fromfile(
-                l.stdout, 'ubyte', count=buffer_size).astype("int")
+        try:  # reader could be break.
+            while True:
+                labels = numpy.fromfile(
+                    l.stdout, 'ubyte', count=buffer_size).astype("int")
 
-            if labels.size != buffer_size:
-                break  # numpy.fromfile returns empty slice after EOF.
+                if labels.size != buffer_size:
+                    break  # numpy.fromfile returns empty slice after EOF.
 
-            images = numpy.fromfile(
-                m.stdout, 'ubyte', count=buffer_size * 28 * 28).reshape(
-                    (buffer_size, 28 * 28)).astype('float32')
+                images = numpy.fromfile(
+                    m.stdout, 'ubyte', count=buffer_size * 28 * 28).reshape(
+                        (buffer_size, 28 * 28)).astype('float32')
 
-            images = images / 255.0 * 2.0 - 1.0
+                images = images / 255.0 * 2.0 - 1.0
 
-            for i in xrange(buffer_size):
-                yield images[i, :], int(labels[i])
-
-        m.terminate()
-        l.terminate()
+                for i in xrange(buffer_size):
+                    yield images[i, :], int(labels[i])
+        finally:
+            m.terminate()
+            l.terminate()
 
     return reader
 

python/paddle/v2/inferencer.py

@@ -16,31 +16,36 @@ def __init__(self, output, parameters):
         for param in gm.getParameters():
             val = param.getBuf(api.PARAMETER_VALUE)
             name = param.getName()
-            assert isinstance(val, api.Matrix)
-            val.copyFromNumpyMat(parameters.get(name))
+            assert isinstance(val, api.Vector)
+            val.copyFromNumpyArray(parameters.get(name).flatten())
         self.__gradient_machine__ = gm
         self.__data_types__ = topo.data_type()
 
     def iter_infer(self, reader, reader_dict=None):
+        if reader_dict is None:
+            reader_dict = self.default_reader_dict()
         feeder = DataFeeder(self.__data_types__, reader_dict)
-        out_args = api.Arguments.createArguments(0)
         self.__gradient_machine__.start()
         for data_batch in reader():
-            yield self.__gradient_machine__.forwardTest(
-                feeder(data_batch), out_args, api.PASS_TEST)
+            yield self.__gradient_machine__.forwardTest(feeder(data_batch))
         self.__gradient_machine__.finish()
 
     def iter_infer_field(self, field, **kwargs):
         for result in self.iter_infer(**kwargs):
             yield [each_result[field] for each_result in result]
 
     def infer(self, field='value', **kwargs):
-        retv = []
-        for result in itertools.izip(
-                self.iter_infer_field(
-                    field=field, **kwargs)):
-            retv.append(numpy.concatenate(result))
-        return retv
+        retv = None
+        for result in self.iter_infer_field(field=field, **kwargs):
+            if retv is None:
+                retv = [[]] * len(result)
+            for i, item in enumerate(result):
+                retv[i].append(item)
+        retv = [numpy.concatenate(out) for out in retv]
+        if len(retv) == 1:
+            return retv[0]
+        else:
+            return retv
 
     def default_reader_dict(self):
         reader_dict = dict()

python/paddle/v2/reader/decorator.py

@@ -14,13 +14,13 @@
 
 __all__ = [
     'map_readers', 'buffered', 'compose', 'chain', 'shuffle',
-    'ComposeNotAligned', 'batched'
+    'ComposeNotAligned', 'batched', 'limited'
 ]
 
-from Queue import Queue
-from threading import Thread
 import itertools
 import random
+from Queue import Queue
+from threading import Thread
 
 
 def map_readers(func, *readers):
@@ -213,3 +213,17 @@ def batched_reader():
             yield batch
 
     return batched_reader
+
+
+def limited(reader, limit):
+    """
+    Limit the max number of samples that reader could return.
+    """
+
+    def limited_reader():
+        for i, item in enumerate(reader()):
+            if i == limit:
+                break
+            yield item
+
+    return limited_reader