def _load_lookup_table_vars(executor, dirname, main_program, lookup_table_vars): if not os.path.isdir(dirname): raise ValueError("There is no directory named '%s'", dirname) lookup_table_dirname = os.path.join(dirname, lookup_table_dir) emb_var_name = lookup_table_vars[0] emb_var = main_program.global_block().var(emb_var_name) emb_files = [] for emb_name in os.listdir(lookup_table_dirname): if emb_var_name in emb_name: emb_files.append(emb_name) convert_program = Program() global_block = convert_program.global_block() emb_var = global_block.create_var( name=emb_var.name, shape=emb_var.shape, dtype=emb_var.dtype, type=core.VarDesc.VarType.SELECTED_ROWS, persistable=True) emb_var.desc.set_type(core.VarDesc.VarType.SELECTED_ROWS) sums = [] for i, emb_file in enumerate(emb_files): var_name = "{}_{}".format(emb_var.name, i) param_var = global_block.create_var( name=var_name, shape=emb_var.shape, dtype=emb_var.dtype, type=core.VarDesc.VarType.SELECTED_ROWS, persistable=True) param_var.desc.set_type(core.VarDesc.VarType.SELECTED_ROWS) global_block.append_op(type='load', inputs={}, outputs={'Out': [param_var]}, attrs={ 'file_path': os.path.join(lookup_table_dirname, var_name) }) sums.append(param_var) global_block.append_op(type='merge_sparse_lookup_table', inputs={"X": sums}, outputs={'Out': emb_var}, attrs={}) global_block.append_op(type='save', inputs={"X": [emb_var]}, outputs={}, attrs={ 'file_path': os.path.join(lookup_table_dirname, emb_var.name) }) global_block.append_op(type='delete_var', inputs={'X': sums}) executor.run(convert_program)
def test_hip_copy_bool_value(self): if core.is_compiled_with_rocm(): paddle.enable_static() main_program = Program() with program_guard(main_program): pinned_var_name = "tensor@Pinned" gpu_var_name = "tensor@GPU" pinned_var = main_program.global_block().create_var( name=pinned_var_name, shape=[1], dtype='bool', persistable=False, stop_gradient=True) gpu_var = main_program.global_block().create_var( name=gpu_var_name, shape=[1], dtype='bool', persistable=False, stop_gradient=True) main_program.global_block().append_op( type="fill_constant", outputs={"Out": gpu_var_name}, attrs={ "shape": [1], "dtype": gpu_var.dtype, "value": False, "place_type": 1 }) main_program.global_block().append_op( type="fill_constant", outputs={"Out": pinned_var_name}, attrs={ "shape": [1], "dtype": gpu_var.dtype, "value": True, "place_type": 2 }) main_program.global_block().append_op( type='memcpy', inputs={'X': pinned_var}, outputs={'Out': gpu_var}, attrs={'dst_place_type': 1}) place = fluid.CUDAPlace(0) exe = fluid.Executor(place) gpu_, pinned_ = exe.run(main_program, feed={}, fetch_list=[gpu_var.name, pinned_var.name]) expect_value = np.array([1]).astype('bool') self.assertTrue(np.array_equal(gpu_, expect_value)) else: pass
def __load_lookup_table_vars(executor, main_program, lookup_table_var, lookup_table_var_path): emb_var = main_program.global_block().var(lookup_table_var) load_program = Program() load_block = load_program.global_block() load_block.append_op(type='load', inputs={}, outputs={'Out': [emb_var]}, attrs={'file_path': lookup_table_var_path}) executor.run(load_program)
def get_prog(self): paddle.enable_static() main_program = Program() with program_guard(main_program): pinned_var = main_program.global_block().create_var( name="tensor@Pinned_0", shape=[10, 10], dtype='float32', persistable=False, stop_gradient=True) main_program.global_block().append_op( type="fill_constant", outputs={"Out": "tensor@Pinned_0"}, attrs={ "shape": [10, 10], "dtype": pinned_var.dtype, "value": 0.0, "place_type": 2 }) return main_program, pinned_var
def test_grad(self): place = core.CPUPlace() program = Program() with program_guard(program): x = layers.data( name='x', shape=[1], dtype='float32', stop_gradient=False) y = layers.data( name='y', shape=[1], dtype='bool', stop_gradient=False) level = 0 out_true, out_false = split_lod_tensor(input=x, mask=y, level=level) out = merge_lod_tensor( in_true=out_true, in_false=out_false, mask=y, x=x, level=level) mean = layers.mean(out) append_backward(mean) tensor = core.LoDTensor() tensor.set(np.arange(10).reshape(10, 1).astype('float32'), place) tensor.set_recursive_sequence_lengths([[3, 6, 1]]) mask_np = np.array([0, 1, 0]).astype('bool') mask_np = np.expand_dims(mask_np, axis=1) mask = core.LoDTensor() mask.set(mask_np, place) exe = Executor(place) scope = core.Scope() g_vars = program.global_block().var(x.name + "@GRAD") g_out = [ item.sum() for item in map(np.array, exe.run(program, feed={'x': tensor, 'y': mask}, fetch_list=[g_vars], scope=scope, return_numpy=False)) ] g_out_sum = np.array(g_out).sum() self.assertAlmostEqual(1.0, g_out_sum, delta=0.1)
def _serialize_persistables(program, executor): """ Serialize parameters using given program and executor. """ vars_ = list(filter(is_persistable, program.list_vars())) # warn if no variable found in model if len(vars_) == 0: warnings.warn("no variable in your model, please ensure there are any " "variables in your model to save") return None # create a new program and clone persitable vars to it save_program = Program() save_block = save_program.global_block() save_var_map = {} for var in vars_: if var.type != core.VarDesc.VarType.RAW: var_copy = _clone_var_in_block(save_block, var) save_var_map[var_copy.name] = var # create in_vars and out_var, then append a save_combine op to save_program in_vars = [] for name in sorted(save_var_map.keys()): in_vars.append(save_var_map[name]) out_var_name = unique_name.generate("out_var") out_var = save_block.create_var(type=core.VarDesc.VarType.RAW, name=out_var_name) out_var.desc.set_persistable(True) save_block.append_op(type='save_combine', inputs={'X': in_vars}, outputs={'Y': out_var}, attrs={ 'file_path': '', 'save_to_memory': True }) # run save_program to save vars # NOTE(zhiqiu): save op will add variable kLookupTablePath to save_program.desc, # which leads to diff between save_program and its desc. Call _sync_with_cpp # to keep consistency. save_program._sync_with_cpp() executor.run(save_program) # return serialized bytes in out_var return global_scope().find_var(out_var_name).get_bytes()
def get_prog(self): paddle.enable_static() main_program = Program() with program_guard(main_program): cpu_var_name = "tensor@Cpu" npu_var_name = "tensor@Npu" cpu_var = main_program.global_block().create_var( name=cpu_var_name, shape=[10, 10], dtype='float32', persistable=False, stop_gradient=True) npu_var = main_program.global_block().create_var( name=npu_var_name, shape=[10, 10], dtype='float32', persistable=False, stop_gradient=True) main_program.global_block().append_op( type="fill_constant", outputs={"Out": npu_var_name}, attrs={ "shape": [10, 10], "dtype": npu_var.dtype, "value": 1.0, "place_type": 4 }) main_program.global_block().append_op( type="fill_constant", outputs={"Out": cpu_var_name}, attrs={ "shape": [10, 10], "dtype": cpu_var.dtype, "value": 0.0, "place_type": 0 }) return main_program, npu_var, cpu_var
def test_seed_cpu_place(self): paddle.enable_static() main_program = Program() with program_guard(main_program): seed_input_name = "tensor@SeedInput" x_var_name = "tensor@X" x_out_var = "tensor@XOut" mask_var_name = "tensor@Mask" seed_input_var = main_program.global_block().create_var( name=seed_input_name, shape=[1], dtype='int32', persistable=False, stop_gradient=True) x_out_var = main_program.global_block().create_var( name=x_out_var, shape=[40, 40], dtype='float32', persistable=False, stop_gradient=True) x_var = main_program.global_block().create_var( name=x_var_name, shape=[40, 40], dtype='float32', persistable=False, stop_gradient=True) mask_var = main_program.global_block().create_var( name=mask_var_name, shape=[1], dtype='int', persistable=False, stop_gradient=True) main_program.global_block().append_op( type="fill_constant", outputs={"Out": x_var_name}, attrs={ "shape": [40, 40], "dtype": x_var.dtype, "value": 1.0, "place_type": 0 }) main_program.global_block().append_op( type='seed', inputs={}, outputs={'Out': seed_input_var}, attrs={'seed': 1, 'force_cpu': True}) main_program.global_block().append_op( type='dropout', inputs={'X': x_var, 'Seed': seed_input_var}, attrs={'dropout_prob': 0.}, outputs={'Out': x_out_var, 'Mask': mask_var}) place = fluid.CPUPlace() if core.is_compiled_with_cuda(): place = fluid.CUDAPlace(0) exe = fluid.Executor(place) x_out, mask_out = exe.run( main_program, feed={}, fetch_list=[x_out_var.name, mask_var.name]) x_in_np = np.ones([40, 40]).astype("float32") self.assertTrue(np.allclose(x_out, x_in_np))
def _load_persistable_vars(executor, dirname, need_load_vars): load_prog = Program() load_block = load_prog.global_block() need_delete_vars = [] for param in need_load_vars: origin_var = param.origin slice_var = param.slice is_slice = param.is_slice offset = param.offset if is_slice: origin = load_block.create_var( name="{}.load".format(origin_var.name), type=origin_var.type, shape=origin_var.shape, dtype=origin_var.dtype, persistable=True) load_block.append_op( type='load', inputs={}, outputs={'Out': [origin]}, attrs={ 'file_path': os.path.join(dirname, origin_var.name) }) slice = load_block.create_var( name=slice_var.name, type=slice_var.type, shape=slice_var.shape, dtype=slice_var.dtype, persistable=True) dim1_flatten = reduce(lambda x, y: x * y, slice.shape[1:]) start = int(offset / dim1_flatten) end = int(offset / dim1_flatten + slice.shape[0]) load_block.append_op( type="slice", inputs={'Input': origin}, outputs={'Out': slice}, attrs={'axes': [0], 'starts': [start], 'ends': [end]}) need_delete_vars.append(origin) else: origin = load_block.create_var( name="{}".format(origin_var.name), type=origin_var.type, shape=origin_var.shape, dtype=origin_var.dtype, persistable=True) load_block.append_op( type='load', inputs={}, outputs={'Out': [origin]}, attrs={ 'file_path': os.path.join(dirname, origin_var.name) }) load_block.append_op( type='delete_var', inputs={'X': need_delete_vars}, ) executor.run(load_prog)
def deserialize_persistables(program, data, executor): """ :api_attr: Static Graph Deserialize given data to parameters according to given program and executor. Args: program(Program): program that contains parameter names (to deserialize). data(bytes): serialized parameters. executor(Executor): executor used to run load op. Returns: Program: deserialized program. Examples: .. code-block:: python import paddle paddle.enable_static() path_prefix = "./infer_model" # User defined network, here a softmax regession example image = paddle.static.data(name='img', shape=[None, 28, 28], dtype='float32') label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') predict = paddle.static.nn.fc(image, 10, activation='softmax') loss = paddle.nn.functional.cross_entropy(predict, label) exe = paddle.static.Executor(paddle.CPUPlace()) exe.run(paddle.static.default_startup_program()) # serialize parameters to bytes. serialized_params = paddle.static.serialize_persistables([image], [predict], exe) # deserialize bytes to parameters. main_program = paddle.static.default_main_program() deserialized_params = paddle.static.deserialize_persistables(main_program, serialized_params, exe) """ if not isinstance(program, Program): raise TypeError( "program type must be `fluid.Program`, but received `%s`" % type(program)) # load params to a tmp program load_program = Program() load_block = load_program.global_block() vars_ = list(filter(is_persistable, program.list_vars())) origin_shape_map = {} load_var_map = {} check_vars = [] sparse_vars = [] for var in vars_: assert isinstance(var, Variable) if var.type == core.VarDesc.VarType.RAW: continue if isinstance(var, Parameter): origin_shape_map[var.name] = tuple(var.desc.get_shape()) if var.type == core.VarDesc.VarType.SELECTED_ROWS: sparse_vars.append(var) continue var_copy = _clone_var_in_block(load_block, var) check_vars.append(var) load_var_map[var_copy.name] = var_copy # append load_combine op to load parameters, load_var_list = [] for name in sorted(load_var_map.keys()): load_var_list.append(load_var_map[name]) load_block.append_op( type='load_combine', inputs={}, outputs={"Out": load_var_list}, # if load from memory, file_path is data attrs={ 'file_path': data, 'model_from_memory': True }) executor.run(load_program) # check var shape for var in check_vars: if not isinstance(var, Parameter): continue var_tmp = paddle.fluid.global_scope().find_var(var.name) assert var_tmp != None, "can't not find var: " + var.name new_shape = (np.array(var_tmp.get_tensor())).shape assert var.name in origin_shape_map, var.name + " MUST in var list." origin_shape = origin_shape_map.get(var.name) if new_shape != origin_shape: raise RuntimeError( "Shape mismatch, program needs a parameter with shape ({}), " "but the loaded parameter ('{}') has a shape of ({}).".format( origin_shape, var.name, new_shape))