diff --git a/python/paddle/fluid/compiler.py b/python/paddle/fluid/compiler.py
index f43fcb2d9f8e7892866f26f96fff21fdf4c2464f..b07a514ccec8a5f088a685a55f054b2e62dfa500 100644
--- a/python/paddle/fluid/compiler.py
+++ b/python/paddle/fluid/compiler.py
@@ -109,9 +109,7 @@ class CompiledProgram(object):
         .. code-block:: python
 
           import paddle.fluid as fluid
-          import paddle.fluid.compiler as compiler
           import numpy
-          import os
 
           place = fluid.CUDAPlace(0) # fluid.CPUPlace()
           exe = fluid.Executor(place)
@@ -121,9 +119,8 @@ class CompiledProgram(object):
           loss = fluid.layers.mean(hidden)
           fluid.optimizer.SGD(learning_rate=0.01).minimize(loss)
 
-          fluid.default_startup_program().random_seed=1
           exe.run(fluid.default_startup_program())
-          compiled_prog = compiler.CompiledProgram(
+          compiled_prog = fluid.CompiledProgram(
                    fluid.default_main_program())
 
           x = numpy.random.random(size=(10, 1)).astype('float32')
@@ -215,12 +212,12 @@ class CompiledProgram(object):
             .. code-block:: python
 
               import paddle.fluid as fluid
-              import paddle.fluid.compiler as compiler
               import numpy
               import os
 
               use_cuda = True
               place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
+              parallel_places = [fluid.CUDAPlace(0), fluid.CUDAPlace(1)] if use_cuda else [fluid.CPUPlace()] * 2
 
               # NOTE: If you use CPU to run the program, you need
               # to specify the CPU_NUM, otherwise, fluid will use
@@ -236,18 +233,30 @@ class CompiledProgram(object):
               data = fluid.data(name='X', shape=[None, 1], dtype='float32')
               hidden = fluid.layers.fc(input=data, size=10)
               loss = fluid.layers.mean(hidden)
+
+              test_program = fluid.default_main_program().clone(for_test=True)
               fluid.optimizer.SGD(learning_rate=0.01).minimize(loss)
 
-              fluid.default_startup_program().random_seed=1
               exe.run(fluid.default_startup_program())
-              compiled_prog = compiler.CompiledProgram(
-                       fluid.default_main_program()).with_data_parallel(
-                                loss_name=loss.name)
-
-              x = numpy.random.random(size=(10, 1)).astype('float32')
-              loss_data, = exe.run(compiled_prog,
-                                   feed={"X": x},
-                                   fetch_list=[loss.name])
+              compiled_train_prog = fluid.CompiledProgram(
+                  fluid.default_main_program()).with_data_parallel(
+                          loss_name=loss.name, places=parallel_places)
+              # NOTE: if not set share_vars_from=compiled_train_prog,
+              # the parameters used in test process are different with 
+              # the parameters used by train process
+              compiled_test_prog = fluid.CompiledProgram(
+                  test_program).with_data_parallel(
+                          share_vars_from=compiled_train_prog,
+                          places=parallel_places)
+
+              train_data = numpy.random.random(size=(10, 1)).astype('float32')
+              loss_data, = exe.run(compiled_train_prog,
+                                feed={"X": train_data},
+                                fetch_list=[loss.name])
+              test_data = numpy.random.random(size=(10, 1)).astype('float32')
+              loss_data, = exe.run(compiled_test_prog,
+                                feed={"X": test_data},
+                                fetch_list=[loss.name])
         """
         assert not self._is_data_parallel, "Already compiled with parallel."
         assert not self._is_inference, "Cannot compile both data parallel and inference"