p60975123
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!28515 [MD] fix dataset chinese doc 

Merge pull request !28515 from liyong126/fix_dataset_doc
This commit is contained in:
i-robot 2022-01-14 01:23:27 +00:00 committed by Gitee
parent 515649ee40 8dc511bd12
commit 67060483cb
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
4 changed files with 126 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
docs/api/api_python/dataset/mindspore.dataset.Dataset.add_sampler.rst
View File

@ -1,14 +1,14 @@
.. py:method:: add_sampler(new_sampler)
为当前数据集添加采样器。
为当前数据集对象添加采样器。
**参数：**
- **new_sampler** (Sampler) ：作用于当前数据集的采样器。
- **new_sampler** (Sampler) ：作用于当前数据集对象的采样器。
**样例：**
>>> # dataset为任意数据集实例
>>> # 对该数据集应用DistributedSampler
>>> # dataset为任意数据集对象的实例
>>> # 对dataset应用DistributedSampler
>>> new_sampler = ds.DistributedSampler(10, 2)
>>> dataset.add_sampler(new_sampler)
>>> dataset.add_sampler(new_sampler)

235
docs/api/api_python/dataset/mindspore.dataset.Dataset.rst
View File

@ -428,11 +428,11 @@
.. py:method:: get_repeat_count()
获取 `RepeatDataset` 中的repeat次数（默认为1）。
获取 `RepeatDataset` 中定义的repeat操作的次数。默认值：1。
**返回：**
int，repeat次数。
int，repeat操作的次数。
.. py:method:: input_indexs
:property:
@ -453,29 +453,26 @@
.. py:method:: map(operations, input_columns=None, output_columns=None, column_order=None, num_parallel_workers=None, python_multiprocessing=False, cache=None, callbacks=None)
将operations列表中的每个operation作用于数据集。
给定一组数据增强列表，按顺序将数据增强作用在数据集对象上。
作用的顺序由每个operation在operations参数中的位置决定。
将首先作用operation[0]，然后operation[1]，operation[2]，以此类推。
每个数据增强操作将数据集对象中的一个或多个数据列作为输入，将数据增强的结果输出为一个或多个数据列。
第一个数据增强操作将 `input_columns` 中指定的列作为输入。
如果数据增强列表中存在多个数据增强操作，则上一个数据增强的输出列将作为下一个数据增强的输入列。
每个operation将数据集中的一列或多列作为输入，并将输出零列或多列。
第一个operation将 `input_columns` 中指定的列作为输入。
如果operations列表中存在多个operation，则上一个operation的输出列将用作下一个operation的输入列。
最后一个operation输出列的列名由 `output_columns` 指定。
只有在 `column_order` 中指定的列才会传播到子节点，并且列的顺序将与 `column_order` 中指定的顺序相同。
最后一个数据增强的输出列的列名由 `output_columns` 指定，如果没有指定 `output_columns` ，输出列名与 `input_columns` 一致。
**参数：**
- **operations** (Union[list[TensorOp], list[functions]]) - 要作用于数据集的operations列表。将按operations列表中显示的顺序作用在数据集。
- **input_columns** (Union[str, list[str]], optional) - 第一个operation输入的列名列表。此列表的大小必须与第一个operation预期的输入列数相匹配。（默认为None，从第一列开始，无论多少列，都将传递给第一个operation）。
- **output_columns** (Union[str, list[str]], optional) - 最后一个operation输出的列名列表。如果 `input_columns` 长度不等于 `output_columns` 长度，则此参数必选。此列表的大小必须与最后一个operation的输出列数相匹配（默认为None，输出列将与输入列具有相同的名称，例如，替换一些列）。
- **column_order** (list[str], optional) - 指定整个数据集中所需的所有列的列表。当 `input_columns` 长度不等于 `output_columns` 长度时，则此参数必选。注意：这里的列表不仅仅是参数 `input_columns` 和 `output_columns` 中指定的列。
- **num_parallel_workers** (int, optional) - 用于并行处理数据集的线程数（默认为None，将使用配置文件中的值）。
- **python_multiprocessing** (bool, optional) - 将Python operations委托给多个工作进程进行并行处理。如果Python operations计算量很大，此选项可能会很有用（默认值为False）。
- **cache** (DatasetCache, optional) - 使用Tensor缓存服务加快数据集处理速度（默认为None，即不使用缓存）。
- **callbacks** (DSCallback, list[DSCallback], optional) - 要调用的Dataset回调函数列表（默认为None）。
- **operations** (Union[list[TensorOp], list[functions]]) - 一组数据增强操作，支持数据集增强算子或者用户自定义的Python Callable对象。map操作将按顺序将一组数据增强作用在数据集对象上。
- **input_columns** (Union[str, list[str]], 可选) - 第一个数据增强操作的输入数据列。此列表的长度必须与 `operations` 列表中第一个数据增强的预期输入列数相匹配。默认值：None。表示所有数据列都将传递给第一个数据增强操作。
- **output_columns** (Union[str, list[str]], 可选) - 最后一个数据增强操作的输出数据列。如果 `input_columns` 长度不等于 `output_columns` 长度，则必须指定此参数。列表的长度必须必须与最后一个数据增强的输出列数相匹配。默认值：None，输出列将与输入列具有相同的名称。
- **column_order** (Union[str, list[str]], 可选) - 指定传递到下一个数据集操作的数据列的顺序。如果 `input_columns` 长度不等于 `output_columns` 长度，则必须指定此参数。 注意：参数的列名不限定在 `input_columns` 和 `output_columns` 中指定的列，也可以是上一个操作输出的未被处理的数据列。默认值：None，按照原输入顺序排列。
- **num_parallel_workers** (int, 可选) - 指定map操作的多进程/多线程并发数，加快处理速度。默认值：None，将使用 `set_num_parallel_workers` 设置的并发数。
- **python_multiprocessing** (bool, 可选) - 启用Python多进程模式加速map操作。当传入的 `operations` 计算量很大时，开启此选项可能会有较好效果。默认值：False。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读 `单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **callbacks** (DSCallback, list[DSCallback], 可选) - 要调用的Dataset回调函数列表。默认值：None。
- **max_rowsize** (int, 可选) - 指定在多进程之间复制数据时，共享内存分配的最大空间，仅当 `python_multiprocessing` 为True时，该选项有效。默认值：16，数量级为MB。
- **offload** (bool, 可选) - 是否进行异构硬件加速，详情请阅读 `数据准备异构加速 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_dataset_offload.html>`_ 。默认值：None。
.. note::
- `operations` 参数主要接收 `mindspore.dataset` 模块中c_transforms、py_transforms算子，以及用户定义的Python函数(PyFuncs)。
@ -487,7 +484,7 @@
**样例：**
>>> # dataset是Dataset的一个实例，它有2列，"image"和"label"。
>>> # dataset是Dataset对象的一个实例，它有2列，"image"和"label"。
>>>
>>> # 定义两个operation，每个operation接受1列输入，输出1列。
>>> decode_op = c_vision.Decode(rgb=True)
@ -496,23 +493,23 @@
>>>
>>> # 1）简单的map示例。
>>>
>>> # 在列“image"上应用decode_op。此列将被
>>> # decode_op的输出列替换。由于未指定column_order，因此两列“image"
>>> # 和“label"将按其原始顺序传播到下一个节点。
>>> # 对"image"对应的数据列进行"decode_op"操作。
>>> # 由于未指定column_order，因此"image"
>>> # 和"label"2列将按其原来的顺序传播到下一个操作。
>>> dataset = dataset.map(operations=[decode_op], input_columns=["image"])
>>>
>>> # 解码列“image"并将其重命名为“decoded_image"。
>>> # 对"image"对应的数据列进行"decode_op"操作并将列名重命名为"decoded_image"。
>>> dataset = dataset.map(operations=[decode_op], input_columns=["image"], output_columns=["decoded_image"])
>>>
>>> # 指定输出列的顺序。
>>> dataset = dataset.map(operations=[decode_op], input_columns=["image"],
... output_columns=None, column_order=["label", "image"])
>>>
>>> # 将列“image"重命名为“decoded_image"，并指定输出列的顺序。
>>> # 将"image"重命名为"decoded_image"，并指定输出列的顺序。
>>> dataset = dataset.map(operations=[decode_op], input_columns=["image"],
... output_columns=["decoded_image"], column_order=["label", "decoded_image"])
>>>
>>> # 将列“image"重命名为“decoded_image"，并只保留此列。
>>> # 将"image"重命名为"decoded_image"，并只保留此列。
>>> dataset = dataset.map(operations=[decode_op], input_columns=["image"],
... output_columns=["decoded_image"], column_order=["decoded_image"])
>>>
@ -524,30 +521,32 @@
>>> # 2）多个operation的map示例。
>>>
>>> # 创建一个数据集，图像被解码，并随机颜色抖动。
>>> # decode_op以列“image"作为输入，并输出一列。将
>>> # decode_op输出的列作为输入传递给random_jitter_op。
>>> # random_jitter_op将输出一列。列“image"将替换为
>>> # decode_op以列"image"作为输入，并输出1列。将
>>> # decode_op输出的数据列作为输入传递给random_jitter_op，
>>> # random_jitter_op将输出1列。列"image"将替换为
>>> # random_jitter_op（最后一个operation）输出的列。所有其他
>>> # 列保持不变。由于未指定column_order，因此
>>> # 列的顺序将保持不变。
>>> dataset = dataset.map(operations=[decode_op, random_jitter_op], input_columns=["image"])
>>>
>>> # 将random_jitter_op输出的列重命名为“image_mapped"。
>>> # 指定列顺序的方式与1中的示例相同。
>>> # 将random_jitter_op输出的列重命名为"image_mapped"。
>>> # 指定列顺序的方式与示例1相同。
>>> dataset = dataset.map(operations=[decode_op, random_jitter_op], input_columns=["image"],
... output_columns=["image_mapped"])
>>>
>>> # 使用用户自定义Python函数的多个operation的map示例。列重命名和指定列顺序
>>> # 的方式与1中的示例相同。
>>> # 的方式与示例1相同。
>>> dataset = ds.NumpySlicesDataset(data=[[0, 1, 2]], column_names=["data"])
>>> dataset = dataset.map(operations=[(lambda x: x * x), (lambda x: x - 1)], input_columns=["data"],
... output_columns=["data_mapped"])
>>>
>>> # 3）输入列数不等于输出列数的示例。
>>> # 3）输入列数和输出列数不等的示例。
>>>
>>> # operation[0] 是一个 lambda，它以 2 列作为输入并输出 3 列。
>>> # operations[1] 是一个 lambda，它以 3 列作为输入并输出 1 列。
>>> # operations[2] 是一个 lambda，它以 1 列作为输入并输出 4 列。
>>> # operation[i]均为lambda函数。
>>> #
>>> # operation[0]输入2列并输出3列。
>>> # operations[1]输入3列并输出1列。
>>> # operations[2]输入1列并输出4列。
>>> #
>>> # 注：operation[i]的输出列数必须等于
>>> # operation[i+1]的输入列。否则，map算子会
@ -562,54 +561,52 @@
>>>
>>> dataset = ds.NumpySlicesDataset(data=([[0, 1, 2]], [[3, 4, 5]]), column_names=["x", "y"])
>>>
>>> # 按以下顺序将所有列传播到子节点：
>>> # 将所有数据列传播到下一个操作：
>>> dataset = dataset.map(operations, input_columns=["x", "y"],
... output_columns=["mod2", "mod3", "mod5", "mod7"],
... column_order=["mod2", "mod3", "mod5", "mod7"])
>>>
>>> # 按以下顺序将某些列传播到子节点：
>>> # 将某些列数据列播到下一个操作：
>>> dataset = dataset.map(operations, input_columns=["x", "y"],
... output_columns=["mod2", "mod3", "mod5", "mod7"],
... column_order=["mod7", "mod3", "col2"])
.. py:method:: num_classes()
获取数据集中的样本的class数目。
获取数据集对象中所有样本的类别数目。
**返回：**
int，class数目。
int，类别的数目。
.. py:method:: output_shapes()
获取输出数据的shape。
获取数据集对象中每列数据的shape。
**返回：**
list，每列shape的列表。
list，每列数据的shape列表。
.. py:method:: output_types()
获取输出数据类型。
获取数据集对象中每列数据的数据类型。
**返回：**
list，每列类型的列表。
list，每列数据的数据类型列表。
.. py:method:: project(columns)
在输入数据集上投影某些列。
从数据集中选择列，并以指定的顺序传输到流水线中。
其他列将被丢弃。
从数据集对象中选择需要的列，并按给定的列名的顺序进行排序，
未指定的数据列将被丢弃。
**参数：**
- **columns** (Union[str, list[str]]) - 要投影列的列名列表。
- **columns** (Union[str, list[str]]) - 要选择的数据列的列名列表。
**返回：**
ProjectDataset，投影后的数据集对象。
ProjectDataset，project操作后的数据集对象。
**样例：**
@ -621,16 +618,16 @@
.. py:method:: rename(input_columns, output_columns)
重命名输入数据集中的列。
对数据集对象按指定的列名进行重命名。
**参数：**
- **input_columns** (Union[str, list[str]]) - 输入列的列名列表。
- **output_columns** (Union[str, list[str]]) - 输出列的列名列表。
- **input_columns** (Union[str, list[str]]) - 待重命名的列名列表。
- **output_columns** (Union[str, list[str]]) - 重命名后的列名列表。
**返回：**
RenameDataset，重命名后数据集对象。
RenameDataset，rename操作后的数据集对象。
**样例：**
@ -638,25 +635,25 @@
>>> input_columns = ["input_col1", "input_col2", "input_col3"]
>>> output_columns = ["output_col1", "output_col2", "output_col3"]
>>>
>>> # 创建一个数据集，其中input_col1重命名为output_col1，
>>> # input_col2重命名为output_col2，input_col3重命名
>>> # 为output_col3。
>>> # 创建一个数据集，其中"nput_col1"重命名为"output_col1"，
>>> # "input_col2"重命名为"output_col2"，"input_col3"重命名
>>> # 为"output_col3"。
>>> dataset = dataset.rename(input_columns=input_columns, output_columns=output_columns)
.. py:method:: repeat(count=None)
重复此数据集 `count` 次。如果count为None或-1，则无限重复。
重复此数据集 `count` 次。如果 `count` 为None或-1，则无限重复。
.. note::
repeat和batch的顺序反映了batch的数量。建议：repeat操作在batch操作之后使用。
**参数：**
- **count** (int) - 数据集重复的次数（默认为None）。
- **count** (int) - 数据集重复的次数。默认值：None。
**返回：**
RepeatDataset，重复操作后的数据集对象。
RepeatDataset，repeat操作后的数据集对象。
**样例：**
@ -665,11 +662,11 @@
>>> # 创建一个数据集，数据集重复50个epoch。
>>> dataset = dataset.repeat(50)
>>>
>>> # 创建一个数据集，其中每个epoch都是单独打乱的。
>>> # 创建一个数据集，其中每个epoch都是独立混洗的。
>>> dataset = dataset.shuffle(10)
>>> dataset = dataset.repeat(50)
>>>
>>> # 创建一个数据集，打乱前先将数据集重复
>>> # 创建一个数据集，混洗前先将数据集重复
>>> # 50个epoch。shuffle算子将
>>> # 整个50个epoch视作一个大数据集。
>>> dataset = dataset.repeat(50)
@ -677,11 +674,11 @@
.. py:method:: reset()
重置下一个epoch的数据集。
重置下一个epoch的数据集对象。
.. py:method:: save(file_name, num_files=1, file_type='mindrecord')
将流水线正在处理的数据保存为通用的数据集格式。支持的数据集格式：'mindrecord'。
将数据处理管道中正处理的数据保存为通用的数据集格式。支持的数据集格式：'mindrecord'。
将数据保存为'mindrecord'格式时存在隐式类型转换。转换表展示如何执行类型转换。
@ -699,8 +696,8 @@
- int32
-
* - uint8
- bytes(1D uint8)
- Drop dimension
- bytes
- 丢失维度信息
* - int16
- int32
-
@ -733,20 +730,20 @@
- 不支持多维字符串
.. note::
1. 如需按顺序保存示例，请将数据集的shuffle设置为False，将 `num_files` 设置为1。
2. 在调用函数之前，不要使用batch算子、repeat算子或具有随机属性的数据增强的map算子。
3. 当数据的维度可变时，只支持1维数组或者在0维变化的多维数组。
4. 不支持DE_UINT64类型、多维的DE_UINT8类型、多维DE_STRING类型。
1. 如需按顺序保存数据，将数据集的 `shuffle` 设置为False，将 `num_files` 设置为1。
2. 在执行保存操作之前，不要使用batch操作、repeat操作或具有随机属性的数据增强的map操作。
3. 当数据的维度可变时，只支持1维数组或者在第0维变化的多维数组。
4. 不支持UINT64类型、多维的UINT8类型、多维STRING类型。
**参数：**
- **file_name** (str) - 数据集文件的路径。
- **num_files** (int, optional) - 数据集文件的数量（默认为1）。
- **file_type** (str, optional) - 数据集格式（默认为'mindrecord'）。
- **num_files** (int, 可选) - 数据集文件的数量，默认值：1。
- **file_type** (str, 可选) - 数据集格式，默认值：'mindrecord'。
.. py:method:: set_dynamic_columns(columns=None)
设置源数据的动态shape信息，需要在定义数据处理流水线后设置。
设置数据集的动态shape信息，需要在定义好完整的数据处理管道后进行设置。
**参数：**
@ -754,29 +751,29 @@
.. py:method:: shuffle(buffer_size)
使用以下策略随机打乱此数据集的行：
使用以下策略混洗此数据集的行：
1. 生成一个shuffle缓冲区包含buffer_size条数据行。
1. 生成一个混洗缓冲区包含 `buffer_size` 条数据行。
2. 从shuffle缓冲区中随机选择一个元素，作为下一行传播到子节点。
2. 从混洗缓冲区中随机选择一个数据行，传递给下一个操作。
3. 从父节点获取下一行（如果有的话），并将其放入shuffle缓冲区中。
3. 从上一个操作获取下一个数据行（如果有的话），并将其放入混洗缓冲区中。
4. 重复步骤2和3，直到打乱缓冲区中没有数据行为止。
4. 重复步骤2和3，直到混洗缓冲区中没有数据行为止。
可以提供随机种子，在第一个epoch中使用。在随后的每个epoch，种子都会被设置成一个新产生的随机值。
在第一个epoch中可以通过 `dataset.config.set_seed` 来设置随机种子，在随后的每个epoch，种子都会被设置成一个新产生的随机值。
**参数：**
- **buffer_size** (int) - 用于shuffle的缓冲区大小（必须大于1）。将buffer_size设置为等于数据集大小将导致在全局shuffle。
- **buffer_size** (int) - 用于混洗的缓冲区大小（必须大于1）。将 `buffer_size` 设置为数据集大小将进行全局混洗。
**返回：**
ShuffleDataset，打乱后的数据集对象。
ShuffleDataset，混洗后的数据集对象。
**异常：**
- **RuntimeError** - 打乱前存在同步操作。
- **RuntimeError** - 混洗前存在通过 `dataset.sync_wait` 进行同步操作。
**样例：**
@ -788,61 +785,57 @@
.. py:method:: skip(count)
跳过此数据集的前N个元素。
跳过此数据集对象的前 `count` 条数据。
**参数：**
- **count** (int) - 要跳过的数据集中的元素个数。
- **count** (int) - 要跳过数据的条数。
**返回：**
SkipDataset，减去跳过的行的数据集对象。
SkipDataset，跳过指定条数据后的数据集对象。
**样例：**
>>> # dataset是Dataset对象的实例
>>> # 创建一个数据集，跳过前3个元素
>>> # 创建一个数据集对象，跳过前3条数据
>>> dataset = dataset.skip(3)
.. py:method:: split(sizes, randomize=True)
将数据集拆分为多个不重叠的数据集。
这是一个通用拆分函数，可以被数据处理流水线中的任何算子调用。
还有如果直接调用ds.split，其中 ds 是一个 MappableDataset，它将被自动调用。
将数据集拆分为多个不重叠的子数据集。
**参数：**
- **sizes** (Union[list[int], list[float]]) - 如果指定了一列整数[s1, s2, …, sn]，数据集将被拆分为n个大小为s1、s2、...、sn的数据集。如果所有输入大小的总和不等于原始数据集大小，则报错。如果指定了一列浮点数[f1, f2, …, fn]，则所有浮点数必须介于0和1之间，并且总和必须为1，否则报错。数据集将被拆分为n个大小为round(f1*K)、round(f2*K)、...、round(fn*K)的数据集，其中K是原始数据集的大小。
如果舍入后：
如果round四舍五入计算后：
- 任何大小等于0，都将发生错误。
- 如果拆分大小的总和<K，K - sigma(round(fi * k))的差值将添加到第一个子数据集。
- 如果拆分大小的总和>K，sigma(round(fi * K)) - K的差值将从第一个足够大的拆分子集中删除，删除差值后至少有1行。
- 任何子数据集的的大小等于0，都将发生错误。
- 如果子数据集大小的总和小于K，K - sigma(round(fi * k))的值将添加到第一个子数据集，sigma为求和操作。
- 如果子数据集大小的总和大于K，sigma(round(fi * K)) - K的值将从第一个足够大的子数据集中删除，且删除后的子数据集大小至少大于1。
- **randomize** (bool, optional) - 确定是否随机拆分数据（默认为True）。如果为True，则数据集将被随机拆分。否则，将使用数据集中的连续行创建每个拆分子集。
- **randomize** (bool, 可选) - 确定是否随机拆分数据，默认值：True，数据集将被随机拆分。否则将按顺序拆分为多个不重叠的子数据集。
.. note::
1. 如果要调用 split，则无法对数据集进行分片。
2. 强烈建议不要对数据集进行打乱，而是使用随机化（randomize=True）。对数据集进行打乱的结果具有不确定性，每个拆分子集中的数据在每个epoch可能都不同。
1. 如果进行拆分操作的数据集对象为MappableDataset类型，则将自动调用一个优化后的split操作。
2. 如果进行split操作，则不应对数据集对象进行分片操作（如指定num_shards或使用DistributerSampler）。相反，如果创建一个DistributerSampler，并在split操作拆分后的子数据集对象上进行分片操作，强烈建议在每个子数据集上设置相同的种子，否则每个分片可能不是同一个子数据集的一部分（请参见示例）。
3. 强烈建议不要对数据集进行混洗，而是使用随机化（randomize=True）。对数据集进行混洗的结果具有不确定性，每个拆分后的子数据集中的数据在每个epoch可能都不同。
**异常：**
- **RuntimeError** - get_dataset_size返回None或此数据集不支持。
- **RuntimeError** - 数据集对象不支持 `get_dataset_size` 或者 `get_dataset_size` 返回None。
- **RuntimeError** - sizes是整数列表，并且size中所有元素的总和不等于数据集大小。
- **RuntimeError** - sizes是float列表，并且计算后存在大小为0的拆分子数据集。
- **RuntimeError** - 数据集在调用拆分之前已进行分片。
- **RuntimeError** - 数据集对象在调用拆分之前已进行分片。
- **ValueError** - sizes是float列表，且并非所有float数都在0和1之间，或者float数的总和不等于1。
**返回：**
tuple(Dataset)，拆分后子数据集对象的元组。
tuple(Dataset)，split操作后子数据集对象的元组。
**样例：**
>>> # TextFileDataset不是可映射dataset，因此将调用通用拆分函数。
>>> # 由于许多数据集默认都打开了shuffle，如需调用拆分函数，请将shuffle设置为False。
>>> dataset = ds.TextFileDataset(text_file_dataset_dir, shuffle=False)
>>> train_dataset, test_dataset = dataset.split([0.9, 0.1])
@ -852,19 +845,19 @@
**参数：**
- **condition_name** (str) - 用于切换发送下一行数据的条件名称。
- **num_batch** (Union[int, None]) - 释放的batch（row）数。当 `num_batch` 为None时，将默认为 `sync_wait` 算子指定的值（默认为None）。
- **data** (Any) - 用户自定义传递给回调函数的数据（默认为None）。
- **condition_name** (str) - 用于触发发送下一个数据行的条件名称。
- **num_batch** (Union[int, None]) - 释放的batch（row）数。当 `num_batch` 为None时，将默认为 `sync_wait` 操作指定的值，默认值：None。
- **data** (Any) - 用户自定义传递给回调函数的数据，默认值：None。
.. py:method:: sync_wait(condition_name, num_batch=1, callback=None)
向输入数据集添加阻塞条件。 将应用同步操作。
为同步操作在数据集对象上添加阻塞条件。
**参数：**
- **condition_name** (str) - 用于切换发送下一行的条件名称。
- **condition_name** (str) - 用于触发发送下一行数据的条件名称。
- **num_batch** (int) - 每个epoch开始时无阻塞的batch数。
- **callback** (function) - `sync_update` 中将调用的回调函数。
- **callback** (function) - `sync_update` 操作中将调用的回调函数。
**返回：**
@ -907,24 +900,24 @@
.. py:method:: take(count=-1)
从数据集中获取最多给定数量的元素。
从数据集中获取最多 `count` 的元素。
.. note::
1. 如果count大于数据集中的元素数或等于-1，则取数据集中的所有元素。
2. take和batch操作顺序很重要，如果take在batch操作之前，则取给定行数；否则取给定batch数。
1. 如果 `count` 大于数据集中的数据条数或等于-1，则取数据集中的所有数据。
2. take和batch操作顺序很重要，如果take在batch操作之前，则取给定条数，否则取给定batch数。
**参数：**
- **count** (int, optional) - 要从数据集中获取的元素数（默认为-1）。
- **count** (int, 可选) - 要从数据集对象中获取的数据条数，默认值：-1，获取所有数据。
**返回：**
TakeDataset，取出指定数目的数据集对象。
TakeDataset，take操作后的数据集对象。
**样例：**
>>> # dataset是Dataset对象的实例。
>>> # 创建一个数据集，包含50个元素。
>>> # 创建一个数据集对象，包含50条数据。
>>> dataset = dataset.take(50)
.. py:method:: to_device(send_epoch_end=True, create_data_info_queue=False)
@ -933,11 +926,11 @@
**参数：**
- **send_epoch_end** (bool, optional) - 是否将end of sequence发送到设备（默认为True）。
- **create_data_info_queue** (bool, optional) - 是否创建存储数据类型和shape的队列（默认值为False）。
- **send_epoch_end** (bool, 可选) - 是否将epoch结束符 `end_of_sequence` 发送到设备，默认值：True。
- **create_data_info_queue** (bool, 可选) - 是否创建存储数据类型和shape的队列，默认值：False。
.. note::
如果设备为Ascend，则逐个传输数据。每次传输的数据最大限制为256M。
如果设备为Ascend，则逐个传输数据。每次数据传输的限制为256M。
**返回：**
@ -949,12 +942,12 @@
.. py:method:: to_json(filename='')
将数据处理流水线序列化为JSON字符串，如果提供了文件名，则转储到文件中。
将数据处理管道序列化为JSON字符串，如果提供了文件名，则转储到文件中。
**参数：**
- **filename** (str) - 另存为JSON格式的文件名。
- **filename** (str) - 保存JSON文件的路径（包含文件名）。
**返回：**
str，流水线的JSON字符串。
str，数据处理管道序列化后的JSON字符串。

8
docs/api/api_python/dataset/mindspore.dataset.Dataset.use_sampler.rst
View File

@ -1,6 +1,6 @@
.. py:method:: use_sampler(new_sampler)
为当前数据集更换一个新的采样器。
为当前数据集对象更换一个新的采样器。
**参数：**
@ -8,7 +8,7 @@
**样例：**
>>> # dataset为任意数据集实例
>>> # 将该数据集的采样器更换为DistributedSampler
>>> # dataset为任意数据集对象的实例
>>> # 将dataset的采样器更换为DistributedSampler
>>> new_sampler = ds.DistributedSampler(10, 2)
>>> dataset.use_sampler(new_sampler)
>>> dataset.use_sampler(new_sampler)

6
docs/api/api_python/dataset/mindspore.dataset.Dataset.zip.rst
View File

@ -1,10 +1,10 @@
.. py:method:: zip(datasets)
将数据集和输入的数据集或者数据集元组按列进行合并压缩。输入数据集中的列名必须不同。
将数据集对象和输入的数据集对象或者数据集对象元组按列进行合并压缩。输入数据集对象中不能有重名的列。
**参数：**
- **datasets** (Union[tuple, class Dataset]) - 数据集对象的元组或单个数据集对象与当前数据集一起合并压缩。
- **datasets** (Union[tuple, class Dataset]) - 数据集对象的元组或单个数据集对象与当前数据集对象一起合并压缩。
**返回：**
@ -13,4 +13,4 @@
**样例：**
>>> # 创建一个数据集，它将dataset和dataset_1进行合并
>>> dataset = dataset.zip(dataset_1)
>>> dataset = dataset.zip(dataset_1)