Add API: Switch global program

python/paddle/v2/framework/framework.py

@@ -538,5 +538,20 @@ def __init__(self, block, shape, dtype, **kwargs):
 
 
 # program is a global instance.
-g_program = Program()
-g_init_program = Program()
+g_program_dict = dict()
+
+
+def switch_g_program(prog, init_prog):
+    g_program_dict['program'] = prog
+    g_program_dict['init_program'] = init_prog
+
+
+def g_program():
+    return g_program_dict['program']
+
+
+def g_init_program():
+    return g_program_dict['init_program']
+
+
+switch_g_program(Program(), Program())

python/paddle/v2/framework/io.py

@@ -45,7 +45,7 @@ def save_vars(executor, dirname, program=None, vars=None, predicate=None):
     """
     if vars is None:
         if program is None:
-            program = g_program
+            program = g_program()
         if not isinstance(program, Program):
             raise TypeError("program should be as Program type or None")
 
@@ -106,7 +106,7 @@ def load_vars(executor, dirname, program=None, vars=None, predicate=None):
     """
     if vars is None:
         if program is None:
-            program = g_program
+            program = g_program()
         if not isinstance(program, Program):
             raise TypeError("program's type should be Program")
 
@@ -164,7 +164,7 @@ def save_inference_model(dirname,
     :return: None
     """
     if program is None:
-        program = g_program
+        program = g_program()
     if not isinstance(target_vars, list):
         target_vars = [target_vars]
 

python/paddle/v2/framework/layer_helper.py

@@ -30,15 +30,15 @@ def name(self):
     def program(self):
         prog = self.kwargs.get('program', None)
         if prog is None:
-            return g_program
+            return g_program()
         else:
             return prog
 
     @property
     def init_program(self):
         prog = self.kwargs.get('init_program', None)
         if prog is None:
-            return g_init_program
+            return g_init_program()
         else:
             return prog
 

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

@@ -23,7 +23,7 @@ def test_mul(self):
         tensor_b = core.LoDTensor()
         tensor_b.set(b_np, place)
         exe = Executor(place)
-        outs = exe.run(g_program,
+        outs = exe.run(g_program(),
                        feed={'a': tensor_a,
                              'b': tensor_b},
                        fetch_list=[out])

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

@@ -1,39 +1,24 @@
+import numpy as np
+import paddle.v2.framework.core as core
+
 import paddle.v2 as paddle
 import paddle.v2.framework.layers as layers
-import paddle.v2.framework.core as core
 import paddle.v2.framework.optimizer as optimizer
-
-from paddle.v2.framework.framework import Program, g_program
-from paddle.v2.framework.io import save_persistables, load_persistables
 from paddle.v2.framework.executor import Executor
-
-import numpy as np
+from paddle.v2.framework.framework import Program, switch_g_program
+from paddle.v2.framework.io import save_persistables, load_persistables
 
 init_program = Program()
 program = Program()
-x = layers.data(
-    name='x',
-    shape=[13],
-    data_type='float32',
-    program=program,
-    init_program=init_program)
+switch_g_program(program, init_program)
+x = layers.data(name='x', shape=[13], data_type='float32')
 
-y_predict = layers.fc(input=x,
-                      size=1,
-                      act=None,
-                      program=program,
-                      init_program=init_program)
+y_predict = layers.fc(input=x, size=1, act=None)
 
-y = layers.data(
-    name='y',
-    shape=[1],
-    data_type='float32',
-    program=program,
-    init_program=init_program)
+y = layers.data(name='y', shape=[1], data_type='float32')
 
-cost = layers.square_error_cost(
-    input=y_predict, label=y, program=program, init_program=init_program)
-avg_cost = layers.mean(x=cost, program=program, init_program=init_program)
+cost = layers.square_error_cost(input=y_predict, label=y)
+avg_cost = layers.mean(x=cost)
 
 sgd_optimizer = optimizer.SGDOptimizer(learning_rate=0.001)
 opts = sgd_optimizer.minimize(avg_cost)
@@ -52,8 +37,8 @@
 
 PASS_NUM = 100
 for pass_id in range(PASS_NUM):
-    save_persistables(exe, "./fit_a_line.model/", program=program)
-    load_persistables(exe, "./fit_a_line.model/", program=program)
+    save_persistables(exe, "./fit_a_line.model/")
+    load_persistables(exe, "./fit_a_line.model/")
     for data in train_reader():
         x_data = np.array(map(lambda x: x[0], data)).astype("float32")
         y_data = np.array(map(lambda x: x[1], data)).astype("float32")
@@ -71,6 +56,7 @@
                        fetch_list=[avg_cost])
         out = np.array(outs[0])
 
+        print out
         if out[0] < 10.0:
             exit(0)  # if avg cost less than 10.0, we think our code is good.
 exit(1)

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

@@ -5,7 +5,7 @@
 
 class TestOperator(unittest.TestCase):
     def test_error_type(self):
-        block = g_program.create_block()
+        block = g_program().create_block()
         try:
             block.append_op()
             self.assertFail()

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

@@ -5,7 +5,7 @@
 
 class TestParameter(unittest.TestCase):
     def test_param(self):
-        b = g_program.create_block()
+        b = g_program().create_block()
         param = b.create_parameter(
             name='fc.w',
             shape=[784, 100],

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

@@ -7,30 +7,30 @@
 
 class TestProgram(unittest.TestCase):
     def test_program(self):
-        b = g_program.current_block()
+        b = g_program().current_block()
         self.assertEqual(-1, b.parent_idx)
         self.assertEqual(0, b.idx)
 
-        b = g_program.create_block()
+        b = g_program().create_block()
         self.assertEqual(1, b.idx)
         self.assertEqual(0, b.parent_idx)
 
-        b = g_program.create_block()
+        b = g_program().create_block()
         self.assertEqual(2, b.idx)
         self.assertEqual(1, b.parent_idx)
 
-        g_program.rollback()
+        g_program().rollback()
 
-        b = g_program.current_block()
+        b = g_program().current_block()
         self.assertEqual(1, b.idx)
         self.assertEqual(0, b.parent_idx)
 
-        b = g_program.create_block()
+        b = g_program().create_block()
         self.assertEqual(3, b.idx)
         self.assertEqual(1, b.parent_idx)
 
-        g_program.rollback()
-        b = g_program.current_block()
+        g_program().rollback()
+        b = g_program().current_block()
         self.assertEqual(1, b.idx)
         self.assertEqual(0, b.parent_idx)
 

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

@@ -31,7 +31,7 @@ def test_rnn(self):
 
         out = rnn()
         self.assertEqual((-1, 80, 32), out.shape)
-        print g_program
+        print g_program()
 
 
 if __name__ == '__main__':