Feature/python.paddle.v2

demo/mnist/api_train.py

@@ -6,42 +6,11 @@
 
 The user api could be simpler and carefully designed.
 """
-import py_paddle.swig_paddle as api
-from py_paddle import DataProviderConverter
-import paddle.trainer.PyDataProvider2 as dp
-import numpy as np
 import random
-from mnist_util import read_from_mnist
-from paddle.trainer_config_helpers import *
-
-
-def optimizer_config():
-    settings(
-        learning_rate=1e-4,
-        learning_method=AdamOptimizer(),
-        batch_size=1000,
-        model_average=ModelAverage(average_window=0.5),
-        regularization=L2Regularization(rate=0.5))
-
-
-def network_config():
-    imgs = data_layer(name='pixel', size=784)
-    hidden1 = fc_layer(input=imgs, size=200)
-    hidden2 = fc_layer(input=hidden1, size=200)
-    inference = fc_layer(input=hidden2, size=10, act=SoftmaxActivation())
-    cost = classification_cost(
-        input=inference, label=data_layer(
-            name='label', size=10))
-    outputs(cost)
 
+import paddle.v2 as paddle
 
-def init_parameter(network):
-    assert isinstance(network, api.GradientMachine)
-    for each_param in network.getParameters():
-        assert isinstance(each_param, api.Parameter)
-        array_size = len(each_param)
-        array = np.random.uniform(-1.0, 1.0, array_size).astype('float32')
-        each_param.getBuf(api.PARAMETER_VALUE).copyFromNumpyArray(array)
+from mnist_util import read_from_mnist
 
 
 def generator_to_batch(generator, batch_size):
@@ -73,132 +42,139 @@ def input_order_converter(generator):
 
 
 def main():
-    api.initPaddle("-use_gpu=false", "-trainer_count=4")  # use 4 cpu cores
+    paddle.raw.initPaddle("-use_gpu=false",
+                          "-trainer_count=4")  # use 4 cpu cores
 
     # get enable_types for each optimizer.
     # enable_types = [value, gradient, momentum, etc]
     # For each optimizer(SGD, Adam), GradientMachine should enable different
     # buffers.
-    opt_config_proto = parse_optimizer_config(optimizer_config)
-    opt_config = api.OptimizationConfig.createFromProto(opt_config_proto)
-    _temp_optimizer_ = api.ParameterOptimizer.create(opt_config)
-    enable_types = _temp_optimizer_.getParameterTypes()
-
-    # Create Simple Gradient Machine.
-    model_config = parse_network_config(network_config)
-    m = api.GradientMachine.createFromConfigProto(
-        model_config, api.CREATE_MODE_NORMAL, enable_types)
-
-    # This type check is not useful. Only enable type hint in IDE.
-    # Such as PyCharm
-    assert isinstance(m, api.GradientMachine)
+    optimizer = paddle.optimizer.Optimizer(
+        learning_method=paddle.optimizer.AdamOptimizer(),
+        learning_rate=1e-4,
+        model_average=paddle.optimizer.ModelAverage(average_window=0.5),
+        regularization=paddle.optimizer.L2Regularization(rate=0.5))
+
+    # define network
+    imgs = paddle.layers.data_layer(name='pixel', size=784)
+    hidden1 = paddle.layers.fc_layer(input=imgs, size=200)
+    hidden2 = paddle.layers.fc_layer(input=hidden1, size=200)
+    inference = paddle.layers.fc_layer(
+        input=hidden2, size=10, act=paddle.config.SoftmaxActivation())
+    cost = paddle.layers.classification_cost(
+        input=inference, label=paddle.layers.data_layer(
+            name='label', size=10))
 
-    # Initialize Parameter by numpy.
-    init_parameter(network=m)
+    model = paddle.model.Model(layers=[cost], optimizer=optimizer)
 
-    # Create Local Updater. Local means not run in cluster.
-    # For a cluster training, here we can change to createRemoteUpdater
-    # in future.
-    updater = api.ParameterUpdater.createLocalUpdater(opt_config)
-    assert isinstance(updater, api.ParameterUpdater)
+    model.rand_parameter()
 
-    # Initialize ParameterUpdater.
-    updater.init(m)
+    model.start()
 
-    # DataProvider Converter is a utility convert Python Object to Paddle C++
-    # Input. The input format is as same as Paddle's DataProvider.
-    converter = DataProviderConverter(
-        input_types=[dp.dense_vector(784), dp.integer_value(10)])
+    batch_evaluator = model.make_evaluator()
+    test_evaluator = model.make_evaluator()
 
     train_file = './data/raw_data/train'
-    test_file = './data/raw_data/t10k'
-
-    # start gradient machine.
-    # the gradient machine must be started before invoke forward/backward.
-    # not just for training, but also for inference.
-    m.start()
-
-    # evaluator can print error rate, etc. It is a C++ class.
-    batch_evaluator = m.makeEvaluator()
-    test_evaluator = m.makeEvaluator()
-
-    # Get Train Data.
-    # TrainData will stored in a data pool. Currently implementation is not care
-    # about memory, speed. Just a very naive implementation.
-    train_data_generator = input_order_converter(read_from_mnist(train_file))
-    train_data = BatchPool(train_data_generator, 512)
-
-    # outArgs is Neural Network forward result. Here is not useful, just passed
-    # to gradient_machine.forward
-    outArgs = api.Arguments.createArguments(0)
-
-    for pass_id in xrange(2):  # we train 2 passes.
-        updater.startPass()
-
-        for batch_id, data_batch in enumerate(train_data()):
-            # data_batch is input images.
-            # here, for online learning, we could get data_batch from network.
-
-            # Start update one batch.
-            pass_type = updater.startBatch(len(data_batch))
-
-            # Start BatchEvaluator.
-            # batch_evaluator can be used between start/finish.
-            batch_evaluator.start()
-
-            # forwardBackward is a shortcut for forward and backward.
-            # It is sometimes faster than invoke forward/backward separately,
-            # because in GradientMachine, it may be async.
-            m.forwardBackward(converter(data_batch), outArgs, pass_type)
-
-            for each_param in m.getParameters():
-                updater.update(each_param)
-
-            # Get cost. We use numpy to calculate total cost for this batch.
-            cost_vec = outArgs.getSlotValue(0)
-            cost_vec = cost_vec.copyToNumpyMat()
-            cost = cost_vec.sum() / len(data_batch)
-
-            # Make evaluator works.
-            m.eval(batch_evaluator)
-
-            # Print logs.
-            print 'Pass id', pass_id, 'Batch id', batch_id, 'with cost=', \
-                cost, batch_evaluator
-
-            batch_evaluator.finish()
-            # Finish batch.
-            #  * will clear gradient.
-            #  * ensure all values should be updated.
-            updater.finishBatch(cost)
-
-        # testing stage. use test data set to test current network.
-        updater.apply()
-        test_evaluator.start()
-        test_data_generator = input_order_converter(read_from_mnist(test_file))
-        for data_batch in generator_to_batch(test_data_generator, 512):
-            # in testing stage, only forward is needed.
-            m.forward(converter(data_batch), outArgs, api.PASS_TEST)
-            m.eval(test_evaluator)
-
-        # print error rate for test data set
-        print 'Pass', pass_id, ' test evaluator: ', test_evaluator
-        test_evaluator.finish()
-        updater.restore()
-
-        updater.catchUpWith()
-        params = m.getParameters()
-        for each_param in params:
-            assert isinstance(each_param, api.Parameter)
-            value = each_param.getBuf(api.PARAMETER_VALUE)
-            value = value.copyToNumpyArray()
-
-            # Here, we could save parameter to every where you want
-            print each_param.getName(), value
-
-        updater.finishPass()
-
-    m.finish()
+    for pass_id in xrange(2):
+        model.start_pass()
+
+        model.finish_pass()
+
+    # # DataProvider Converter is a utility convert Python Object to Paddle C++
+    # # Input. The input format is as same as Paddle's DataProvider.
+    # converter = paddle.data.DataProviderConverter(input_types=[
+    #     paddle.data.dense_vector(784), paddle.data.integer_value(10)
+    # ])
+    #
+    # train_file = './data/raw_data/train'
+    # test_file = './data/raw_data/t10k'
+    #
+    # # start gradient machine.
+    # # the gradient machine must be started before invoke forward/backward.
+    # # not just for training, but also for inference.
+    # m.start()
+    #
+    # # evaluator can print error rate, etc. It is a C++ class.
+    # batch_evaluator = m.makeEvaluator()
+    # test_evaluator = m.makeEvaluator()
+    #
+    # # Get Train Data.
+    # # TrainData will stored in a data pool. Currently implementation is not care
+    # # about memory, speed. Just a very naive implementation.
+    # train_data_generator = input_order_converter(read_from_mnist(train_file))
+    # train_data = BatchPool(train_data_generator, 512)
+    #
+    # # outArgs is Neural Network forward result. Here is not useful, just passed
+    # # to gradient_machine.forward
+    # outArgs = paddle.raw.Arguments.createArguments(0)
+    #
+    # for pass_id in xrange(2):  # we train 2 passes.
+    #     updater.startPass()
+    #
+    #     for batch_id, data_batch in enumerate(train_data()):
+    #         # data_batch is input images.
+    #         # here, for online learning, we could get data_batch from network.
+    #
+    #         # Start update one batch.
+    #         pass_type = updater.startBatch(len(data_batch))
+    #
+    #         # Start BatchEvaluator.
+    #         # batch_evaluator can be used between start/finish.
+    #         batch_evaluator.start()
+    #
+    #         # forwardBackward is a shortcut for forward and backward.
+    #         # It is sometimes faster than invoke forward/backward separately,
+    #         # because in GradientMachine, it may be async.
+    #         m.forwardBackward(converter(data_batch), outArgs, pass_type)
+    #
+    #         for each_param in m.getParameters():
+    #             updater.update(each_param)
+    #
+    #         # Get cost. We use numpy to calculate total cost for this batch.
+    #         cost_vec = outArgs.getSlotValue(0)
+    #         cost_vec = cost_vec.copyToNumpyMat()
+    #         cost = cost_vec.sum() / len(data_batch)
+    #
+    #         # Make evaluator works.
+    #         m.eval(batch_evaluator)
+    #
+    #         # Print logs.
+    #         print 'Pass id', pass_id, 'Batch id', batch_id, 'with cost=', \
+    #             cost, batch_evaluator
+    #
+    #         batch_evaluator.finish()
+    #         # Finish batch.
+    #         #  * will clear gradient.
+    #         #  * ensure all values should be updated.
+    #         updater.finishBatch(cost)
+    #
+    #     # testing stage. use test data set to test current network.
+    #     updater.apply()
+    #     test_evaluator.start()
+    #     test_data_generator = input_order_converter(read_from_mnist(test_file))
+    #     for data_batch in generator_to_batch(test_data_generator, 512):
+    #         # in testing stage, only forward is needed.
+    #         m.forward(converter(data_batch), outArgs, paddle.raw.PASS_TEST)
+    #         m.eval(test_evaluator)
+    #
+    #     # print error rate for test data set
+    #     print 'Pass', pass_id, ' test evaluator: ', test_evaluator
+    #     test_evaluator.finish()
+    #     updater.restore()
+    #
+    #     updater.catchUpWith()
+    #     params = m.getParameters()
+    #     for each_param in params:
+    #         assert isinstance(each_param, paddle.raw.Parameter)
+    #         value = each_param.getBuf(paddle.raw.PARAMETER_VALUE)
+    #         value = value.copyToNumpyArray()
+    #
+    #         # Here, we could save parameter to every where you want
+    #         print each_param.getName(), value
+    #
+    #     updater.finishPass()
+
+    model.finish()
 
 
 if __name__ == '__main__':

python/CMakeLists.txt

@@ -4,11 +4,12 @@ set(OUTPUT_DIR
 file(GLOB TRAINER_PY_FILES . ./paddle/trainer/*.py)
 file(GLOB HELPERS_PY_FILES . ./paddle/trainer_config_helpers/*.py)
 file(GLOB UTILS_PY_FILES . ./paddle/utils/*.py)
-
+file(GLOB V2_PY_FILES . ./paddle/v2/*.py)
 set(PY_FILES paddle/__init__.py
              ${TRAINER_PY_FILES}
              ${HELPERS_PY_FILES}
-             ${UTILS_PY_FILES})
+             ${UTILS_PY_FILES}
+             ${V2_PY_FILES})
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/setup.py.in
     ${CMAKE_CURRENT_BINARY_DIR}/setup.py)

python/paddle/trainer_config_helpers/__init__.py

@@ -21,5 +21,6 @@
 from optimizers import *
 from attrs import *
 from config_parser_utils import *
+
 # This will enable operator overload for LayerOutput
 import layer_math

python/paddle/v2/__init__.py

@@ -0,0 +1,22 @@
+"""
+This is an experimental package for Paddle new API.
+
+Currently, we use should always use
+
+..  code-block: python
+
+    import paddle.v2 as paddle
+
+as our import statement. The API is in flux, never use this package in
+production.
+"""
+
+import py_paddle.swig_paddle as raw
+import config
+import data
+import paddle.proto as proto
+import layers
+import optimizer
+import model
+
+__all__ = ['config', 'data', 'raw', 'proto', 'layers', 'optimizer', 'model']

python/paddle/v2/config.py

@@ -0,0 +1,12 @@
+from paddle.trainer_config_helpers import *
+from paddle.trainer.config_parser import parse_config as parse
+from paddle.trainer_config_helpers.config_parser_utils import \
+    parse_network_config as parse_network
+from paddle.trainer_config_helpers.config_parser_utils import \
+    parse_optimizer_config as parse_optimizer
+
+import paddle.trainer_config_helpers as tmp
+
+__all__ = ['parse', 'parse_network', 'parse_optimizer']
+
+__all__.extend(filter(lambda x: x[:2] != '__', dir(tmp)))