Add docs and clean up unused code

python/paddle/trainer/config_parser.py

@@ -3371,7 +3371,7 @@ def make_importer(config_dir, config_args):
     return Import
 
 
-default_settings = dict(
+DEFAULT_SETTING = dict(
     batch_size=None,
     mini_batch_size=None,
     algorithm='async_sgd',
@@ -3404,7 +3404,7 @@ default_settings = dict(
     adam_beta2=0.999,
     adam_epsilon=1e-8, )
 
-settings = copy.deepcopy(default_settings)
+settings = copy.deepcopy(DEFAULT_SETTING)
 
 settings_deprecated = dict(usage_ratio=1., )
 

python/paddle/trainer_config_helpers/config_parser_utils.py

@@ -15,7 +15,6 @@
 import copy
 import paddle.trainer.config_parser as config_parser
 from paddle.proto.TrainerConfig_pb2 import OptimizationConfig
-
 '''
 This file is a wrapper of formal config_parser. The main idea of this file is to
 separete different config logic into different function, such as network configuration
@@ -38,7 +37,7 @@ def parse_network_config(network_conf, config_arg_str=''):
 
 
 def parse_optimizer_config(optimizer_conf, config_arg_str=''):
-    config_parser.settings = copy.deepcopy(config_parser.default_settings)
+    config_parser.settings = copy.deepcopy(config_parser.DEFAULT_SETTING)
     optimizer_conf()
     opt_config = OptimizationConfig()
     for k, v in config_parser.settings.iteritems():

python/paddle/v2/evaluator.py

@@ -13,8 +13,8 @@
 # limitations under the License.
 
 import paddle.trainer_config_helpers.evaluators as evs
-import inspect
 from config_base import __convert_to_v2__
+import inspect
 
 __all__ = []
 
@@ -27,7 +27,8 @@ def initialize():
         __ev__ = getattr(evs, __ev_name__)
         __new_name__ = convert_to_new_name(__ev_name__)
 
-        globals()[__new_name__] = __ev__
+        globals()[__new_name__] = __convert_to_v2__(__ev__, __new_name__,
+                                                    __name__)
         globals()[__new_name__].__name__ = __new_name__
         __all__.append(__new_name__)
 

python/paddle/v2/inference.py

@@ -12,9 +12,9 @@ class Inference(object):
     """
     Inference combines neural network output and parameters together
     to do inference.
-    
+
     ..  code-block:: python
-    
+
         inferer = Inference(output_layer=prediction, parameters=parameters)
         for data_batch in batches:
             print inferer.infer(data_batch)
@@ -92,8 +92,8 @@ def infer(output_layer, parameters, input, feeding=None, field='value'):
 
     ..  code-block:: python
 
-        result = paddle.infer(output_layer=prediction, 
-                              parameters=parameters, 
+        result = paddle.infer(output_layer=prediction,
+                              parameters=parameters,
                               input=SomeData)
         print result
 
@@ -101,14 +101,14 @@ def infer(output_layer, parameters, input, feeding=None, field='value'):
 
     ..  code-block:: python
 
-        result = paddle.infer(output_layer=[prediction1, prediction2], 
-                              parameters=parameters, 
+        result = paddle.infer(output_layer=[prediction1, prediction2],
+                              parameters=parameters,
                               input=SomeData,
                               field=[id, value]])
         print result
 
     :param output_layer: output of the neural network that would be inferred
-    :type output_layer: paddle.v2.config_base.Layer or a list of 
+    :type output_layer: paddle.v2.config_base.Layer or a list of
                         paddle.v2.config_base.Layer
     :param parameters: parameters of the neural network.
     :type parameters: paddle.v2.parameters.Parameters
@@ -117,14 +117,14 @@ def infer(output_layer, parameters, input, feeding=None, field='value'):
     :type input: collections.Iterable
     :param feeding: Reader dictionary. Default could generate from input
                         value.
-    :param field: The prediction field. It should in [`value`, `id`, `prob`]. 
-                  `value` and `prob` mean return the prediction probabilities, 
+    :param field: The prediction field. It should in [`value`, `id`, `prob`].
+                  `value` and `prob` mean return the prediction probabilities,
                   `id` means return the prediction labels. Default is `value`.
-                  Note that `prob` only used when output_layer is beam_search 
+                  Note that `prob` only used when output_layer is beam_search
                   or max_id.
     :type field: str
-    :return: The prediction result. If there are multiple outout_layers and fields, 
-             the return order is outout_layer1.field1, outout_layer2.field1, ..., 
+    :return: The prediction result. If there are multiple outout_layers and fields,
+             the return order is outout_layer1.field1, outout_layer2.field1, ...,
              outout_layer1.field2, outout_layer2.field2 ...
     :rtype: numpy.ndarray
     """

python/paddle/v2/layer.py

@@ -33,26 +33,14 @@ The primary usage shows below.
 
 import collections
 import copy
+import re
 import paddle.trainer_config_helpers.layers as v1_layers
 import paddle.trainer.config_parser as cp
 from paddle.proto.ModelConfig_pb2 import ModelConfig, SubModelConfig
+from config_base import __convert_to_v2__
+import config_base
 
 __all__ = ['data', 'parse_network']
-__layer_map__ = {}
-
-
-def __wrap__(f):
-    def wrapped(*args, **xargs):
-        out = f(*args, **xargs)
-        outs = out
-        if not isinstance(out, collections.Sequence):
-            outs = [out]
-        for l in outs:
-            if isinstance(l, v1_layers.LayerOutput):
-                __layer_map__[l.full_name] = l
-        return out
-
-    return wrapped
 
 
 def __need_to_keep__(name):
@@ -90,7 +78,7 @@ for name in v1_layers.__all__:
         continue
     new_name = __convert_name__(name)
     if callable(obj) and __need_to_wrap__(name):
-        globals()[new_name] = __wrap__(obj)
+        globals()[new_name] = __convert_to_v2__(obj, new_name, __name__)
     else:
         globals()[new_name] = obj
     __all__.append(new_name)
@@ -102,9 +90,21 @@ def __data_layer__(name, type, **kwargs):
     return l
 
 
-data = __wrap__(__data_layer__)
+def __map_data_docstr__(doc):
+    doc = re.sub(r'(data = [^\)]+)\).*',
+                 "data = paddle.layer.data(name=\"input\", "
+                 "type=paddle.data_type.dense_vector(1000))", doc)
+
+    doc = re.sub(r':param size:.*', ':param type: Data type of this data layer',
+                 doc)
+    doc = re.sub(r':type size:.*', ":type size: paddle.v2.data_type.InputType",
+                 doc)
+    return doc
+
+
+__data_layer__.__doc__ = __map_data_docstr__(v1_layers.data_layer.__doc__)
 
-LayerV2 = v1_layers.LayerOutput
+data = __convert_to_v2__(__data_layer__, 'name', __name__)
 
 
 def __get_used_layers__(output_layers, extra_layers=None):
@@ -273,7 +273,7 @@ def parse_network(output_layers, extra_layers=None):
 
 
 def get_layer(name):
-    return __layer_map__.get(name)
+    return config_base.__layer_map__.get(name)
 
 
 cp.begin_parse()

python/paddle/v2/tests/test_rnn_layer.py

@@ -32,6 +32,7 @@ class RNNTest(unittest.TestCase):
 
         def parse_old_rnn():
             reset_parser()
+
             def step(y):
                 mem = conf_helps.memory(name="rnn_state", size=hidden_dim)
                 out = conf_helps.fc_layer(
@@ -52,6 +53,7 @@ class RNNTest(unittest.TestCase):
 
         def parse_new_rnn():
             reset_parser()
+
             def new_step(y):
                 mem = layer.memory(name="rnn_state", size=hidden_dim)
                 out = layer.fc(input=[y, mem],
@@ -72,7 +74,6 @@ class RNNTest(unittest.TestCase):
                                     parse_new_rnn().splitlines(1))
         print ''.join(diff)
 
-
     def test_sequence_rnn_multi_input(self):
         dict_dim = 10
         word_dim = 8
@@ -81,6 +82,7 @@ class RNNTest(unittest.TestCase):
 
         def parse_old_rnn():
             reset_parser()
+
             def test():
                 data = conf_helps.data_layer(name="word", size=dict_dim)
                 label = conf_helps.data_layer(name="label", size=label_dim)

python/paddle/v2/topology.py

@@ -17,34 +17,11 @@ import collections
 from paddle.proto.ModelConfig_pb2 import ModelConfig
 import paddle.trainer_config_helpers as conf_helps
 import layer as v2_layer
+import config_base
 
 __all__ = ['Topology']
 
 
-def __flatten__(lis):
-    """
-    Given a list, possibly nested to any level, return it flattened.
-    """
-    new_lis = []
-    for item in lis:
-        if isinstance(item, collections.Sequence):
-            new_lis.extend(__flatten__(item))
-        else:
-            new_lis.append(item)
-    return new_lis
-
-
-def __bfs_travel__(callback, *layers):
-    layers = __flatten__(layers)
-    for each_layer in layers:
-        __break__ = callback(each_layer)
-        if __break__:
-            return
-        __layers__ = each_layer.__parent_layers__.values() + \
-                     each_layer.extra_parent()
-        __bfs_travel__(callback, *__layers__)
-
-
 class Topology(object):
     """
     Topology is used to store the information about all layers
@@ -125,5 +102,5 @@ class Topology(object):
 
 
 def __check_layer_type__(layer):
-    if not isinstance(layer, v2_layer.LayerV2):
-        raise ValueError('layer should have type paddle.layer.Layer')
+    if not isinstance(layer, config_base.Layer):
+        raise ValueError('layer should have type paddle.v2.config_base.Layer')