add topology test

demo/mnist/api_train_v2.py

@@ -26,7 +26,7 @@ def main():
                                 act=paddle.activation.Softmax())
     cost = paddle.layer.classification_cost(input=inference, label=label)
 
-    parameters = paddle.parameters.create([cost])
+    parameters = paddle.parameters.create(cost)
     for param_name in parameters.keys():
         array = parameters.get(param_name)
         array[:] = numpy.random.uniform(low=-1.0, high=1.0, size=array.shape)

python/paddle/v2/data_type.py

@@ -14,9 +14,9 @@
 
 from paddle.trainer.PyDataProvider2 import \
     InputType, dense_vector, sparse_binary_vector,\
-    sparse_vector, integer_value
+    sparse_vector, integer_value, DataType
 
 __all__ = [
     'InputType', 'dense_vector', 'sparse_binary_vector', 'sparse_vector',
-    'integer_value'
+    'integer_value', 'DataType'
 ]

python/paddle/v2/tests/CMakeLists.txt

+add_test(NAME topology_test
+        COMMAND ${PROJ_ROOT}/paddle/.set_python_path.sh -d ${PROJ_ROOT}/python/
+        ${PYTHON_EXECUTABLE} ${PROJ_ROOT}/python/paddle/v2/tests/topology_test.py
+        WORKING_DIRECTORY ${PROJ_ROOT}/python/paddle)

python/paddle/v2/tests/topology_test.py

+# Copyright PaddlePaddle contributors. 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 unittest
+import paddle.v2.layer as layer
+import paddle.v2.topology as topology
+import paddle.v2.data_type as data_type
+import paddle.trainer_config_helpers as conf_helps
+
+
+class TestTopology(unittest.TestCase):
+    def test_parse(self):
+        pixel = layer.data(name='pixel', type=data_type.dense_vector(784))
+        label = layer.data(name='label', type=data_type.integer_value(10))
+        hidden = layer.fc(input=pixel,
+                          size=100,
+                          act=conf_helps.SigmoidActivation())
+        inference = layer.fc(input=hidden,
+                             size=10,
+                             act=conf_helps.SoftmaxActivation())
+        maxid = layer.max_id(input=inference)
+        cost1 = layer.classification_cost(input=inference, label=label)
+        cost2 = layer.cross_entropy_cost(input=inference, label=label)
+
+        print topology.Topology(cost2).proto()
+        print topology.Topology([cost1]).proto()
+        print topology.Topology([cost1, cost2]).proto()
+        print topology.Topology(cost2).proto()
+        print topology.Topology([inference, maxid]).proto()
+
+    def test_data_type(self):
+        pixel = layer.data(name='pixel', type=data_type.dense_vector(784))
+        label = layer.data(name='label', type=data_type.integer_value(10))
+        hidden = layer.fc(input=pixel,
+                          size=100,
+                          act=conf_helps.SigmoidActivation())
+        inference = layer.fc(input=hidden,
+                             size=10,
+                             act=conf_helps.SoftmaxActivation())
+        cost = layer.classification_cost(input=inference, label=label)
+        topo = topology.Topology(cost)
+        type = topo.data_type()
+        self.assertEqual(len(type), 2)
+        self.assertEqual(type[0][0], "pixel")
+        self.assertEqual(type[0][1].type, data_type.DataType.Dense)
+        self.assertEqual(type[0][1].dim, 784)
+        self.assertEqual(type[1][0], "label")
+        self.assertEqual(type[1][1].type, data_type.DataType.Index)
+        self.assertEqual(type[1][1].dim, 10)
+
+    def test_get_layer(self):
+        pixel = layer.data(name='pixel', type=data_type.dense_vector(784))
+        label = layer.data(name='label', type=data_type.integer_value(10))
+        hidden = layer.fc(input=pixel,
+                          size=100,
+                          act=conf_helps.SigmoidActivation())
+        inference = layer.fc(input=hidden,
+                             size=10,
+                             act=conf_helps.SoftmaxActivation())
+        cost = layer.classification_cost(input=inference, label=label)
+        topo = topology.Topology(cost)
+        pixel_layer = topo.get_layer("pixel")
+        label_layer = topo.get_layer("label")
+        self.assertEqual(pixel_layer, pixel)
+        self.assertEqual(label_layer, label)
+
+
+if __name__ == '__main__':
+    unittest.main()

python/paddle/v2/topology.py

@@ -31,7 +31,8 @@ class Topology(object):
 
     def __init__(self, layers):
         if not isinstance(layers, collections.Sequence):
-            raise ValueError("input of Topology should be a list of Layer")
+            __check_layer_type__(layers)
+            layers = [layers]
         for layer in layers:
             if not isinstance(layer, v2_layer.LayerV2):
                 raise ValueError('layer should have type paddle.layer.Layer')
@@ -97,6 +98,11 @@ class Topology(object):
         return data_types_lists
 
 
+def __check_layer_type__(layer):
+    if not isinstance(layer, v2_layer.LayerV2):
+        raise ValueError('layer should have type paddle.layer.Layer')
+
+
 if __name__ == '__main__':
     pixel = v2_layer.data(name='pixel', type=data_type.dense_vector(784))
     label = v2_layer.data(name='label', type=data_type.integer_value(10))
@@ -110,8 +116,8 @@ if __name__ == '__main__':
     cost1 = v2_layer.classification_cost(input=inference, label=label)
     cost2 = v2_layer.cross_entropy_cost(input=inference, label=label)
 
-    print Topology(cost1).proto()
     print Topology(cost2).proto()
-    print Topology(cost1, cost2).proto()
+    print Topology([cost1]).proto()
+    print Topology([cost1, cost2]).proto()
     print Topology(cost2).proto()
-    print Topology(inference, maxid).proto()
+    print Topology([inference, maxid]).proto()