main_program = fluid.Program()
    startup_program = fluid.Program()
    with fluid.unique_name.guard():
        with fluid.program_guard(main_program=main_program, startup_program=startup_program):
            data = fluid.layers.data(name='X', shape=[1], dtype='float32')
            initializer = fluid.initializer.Constant(value=2.0)
            param_attrs = fluid.ParamAttr(initializer=initializer)
            y_predict = fluid.layers.fc(name="fc", input=data, size=10, param_attr=param_attrs)
            place = fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run(startup_program)
            x = np.random.random(size=(10, 1)).astype('float32')
            compiled_prog = fluid.compiler.CompiledProgram(main_program)
            for i in range(10):
                res = exe.run(compiled_prog,
                              feed={"X": x},
                              fetch_list=["fc.w_0"])[0][0]
            clone = main_program.clone(for_test=False)
            x = clone.__dict__.copy()
            y = main_program.__dict__.copy()
            # a.pop("desc")
            # b.pop("desc")
            clone_z = main_program.clone(for_test=True)
            assert operator.eq(x["blocks"].sort(), y["blocks"].sort())
            assert operator.eq(x["blocks"].sort(), clone_z.__dict__["blocks"].sort())

你好，你的网络好像没有定义反向op，所以没裁剪反向op

反向op不是框架自动生成的吗？

反向是自动生成的，但是要在optimizer.minimize()这一步生成。例程：https://github.com/PaddlePaddle/examples/blob/master/community_examples/recompute/demo.py

加上这段代码 ，clone之后还是一样的。其实我就是想知道那个for test参数有没有生效。

main_program = fluid.Program()
    startup_program = fluid.Program()
    with fluid.unique_name.guard():
        with fluid.program_guard(main_program=main_program, startup_program=startup_program):
            data = fluid.layers.data(name='X', shape=[1], dtype='float32')
            label = fluid.layers.data(name="Y", shape=[1], dtype='int64')
            initializer = fluid.initializer.Constant(value=2.0)
            param_attrs = fluid.ParamAttr(initializer=initializer)
            y_predict = fluid.layers.fc(name="fc", input=data, size=10, param_attr=param_attrs)
            cost = fluid.layers.cross_entropy(input=y_predict, label=label)
            sum_cost = fluid.layers.reduce_mean(cost)
            optimizer = fluid.optimizer.Momentum(learning_rate=0.1, momentum=0.1)
            optimizer.minimize(sum_cost)
            place = fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run(startup_program)
            x = np.random.random(size=(10, 1)).astype('float32')
            y = np.ones(shape=(10, 1)).astype("int64")
            compiled_prog = fluid.compiler.CompiledProgram(main_program)
            for i in range(10):
                res = exe.run(compiled_prog,
                              feed={"X": x, "Y": y},
                              fetch_list=["fc.w_0"])[0][0]
            clone = main_program.clone(for_test=False)
            x = clone.__dict__.copy()
            y = main_program.__dict__.copy()
            # a.pop("desc")
            # b.pop("desc")
            clone_z = main_program.clone(for_test=True)
            assert operator.eq(x["blocks"].sort(), y["blocks"].sort())
            assert operator.eq(x["blocks"].sort(), clone_z.__dict__["blocks"].sort())

我这里看到clone_z和main_program是不一样的了，clone_z里面没有反向，所以 assert operator.eq(x["blocks"].sort(), clone_z.dict["blocks"].sort())不成立

为啥我这里运行是一样的呢。。。。

我直接print的，你可以试试：

from paddle import fluid
import numpy as np

if True:
    main_program = fluid.Program()
    startup_program = fluid.Program()
    with fluid.unique_name.guard():
        with fluid.program_guard(main_program=main_program, startup_program=startup_program):
            data = fluid.layers.data(name='X', shape=[1], dtype='float32')
            label = fluid.layers.data(name="Y", shape=[1], dtype='int64')
            initializer = fluid.initializer.Constant(value=2.0)
            param_attrs = fluid.ParamAttr(initializer=initializer)
            y_predict = fluid.layers.fc(name="fc", input=data, size=10, param_attr=param_attrs)
            cost = fluid.layers.cross_entropy(input=y_predict, label=label)
            sum_cost = fluid.layers.reduce_mean(cost)
            optimizer = fluid.optimizer.Momentum(learning_rate=0.1, momentum=0.1)
            optimizer.minimize(sum_cost)
            place = fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run(startup_program)
            x = np.random.random(size=(10, 1)).astype('float32')
            y = np.ones(shape=(10, 1)).astype("int64")
            compiled_prog = fluid.compiler.CompiledProgram(main_program)
            for i in range(10):
                res = exe.run(compiled_prog,
                              feed={"X": x, "Y": y},
                              fetch_list=["fc.w_0"])[0][0]

            clone_z = main_program.clone(for_test=True)
            print(main_program.__dict__.copy())
            print(clone_z.__dict__.copy())

明白了 ，之前比较的方式有问题，多谢解答~