diff --git a/paddle/fluid/API.spec b/paddle/fluid/API.spec index 7394f4c2090b265bf70c4b5b44e6bbd414c867b4..7e35795a100d16465fe1dae256ca6b2c200976c9 100644 --- a/paddle/fluid/API.spec +++ b/paddle/fluid/API.spec @@ -95,12 +95,12 @@ paddle.fluid.io.DataLoader.from_dataset (ArgSpec(args=['dataset', 'places', 'dro paddle.fluid.io.DataLoader.from_generator (ArgSpec(args=['feed_list', 'capacity', 'use_double_buffer', 'iterable', 'return_list'], varargs=None, keywords=None, defaults=(None, None, True, True, False)), ('document', 'e3bdde36774236c3e381d2218e9cc09e')) paddle.fluid.io.cache (ArgSpec(args=['reader'], varargs=None, keywords=None, defaults=None), ('document', '1676886070eb607cb608f7ba47be0d3c')) paddle.fluid.io.map_readers (ArgSpec(args=['func'], varargs='readers', keywords=None, defaults=None), ('document', '2d0903e1d2f00b4f1d6618e6b5310121')) -paddle.fluid.io.buffered (ArgSpec(args=['reader', 'size'], varargs=None, keywords=None, defaults=None), ('document', '0d6186f109feceb99f60ec50a0a624cb')) +paddle.fluid.io.buffered (ArgSpec(args=['reader', 'size'], varargs=None, keywords=None, defaults=None), ('document', 'e095a541160c5dc2994eada9a1c7ad56')) paddle.fluid.io.compose (ArgSpec(args=[], varargs='readers', keywords='kwargs', defaults=None), ('document', '81c933c8da58041d91f084dcf6322349')) paddle.fluid.io.chain (ArgSpec(args=[], varargs='readers', keywords=None, defaults=None), ('document', 'e0311508658a7e741fc39feea8be0ad2')) paddle.fluid.io.shuffle (ArgSpec(args=['reader', 'buf_size'], varargs=None, keywords=None, defaults=None), ('document', '961d0a950cc837c8b13577301dee7bd8')) paddle.fluid.io.firstn (ArgSpec(args=['reader', 'n'], varargs=None, keywords=None, defaults=None), ('document', 'db83c761a5530a05c1ffe2f6f78198f4')) -paddle.fluid.io.xmap_readers (ArgSpec(args=['mapper', 'reader', 'process_num', 'buffer_size', 'order'], varargs=None, keywords=None, defaults=(False,)), ('document', '9c804a42f8a4dbaa76b3c98e0ab7f796')) +paddle.fluid.io.xmap_readers (ArgSpec(args=['mapper', 'reader', 'process_num', 'buffer_size', 'order'], varargs=None, keywords=None, defaults=(False,)), ('document', '17a1d4e59c4260a9416ff269c5e347a3')) paddle.fluid.io.multiprocess_reader (ArgSpec(args=['readers', 'use_pipe', 'queue_size'], varargs=None, keywords=None, defaults=(True, 1000)), ('document', '7d8b3a96e592107c893d5d51ce968ba0')) paddle.fluid.initializer.ConstantInitializer ('paddle.fluid.initializer.ConstantInitializer', ('document', '911263fc30c516c55e89cd72086a23f8')) paddle.fluid.initializer.ConstantInitializer.__init__ (ArgSpec(args=['self', 'value', 'force_cpu'], varargs=None, keywords=None, defaults=(0.0, False)), ('document', '6adf97f83acf6453d4a6a4b1070f3754')) @@ -172,7 +172,7 @@ paddle.fluid.layers.split (ArgSpec(args=['input', 'num_or_sections', 'dim', 'nam paddle.fluid.layers.ctc_greedy_decoder (ArgSpec(args=['input', 'blank', 'input_length', 'padding_value', 'name'], varargs=None, keywords=None, defaults=(None, 0, None)), ('document', '31e0cbec2898efae95853034adadfe2b')) paddle.fluid.layers.edit_distance (ArgSpec(args=['input', 'label', 'normalized', 'ignored_tokens', 'input_length', 'label_length'], varargs=None, keywords=None, defaults=(True, None, None, None)), ('document', '25f0dd786a98aac31490020725604fe1')) paddle.fluid.layers.l2_normalize (ArgSpec(args=['x', 'axis', 'epsilon', 'name'], varargs=None, keywords=None, defaults=(1e-12, None)), ('document', '30eeab67154ef09ab3e884117a8d4aee')) -paddle.fluid.layers.matmul (ArgSpec(args=['x', 'y', 'transpose_x', 'transpose_y', 'alpha', 'name'], varargs=None, keywords=None, defaults=(False, False, 1.0, None)), ('document', '3720b4a386585094435993deb028b592')) +paddle.fluid.layers.matmul (ArgSpec(args=['x', 'y', 'transpose_x', 'transpose_y', 'alpha', 'name'], varargs=None, keywords=None, defaults=(False, False, 1.0, None)), ('document', '8de6d8c13f8fa54ac77e51c5f6bc4cf2')) paddle.fluid.layers.topk (ArgSpec(args=['input', 'k', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', 'e50940f3ce5a08cc477b72f517491bf3')) paddle.fluid.layers.warpctc (ArgSpec(args=['input', 'label', 'blank', 'norm_by_times', 'input_length', 'label_length'], varargs=None, keywords=None, defaults=(0, False, None, None)), ('document', '79aaea078ddea57a82ed7906d71dedc7')) paddle.fluid.layers.sequence_reshape (ArgSpec(args=['input', 'new_dim'], varargs=None, keywords=None, defaults=None), ('document', 'eeb1591cfc854c6ffdac77b376313c44')) @@ -194,7 +194,7 @@ paddle.fluid.layers.autoincreased_step_counter (ArgSpec(args=['counter_name', 'b paddle.fluid.layers.reshape (ArgSpec(args=['x', 'shape', 'actual_shape', 'act', 'inplace', 'name'], varargs=None, keywords=None, defaults=(None, None, False, None)), ('document', 'd7a6d59e464a7ef1184eb6caefeb49f1')) paddle.fluid.layers.squeeze (ArgSpec(args=['input', 'axes', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', 'ebbac07662a6e22e8e299ced880c7775')) paddle.fluid.layers.unsqueeze (ArgSpec(args=['input', 'axes', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', 'b9bd3129d36a70e7c4385df51ff71c62')) -paddle.fluid.layers.lod_reset (ArgSpec(args=['x', 'y', 'target_lod'], varargs=None, keywords=None, defaults=(None, None)), ('document', '74498d37dd622ac472cb36887fce09ea')) +paddle.fluid.layers.lod_reset (ArgSpec(args=['x', 'y', 'target_lod'], varargs=None, keywords=None, defaults=(None, None)), ('document', 'f1f04ae9bdcf8f3adc0658db6904aa0e')) paddle.fluid.layers.lod_append (ArgSpec(args=['x', 'level'], varargs=None, keywords=None, defaults=None), ('document', '37663c7c179e920838a250ea0e28d909')) paddle.fluid.layers.lrn (ArgSpec(args=['input', 'n', 'k', 'alpha', 'beta', 'name'], varargs=None, keywords=None, defaults=(5, 1.0, 0.0001, 0.75, None)), ('document', 'fa565b65fb98d3ca82361c79f41b06b2')) paddle.fluid.layers.pad (ArgSpec(args=['x', 'paddings', 'pad_value', 'name'], varargs=None, keywords=None, defaults=(0.0, None)), ('document', '46b3ada86dd2c79042dca90a55e08f66')) @@ -269,7 +269,7 @@ paddle.fluid.layers.logical_xor (ArgSpec(args=['x', 'y', 'out', 'name'], varargs paddle.fluid.layers.logical_not (ArgSpec(args=['x', 'out', 'name'], varargs=None, keywords=None, defaults=(None, None)), ('document', '75fa78bea3ba82366dd99d2f92da56ef')) paddle.fluid.layers.clip (ArgSpec(args=['x', 'min', 'max', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', '4ad0d96a149f023cb72199ded4ce6e9d')) paddle.fluid.layers.clip_by_norm (ArgSpec(args=['x', 'max_norm', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', 'a5f4917fda557ceb834168cdbec6d51b')) -paddle.fluid.layers.mean (ArgSpec(args=['x', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', '597257fb94d0597c404a6a5c91ab5258')) +paddle.fluid.layers.mean (ArgSpec(args=['x', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', 'b817a28920b04ceeb4976aa2562f94df')) paddle.fluid.layers.mul (ArgSpec(args=['x', 'y', 'x_num_col_dims', 'y_num_col_dims', 'name'], varargs=None, keywords=None, defaults=(1, 1, None)), ('document', 'a91eb670033cd103cd8b24624fef5f69')) paddle.fluid.layers.sigmoid_cross_entropy_with_logits (ArgSpec(args=['x', 'label', 'ignore_index', 'name', 'normalize'], varargs=None, keywords=None, defaults=(-100, None, False)), ('document', '8cdf9e34f73b6f0ed8b60b59a8207fb6')) paddle.fluid.layers.maxout (ArgSpec(args=['x', 'groups', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', '406eee439e41988c8a0304186626a0dd')) @@ -283,7 +283,7 @@ paddle.fluid.layers.grid_sampler (ArgSpec(args=['x', 'grid', 'name'], varargs=No paddle.fluid.layers.log_loss (ArgSpec(args=['input', 'label', 'epsilon', 'name'], varargs=None, keywords=None, defaults=(0.0001, None)), ('document', 'ef1701e11d60508fe8f02dd2a8c60bdf')) paddle.fluid.layers.add_position_encoding (ArgSpec(args=['input', 'alpha', 'beta', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', 'bd8b28e6c1640b13a42b0524f86f7800')) paddle.fluid.layers.bilinear_tensor_product (ArgSpec(args=['x', 'y', 'size', 'act', 'name', 'param_attr', 'bias_attr'], varargs=None, keywords=None, defaults=(None, None, None, None)), ('document', '6755168c4b2308e1e4f54cb56fa7dcb2')) -paddle.fluid.layers.merge_selected_rows (ArgSpec(args=['x', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', 'b2b0e5d5c155ce24bafc38b78cd0b164')) +paddle.fluid.layers.merge_selected_rows (ArgSpec(args=['x', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', 'e98af04d4e8c94bae899e91f6f3ac523')) paddle.fluid.layers.get_tensor_from_selected_rows (ArgSpec(args=['x', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', '2c568321feb4d16c41a83df43f95089d')) paddle.fluid.layers.lstm (ArgSpec(args=['input', 'init_h', 'init_c', 'max_len', 'hidden_size', 'num_layers', 'dropout_prob', 'is_bidirec', 'is_test', 'name', 'default_initializer', 'seed'], varargs=None, keywords=None, defaults=(0.0, False, False, None, None, -1)), ('document', '5193cf1113f9d8d8f682ee5a5fc8b391')) paddle.fluid.layers.shuffle_channel (ArgSpec(args=['x', 'group', 'name'], varargs=None, keywords=None, defaults=(None,)), ('document', '50c06087a53aee4c466afe6fca057d2b')) @@ -332,7 +332,7 @@ paddle.fluid.layers.zeros (ArgSpec(args=['shape', 'dtype', 'force_cpu'], varargs paddle.fluid.layers.reverse (ArgSpec(args=['x', 'axis'], varargs=None, keywords=None, defaults=None), ('document', '628135603692137d52bcf5a8d8d6816d')) paddle.fluid.layers.has_inf (ArgSpec(args=['x'], varargs=None, keywords=None, defaults=None), ('document', 'aca8a35516cef98af836fb6a64ac8acb')) paddle.fluid.layers.has_nan (ArgSpec(args=['x'], varargs=None, keywords=None, defaults=None), ('document', '99f4cf36db08a4e23c8c3857e2af1316')) -paddle.fluid.layers.isfinite (ArgSpec(args=['x'], varargs=None, keywords=None, defaults=None), ('document', 'b9fff4ffc8d11934cde099f4c39bf841')) +paddle.fluid.layers.isfinite (ArgSpec(args=['x'], varargs=None, keywords=None, defaults=None), ('document', '9e40eab383fbe2d76e065345cb27f140')) paddle.fluid.layers.range (ArgSpec(args=['start', 'end', 'step', 'dtype'], varargs=None, keywords=None, defaults=None), ('document', '3e982b788b95f959eafeeb0696a3cbde')) paddle.fluid.layers.linspace (ArgSpec(args=['start', 'stop', 'num', 'dtype'], varargs=None, keywords=None, defaults=None), ('document', '156e653497804566a43f6a53d48b08c4')) paddle.fluid.layers.zeros_like (ArgSpec(args=['x', 'out'], varargs=None, keywords=None, defaults=(None,)), ('document', '5432543db3ff898451aa3af6bb38ab56')) diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py index 54d9934ee7cc6b211d2ef1d2f80bf277ccc40c0f..73773eaceb031e818dd2b068d95bf64af2ca843b 100755 --- a/python/paddle/fluid/layers/nn.py +++ b/python/paddle/fluid/layers/nn.py @@ -6643,7 +6643,7 @@ def matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None): transpose_x (bool): Whether to transpose :math:`x` before multiplication. transpose_y (bool): Whether to transpose :math:`y` before multiplication. alpha (float): The scale of output. Default 1.0. - name(str|None): A name for this layer(optional). If set None, the layer + name(str|optional): A name for this layer(optional). If set None, the layer will be named automatically. Returns: @@ -6654,30 +6654,57 @@ def matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None): # Examples to clarify shapes of the inputs and output # x: [B, ..., M, K], y: [B, ..., K, N] - # fluid.layers.matmul(x, y) # out: [B, ..., M, N] + # fluid.layers.matmul(x, y) + # out: [B, ..., M, N] # x: [B, M, K], y: [B, K, N] - # fluid.layers.matmul(x, y) # out: [B, M, N] + # fluid.layers.matmul(x, y) + # out: [B, M, N] # x: [B, M, K], y: [K, N] - # fluid.layers.matmul(x, y) # out: [B, M, N] + # fluid.layers.matmul(x, y) + # out: [B, M, N] # x: [M, K], y: [K, N] - # fluid.layers.matmul(x, y) # out: [M, N] + # fluid.layers.matmul(x, y) + # out: [M, N] # x: [B, M, K], y: [K] - # fluid.layers.matmul(x, y) # out: [B, M] + # fluid.layers.matmul(x, y) + # out: [B, M] # x: [K], y: [K] - # fluid.layers.matmul(x, y) # out: [1] + # fluid.layers.matmul(x, y) + # out: [1] # x: [M], y: [N] - # fluid.layers.matmul(x, y, True, True) # out: [M, N] + # fluid.layers.matmul(x, y, True, True) + # out: [M, N] import paddle.fluid as fluid - x = fluid.layers.data(name='x', shape=[2, 3], dtype='float32') - y = fluid.layers.data(name='y', shape=[3, 2], dtype='float32') - out = fluid.layers.matmul(x, y, True, True) + import numpy + + # Graph Organizing + x = fluid.data(name='x', shape=[2, 3], dtype='float32') + y = fluid.data(name='y', shape=[3, 2], dtype='float32') + output = fluid.layers.matmul(x, y, True, True) + + # Create an executor using CPU as an example + exe = fluid.Executor(fluid.CPUPlace()) + + # Execute + input_x = numpy.ones([2, 3]).astype(numpy.float32) + input_y = numpy.ones([3, 2]).astype(numpy.float32) + res, = exe.run(fluid.default_main_program(), + feed={'x':input_x, 'y':input_y}, + fetch_list=[output]) + print(res) + ''' + Output Value: + [[2. 2. 2.] + [2. 2. 2.] + [2. 2. 2.]] + ''' """ def __check_input(x, y): @@ -8747,6 +8774,9 @@ def lod_reset(x, y=None, target_lod=None): y.data = [[2, 4]] y.dims = [1, 3] + target_lod: + This parameter does not work when y is not none. + then we get a 1-level LoDTensor: out.lod = [[2, 4]] out.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]] @@ -8764,6 +8794,9 @@ def lod_reset(x, y=None, target_lod=None): y.data = [[1.1], [2.1], [3.1], [4.1], [5.1], [6.1]] y.dims = [6, 1] + target_lod: + This parameter does not work when y is not none. + then we get a 2-level LoDTensor: out.lod = [[2, 2], [2, 2, 1, 1]] out.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]] @@ -8771,9 +8804,9 @@ def lod_reset(x, y=None, target_lod=None): Args: x (Variable): Input variable which could be a Tensor or LoDTensor. - y (Variable|None): If provided, output's LoD would be derived + y (Variable|optional): If provided, output's LoD would be derived from :attr:`y`. - target_lod (list|tuple|None): One level LoD which should be considered + target_lod (list|tuple|optional): One level LoD which should be considered as target LoD when :attr:`y` not provided. Returns: @@ -8786,9 +8819,35 @@ def lod_reset(x, y=None, target_lod=None): .. code-block:: python import paddle.fluid as fluid - x = fluid.layers.data(name='x', shape=[10]) - y = fluid.layers.data(name='y', shape=[10, 20], lod_level=2) - out = fluid.layers.lod_reset(x=x, y=y) + import numpy + + # Graph Organizing + x = fluid.data(name='x', shape=[6]) + y = fluid.data(name='y', shape=[6], lod_level=1) + output = fluid.layers.lod_reset(x=x, y=y) + + # Create an executor using CPU as an example + place = fluid.CPUPlace() + exe = fluid.Executor(place) + + # Execute + x_tensor = fluid.core.LoDTensor() + x_tensor.set(numpy.ones([6]).astype(numpy.float32), place) + y_ndarray = numpy.ones([6]).astype(numpy.float32) + y_lod = [[2, 2], [2, 2, 1, 1]] + y_tensor = fluid.create_lod_tensor(y_ndarray, y_lod, place) + + res, = exe.run(fluid.default_main_program(), + feed={'x':x_tensor, 'y':y_tensor}, + fetch_list=[output], + return_numpy=False) + print(res) + # Output Value: + # lod: [[0, 2, 4], [0, 2, 4, 5, 6]] + # dim: 6 + # layout: NCHW + # dtype: float + # data: [1 1 1 1 1 1] """ helper = LayerHelper("lod_reset", **locals()) out = helper.create_variable_for_type_inference(dtype=x.dtype) @@ -14281,9 +14340,27 @@ def mean(x, name=None): .. code-block:: python import paddle.fluid as fluid - input = fluid.layers.data( + import numpy + + # Graph Organizing + input = fluid.data( name='data', shape=[2, 3], dtype='float32') - mean = fluid.layers.mean(input) + output = fluid.layers.mean(input) + + # Create an executor using CPU as an example + place = fluid.CPUPlace() + exe = fluid.Executor(place) + + # Execute + x_ndarray = numpy.ones([2, 3]).astype(numpy.float32) + res, = exe.run(fluid.default_main_program(), + feed={'data':x_ndarray}, + fetch_list=[output]) + print(res) + ''' + Output Value: + [1.] + ''' """ helper = LayerHelper("mean", **locals()) @@ -14316,11 +14393,47 @@ def merge_selected_rows(x, name=None): .. code-block:: python import paddle.fluid as fluid - b = fluid.default_main_program().global_block() - var = b.create_var( - name="X", dtype="float32", persistable=True, - type=fluid.core.VarDesc.VarType.SELECTED_ROWS) + import numpy + + place = fluid.CPUPlace() + block = fluid.default_main_program().global_block() + + var = block.create_var(name="X2", + dtype="float32", + persistable=True, + type=fluid.core.VarDesc.VarType.SELECTED_ROWS) y = fluid.layers.merge_selected_rows(var) + z = fluid.layers.get_tensor_from_selected_rows(y) + + x_rows = [0, 2, 2, 4, 19] + row_numel = 2 + np_array = numpy.ones((len(x_rows), row_numel)).astype("float32") + + x = fluid.global_scope().var("X2").get_selected_rows() + x.set_rows(x_rows) + x.set_height(20) + x_tensor = x.get_tensor() + x_tensor.set(np_array, place) + + exe = fluid.Executor(place=place) + result = exe.run(fluid.default_main_program(), fetch_list=[z]) + + print("x_rows: ", x_rows) + print("np_array: ", np_array) + print("result: ", result) + ''' + Output Values: + ('x_rows: ', [0, 2, 2, 4, 19]) + ('np_array: ', array([[1., 1.], + [1., 1.], + [1., 1.], + [1., 1.], + [1., 1.]], dtype=float32)) + ('result: ', [array([[1., 1.], + [2., 2.], + [1., 1.], + [1., 1.]], dtype=float32)]) + ''' """ helper = LayerHelper("merge_selected_rows", **locals()) diff --git a/python/paddle/fluid/layers/tensor.py b/python/paddle/fluid/layers/tensor.py index 4523dfd9589e83daf7c796415d0c224cfb39dc12..8b402ef39d86ee068bbed534d44dc8b02bd244f0 100644 --- a/python/paddle/fluid/layers/tensor.py +++ b/python/paddle/fluid/layers/tensor.py @@ -950,11 +950,14 @@ def has_nan(x): def isfinite(x): """ - Test if any of x contains an infinity/NAN number. If all the elements are finite, + Test if any of x contains an infinity / nan number. If all the elements are finite, returns true, else false. + Note: The input to this operator Tensor / LoDTensor data type must be one of + int32 / float / double. + Args: - x(variable): The Tensor/LoDTensor to be checked. + x(Variable): The Tensor / LoDTensor to be checked. Returns: Variable: The tensor variable storing the output, contains a bool value. @@ -964,10 +967,19 @@ def isfinite(x): .. code-block:: python import paddle.fluid as fluid - var = fluid.layers.data(name="data", - shape=(4, 6), - dtype="float32") - out = fluid.layers.isfinite(var) + import numpy + + # Graph Organizing + var = fluid.data(name="data", shape=(4, 6), dtype="float32") + output = fluid.layers.isfinite(var) + + # Create an executor using CPU as an example + exe = fluid.Executor(fluid.CPUPlace()) + + # Execute + img = numpy.ones((4, 6)).astype(numpy.float32) + res, = exe.run(fluid.default_main_program(), feed={'data':img}, fetch_list=[output]) + print(res) # Output Value: [ True] """ helper = LayerHelper("isfinite", **locals()) out = helper.create_variable_for_type_inference(dtype=x.dtype) diff --git a/python/paddle/reader/decorator.py b/python/paddle/reader/decorator.py index 9fcc8fc2a1386565dcfef73d004ef948ee0dd437..8afbb2a54401e2988e9b8a10e244c61979afc2d6 100644 --- a/python/paddle/reader/decorator.py +++ b/python/paddle/reader/decorator.py @@ -280,12 +280,33 @@ def buffered(reader, size): buffer. Reading from the buffered data reader will proceed as long as the buffer is not empty. - :param reader: the data reader to read from. - :type reader: callable - :param size: max buffer size. - :type size: int + Args: + reader (callable): The data reader to read from. + size (int): Max buffer size. + + Return: + Variable: The buffered data reader. + + Examples: + .. code-block:: python + + import paddle.reader as reader + import time + + def reader_creator_10(dur): + def reader(): + for i in range(10): + time.sleep(dur) + yield i + return reader - :returns: the buffered data reader. + for size in range(20): + b = reader.buffered(reader_creator_10(0), size) + c = 0 + for i in b(): + assert i == c + c += 1 + assert c == 10 """ class EndSignal(): @@ -364,16 +385,51 @@ def xmap_readers(mapper, reader, process_num, buffer_size, order=False): """ Use multi-threads to map samples from reader by a mapper defined by user. - Args: - mapper (callable): a function to map the data from reader. - reader (callable): a data reader which yields the data. - process_num (int): thread number to handle original sample. - buffer_size (int): size of the queue to read data in. - order (bool): whether to keep the data order from original reader. + Parameters: + mapper (callable): A function to map the data from reader. + reader (callable): A data reader which yields the data. + process_num (int): Thread number to handle original sample. + buffer_size (int): Size of the queue to read data in. + order (bool): Whether to keep the data order from original reader. Default False. Returns: - callable: a decorated reader with data mapping. + A decorated reader with data mapping. + + Example: + + .. code-block:: python + + import paddle.reader as reader + import time + + def reader_creator_10(dur): + def reader(): + for i in range(10): + time.sleep(dur) + yield i + return reader + + def mapper(x): + return (x + 1) + + orders = (True, False) + thread_num = (1, 2, 4, 8, 16) + buffer_size = (1, 2, 4, 8, 16) + for order in orders: + for t_num in thread_num: + for size in buffer_size: + user_reader = reader.xmap_readers(mapper, + reader_creator_10(0), + t_num, size, order) + for n in range(3): + result = list() + for i in user_reader(): + result.append(i) + if not order: + result.sort() + for idx, e in enumerate(result): + assert e == mapper(idx) """ end = XmapEndSignal()