unify layer names (#4913)

python/paddle/v2/framework/layers.py

@@ -3,17 +3,17 @@ import paddle.v2.framework.core as core
 from paddle.v2.framework.framework import OpProtoHolder, Variable
 import re
 
-__all__ = ['fc_layer', 'data_layer', 'cross_entropy', 'conv2d_layer']
+__all__ = ['fc', 'data', 'cross_entropy', 'conv2d']
 
 
-def fc_layer(input,
-             size,
-             param_attr=None,
-             bias_attr=True,
-             name=None,
-             act=None,
-             num_flatten_dims=1,
-             program=None):
+def fc(input,
+       size,
+       param_attr=None,
+       bias_attr=True,
+       name=None,
+       act=None,
+       num_flatten_dims=1,
+       program=None):
     # create helper
     helper = LayerHelper('fc', **locals())
 
@@ -51,11 +51,11 @@ def fc_layer(input,
     return helper.append_activation(pre_activation)
 
 
-def data_layer(name,
-               shape,
-               data_type='float32',
-               type=core.VarDesc.VarType.LOD_TENSOR,
-               program=None):
+def data(name,
+         shape,
+         data_type='float32',
+         type=core.VarDesc.VarType.LOD_TENSOR,
+         program=None):
     helper = LayerHelper('data', **locals())
     shape = [-1] + shape  # append batch size as -1
     return helper.create_global_variable(
@@ -145,17 +145,17 @@ def square_error_cost(input, label, **kwargs):
     return square_out
 
 
-def conv2d_layer(input,
-                 num_filters,
-                 name=None,
-                 filter_size=[1, 1],
-                 act=None,
-                 groups=None,
-                 stride=[1, 1],
-                 padding=None,
-                 bias_attr=None,
-                 param_attr=None,
-                 program=None):
+def conv2d(input,
+           num_filters,
+           name=None,
+           filter_size=[1, 1],
+           act=None,
+           groups=None,
+           stride=[1, 1],
+           padding=None,
+           bias_attr=None,
+           param_attr=None,
+           program=None):
     helper = LayerHelper('conv2d', **locals())
     dtype = helper.input_dtype()
 

python/paddle/v2/framework/tests/test_layers.py

-from paddle.v2.framework.layers import fc_layer, data_layer, cross_entropy, mean, square_error_cost, conv2d_layer
+import paddle.v2.framework.layers as layers
 from paddle.v2.framework.framework import Program, g_program
 import paddle.v2.framework.core as core
 import unittest
@@ -7,15 +7,16 @@ import unittest
 class TestBook(unittest.TestCase):
     def test_fit_a_line(self):
         program = Program()
-        x = data_layer(
+        x = layers.data(
             name='x', shape=[13], data_type='float32', program=program)
-        y_predict = fc_layer(input=x, size=1, act=None, program=program)
+        y_predict = layers.fc(input=x, size=1, act=None, program=program)
 
-        y = data_layer(
+        y = layers.data(
             name='y', shape=[1], data_type='float32', program=program)
-        cost = square_error_cost(input=y_predict, label=y, program=program)
+        cost = layers.square_error_cost(
+            input=y_predict, label=y, program=program)
 
-        avg_cost = mean(x=cost, program=program)
+        avg_cost = layers.mean(x=cost, program=program)
         self.assertIsNotNone(avg_cost)
         program.append_backward(avg_cost, set())
         print str(program)
@@ -24,16 +25,18 @@ class TestBook(unittest.TestCase):
         program = Program()
 
         # Change g_program, so the rest layers use `g_program`
-        images = data_layer(
+        images = layers.data(
             name='pixel', shape=[784], data_type='float32', program=program)
-        label = data_layer(
+        label = layers.data(
             name='label', shape=[1], data_type='int32', program=program)
-        hidden1 = fc_layer(input=images, size=128, act='relu', program=program)
-        hidden2 = fc_layer(input=hidden1, size=64, act='relu', program=program)
-        predict = fc_layer(
-            input=hidden2, size=10, act='softmax', program=program)
-        cost = cross_entropy(input=predict, label=label, program=program)
-        avg_cost = mean(x=cost, program=program)
+        hidden1 = layers.fc(input=images, size=128, act='relu', program=program)
+        hidden2 = layers.fc(input=hidden1, size=64, act='relu', program=program)
+        predict = layers.fc(input=hidden2,
+                            size=10,
+                            act='softmax',
+                            program=program)
+        cost = layers.cross_entropy(input=predict, label=label, program=program)
+        avg_cost = layers.mean(x=cost, program=program)
         self.assertIsNotNone(avg_cost)
         # print str(program)
 
@@ -48,11 +51,10 @@ class TestBook(unittest.TestCase):
         # print str(program)
 
     def test_simple_conv2d(self):
-        pd = core.ProgramDesc.__create_program_desc__()
-        program = Program(desc=pd)
-        images = data_layer(
+        program = Program()
+        images = layers.data(
             name='pixel', shape=[3, 48, 48], data_type='int32', program=program)
-        conv2d_layer(
+        layers.conv2d(
             input=images, num_filters=3, filter_size=[4, 4], program=program)
 
         print str(program)