Merge pull request PaddlePaddle#1747 from reyoung/feature/fix_evaluat…

…or_in_layer_v2

Feature/fix evaluator in layer v2

python/paddle/v2/__init__.py

@@ -21,6 +21,7 @@
 import topology
 import data_feeder
 import networks
+import evaluator
 from . import dataset
 from . import reader
 from . import plot
@@ -35,7 +36,7 @@
 __all__ = [
     'optimizer', 'layer', 'activation', 'parameters', 'init', 'trainer',
     'event', 'data_type', 'attr', 'pooling', 'data_feeder', 'dataset', 'reader',
-    'topology', 'networks', 'infer', 'plot'
+    'topology', 'networks', 'infer', 'plot', 'evaluator'
 ]
 
 

python/paddle/v2/config_base.py

@@ -65,13 +65,27 @@ class Layer(object):
     def __init__(self, name=None, parent_layers=None):
         assert isinstance(parent_layers, dict)
         self.name = name
-        self.__contex__ = {}
+        self.__context__ = {}
         self.__parent_layers__ = parent_layers
+        self.__children_layers__ = []  # used for evaluator.
+
+    def append_child(self, layer, parent_names):
+        self.__children_layers__.append((layer, parent_names))
 
     def to_proto(self, context):
         """
         function to set proto attribute
         """
+        self.__context__ = context
+
+        # short cut if myself is parsed before.
+        if self.context_name() in context:
+            if self.use_context_name():
+                return context[self.context_name()]
+            else:
+                return context[self.name]
+
+        # parse parent before myself
         kwargs = dict()
         for layer_name in self.__parent_layers__:
             if not isinstance(self.__parent_layers__[layer_name],
@@ -83,12 +97,29 @@ def to_proto(self, context):
                                self.__parent_layers__[layer_name])
             kwargs[layer_name] = v1_layer
 
+        # parse myself.
+        ret_val = self.to_proto_impl(**kwargs)
+
+        if self.context_name() is not None and \
+                        self.context_name() not in context:
+            context[self.context_name()] = ret_val
+
+        # parse children.
+        for layer, pnames in self.__children_layers__:
+            drop = False
+
+            # child will only be parsed if all parents are in context.
+            for pname in pnames:
+                if pname not in context:
+                    drop = True
+                    break
+            if drop:
+                continue
+            layer.to_proto(context=context)
+
         if self.context_name() is None:
-            return self.to_proto_impl(**kwargs)
-        elif self.context_name() not in context:
-            context[self.context_name()] = self.to_proto_impl(**kwargs)
-        self.__contex__ = context
-        if self.use_context_name():
+            return ret_val
+        elif self.use_context_name():
             return context[self.context_name()]
         else:
             return context[self.name]
@@ -113,10 +144,13 @@ def calculate_size(self):
         this layer is called.
         :return:
         """
-        return self.__contex__[self.context_name()].size
+        return self.__context__[self.context_name()].size
 
 
-def __convert_to_v2__(method_name, parent_names, is_default_name=True):
+def __convert_to_v2__(method_name,
+                      parent_names,
+                      is_default_name=True,
+                      attach_parent=False):
     if is_default_name:
         wrapper = wrap_name_default(name_prefix=method_name)
     else:
@@ -129,9 +163,20 @@ def __init__(self, **kwargs):
             parent_layers = dict()
             other_kwargs = dict()
             for pname in parent_names:
-                if kwargs.has_key(pname):
+                if pname in kwargs:
                     parent_layers[pname] = kwargs[pname]
 
+            if attach_parent:
+                pnames = [x.context_name() for x in parent_layers.values()]
+
+                for pname in parent_layers:
+                    layers = kwargs[pname]
+                    if not isinstance(layers, collections.Sequence):
+                        layers = [layers]
+
+                    for layer in layers:
+                        layer.append_child(self, pnames)
+
             for key in kwargs.keys():
                 if key not in parent_names:
                     other_kwargs[key] = kwargs[key]

python/paddle/v2/evaluator.py

@@ -0,0 +1,47 @@
+# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle.trainer_config_helpers.evaluators as evs
+import inspect
+from config_base import __convert_to_v2__
+
+__all__ = []
+
+
+def initialize():
+    def convert_to_new_name(nm):
+        return nm[:-len("_evaluator")]
+
+    for __ev_name__ in filter(lambda x: x.endswith('_evaluator'), evs.__all__):
+        __ev__ = getattr(evs, __ev_name__)
+        if hasattr(__ev__, 'argspec'):
+            argspec = __ev__.argspec
+        else:
+            argspec = inspect.getargspec(__ev__)
+        parent_names = filter(lambda x: x in ['input', 'label', 'weight'],
+                              argspec.args)
+        v2_ev = __convert_to_v2__(
+            __ev_name__,
+            parent_names=parent_names,
+            is_default_name='name' in argspec.args,
+            attach_parent=True)
+
+        __new_name__ = convert_to_new_name(__ev_name__)
+
+        globals()[__new_name__] = v2_ev
+        globals()[__new_name__].__name__ = __new_name__
+        __all__.append(__new_name__)
+
+
+initialize()

python/paddle/v2/tests/test_layer.py

@@ -19,6 +19,7 @@
 import paddle.v2.layer as layer
 import paddle.v2.pooling as pooling
 import paddle.v2.networks as networks
+import paddle.v2.evaluator as evaluator
 
 pixel = layer.data(name='pixel', type=data_type.dense_vector(128))
 label = layer.data(name='label', type=data_type.integer_value(10))
@@ -262,5 +263,20 @@ def test_vgg(self):
         print layer.parse_network(vgg_out)
 
 
+class EvaluatorTest(unittest.TestCase):
+    def test_evaluator(self):
+        img = layer.data(name='pixel', type=data_type.dense_vector(784))
+        output = layer.fc(input=img,
+                          size=10,
+                          act=activation.Softmax(),
+                          name='fc_here')
+        lbl = layer.data(name='label', type=data_type.integer_value(10))
+        cost = layer.cross_entropy_cost(input=output, label=lbl)
+
+        evaluator.classification_error(input=output, label=lbl)
+        print layer.parse_network(cost)
+        print layer.parse_network(output)
+
+
 if __name__ == '__main__':
     unittest.main()