Example #1
0
 def run_static_mode(self):
     main_program = fluid.Program()
     with fluid.program_guard(main_program):
         static_out = dygraph_to_static_func(self.dygraph_func)(
             self.input, self.iter_num)
     exe = fluid.Executor(self.place)
     numpy_res = exe.run(main_program, fetch_list=static_out)
     return numpy_res
Example #2
0
    def run_static_mode(self):
        main_program = fluid.Program()
        with fluid.program_guard(main_program):
            tensor_list = dygraph_to_static_func(self.dygraph_func)(self.input)
        exe = fluid.Executor(self.place)
        static_res = exe.run(main_program, fetch_list=tensor_list[0])

        return static_res[0]
Example #3
0
 def _run_static(self):
     main_program = fluid.Program()
     with fluid.program_guard(main_program):
         static_func = dygraph_to_static_func(self.dyfunc)
         out = static_func(self.len)
         exe = fluid.Executor(self.place)
         ret = exe.run(main_program, fetch_list=out)
     return ret
Example #4
0
    def get_static_output(self):
        main_program = fluid.Program()
        with fluid.program_guard(main_program):
            static_out = dygraph_to_static_func(self.dygraph_func)(self.input)

        exe = fluid.Executor(self.place)
        static_res = exe.run(main_program, fetch_list=static_out)

        return static_res[0]
Example #5
0
 def _run_static(self):
     main_program = fluid.Program()
     with fluid.program_guard(main_program):
         x_v = fluid.layers.assign(self.x)
         # Transform into static graph
         out = dygraph_to_static_func(self.dyfunc)(x_v)
         exe = fluid.Executor(place)
         ret = exe.run(main_program, fetch_list=out)
         return ret
Example #6
0
    def _run_static(self):
        main_program = fluid.Program()
        with fluid.program_guard(main_program):
            x_var = fluid.layers.assign(self.x)
            static_func = dygraph_to_static_func(self.dyfunc)

            out = static_func(x_var)
            exe = fluid.Executor(self.place)
            ret = exe.run(main_program, fetch_list=out)
        return ret
Example #7
0
 def run_static_mode(self):
     main_program = fluid.Program()
     with fluid.program_guard(main_program):
         tensor_array = dygraph_to_static_func(self.dygraph_func)(self.input)
         static_out = fluid.layers.array_read(
             tensor_array,
             i=fluid.layers.fill_constant(
                 shape=[1], value=0, dtype='int64'))
     exe = fluid.Executor(self.place)
     numpy_res = exe.run(main_program, fetch_list=static_out)
     return numpy_res[0]
    def get_static_output(self):
        startup_program = fluid.Program()
        startup_program.random_seed = SEED
        main_program = fluid.Program()
        main_program.random_seed = SEED
        with fluid.program_guard(main_program, startup_program):
            static_out = dygraph_to_static_func(self.dygraph_func)()

        exe = fluid.Executor(fluid.CPUPlace())
        exe.run(startup_program)
        static_res = exe.run(main_program, fetch_list=static_out)
        return static_res[0]
Example #9
0
import paddle.fluid as fluid
from paddle.fluid.dygraph.jit import dygraph_to_static_func


def dyfunc_Linear(input):
    fc = fluid.dygraph.Linear(
        input_dim=10,
        output_dim=5,
        act='relu',
        param_attr=fluid.ParamAttr(initializer=fluid.initializer.Constant(
            value=0.99)),
        bias_attr=fluid.ParamAttr(initializer=fluid.initializer.Constant(
            value=0.5)),
    )
    res = fc(input)
    return res


startup_program = fluid.Program()
main_program = fluid.Program()
with fluid.program_guard(main_program, startup_program):
    input = np.random.random((4, 3, 10)).astype('float32')
    data = fluid.layers.assign(input)
    static_out = dygraph_to_static_func(dyfunc_Linear)(data)

exe = fluid.Executor(fluid.CPUPlace())
exe.run(startup_program)
static_res = exe.run(main_program, fetch_list=static_out)

print(static_res[0])
Example #10
0
from __future__ import print_function

import paddle.fluid as fluid
import numpy as np
from paddle.fluid.dygraph.jit import dygraph_to_static_func


def dyfunc_with_if_else(x_v, label=None):
    if fluid.layers.mean(x_v).numpy()[0] > 5:
        x_v = x_v - 1
    else:
        x_v = x_v + 1
    # plain if in python
    if label is not None:
        loss = fluid.layers.cross_entropy(x_v, label)
        return loss
    return x_v


main_program = fluid.Program()
with fluid.program_guard(main_program):
    x = np.random.random([5, 6]).astype('float32')
    x_v = fluid.layers.assign(x)
    # Transform into static graph
    out = dygraph_to_static_func(dyfunc_with_if_else)(x_v)
    exe = fluid.Executor(fluid.CPUPlace())
    ret = exe.run(main_program, fetch_list=out)
    print(ret[0])