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

!29254 modify doc 

Merge pull request !29254 from xumengjuan1/code_docs_xmjformat1
This commit is contained in:
i-robot 2022-01-19 02:37:18 +00:00 committed by Gitee
parent a739e38394 f51fd70911
commit b378a9c8ab
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
212 changed files with 82 additions and 5587 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
docs/api/api_python/dataset/mindspore.dataset.BuiltinSampler.rst
View File

@ -6,12 +6,6 @@
- **sampler** (Sampler) - 用于从数据集中选择样本的对象。仅支持内置采样器（DistributedSampler、PKSampler、RandomSampler、SequentialSampler、SubsetRandomSampler、WeightedRandomSampler）。
**样例：**
>>> sampler = ds.SequentialSampler(start_index=0, num_samples=3)
>>> sampler.add_child(ds.RandomSampler(num_samples=2))
>>> dataset = ds.Cifar10Dataset(cifar10_dataset_dir, sampler=sampler)
.. py:method:: get_child()
获取给定采样器的子采样器。

43
docs/api/api_python/dataset/mindspore.dataset.CLUEDataset.rst
View File

@ -15,7 +15,7 @@ mindspore.dataset.CLUEDataset
- **num_samples** (int, 可选) - 指定从数据集中读取的样本数。默认值：None，读取所有样本。
- **num_parallel_workers** (int, 可选) - 指定读取数据的工作线程数。默认值：None，使用mindspore.dataset.config中配置的线程数。
- **shuffle** (Union[bool, Shuffle], 可选) - 每个epoch中数据混洗的模式，支持传入bool类型与枚举类型进行指定，默认值：mindspore.dataset.Shuffle.GLOBAL。
如果`shuffle`为False，则不混洗，如果`shuffle`为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。
如果 `shuffle` 为False，则不混洗，如果 `shuffle` 为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。
通过传入枚举变量设置数据混洗的模式：
- **Shuffle.GLOBAL**：混洗文件和样本。
@ -28,34 +28,34 @@ mindspore.dataset.CLUEDataset
根据给定的 `task` 参数配置，数据集会生成不同的输出列：
- `task` = 'AFQMC'
- usage = 'train'，输出列: `[sentence1, dtype=string]`, `[sentence2, dtype=string]`, `[label, dtype=string]`.
- usage = 'test'，输出列: `[id, dtype=uint8]`, `[sentence1, dtype=string]`, `[sentence2, dtype=string]`.
- usage = 'eval'，输出列: `[sentence1, dtype=string]`, `[sentence2, dtype=string]`, `[label, dtype=string]`.
- usage = 'train'，输出列: `[sentence1, dtype=string]` , `[sentence2, dtype=string]` , `[label, dtype=string]` .
- usage = 'test'，输出列: `[id, dtype=uint8]` , `[sentence1, dtype=string]` , `[sentence2, dtype=string]` .
- usage = 'eval'，输出列: `[sentence1, dtype=string]` , `[sentence2, dtype=string]` , `[label, dtype=string]` .
- `task` = 'TNEWS'
- usage = 'train'，输出列: `[label, dtype=string]`, `[label_des, dtype=string]`, `[sentence, dtype=string]`, `[keywords, dtype=string]`.
- usage = 'test'，输出列: `[label, dtype=string]`, `[label_des, dtype=string]`, `[sentence, dtype=string]`, `[keywords, dtype=string]`.
- usage = 'eval'，输出列: `[label, dtype=string]`, `[label_des, dtype=string]`, `[sentence, dtype=string]`, `[keywords, dtype=string]`.
- usage = 'train'，输出列: `[label, dtype=string]` , `[label_des, dtype=string]` , `[sentence, dtype=string]` , `[keywords, dtype=string]` .
- usage = 'test'，输出列: `[label, dtype=string]` , `[label_des, dtype=string]` , `[sentence, dtype=string]` , `[keywords, dtype=string]` .
- usage = 'eval'，输出列: `[label, dtype=string]` , `[label_des, dtype=string]` , `[sentence, dtype=string]` , `[keywords, dtype=string]` .
- `task` = 'IFLYTEK'
- usage = 'train'，输出列: `[label, dtype=string]`, `[label_des, dtype=string]`, `[sentence, dtype=string]`.
- usage = 'test'，输出列: `[id, dtype=string]`, `[sentence, dtype=string]`.
- usage = 'eval'，输出列: `[label, dtype=string]`, `[label_des, dtype=string]`, `[sentence, dtype=string]`.
- usage = 'train'，输出列: `[label, dtype=string]` , `[label_des, dtype=string]` , `[sentence, dtype=string]` .
- usage = 'test'，输出列: `[id, dtype=string]` , `[sentence, dtype=string]` .
- usage = 'eval'，输出列: `[label, dtype=string]` , `[label_des, dtype=string]` , `[sentence, dtype=string]` .
- `task` = 'CMNLI'
- usage = 'train'，输出列: `[sentence1, dtype=string]`, `[sentence2, dtype=string]`, `[label, dtype=string]`.
- usage = 'test'，输出列: `[id, dtype=uint8]`, `[sentence1, dtype=string]`, `[sentence2, dtype=string]`.
- usage = 'eval'，输出列: `[sentence1, dtype=string]`, `[sentence2, dtype=string]`, `[label, dtype=string]`.
- usage = 'train'，输出列: `[sentence1, dtype=string]` , `[sentence2, dtype=string]` , `[label, dtype=string]` .
- usage = 'test'，输出列: `[id, dtype=uint8]` , `[sentence1, dtype=string]` , `[sentence2, dtype=string]` .
- usage = 'eval'，输出列: `[sentence1, dtype=string]` , `[sentence2, dtype=string]` , `[label, dtype=string]` .
- `task` = 'WSC'
- usage = 'train'，输出列: `[span1_index, dtype=uint8]`, `[span2_index, dtype=uint8]`, `[span1_text, dtype=string]`, `[span2_text, dtype=string]`, `[idx, dtype=uint8]`, `[text, dtype=string]`, `[label, dtype=string]`.
- usage = 'test'，输出列: `[span1_index, dtype=uint8]`, `[span2_index, dtype=uint8]`, `[span1_text, dtype=string]`, `[span2_text, dtype=string]`, `[idx, dtype=uint8]`, `[text, dtype=string]`.
- usage = 'eval'，输出列: `[span1_index, dtype=uint8]`, `[span2_index, dtype=uint8]`, `[span1_text, dtype=string]`, `[span2_text, dtype=string]`, `[idx, dtype=uint8]`, `[text, dtype=string]`, `[label, dtype=string]`.
- usage = 'train'，输出列: `[span1_index, dtype=uint8]` , `[span2_index, dtype=uint8]` , `[span1_text, dtype=string]` , `[span2_text, dtype=string]` , `[idx, dtype=uint8]` , `[text, dtype=string]` , `[label, dtype=string]` .
- usage = 'test'，输出列: `[span1_index, dtype=uint8]` , `[span2_index, dtype=uint8]` , `[span1_text, dtype=string]` , `[span2_text, dtype=string]` , `[idx, dtype=uint8]` , `[text, dtype=string]` .
- usage = 'eval'，输出列: `[span1_index, dtype=uint8]` , `[span2_index, dtype=uint8]` , `[span1_text, dtype=string]` , `[span2_text, dtype=string]` , `[idx, dtype=uint8]` , `[text, dtype=string]` , `[label, dtype=string]` .
- `task` = 'CSL'
- usage = 'train'，输出列: `[id, dtype=uint8]`, `[abst, dtype=string]`, `[keyword, dtype=string]`, `[label, dtype=string]`.
- usage = 'test'，输出列: `[id, dtype=uint8]`, `[abst, dtype=string]`, `[keyword, dtype=string]`.
- usage = 'eval'，输出列: `[id, dtype=uint8]`, `[abst, dtype=string]`, `[keyword, dtype=string]`, `[label, dtype=string]`.
- usage = 'train'，输出列: `[id, dtype=uint8]` , `[abst, dtype=string]` , `[keyword, dtype=string]` , `[label, dtype=string]` .
- usage = 'test'，输出列: `[id, dtype=uint8]` , `[abst, dtype=string]` , `[keyword, dtype=string]` .
- usage = 'eval'，输出列: `[id, dtype=uint8]` , `[abst, dtype=string]` , `[keyword, dtype=string]` , `[label, dtype=string]` .
**异常：**
@ -64,11 +64,6 @@ mindspore.dataset.CLUEDataset
- **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
- **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
**样例：**
>>> clue_dataset_dir = ["/path/to/clue_dataset_file"] # 包含一个或多个CLUE数据集文件
>>> dataset = ds.CLUEDataset(dataset_files=clue_dataset_dir, task='AFQMC', usage='train')
**关于CLUE数据集：**
CLUE，又名中文语言理解测评基准，包含许多有代表性的数据集，涵盖单句分类、句对分类和机器阅读理解等任务。

7
docs/api/api_python/dataset/mindspore.dataset.CSVDataset.rst
View File

@ -14,7 +14,7 @@
- **num_samples** (int, 可选) - 指定从数据集中读取的样本数。默认值：None，读取全部样本。
- **num_parallel_workers** (int, 可选) - 指定读取数据的工作线程数。默认值：None，使用mindspore.dataset.config中配置的线程数。
- **shuffle** (Union[bool, Shuffle], 可选) - 每个epoch中数据混洗的模式，支持传入bool类型与枚举类型进行指定，默认值：mindspore.dataset.Shuffle.GLOBAL。
如果`shuffle`为False，则不混洗，如果`shuffle`为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。
如果 `shuffle` 为False，则不混洗，如果 `shuffle` 为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。
通过传入枚举变量设置数据混洗的模式：
- **Shuffle.GLOBAL**：混洗文件和文件中的数据。
@ -31,11 +31,6 @@
- **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
- **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
**样例：**
>>> csv_dataset_dir = ["/path/to/csv_dataset_file"] # 此列表可以包含一个或多个CSV文件
>>> dataset = ds.CSVDataset(dataset_files=csv_dataset_dir, column_names=['col1', 'col2', 'col3', 'col4'])
.. include:: mindspore.dataset.Dataset.rst
.. include:: mindspore.dataset.Dataset.zip.rst

13
docs/api/api_python/dataset/mindspore.dataset.CelebADataset.rst
View File

@ -5,7 +5,7 @@ mindspore.dataset.CelebADataset
读取和解析CelebA数据集的源文件构建数据集。目前仅支持解析CelebA数据集中的 `list_attr_celeba.txt` 文件作为数据集的label。
生成的数据集有两列 `[image, attr]`。`image` 列的数据类型为uint8。`attr` 列的数据类型为uint32，并以one-hot编码的形式生成。
生成的数据集有两列 `[image, attr]` 。 `image` 列的数据类型为uint8。`attr` 列的数据类型为uint32，并以one-hot编码的形式生成。
**参数：**
@ -19,7 +19,7 @@ mindspore.dataset.CelebADataset
- **num_samples** (int, 可选) - 指定从数据集中读取的样本数，可以小于数据集总数。默认值：None，读取全部样本图片。
- **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数，默认值：None。指定此参数后， `num_samples` 表示每个分片的最大样本数。
- **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号，默认值：None。只有当指定了 `num_shards` 时才能指定此参数。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读`单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读 `单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
**异常：**
@ -59,15 +59,6 @@ mindspore.dataset.CelebADataset
- False
- 不允许
**样例：**
>>> celeba_dataset_dir = "/path/to/celeba_dataset_directory"
>>>
>>> # 从CelebA数据集中随机读取5张样本图片
>>> dataset = ds.CelebADataset(dataset_dir=celeba_dataset_dir, usage='train', num_samples=5)
>>>
>>> # 注：在生成的数据集对象中，每一次迭代得到的数据行都有"image"和"attr" 两个键
**关于CelebA数据集：**
CelebFaces Attributes Dataset（CelebA）数据集是一个大规模的人脸属性数据集，拥有超过20万张名人图像，每个图像都有40个属性标注。此数据集包含了大量不同姿态、各种背景的人脸图像，种类丰富、数量庞大、标注充分。数据集总体包含：

16
docs/api/api_python/dataset/mindspore.dataset.Cifar100Dataset.rst
View File

@ -5,7 +5,7 @@ mindspore.dataset.Cifar100Dataset
读取和解析CIFAR-100数据集的源文件构建数据集。
生成的数据集有三列: `[image, coarse_label, fine_label]`。 `image` 列的数据类型为uint8。 `coarse_label` 和 `fine_labels` 列的数据类型为uint32。
生成的数据集有三列: `[image, coarse_label, fine_label]` 。 `image` 列的数据类型为uint8。 `coarse_label` 和 `fine_labels` 列的数据类型为uint32。
**参数：**
@ -18,7 +18,7 @@ mindspore.dataset.Cifar100Dataset
- **sampler** (Sampler, 可选) - 指定从数据集中选取样本的采样器，默认值：None，下表中会展示不同配置的预期行为。
- **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数，默认值：None。指定此参数后， `num_samples` 表示每个分片的最大样本数。
- **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号，默认值：None。只有当指定了 `num_shards` 时才能指定此参数。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读`单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读 `单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
**异常：**
@ -58,18 +58,6 @@ mindspore.dataset.Cifar100Dataset
- False
- 不允许
**样例：**
>>> cifar100_dataset_dir = "/path/to/cifar100_dataset_directory"
>>>
>>> # 1) 按数据集文件的读取顺序，依次获取CIFAR-100数据集中的所有样本
>>> dataset = ds.Cifar100Dataset(dataset_dir=cifar100_dataset_dir, shuffle=False)
>>>
>>> # 2) 从CIFAR100数据集中随机抽取350个样本
>>> dataset = ds.Cifar100Dataset(dataset_dir=cifar100_dataset_dir, num_samples=350, shuffle=True)
>>>
>>> # 提示： 在CIFAR-100数据集生成的数据集对象中，每一次迭代得到的数据行都有"image", "fine_label" 和 "coarse_label"三个键
**关于CIFAR-100数据集:**
CIFAR-100数据集和CIFAR-10数据集非常相似，CIFAR-100有100个类别，每类包含600张图片，其中500张训练图片和100张测试图片。这100个类别又被分成20个超类。每个图片都有一个"fine"标签（所属子类）和一个"coarse"标签(所属超类)。

19
docs/api/api_python/dataset/mindspore.dataset.Cifar10Dataset.rst
View File

@ -5,7 +5,7 @@ mindspore.dataset.Cifar10Dataset
读取和解析CIFAR-10数据集的源文件构建数据集。该API目前仅支持解析二进制版本的CIFAR-10文件（CIFAR-10 binary version）。
生成的数据集有两列: `[image, label]`。`image` 列的数据类型是uint8。`label` 列的数据类型是uint32。
生成的数据集有两列: `[image, label]` 。 `image` 列的数据类型是uint8。`label` 列的数据类型是uint32。
**参数：**
@ -18,7 +18,7 @@ mindspore.dataset.Cifar10Dataset
- **sampler** (Sampler, 可选) - 指定从数据集中选取样本的采样器，默认值：None，下表中会展示不同配置的预期行为。
- **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数，默认值：None。指定此参数后， `num_samples` 表示每个分片的最大样本数。
- **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号，默认值：None。只有当指定了 `num_shards` 时才能指定此参数。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读`单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读 `单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
**异常：**
@ -58,21 +58,6 @@ mindspore.dataset.Cifar10Dataset
- False
- 不允许
**样例：**
>>> cifar10_dataset_dir = "/path/to/cifar10_dataset_directory"
>>>
>>> # 1) 按数据集文件的读取顺序，获取CIFAR-10数据集中的所有样本
>>> dataset = ds.Cifar10Dataset(dataset_dir=cifar10_dataset_dir, shuffle=False)
>>>
>>> # 2) 从CIFAR10数据集中随机抽取350个样本
>>> dataset = ds.Cifar10Dataset(dataset_dir=cifar10_dataset_dir, num_samples=350, shuffle=True)
>>>
>>> # 3) 对CIFAR10数据集进行分布式训练，并将数据集拆分为2个分片，当前数据集仅加载分片ID号为0的数据
>>> dataset = ds.Cifar10Dataset(dataset_dir=cifar10_dataset_dir, num_shards=2, shard_id=0)
>>>
>>> # 提示：在CIFAR-10数据集生成的数据集对象中，每一次迭代得到的数据行都有"image"和"label"两个键
**关于CIFAR-10数据集:**
CIFAR-10数据集由60000张32x32彩色图片组成，总共有10个类别，每类6000张图片。有50000个训练样本和10000个测试样本。10个类别包含飞机、汽车、鸟类、猫、鹿、狗、青蛙、马、船和卡车。

39
docs/api/api_python/dataset/mindspore.dataset.CocoDataset.rst
View File

@ -17,15 +17,15 @@
- **sampler** (Sampler, 可选) - 指定从数据集中选取样本的采样器，默认值：None，下表中会展示不同配置的预期行为。
- **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数，默认值：None。指定此参数后， `num_samples` 表示每个分片的最大样本数。
- **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号，默认值：None。只有当指定了 `num_shards` 时才能指定此参数。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读`单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读 `单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **extra_metadata** (bool, 可选) - 用于指定是否额外输出一个数据列用于表示图片元信息。如果为True，则将额外输出一个名为 `[_meta-filename, dtype=string]` 的数据列，默认值：False。
根据不同 `task` 参数设置，生成数据集具有不同的输出列：
- `task` = 'Detection', 输出列: `[image, dtype=uint8]`, `[bbox, dtype=float32]`, `[category_id, dtype=uint32]`, `[iscrowd, dtype=uint32]`。
- `task` = 'Stuff', 输出列: `[image, dtype=uint8]`, `[segmentation,dtype=float32]`, `[iscrowd,dtype=uint32]`。
- `task` = 'Keypoint', 输出列: `[image, dtype=uint8]`, `[keypoints, dtype=float32]`, `[num_keypoints, dtype=uint32]`。
- `task` = 'Panoptic', 输出列: `[image, dtype=uint8]`, `[bbox, dtype=float32]`, `[category_id, dtype=uint32]`, `[iscrowd, dtype=uint32]`, `[area, dtype=uint32]`。
- `task` = 'Detection', 输出列: `[image, dtype=uint8]` , `[bbox, dtype=float32]` , `[category_id, dtype=uint32]` , `[iscrowd, dtype=uint32]` 。
- `task` = 'Stuff', 输出列: `[image, dtype=uint8]` , `[segmentation,dtype=float32]` , `[iscrowd,dtype=uint32]` 。
- `task` = 'Keypoint', 输出列: `[image, dtype=uint8]` , `[keypoints, dtype=float32]` , `[num_keypoints, dtype=uint32]` 。
- `task` = 'Panoptic', 输出列: `[image, dtype=uint8]` , `[bbox, dtype=float32]` , `[category_id, dtype=uint32]` , `[iscrowd, dtype=uint32]` , `[area, dtype=uint32]` 。
**异常：**
@ -36,7 +36,7 @@
- **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
- **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
- **RuntimeError** - 解析 `annotation_file` 指定的JSON文件失败。
- **ValueError** - `task` 参数取值不为 `Detection`、`Stuff`、`Panoptic` 或 `Keypoint`。
- **ValueError** - `task` 参数取值不为 `Detection` 、 `Stuff` 、`Panoptic` 或 `Keypoint` 。
- **ValueError** - `annotation_file` 参数对应的文件不存在。
- **ValueError** - `dataset_dir` 参数路径不存在。
- **ValueError** - `shard_id` 参数值错误（小于0或者大于等于 `num_shards` ）。
@ -73,33 +73,6 @@
- False
- 不允许
**样例：**
>>> coco_dataset_dir = "/path/to/coco_dataset_directory/images"
>>> coco_annotation_file = "/path/to/coco_dataset_directory/annotation_file"
>>>
>>> # 1）读取COCO数据集中 `Detection` 任务中的数据。
>>> dataset = ds.CocoDataset(dataset_dir=coco_dataset_dir,
... annotation_file=coco_annotation_file,
... task='Detection')
>>>
>>> # 2）读取COCO数据集中 `Stuff` 任务中的数据。
>>> dataset = ds.CocoDataset(dataset_dir=coco_dataset_dir,
... annotation_file=coco_annotation_file,
... task='Stuff')
>>>
>>> # 3）读取COCO数据集中 `Panoptic` 任务中的数据。
>>> dataset = ds.CocoDataset(dataset_dir=coco_dataset_dir,
... annotation_file=coco_annotation_file,
... task='Panoptic')
>>>
>>> # 4）读取COCO数据集中 `Keypoint` 任务中的数据。
>>> dataset = ds.CocoDataset(dataset_dir=coco_dataset_dir,
... annotation_file=coco_annotation_file,
... task='Keypoint')
>>>
>>> # 在生成的COCO数据集对象中，每一次迭代得到的数据行都有"image"和"annotation"两个键。
**关于COCO数据集：**
Microsoft Common Objects in Context（COCO）是一个大型数据集，该数据集专门为目标检测，语义分割和字幕生成任务而设计。它拥有330K张图像（标记数量大于200K个）、1500000个目标实例、80个目标类别、91个对象类别、每张图片均有5个字幕、带关键点标注的人有250000个。与流行的ImageNet数据集相比，COCO的类别较少，但每个类别中的图片样本非常多。

12
docs/api/api_python/dataset/mindspore.dataset.DSCallback.rst
View File

@ -11,18 +11,6 @@ mindspore.dataset.DSCallback
- **step_size** (int, optional) - 定义相邻的 `ds_step_begin`/`ds_step_end` 调用之间相隔的step数，默认值：1，表示每个step都会调用。
**样例：**
>>> from mindspore.dataset import DSCallback
>>>
>>> class PrintInfo(DSCallback):
... def ds_epoch_end(self, ds_run_context):
... print(cb_params.cur_epoch_num)
... print(cb_params.cur_step_num)
>>>
>>> # dataset为任意数据集实例，op为任意数据处理算子
>>> dataset = dataset.map(operations=op, callbacks=PrintInfo())
.. py:method:: ds_begin(ds_run_context)
用于定义在数据处理管道启动前执行的回调方法。

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

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

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

@ -10,19 +10,6 @@
执行了给定操作函数的数据集对象。
**样例：**
>>> # dataset是任意数据集对象的实例
>>>
>>> # 声明一个名为apply_func函数，对数据集对象执行batch操作，并返回值处理后的Dataset对象
>>> # 注意apply_func函数的输入参数data需要为 `Dataset` 对象
>>> def apply_func(data):
... data = data.batch(2)
... return data
>>>
>>> # 通过apply操作调用apply_func函数，得到处理后的数据集对象
>>> dataset = dataset.apply(apply_func)
**异常：**
- **TypeError：** `apply_func` 的类型不是函数。
@ -64,35 +51,6 @@
Dataset， `batch` 操作后的数据集对象。
**样例：**
>>> # 1）创建一个数据集对象，每100条数据合并成一个批处理数据
>>> # 如果最后一个批次数据小于给定的批次大小（batch_size)，则丢弃这个批次
>>> dataset = dataset.batch(100, True)
>>>
>>> # 2）根据批次编号调整图像大小，如果是第5批，则图像大小调整为(5^2, 5^2) = (25, 25)
>>> def np_resize(col, BatchInfo):
... output = col.copy()
... s = (BatchInfo.get_batch_num() + 1) ** 2
... index = 0
... for c in col:
... img = Image.fromarray(c.astype('uint8')).convert('RGB')
... img = img.resize((s, s), Image.ANTIALIAS)
... output[index] = np.array(img)
... index += 1
... return (output,)
>>> dataset = dataset.batch(batch_size=8, input_columns=["image"], per_batch_map=np_resize)
>>>
>>> # 3）创建一个数据集对象，动态指定批处理大小
>>> # 定义一个批处理函数，每次将batch_size加一
>>> def add_one(BatchInfo):
... return BatchInfo.get_batch_num() + 1
>>> dataset = dataset.batch(batch_size=add_one, drop_remainder=True)
>>>
>>> # 4）创建一个数据集对象，并执行batch数据，指定column_order更换数据列顺序
>>> # 假设数据集对象的数据列原顺序是["image", "label"]
>>> dataset = dataset.batch(32, column_order=["label", "image"])
.. py:method:: bucket_batch_by_length(column_names, bucket_boundaries, bucket_batch_sizes, element_length_function=None, pad_info=None, pad_to_bucket_boundary=False, drop_remainder=False)
根据数据的长度进行分桶，每个桶将在数据填满的时候进行填充和批处理操作。
@ -120,28 +78,6 @@
Dataset，按长度进行分桶和批处理操作后的数据集对象。
**样例：**
>>> # 创建一个数据集对象，其中给定条数的数据会被组成一个批次数据
>>> # 如果最后一个批次数据小于给定的批次大小（batch_size)，则丢弃这个批次
>>> import numpy as np
>>> def generate_2_columns(n):
... for i in range(n):
... yield (np.array([i]), np.array([j for j in range(i + 1)]))
>>>
>>> column_names = ["col1", "col2"]
>>> dataset = ds.GeneratorDataset(generate_2_columns(8), column_names)
>>> bucket_boundaries = [5, 10]
>>> bucket_batch_sizes = [2, 1, 1]
>>> element_length_function = (lambda col1, col2: max(len(col1), len(col2)))
>>> # 将对列名为"col2"的列进行填充，填充后的shape为[bucket_boundaries[i]]，其中i是当前正在批处理的桶的索引
>>> pad_info = {"col2": ([None], -1)}
>>> pad_to_bucket_boundary = True
>>> dataset = dataset.bucket_batch_by_length(column_names, bucket_boundaries,
... bucket_batch_sizes,
... element_length_function, pad_info,
... pad_to_bucket_boundary)
.. py:method:: build_sentencepiece_vocab(columns, vocab_size, character_coverage, model_type, params)
迭代源数据集对象获取数据并构建SentencePiece词汇表。
@ -160,17 +96,6 @@
构建好的SentencePiece词汇表。
**样例：**
>>> from mindspore.dataset.text import SentencePieceModel
>>>
>>> # DE_C_INTER_SENTENCEPIECE_MODE 是一个映射字典
>>> from mindspore.dataset.text.utils import DE_C_INTER_SENTENCEPIECE_MODE
>>> dataset = ds.TextFileDataset("/path/to/sentence/piece/vocab/file", shuffle=False)
>>> dataset = dataset.build_sentencepiece_vocab(["text"], 5000, 0.9995,
... DE_C_INTER_SENTENCEPIECE_MODE[SentencePieceModel.UNIGRAM],
... {})
.. py:method:: build_vocab(columns, freq_range, top_k, special_tokens, special_first)
迭代源数据集对象获取数据并构建词汇表。
@ -191,20 +116,6 @@
构建好的词汇表。
**样例：**
>>> def gen_corpus():
... # key：单词，value：出现次数，键的取值采用字母表示有利于排序和显示。
... corpus = {"Z": 4, "Y": 4, "X": 4, "W": 3, "U": 3, "V": 2, "T": 1}
... for k, v in corpus.items():
... yield (np.array([k] * v, dtype='S'),)
>>> column_names = ["column1", "column2", "column3"]
>>> dataset = ds.GeneratorDataset(gen_corpus, column_names)
>>> dataset = dataset.build_vocab(columns=["column3", "column1", "column2"],
... freq_range=(1, 10), top_k=5,
... special_tokens=["<pad>", "<unk>"],
... special_first=True,vocab='vocab')
.. py:method:: close_pool()
关闭数据集对象中的多进程池。如果您熟悉多进程库，可以将此视为进程池对象的析构函数。
@ -224,13 +135,6 @@
Dataset，拼接后的数据集对象。
**样例：**
>>> # 使用"+"运算符拼接dataset_1和dataset_2，获得拼接后的数据集对象
>>> dataset = dataset_1 + dataset_2
>>> # 通过concat操作拼接dataset_1和dataset_2，获得拼接后的数据集对象
>>> dataset = dataset_1.concat(dataset_2)
.. py:method:: create_dict_iterator(num_epochs=-1, output_numpy=False)
基于数据集对象创建迭代器，输出的数据为字典类型。
@ -244,16 +148,6 @@
DictIterator，基于数据集对象创建的字典迭代器。
**样例：**
>>> # dataset是任意数据集对象的实例
>>> iterator = dataset.create_dict_iterator()
>>> for item in iterator:
... # item 是一个dict
... print(type(item))
... break
<class 'dict'>
.. py:method:: create_tuple_iterator(columns=None, num_epochs=-1, output_numpy=False, do_copy=True)
基于数据集对象创建迭代器，输出数据为ndarray组成的列表。
@ -271,16 +165,6 @@
TupleIterator，基于数据集对象创建的元组迭代器。
**样例：**
>>> # dataset是任意数据集对象的实例
>>> iterator = dataset.create_tuple_iterator()
>>> for item in iterator：
... # item 是一个list
... print(type(item))
... break
<class 'list'>
.. py:method:: device_que(send_epoch_end=True, create_data_info_queue=False)
将数据异步传输到Ascend/GPU设备上。
@ -306,18 +190,6 @@
两个列表代表最小shape和最大shape，每个列表中的shape按照数据列的顺序排列。
**样例：**
>>> import numpy as np
>>>
>>> def generator1():
>>> for i in range(1, 100):
>>> yield np.ones((16, i, 83)), np.array(i)
>>>
>>> dataset = ds.GeneratorDataset(generator1, ["data1", "data2"])
>>> dataset.set_dynamic_columns(columns={"data1": [16, None, 83], "data2": []})
>>> min_shapes, max_shapes = dataset.dynamic_min_max_shapes()
.. py:method:: filter(predicate, input_columns=None, num_parallel_workers=None)
@ -334,16 +206,6 @@
Dataset，执行给定筛选过滤操作的数据集对象。
**样例：**
>>> # 生成一个list，其取值范围为（0，63）
>>> def generator_1d():
... for i in range(64):
... yield (np.array(i),)
>>> dataset = ds.GeneratorDataset(generator_1d, ["data"])
>>> # 过滤掉数值大于或等于11的数据
>>> dataset = dataset.filter(predicate=lambda data: data < 11, input_columns = ["data"])
.. py:method:: flat_map(func)
@ -357,21 +219,6 @@
执行给定操作后的数据集对象。
**样例：**
>>> # 以NumpySlicesDataset为例
>>> dataset = ds.NumpySlicesDataset([[0, 1], [2, 3]])
>>>
>>> def flat_map_func(array):
... # 使用数组创建NumpySlicesDataset
... dataset = ds.NumpySlicesDataset(array)
... # 将数据集对象中的数据重复两次
... dataset = dataset.repeat(2)
... return dataset
>>>
>>> dataset = dataset.flat_map(flat_map_func)
>>> # [[0, 1], [0, 1], [2, 3], [2, 3]]
**异常：**
- **TypeError** - `func` 不是函数。
@ -385,12 +232,6 @@
int，一个批处理数据中包含的数据条数。
**样例：**
>>> # dataset是任意数据集对象的实例
>>> dataset = dataset.batch(16)
>>> batch_size = dataset.get_batch_size()
.. py:method:: get_class_indexing()
返回类别索引。
@ -399,11 +240,6 @@
dict，描述类别名称到索引的键值对映射关系，通常为str-to-int格式。针对COCO数据集，类别名称到索引映射关系描述形式为str-to-list<int>格式，列表中的第二个数字表示超级类别。
**样例：**
>>> # dataset是数据集类的实例化对象
>>> class_indexing = dataset.get_class_indexing()
.. py:method:: get_col_names()
@ -413,11 +249,6 @@
list，数据集中所有列名组成列表。
**样例：**
>>> # dataset是数据集类的实例化对象
>>> col_names = dataset.get_col_names()
.. py:method:: get_dataset_size()
返回一个epoch中的batch数。
@ -443,14 +274,6 @@
input index信息的元组。
**样例：**
>>> # dataset是Dataset对象的实例
>>> # 设置input_indexs
>>> dataset.input_indexs = 10
>>> print(dataset.input_indexs)
10
.. py:method:: map(operations, input_columns=None, output_columns=None, column_order=None, num_parallel_workers=None, python_multiprocessing=False, cache=None, callbacks=None)
给定一组数据增强列表，按顺序将数据增强作用在数据集对象上。
@ -482,95 +305,6 @@
MapDataset，map操作后的数据集。
**样例：**
>>> # dataset是Dataset对象的一个实例，它有2列，"image"和"label"。
>>>
>>> # 定义两个operation，每个operation接受1列输入，输出1列。
>>> decode_op = c_vision.Decode(rgb=True)
>>> random_jitter_op = c_vision.RandomColorAdjust(brightness=(0.8, 0.8), contrast=(1, 1),
... saturation=(1, 1), hue=(0, 0))
>>>
>>> # 1）简单的map示例。
>>>
>>> # 对"image"对应的数据列进行"decode_op"操作。
>>> # 由于未指定column_order，因此"image"
>>> # 和"label"2列将按其原来的顺序传播到下一个操作。
>>> dataset = dataset.map(operations=[decode_op], input_columns=["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"，并指定输出列的顺序。
>>> dataset = dataset.map(operations=[decode_op], input_columns=["image"],
... output_columns=["decoded_image"], column_order=["label", "decoded_image"])
>>>
>>> # 将"image"重命名为"decoded_image"，并只保留此列。
>>> dataset = dataset.map(operations=[decode_op], input_columns=["image"],
... output_columns=["decoded_image"], column_order=["decoded_image"])
>>>
>>> # 使用用户自定义Python函数的map简单示例。列重命名和指定列顺序
>>> # 的方式同前面的示例相同。
>>> dataset = ds.NumpySlicesDataset(data=[[0, 1, 2]], column_names=["data"])
>>> dataset = dataset.map(operations=[(lambda x: x + 1)], input_columns=["data"])
>>>
>>> # 2）多个operation的map示例。
>>>
>>> # 创建一个数据集，图像被解码，并随机颜色抖动。
>>> # 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相同。
>>> dataset = dataset.map(operations=[decode_op, random_jitter_op], input_columns=["image"],
... output_columns=["image_mapped"])
>>>
>>> # 使用用户自定义Python函数的多个operation的map示例。列重命名和指定列顺序
>>> # 的方式与示例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）输入列数和输出列数不等的示例。
>>>
>>> # operation[i]均为lambda函数。
>>> #
>>> # operation[0]输入2列并输出3列。
>>> # operations[1]输入3列并输出1列。
>>> # operations[2]输入1列并输出4列。
>>> #
>>> # 注：operation[i]的输出列数必须等于
>>> # operation[i+1]的输入列。否则，map算子会
>>> # 出错。
>>> operations = [(lambda x, y: (x, x + y, x + y + 1)),
... (lambda x, y, z: x * y * z),
... (lambda x: (x % 2, x % 3, x % 5, x % 7))]
>>>
>>> # 注：由于输入列数与
>>> # 输出列数不相同，必须指定output_columns和column_order
>>> # 参数。否则，此map算子也会出错。
>>>
>>> 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()
获取数据集对象中所有样本的类别数目。
@ -608,14 +342,6 @@
ProjectDataset，project操作后的数据集对象。
**样例：**
>>> # dataset是Dataset对象的实例
>>> columns_to_project = ["column3", "column1", "column2"]
>>>
>>> # 创建一个数据集，无论列的原始顺序如何，依次包含column3, column1, column2。
>>> dataset = dataset.project(columns=columns_to_project)
.. py:method:: rename(input_columns, output_columns)
对数据集对象按指定的列名进行重命名。
@ -629,17 +355,6 @@
RenameDataset，rename操作后的数据集对象。
**样例：**
>>> # dataset是Dataset对象的实例
>>> input_columns = ["input_col1", "input_col2", "input_col3"]
>>> output_columns = ["output_col1", "output_col2", "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，则无限重复。
@ -655,23 +370,6 @@
RepeatDataset，repeat操作后的数据集对象。
**样例：**
>>> # dataset是Dataset对象的实例
>>>
>>> # 创建一个数据集，数据集重复50个epoch。
>>> dataset = dataset.repeat(50)
>>>
>>> # 创建一个数据集，其中每个epoch都是独立混洗的。
>>> dataset = dataset.shuffle(10)
>>> dataset = dataset.repeat(50)
>>>
>>> # 创建一个数据集，混洗前先将数据集重复
>>> # 50个epoch。shuffle算子将
>>> # 整个50个epoch视作一个大数据集。
>>> dataset = dataset.repeat(50)
>>> dataset = dataset.shuffle(10)
.. py:method:: reset()
重置下一个epoch的数据集对象。
@ -775,14 +473,6 @@
- **RuntimeError** - 混洗前存在通过 `dataset.sync_wait` 进行同步操作。
**样例：**
>>> # dataset是Dataset对象的实例
>>> # 可以选择设置第一个epoch的种子
>>> ds.config.set_seed(58)
>>> # 使用大小为4的shuffle缓冲区创建打乱后的数据集。
>>> dataset = dataset.shuffle(4)
.. py:method:: skip(count)
跳过此数据集对象的前 `count` 条数据。
@ -795,12 +485,6 @@
SkipDataset，跳过指定条数据后的数据集对象。
**样例：**
>>> # dataset是Dataset对象的实例
>>> # 创建一个数据集对象，跳过前3条数据
>>> dataset = dataset.skip(3)
.. py:method:: split(sizes, randomize=True)
将数据集拆分为多个不重叠的子数据集。
@ -834,11 +518,6 @@
tuple(Dataset)，split操作后子数据集对象的元组。
**样例：**
>>> dataset = ds.TextFileDataset(text_file_dataset_dir, shuffle=False)
>>> train_dataset, test_dataset = dataset.split([0.9, 0.1])
.. py:method:: sync_update(condition_name, num_batch=None, data=None)
释放阻塞条件并使用给定数据触发回调函数。
@ -867,37 +546,6 @@
- **RuntimeError** - 条件名称已存在。
**样例：**
>>> import numpy as np
>>> def gen():
... for i in range(100)：
... yield (np.array(i),)
>>>
>>> class Augment:
... def __init__(self, loss)：
... self.loss = loss
...
... def preprocess(self, input_)：
... return input_
...
... def update(self, data)：
... self.loss = data["loss"]
>>>
>>> batch_size = 4
>>> dataset = ds.GeneratorDataset(gen, column_names=["input"])
>>>
>>> aug = Augment(0)
>>> dataset = dataset.sync_wait(condition_name="policy", callback=aug.update)
>>> dataset = dataset.map(operations=[aug.preprocess], input_columns=["input"])
>>> dataset = dataset.batch(batch_size)
>>> count = 0
>>> for data in dataset.create_dict_iterator(num_epochs=1, output_numpy=True)：
... assert data["input"][0] == count
... count += batch_size
... data = {"loss": count}
... dataset.sync_update(condition_name="policy", data=data)
.. py:method:: take(count=-1)
从数据集中获取最多 `count` 的元素。
@ -914,12 +562,6 @@
TakeDataset，take操作后的数据集对象。
**样例：**
>>> # dataset是Dataset对象的实例。
>>> # 创建一个数据集对象，包含50条数据。
>>> dataset = dataset.take(50)
.. py:method:: to_device(send_epoch_end=True, create_data_info_queue=False)
将数据从CPU传输到GPU、Ascend或其他设备。

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

@ -5,10 +5,3 @@
**参数：**
- **new_sampler** (Sampler) ：替换的新采样器。
**样例：**
>>> # dataset为任意数据集对象的实例
>>> # 将dataset的采样器更换为DistributedSampler
>>> new_sampler = ds.DistributedSampler(10, 2)
>>> dataset.use_sampler(new_sampler)

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

@ -9,8 +9,3 @@
**返回：**
ZipDataset，合并压缩后的数据集对象。
**样例：**
>>> # 创建一个数据集，它将dataset和dataset_1进行合并
>>> dataset = dataset.zip(dataset_1)

30
docs/api/api_python/dataset/mindspore.dataset.DatasetCache.rst
View File

@ -18,36 +18,6 @@ mindspore.dataset.DatasetCache
- **num_connections** (int, optional) - TCP/IP连接数量。默认值：None，表示连接数量为12。
- **prefetch_size** (int, optional) - 指定缓存队列大小，使用缓存功能算子时，将直接从缓存队列中获取数据。默认值：None，表示缓存队列大小为20。
**样例：**
>>> import mindspore.dataset as ds
>>>
>>> # 创建数据缓存客户端实例，其中 `session_id` 由命令 `cache_admin -g` 生成
>>> some_cache = ds.DatasetCache(session_id=session_id, size=0)
>>>
>>> dataset_dir = "path/to/imagefolder_directory"
>>> ds1 = ds.ImageFolderDataset(dataset_dir, cache=some_cache)
.. py:method:: get_stat()
获取缓存实例的统计信息。在数据管道结束后，可获取三类统计信息，包括平均缓存命中数（avg_cache_sz），内存中的缓存数（num_mem_cached）和磁盘中的缓存数（num_disk_cached）。
**样例：**
>>> import mindspore.dataset as ds
>>>
>>> # 创建数据缓存客户端实例，其中 `session_id` 由命令 `cache_admin -g` 生成
>>> some_cache = ds.DatasetCache(session_id=session_id, size=0)
>>>
>>> dataset_dir = "path/to/imagefolder_directory"
>>> ds1 = ds.ImageFolderDataset(dataset_dir, cache=some_cache)
>>> for _ in ds1.create_dict_iterator(num_epochs=1):
... pass
>>> # 数据管道执行结束之后，才能获取cache的统计信息
>>> stat = some_cache.get_stat()
>>> # 获取平均缓存命中数（avg_cache_sz）
>>> cache_sz = stat.avg_cache_sz
>>> # 获取内存中的缓存数（num_mem_cached）
>>> num_mem_cached = stat.num_mem_cached
>>> # 获取磁盘中的缓存数（num_disk_cached）
>>> num_dick_cached = stat.num_disk_cached

8
docs/api/api_python/dataset/mindspore.dataset.DistributedSampler.rst
View File

@ -25,12 +25,4 @@ mindspore.dataset.DistributedSampler
- **RuntimeError** - `shard_id` 小于0或大于等于 `num_shards` 。
- **RuntimeError** - `offset` 大于 `num_shards` 。
**样例：**
>>> # 创建一个分布式采样器，共10个分片。当前分片为分片5。
>>> sampler = ds.DistributedSampler(10, 5)
>>> dataset = ds.ImageFolderDataset(image_folder_dataset_dir,
... num_parallel_workers=8,
... sampler=sampler)
.. include:: mindspore.dataset.BuiltinSampler.rst

59
docs/api/api_python/dataset/mindspore.dataset.GeneratorDataset.rst
View File

@ -69,65 +69,6 @@
- False
- 不允许
**样例：**
>>> import numpy as np
>>>
>>> # 1）定义一个Python生成器作为GeneratorDataset的可调用对象。
>>> def generator_multidimensional():
... for i in range(64):
... yield (np.array([[i, i + 1], [i + 2, i + 3]]),)
>>>
>>> dataset = ds.GeneratorDataset(source=generator_multidimensional, column_names=["multi_dimensional_data"])
>>>
>>> # 2）定义一个Python生成器返回多列数据，作为GeneratorDataset的可调用对象。
>>> def generator_multi_column():
... for i in range(64):
... yield np.array([i]), np.array([[i, i + 1], [i + 2, i + 3]])
>>>
>>> dataset = ds.GeneratorDataset(source=generator_multi_column, column_names=["col1", "col2"])
>>>
>>> # 3）定义一个可迭代数据集对象，作为GeneratorDataset的可调用对象。
>>> class MyIterable:
... def __init__(self):
... self._index = 0
... self._data = np.random.sample((5, 2))
... self._label = np.random.sample((5, 1))
...
... def __next__(self):
... if self._index >= len(self._data):
... raise StopIteration
... else:
... item = (self._data[self._index], self._label[self._index])
... self._index += 1
... return item
...
... def __iter__(self):
... self._index = 0
... return self
...
... def __len__(self):
... return len(self._data)
>>>
>>> dataset = ds.GeneratorDataset(source=MyIterable(), column_names=["data", "label"])
>>>
>>> # 4）定义一个支持随机访问数据集对象，作为GeneratorDataset的可调用对象。
>>> class MyAccessible:
... def __init__(self):
... self._data = np.random.sample((5, 2))
... self._label = np.random.sample((5, 1))
...
... def __getitem__(self, index):
... return self._data[index], self._label[index]
...
... def __len__(self):
... return len(self._data)
>>>
>>> dataset = ds.GeneratorDataset(source=MyAccessible(), column_names=["data", "label"])
>>>
>>> # 注意，Python的list、dict、tuple也是支持随机可访问的，同样可以作为GeneratorDataset的输入
>>> dataset = ds.GeneratorDataset(source=[(np.array(0),), (np.array(1),), (np.array(2),)], column_names=["col"])
.. include:: mindspore.dataset.Dataset.add_sampler.rst
.. include:: mindspore.dataset.Dataset.rst

69
docs/api/api_python/dataset/mindspore.dataset.GraphData.rst
View File

@ -20,13 +20,6 @@ mindspore.dataset.GraphData
- **num_client** (int, 可选) - 期望连接到服务器的最大客户端数。服务器将根据该参数分配资源。该参数仅在工作模式设置为 'server' 时有效，默认值：1。
- **auto_shutdown** (bool, 可选) - 当工作模式设置为 'server' 时有效。当连接的客户端数量达到 `num_client` ，且没有客户端正在连接时，服务器将自动退出，默认值：True。
**样例：**
>>> graph_dataset_dir = "/path/to/graph_dataset_file"
>>> graph_dataset = ds.GraphData(dataset_file=graph_dataset_dir, num_parallel_workers=2)
>>> nodes = graph_dataset.get_all_nodes(node_type=1)
>>> features = graph_dataset.get_node_feature(node_list=nodes, feature_types=[1])
.. py:method:: get_all_edges(edge_type)
@ -34,7 +27,7 @@ mindspore.dataset.GraphData
**参数：**
- **edge_type** (int) - 指定边的类型，在数据集转换为MindRecord格式时，需要指定`edge_type`的值，并在此API中对应使用。详见 `加载图数据集 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/load_dataset_gnn.html>`_ 。
- **edge_type** (int) - 指定边的类型，在数据集转换为MindRecord格式时，需要指定 `edge_type` 的值，并在此API中对应使用。详见 `加载图数据集 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/load_dataset_gnn.html>`_ 。
**返回：**
@ -44,10 +37,6 @@ mindspore.dataset.GraphData
**TypeError**：参数 `edge_type` 的类型不为整型。
**样例：**
>>> edges = graph_dataset.get_all_edges(edge_type=0)
.. py:method:: get_all_neighbors(node_list, neighbor_type, output_format=<OutputFormat.NORMAL)
获取 `node_list` 所有节点的相邻节点，以 `neighbor_type` 类型返回。格式的定义参见以下示例：1表示两个节点之间连接，0表示不连接。
@ -151,23 +140,13 @@ mindspore.dataset.GraphData
- **TypeError** - 参数 `node_list` 的类型不为列表或numpy.ndarray。
- **TypeError** - 参数 `neighbor_type` 的类型不为整型。
**样例：**
>>> from mindspore.dataset.engine import OutputFormat
>>> nodes = graph_dataset.get_all_nodes(node_type=1)
>>> neighbors = graph_dataset.get_all_neighbors(node_list=nodes, neighbor_type=2)
>>> neighbors_coo = graph_dataset.get_all_neighbors(node_list=nodes, neighbor_type=2,
... output_format=OutputFormat.COO)
>>> offset_table, neighbors_csr = graph_dataset.get_all_neighbors(node_list=nodes, neighbor_type=2,
... output_format=OutputFormat.CSR)
.. py:method:: get_all_nodes(node_type)
获取图中的所有节点。
**参数：**
- **node_type** (int) - 指定节点的类型。在数据集转换为MindRecord格式时，需要指定`node_type`的值，并在此API中对应使用。详见 `加载图数据集 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/load_dataset_gnn.html>`_ 。
- **node_type** (int) - 指定节点的类型。在数据集转换为MindRecord格式时，需要指定 `node_type` 的值，并在此API中对应使用。详见 `加载图数据集 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/load_dataset_gnn.html>`_ 。
**返回：**
@ -177,10 +156,6 @@ mindspore.dataset.GraphData
**TypeError**：参数 `node_type` 的类型不为整型。
**样例：**
>>> nodes = graph_dataset.get_all_nodes(node_type=1)
.. py:method:: get_edges_from_nodes(node_list)
从节点获取边。
@ -197,10 +172,6 @@ mindspore.dataset.GraphData
**TypeError**：参数 `edge_list` 的类型不为列表或numpy.ndarray。
**样例：**
>>> edges = graph_dataset.get_edges_from_nodes(node_list=[(101, 201), (103, 207)])
.. py:method:: get_edge_feature(edge_list, feature_types)
获取 `edge_list` 列表中边的特征，以 `feature_types` 类型返回。
@ -219,11 +190,6 @@ mindspore.dataset.GraphData
- **TypeError** - 参数 `edge_list` 的类型不为列表或numpy.ndarray。
- **TypeError** - 参数 `feature_types` 的类型不为列表或numpy.ndarray。
**样例：**
>>> edges = graph_dataset.get_all_edges(edge_type=0)
>>> features = graph_dataset.get_edge_feature(edge_list=edges, feature_types=[1])
.. py:method:: get_neg_sampled_neighbors(node_list, neg_neighbor_num, neg_neighbor_type)
@ -245,12 +211,6 @@ mindspore.dataset.GraphData
- **TypeError** - 参数 `neg_neighbor_num` 的类型不为整型。
- **TypeError** - 参数 `neg_neighbor_type` 的类型不为整型。
**样例：**
>>> nodes = graph_dataset.get_all_nodes(node_type=1)
>>> neg_neighbors = graph_dataset.get_neg_sampled_neighbors(node_list=nodes, neg_neighbor_num=5,
... neg_neighbor_type=2)
.. py:method:: get_nodes_from_edges(edge_list)
从图中的边获取节点。
@ -267,11 +227,6 @@ mindspore.dataset.GraphData
**TypeError：** 参数 `edge_list` 不为列表或ndarray。
**样例：**
>>> edge_list = graph_dataset.get_all_edges(node_type=1)
>>> nodes = graph_dataset.get_nodes_from_edges(edge_list)
.. py:method:: get_node_feature(node_list, feature_types)
获取 `node_list` 中节点的特征，以 `feature_types` 类型返回。
@ -290,11 +245,6 @@ mindspore.dataset.GraphData
- **TypeError** - 参数 `node_list` 的类型不为列表或numpy.ndarray。
- **TypeError** - 参数 `feature_types` 的类型不为列表或numpy.ndarray。
**样例：**
>>> nodes = graph_dataset.get_all_nodes(node_type=1)
>>> features = graph_dataset.get_node_feature(node_list=nodes, feature_types=[2, 3])
.. py:method:: get_sampled_neighbors(node_list, neighbor_nums, neighbor_types, strategy=<SamplingStrategy.RANDOM: 0>)
获取已采样相邻节点信息。此API支持多跳相邻节点采样。即将上一次采样结果作为下一跳采样的输入，最多允许6跳。采样结果平铺成列表，格式为[input node, 1-hop sampling result, 2-hop samling result ...]
@ -319,12 +269,6 @@ mindspore.dataset.GraphData
- **TypeError** - 参数 `neighbor_nums` 的类型不为列表或numpy.ndarray。
- **TypeError** - 参数 `neighbor_types` 的类型不为列表或numpy.ndarray。
**样例：**
>>> nodes = graph_dataset.get_all_nodes(node_type=1)
>>> neighbors = graph_dataset.get_sampled_neighbors(node_list=nodes, neighbor_nums=[2, 2],
... neighbor_types=[2, 1])
.. py:method:: graph_info()
@ -334,10 +278,6 @@ mindspore.dataset.GraphData
dict，图的元信息。键为 `node_num` 、 `node_type` 、 `node_feature_type` 、 `edge_num` 、 `edge_type` 和 `edge_feature_type` 。
**样例：**
>>> graph_info = graph_dataset.graph_info()
.. py:method:: random_walk(target_nodes, meta_path, step_home_param=1.0, step_away_param=1.0, default_node=-1)
@ -359,8 +299,3 @@ mindspore.dataset.GraphData
- **TypeError** - 参数 `target_nodes` 的类型不为列表或numpy.ndarray。
- **TypeError** - 参数 `meta_path` 的类型不为列表或numpy.ndarray。
**样例：**
>>> nodes = graph_dataset.get_all_nodes(node_type=1)
>>> walks = graph_dataset.random_walk(target_nodes=nodes, meta_path=[2, 1, 2])

16
docs/api/api_python/dataset/mindspore.dataset.ImageFolderDataset.rst
View File

@ -62,22 +62,6 @@ mindspore.dataset.ImageFolderDataset
- False
- 不允许
**样例：**
>>> image_folder_dataset_dir = "/path/to/image_folder_dataset_directory"
>>>
>>> # 1）使用8个线程读取image_folder_dataset_dir中的所有图像文件。
>>> dataset = ds.ImageFolderDataset(dataset_dir=image_folder_dataset_dir,
... num_parallel_workers=8)
>>>
>>> # 2）从标签为0和1的cat文件夹为和dog文件夹中读取所有图像文件。
>>> dataset = ds.ImageFolderDataset(dataset_dir=image_folder_dataset_dir,
... class_indexing={"cat":0, "dog":1})
>>>
>>> # 3）读取image_folder_dataset_dir中所有扩展名为.JPEG和.png（区分大小写）的图像文件。
>>> dataset = ds.ImageFolderDataset(dataset_dir=image_folder_dataset_dir,
... extensions=[".JPEG", ".png"])
**关于ImageFolderDataset：**
您可以将图片数据文件构建成如下目录结构，并通过MindSpore的API进行读取。

14
docs/api/api_python/dataset/mindspore.dataset.ManifestDataset.rst
View File

@ -5,7 +5,7 @@
读取和解析Manifest数据文件构建数据集。
生成的数据集有两列： `[image, label]`。`image` 列的数据类型为uint8类型。`label` 列的数据类型为uint64类型。
生成的数据集有两列： `[image, label]` 。 `image` 列的数据类型为uint8类型。 `label` 列的数据类型为uint64类型。
**参数：**
@ -19,7 +19,7 @@
- **decode** (bool, 可选) - 是否对读取的图片进行解码操作，默认值：False，不解码。
- **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数，默认值：None。指定此参数后， `num_samples` 表示每个分片的最大样本数。
- **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号，默认值：None。只有当指定了 `num_shards` 时才能指定此参数。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读`单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读 `单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
**异常：**
@ -62,16 +62,6 @@
- False
- 不允许
**样例：**
>>> manifest_dataset_dir = "/path/to/manifest_dataset_file"
>>>
>>> # 1）使用8个线程读取Manifest数据集文件，并指定读取"train"子集数据
>>> dataset = ds.ManifestDataset(dataset_file=manifest_dataset_dir, usage="train", num_parallel_workers=8)
>>>
>>> # 2） 对Manifest数据集进行分布式训练，并将数据集拆分为2个分片，当前数据集仅加载分片ID号为0的数据
>>> dataset = ds.ManifestDataset(dataset_file=manifest_dataset_dir, num_shards=2, shard_id=0)
.. include:: mindspore.dataset.Dataset.add_sampler.rst
.. include:: mindspore.dataset.Dataset.rst

5
docs/api/api_python/dataset/mindspore.dataset.MindDataset.rst
View File

@ -62,11 +62,6 @@
- False
- 不允许
**样例：**
>>> mind_dataset_dir = ["/path/to/mind_dataset_file"] # 此列表可以包含一个或多个MindRecord文件
>>> dataset = ds.MindDataset(dataset_files=mind_dataset_dir)
.. include:: mindspore.dataset.Dataset.add_sampler.rst
.. include:: mindspore.dataset.Dataset.rst

11
docs/api/api_python/dataset/mindspore.dataset.MnistDataset.rst
View File

@ -18,7 +18,7 @@ mindspore.dataset.MnistDataset
- **sampler** (Sampler, 可选) - 指定从数据集中选取样本的采样器，默认值：None，下表中会展示不同配置的预期行为。
- **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数，默认值：None。指定此参数后， `num_samples` 表示每个分片的最大样本数。
- **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号，默认值：None。只有当指定了 `num_shards` 时才能指定此参数。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读`单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读 `单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
**异常：**
@ -58,15 +58,6 @@ mindspore.dataset.MnistDataset
- False
- 不允许
**样例：**
>>> mnist_dataset_dir = "/path/to/mnist_dataset_directory"
>>>
>>> # 从MNIST数据集中随机读取3个样本
>>> dataset = ds.MnistDataset(dataset_dir=mnist_dataset_dir, num_samples=3)
>>>
>>> # 提示：在MNIST数据集生成的数据集对象中，每一次迭代得到的数据行都有"image"和"label"两个键
**关于MNIST数据集:**
MNIST手写数字数据集是NIST数据集的子集，共有60,000个训练样本和10,000个测试样本。

19
docs/api/api_python/dataset/mindspore.dataset.NumpySlicesDataset.rst
View File

@ -58,25 +58,6 @@ mindspore.dataset.NumpySlicesDataset
- **RuntimeError:** 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
- **ValueError:** `shard_id` 参数值错误（小于0或者大于等于 `num_shards` ）。
**样例：**
>>> # 1) 输入的 `data` 参数类型为list，指定输出列名为"column_1"
>>> data = [1, 2, 3]
>>> dataset = ds.NumpySlicesDataset(data=data, column_names=["column_1"])
>>>
>>> # 2) 输入的 `data` 参数类型为dict，并且使用column_names的默认行为，即采用键名作为生成列名。
>>> data = {"a": [1, 2], "b": [3, 4]}
>>> dataset = ds.NumpySlicesDataset(data=data)
>>>
>>> # 3) 输入的 `data` 参数类型是由list组成的tuple，每个元组分别生成一个输出列，共三个输出列
>>> data = ([1, 2], [3, 4], [5, 6])
>>> dataset = ds.NumpySlicesDataset(data=data, column_names=["column_1", "column_2", "column_3"])
>>>
>>> # 4) 从CSV文件加载数据
>>> import pandas as pd
>>> df = pd.read_csv(filepath_or_buffer=csv_dataset_dir[0])
>>> dataset = ds.NumpySlicesDataset(data=dict(df), shuffle=False)
.. include:: mindspore.dataset.Dataset.add_sampler.rst
.. include:: mindspore.dataset.Dataset.rst

8
docs/api/api_python/dataset/mindspore.dataset.PKSampler.rst
View File

@ -22,12 +22,4 @@ mindspore.dataset.PKSampler
- **RuntimeError：** `num_val` 不是正值。
- **ValueError：** `num_samples` 为负值。
**样例：**
>>> # 创建一个PKSampler，从每个类中获取3个样本。
>>> sampler = ds.PKSampler(3)
>>> dataset = ds.ImageFolderDataset(image_folder_dataset_dir,
... num_parallel_workers=8,
... sampler=sampler)
.. include:: mindspore.dataset.BuiltinSampler.rst

6
docs/api/api_python/dataset/mindspore.dataset.PaddedDataset.rst
View File

@ -15,12 +15,6 @@ mindspore.dataset.PaddedDataset
- **TypeError** - `padded_samples` 的元素类型不为dict。
- **ValueError** - `padded_samples` 为空列表。
**样例：**
>>> import numpy as np
>>> data = [{'image': np.zeros(1, np.uint8)}, {'image': np.zeros(2, np.uint8)}]
>>> dataset = ds.PaddedDataset(padded_samples=data)
.. include:: mindspore.dataset.Dataset.add_sampler.rst
.. include:: mindspore.dataset.Dataset.rst

8
docs/api/api_python/dataset/mindspore.dataset.RandomSampler.rst
View File

@ -16,12 +16,4 @@ mindspore.dataset.RandomSampler
- **TypeError：** `num_samples` 不是整数值。
- **ValueError：** `num_samples` 为负值。
**样例：**
>>> # 创建一个RandomSampler
>>> sampler = ds.RandomSampler()
>>> dataset = ds.ImageFolderDataset(image_folder_dataset_dir,
... num_parallel_workers=8,
... sampler=sampler)
.. include:: mindspore.dataset.BuiltinSampler.rst

20
docs/api/api_python/dataset/mindspore.dataset.Schema.rst
View File

@ -17,16 +17,6 @@ mindspore.dataset.Schema
**RuntimeError**： 模式文件加载失败。
**样例：**
>>> from mindspore import dtype as mstype
>>>
>>> # 创建模式；指定列名、mindspore.dtype和列shape。
>>> schema = ds.Schema()
>>> schema.add_column(name='col1', de_type=mstype.int64, shape=[2])
.. py:method::add_column(name, de_type, shape=None)
向schema中添加新列。
**参数：**
@ -70,16 +60,6 @@ mindspore.dataset.Schema
- **RuntimeError:** 列name字段缺失。
- **RuntimeError:** 列type字段缺失。
**样例：**
>>> schema = Schema()
>>> columns1 = [{'name': 'image', 'type': 'int8', 'shape': [3, 3]},
>>> {'name': 'label', 'type': 'int8', 'shape': [1]}]
>>> schema.parse_columns(columns1)
>>> columns2 = {'image': {'shape': [3, 3], 'type': 'int8'}, 'label': {'shape': [1], 'type': 'int8'}}
>>> schema.parse_columns(columns2)
.. py:method::to_json()
获取schema的JSON字符串。

8
docs/api/api_python/dataset/mindspore.dataset.SequentialSampler.rst
View File

@ -17,12 +17,4 @@ mindspore.dataset.SequentialSampler
- **RuntimeError：** `start_index` 为负值。
- **ValueError：** `num_samples` 为负值。
**样例：**
>>> # 创建SequentialSampler
>>> sampler = ds.SequentialSampler()
>>> dataset = ds.ImageFolderDataset(image_folder_dataset_dir,
... num_parallel_workers=8,
... sampler=sampler)
.. include:: mindspore.dataset.BuiltinSampler.rst

8
docs/api/api_python/dataset/mindspore.dataset.SubsetRandomSampler.rst
View File

@ -16,12 +16,4 @@ mindspore.dataset.SubsetRandomSampler
- **TypeError：** `num_samples` 不是整数值。
- **ValueError：** `num_samples` 为负值。
**样例：**
>>> indices = [0, 1, 2, 3, 7, 88, 119]
>>>
>>> # 创建一个SubsetRandomSampler，根据提供的索引序列，对数据集进行随机采样
>>> sampler = ds.SubsetRandomSampler(indices)
>>> data = ds.ImageFolderDataset(image_folder_dataset_dir, num_parallel_workers=8, sampler=sampler)
.. include:: mindspore.dataset.BuiltinSampler.rst

10
docs/api/api_python/dataset/mindspore.dataset.SubsetSampler.rst
View File

@ -16,14 +16,4 @@ mindspore.dataset.SubsetSampler
- **TypeError：** `num_samples` 不是整数值。
- **ValueError：** `num_samples` 为负值。
**样例：**
>>> indices = [0, 1, 2, 3, 4, 5]
>>>
>>> # 创建SubsetSampler，根据提供的索引序列，对数据集进行采样
>>> sampler = ds.SubsetSampler(indices)
>>> dataset = ds.ImageFolderDataset(image_folder_dataset_dir,
... num_parallel_workers=8,
... sampler=sampler)
.. include:: mindspore.dataset.BuiltinSampler.rst

21
docs/api/api_python/dataset/mindspore.dataset.TFRecordDataset.rst
View File

@ -18,7 +18,7 @@ mindspore.dataset.TFRecordDataset
- 如果 `num_samples` 和numRows字段（由参数 `schema` 定义）的值都大于0，此时仅有参数 `num_samples` 生效且读取给定数量的数据。
- **num_parallel_workers** (int, 可选) - 指定读取数据的工作线程数。默认值：None，使用mindspore.dataset.config中配置的线程数。
- **shuffle** (Union[bool, Shuffle], 可选) - 每个epoch中数据混洗的模式，支持传入bool类型与枚举类型进行指定，默认值：mindspore.dataset.Shuffle.GLOBAL。
如果`shuffle`为False，则不混洗，如果`shuffle`为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。
如果 `shuffle` 为False，则不混洗，如果 `shuffle` 为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。
通过传入枚举变量设置数据混洗的模式：
- **Shuffle.GLOBAL**：混洗文件和样本。
@ -37,25 +37,6 @@ mindspore.dataset.TFRecordDataset
- **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
- **ValueError** - `shard_id` 参数值错误（小于0或者大于等于 `num_shards` ）。
**样例：**
>>> from mindspore import dtype as mstype
>>>
>>> tfrecord_dataset_dir = ["/path/to/tfrecord_dataset_file"] # 此列表可以包含一个或多个TFRecord文件
>>> tfrecord_schema_file = "/path/to/tfrecord_schema_file"
>>>
>>> # 1) 从tfrecord_dataset_dir路径的文件读取数据集。
>>> # 由于未指定Schema，则将解析TFRecord文件数据的第一行的元数据将用作Schema。
>>> dataset = ds.TFRecordDataset(dataset_files=tfrecord_dataset_dir)
>>>
>>> # 2) 用户使用自定义的Schema从tfrecord_dataset_dir路径的文件读取数据集。
>>> schema = ds.Schema()
>>> schema.add_column(name='col_1d', de_type=mstype.int64, shape=[2])
>>> dataset = ds.TFRecordDataset(dataset_files=tfrecord_dataset_dir, schema=schema)
>>>
>>> # 3) 用户通过传入JSON文件构造Schema，从tfrecord_dataset_dir路径的文件读取数据集。
>>> dataset = ds.TFRecordDataset(dataset_files=tfrecord_dataset_dir, schema=tfrecord_schema_file)
.. include:: mindspore.dataset.Dataset.rst
.. include:: mindspore.dataset.Dataset.zip.rst

7
docs/api/api_python/dataset/mindspore.dataset.TextFileDataset.rst
View File

@ -11,7 +11,7 @@
- **num_samples** (int，可选) - 指定从数据集中读取的样本数。默认值：None，读取所有样本。
- **num_parallel_workers** (int, 可选) - 指定读取数据的工作线程数。默认值：None，使用mindspore.dataset.config中配置的线程数。
- **shuffle** (Union[bool, Shuffle], 可选) - 每个epoch中数据混洗的模式，支持传入bool类型与枚举类型进行指定，默认值：mindspore.dataset.Shuffle.GLOBAL。
如果`shuffle`为False，则不混洗，如果`shuffle`为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。
如果 `shuffle` 为False，则不混洗，如果 `shuffle` 为True，等同于将 `shuffle` 设置为mindspore.dataset.Shuffle.GLOBAL。
通过传入枚举变量设置数据混洗的模式：
- **Shuffle.GLOBAL**：混洗文件和样本。
@ -28,11 +28,6 @@
- **RuntimeError** - 指定了 `num_shards` 参数，但是未指定 `shard_id` 参数。
- **RuntimeError** - 指定了 `shard_id` 参数，但是未指定 `num_shards` 参数。
**样例：**
>>> text_file_dataset_dir = ["/path/to/text_file_dataset_file"] # 此列表可以包含一个或多个文本文件
>>> dataset = ds.TextFileDataset(dataset_files=text_file_dataset_dir)
.. include:: mindspore.dataset.Dataset.rst
.. include:: mindspore.dataset.Dataset.zip.rst

29
docs/api/api_python/dataset/mindspore.dataset.VOCDataset.rst
View File

@ -22,13 +22,13 @@ mindspore.dataset.VOCDataset
- **sampler** (Sampler, 可选) - 指定从数据集中选取样本的采样器，默认值：None，下表中会展示不同配置的预期行为。
- **num_shards** (int, 可选) - 指定分布式训练时将数据集进行划分的分片数，默认值：None。指定此参数后， `num_samples` 表示每个分片的最大样本数。
- **shard_id** (int, 可选) - 指定分布式训练时使用的分片ID号，默认值：None。只有当指定了 `num_shards` 时才能指定此参数。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读`单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **cache** (DatasetCache, 可选) - 单节点数据缓存服务，用于加快数据集处理，详情请阅读 `单节点数据缓存 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/cache.html>`_ 。默认值：None，不使用缓存。
- **extra_metadata** (bool, 可选) - 用于指定是否额外输出一个数据列用于表示图片元信息。如果为True，则将额外输出一个名为 `[_meta-filename, dtype=string]` 的数据列，默认值：False。
根据给定的`task`配置，生成数据集具有不同的输出列：
根据给定的 `task` 配置，生成数据集具有不同的输出列：
- `task` = 'Detection'，输出列： `[image, dtype=uint8]`, `[bbox, dtype=float32]`, `[label, dtype=uint32]`, `[difficult, dtype=uint32]`, `[truncate, dtype=uint32]`。
- `task` = 'Segmentation'，输出列： `[image, dtype=uint8]`, `[target, dtype=uint8]`。
- `task` = 'Detection'，输出列： `[image, dtype=uint8]` , `[bbox, dtype=float32]` , `[label, dtype=uint32]` , `[difficult, dtype=uint32]` , `[truncate, dtype=uint32]` 。
- `task` = 'Segmentation'，输出列： `[image, dtype=uint8]` , `[target, dtype=uint8]` 。
**异常：**
@ -77,27 +77,6 @@ mindspore.dataset.VOCDataset
- False
- 不允许
**样例：**
>>> voc_dataset_dir = "/path/to/voc_dataset_directory"
>>>
>>> # 1) 读取VOC数据的Segmentation任务中的train部分进行训练
>>> dataset = ds.VOCDataset(dataset_dir=voc_dataset_dir, task="Segmentation", usage="train")
>>>
>>> # 2) 读取VOC数据的Detection任务中的train部分进行训练
>>> dataset = ds.VOCDataset(dataset_dir=voc_dataset_dir, task="Detection", usage="train")
>>>
>>> # 3) 以8个线程随机顺序读取voc_dataset_dir中的所有VOC数据集样本
>>> dataset = ds.VOCDataset(dataset_dir=voc_dataset_dir, task="Detection", usage="train",
... num_parallel_workers=8)
>>>
>>> # 4) 读voc_dataset_dir中的所有VOC数据集图片样本，且对图像进行解码
>>> dataset = ds.VOCDataset(dataset_dir=voc_dataset_dir, task="Detection", usage="train",
... decode=True, shuffle=False)
>>>
>>> # 在VOC数据集中，如果task='Segmentation'，每一次迭代得到的数据行都有"image"和"target"两个键。
>>> # 在VOC数据集中，如果task='Detection'，每一次迭代得到的数据行都有"image"和"annotation"两个键。
**关于VOC数据集：**
PASCAL Visual Object Classes（VOC）是视觉目标识别和检测的挑战赛，它为视觉和机器学习社区提供了图像和标注的标准数据集，称为VOC数据集。

66
docs/api/api_python/dataset/mindspore.dataset.WaitedDSCallback.rst
View File

@ -17,72 +17,6 @@ mindspore.dataset.WaitedDSCallback
- **step_size** (int, optional) - 每个step包含的数据行数。通常step_size与batch_size一致，默认值：1。
**样例：**
>>> import mindspore.nn as nn
>>> from mindspore.dataset import WaitedDSCallback
>>> from mindspore import context
>>> from mindspore.train import Model
>>> from mindspore.train.callback import Callback
>>>
>>> context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
>>>
>>> # 自定义用于数据处理管道同步数据的回调类
>>> class MyWaitedCallback(WaitedDSCallback):
... def __init__(self, events, step_size=1):
... super().__init__(step_size)
... self.events = events
...
... # epoch开始前数据处理管道要执行的回调函数
... def sync_epoch_begin(self, train_run_context, ds_run_context):
... event = f"ds_epoch_begin_{ds_run_context.cur_epoch_num}_{ds_run_context.cur_step_num}"
... self.events.append(event)
...
... # step开始前数据处理管道要执行的回调函数
... def sync_step_begin(self, train_run_context, ds_run_context):
... event = f"ds_step_begin_{ds_run_context.cur_epoch_num}_{ds_run_context.cur_step_num}"
... self.events.append(event)
>>>
>>> # 自定义用于网络训练时同步数据的回调类
>>> class MyMSCallback(Callback):
... def __init__(self, events):
... self.events = events
...
... # epoch结束网络训练要执行的回调函数
... def epoch_end(self, run_context):
... cb_params = run_context.original_args()
... event = f"ms_epoch_end_{cb_params.cur_epoch_num}_{cb_params.cur_step_num}"
... self.events.append(event)
...
... # step结束网络训练要执行的回调函数
... def step_end(self, run_context):
... cb_params = run_context.original_args()
... event = f"ms_step_end_{cb_params.cur_epoch_num}_{cb_params.cur_step_num}"
... self.events.append(event)
>>>
>>> # 自定义网络
>>> class Net(nn.Cell):
... def construct(self, x, y):
... return x
>>>
>>> # 声明一个网络训练与数据处理同步的数据
>>> events = []
>>>
>>> # 声明数据处理管道和网络训练的回调类
>>> my_cb1 = MyWaitedCallback(events, 1)
>>> my_cb2 = MyMSCallback(events)
>>> arr = [1, 2, 3, 4]
>>> # 构建数据处理管道
>>> data = ds.NumpySlicesDataset((arr, arr), column_names=["c1", "c2"], shuffle=False)
>>> # 将数据处理管道的回调类加入到map中
>>> data = data.map(operations=(lambda x: x), callbacks=my_cb1)
>>>
>>> net = Net()
>>> model = Model(net)
>>>
>>> # 将数据处理管道和网络训练的回调类加入到模型训练的回调列表中
>>> model.train(2, data, dataset_sink_mode=False, callbacks=[my_cb2, my_cb1])
.. py:method:: begin(run_context)
用于定义在网络训练开始前执行的回调方法。

10
docs/api/api_python/dataset/mindspore.dataset.WeightedRandomSampler.rst
View File

@ -19,14 +19,4 @@ mindspore.dataset.WeightedRandomSampler
- **RuntimeError：** `weights` 为空或全为零。
- **ValueError：** `num_samples` 为负值。
**样例：**
>>> weights = [0.9, 0.01, 0.4, 0.8, 0.1, 0.1, 0.3]
>>>
>>> # 创建一个WeightedRandomSampler，将对4个元素进行有放回采样
>>> sampler = ds.WeightedRandomSampler(weights, 4)
>>> dataset = ds.ImageFolderDataset(image_folder_dataset_dir,
... num_parallel_workers=8,
... sampler=sampler)
.. include:: mindspore.dataset.BuiltinSampler.rst

7
docs/api/api_python/dataset/mindspore.dataset.compare.rst
View File

@ -13,10 +13,3 @@ mindspore.dataset.compare
**返回：**
bool，两个数据处理管道是否相等。
**样例：**
>>> pipeline1 = ds.MnistDataset(mnist_dataset_dir, 100)
>>> pipeline2 = ds.Cifar10Dataset(cifar_dataset_dir, 100)
>>> ds.compare(pipeline1, pipeline2)

13
docs/api/api_python/dataset/mindspore.dataset.deserialize.rst
View File

@ -20,16 +20,3 @@ mindspore.dataset.deserialize
**异常：**
- **OSError:** - `json_filepath` 不为None且JSON文件解析失败时。
**样例：**
>>> dataset = ds.MnistDataset(mnist_dataset_dir, 100)
>>> one_hot_encode = c_transforms.OneHot(10) # num_classes是输入参数
>>> dataset = dataset.map(operation=one_hot_encode, input_column_names="label")
>>> dataset = dataset.batch(batch_size=10, drop_remainder=True)
>>> # 用例1：序列化/反序列化 JSON文件
>>> ds.serialize(dataset, json_filepath="/path/to/mnist_dataset_pipeline.json")
>>> dataset = ds.deserialize(json_filepath="/path/to/mnist_dataset_pipeline.json")
>>> # 用例2：序列化/反序列化 Python字典
>>> serialized_data = ds.serialize(dataset)
>>> dataset = ds.deserialize(input_dict=serialized_data)

11
docs/api/api_python/dataset/mindspore.dataset.serialize.rst
View File

@ -20,14 +20,3 @@
**异常：**
**OSError:** 无法打开文件。
**样例：**
>>> dataset = ds.MnistDataset(mnist_dataset_dir, 100)
>>> one_hot_encode = c_transforms.OneHot(10) # num_classes是输入参数
>>> dataset = dataset.map(operation=one_hot_encode, input_column_names="label")
>>> dataset = dataset.batch(batch_size=10, drop_remainder=True)
>>> # 将其序列化为JSON文件
>>> ds.engine.serialize(dataset, json_filepath="/path/to/mnist_dataset_pipeline.json")
>>> serialized_data = ds.engine.serialize(dataset) # 将其序列化为Python字典

9
docs/api/api_python/dataset/mindspore.dataset.show.rst
View File

@ -9,12 +9,3 @@ mindspore.dataset.show
- **dataset** (Dataset): 数据处理管道对象。
- **indentation** (int, optional): 设置MindSpore的INFO级别日志文件打印时的缩进字符数。若为None，则不缩进。
**样例：**
>>> dataset = ds.MnistDataset(mnist_dataset_dir, 100)
>>> one_hot_encode = c_transforms.OneHot(10)
>>> dataset = dataset.map(operation=one_hot_encode, input_column_names="label")
>>> dataset = dataset.batch(batch_size=10, drop_remainder=True)
>>> ds.show(dataset)

27
docs/api/api_python/dataset/mindspore.dataset.utils.imshow_det_bbox.rst
View File

@ -27,31 +27,6 @@
numpy.ndarray，带边界框和类别置信度的图像。
**样例：**
>>> import numpy as np
>>> from mindspore.dataset.utils.browse_dataset import imshow_det_bbox
>>>
>>> # 读取VOC数据集.
>>> voc_dataset_dir = "/path/to/voc_dataset_directory"
>>> dataset = ds.VOCDataset(voc_dataset_dir, task="Detection", shuffle=False, decode=True, num_samples=5)
>>> dataset_iter = dataset.create_dict_iterator(output_numpy=True, num_epochs=1)
>>>
>>> # 调用imshow_det_bbox自动标注图像
>>> for index, data in enumerate(dataset_iter):
... image = data["image"]
... bbox = data["bbox"]
... label = data["label"]
... # draw image with bboxes
... imshow_det_bbox(image, bbox, label,
... class_names=['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat',
... 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person',
... 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'],
... win_name="my_window",
... wait_time=5000,
... show=True,
... out_file="voc_dataset_{}.jpg".format(str(index)))
**`imshow_det_bbox` 在VOC2012数据集的使用图示:**
** `imshow_det_bbox` 在VOC2012数据集的使用图示:**
.. image:: api_img/browse_dataset.png

5
docs/api/api_python/dataset/mindspore.dataset.zip.rst
View File

@ -14,8 +14,3 @@
- **ValueError** - datasets参数的长度为1。
- **TypeError** - datasets参数不是元组。
**样例：**
>>> # 创建一个将dataset_1和dataset_2合并后数据集dataset。
>>> dataset = ds.zip((dataset_1, dataset_2))

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.AllpassBiquad.rst
View File

@ -19,12 +19,3 @@ mindspore.dataset.audio.transforms.AllpassBiquad
- **sample_rate** (int) - 采样频率（单位：Hz），不能为零。
- **central_freq** (float) - 中心频率（单位：Hz）。
- **Q** (float, 可选) - `品质因子 <https://zh.wikipedia.org/wiki/%E5%93%81%E8%B3%AA%E5%9B%A0%E5%AD%90>`_ ，能够反映带宽与采样频率和中心频率的关系，取值范围为(0, 1]，默认值：0.707。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.AllpassBiquad(44100, 200.0)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.AmplitudeToDB.rst
View File

@ -16,12 +16,3 @@ mindspore.dataset.audio.transforms.AmplitudeToDB
- **amin** (float, 可选) - 波形取值下界，低于该值的波形将会被裁切，取值必须大于0，默认值：1e-10。
- **top_db** (float, 可选) - 最小负截止分贝值，默认值：80.0。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.random.random([1, 400//2+1, 30])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.AmplitudeToDB(stype=ScaleType.POWER)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.Angle.rst
View File

@ -6,12 +6,3 @@ mindspore.dataset.audio.transforms.Angle
计算复数序列的角度。
.. note:: 待处理音频维度需为(..., complex=2)，其中第0维代表实部，第1维代表虚部。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.array([[1.43, 5.434], [23.54, 89.38]])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.Angle()]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.BandBiquad.rst
View File

@ -17,12 +17,3 @@ mindspore.dataset.audio.transforms.BandBiquad
- **central_freq** (float) - 中心频率（单位：Hz）。
- **Q** (float, 可选) - `品质因子 <https://zh.wikipedia.org/wiki/%E5%93%81%E8%B3%AA%E5%9B%A0%E5%AD%90>`_ ，能够反映带宽与采样频率和中心频率的关系，取值范围为(0, 1]，默认值：0.707。
- **noise** (bool, 可选) - 若为True，则使用非音调音频（如打击乐）模式；若为False，则使用音调音频（如语音、歌曲或器乐）模式，默认值：False。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.BandBiquad(44100, 200.0)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.BandpassBiquad.rst
View File

@ -25,12 +25,3 @@ mindspore.dataset.audio.transforms.BandpassBiquad
- **central_freq** (float) - 中心频率（单位：Hz）。
- **Q** (float, 可选) - `品质因子 <https://zh.wikipedia.org/wiki/%E5%93%81%E8%B3%AA%E5%9B%A0%E5%AD%90>`_ ，能够反映带宽与采样频率和中心频率的关系，取值范围为(0, 1]，默认值：0.707。
- **const_skirt_gain** (bool, 可选) - 若为True，则使用恒定裙边增益（峰值增益为Q）；若为False，则使用恒定的0dB峰值增益。默认值：False。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.BandpassBiquad(44100, 200.0)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.BandrejectBiquad.rst
View File

@ -21,12 +21,3 @@ mindspore.dataset.audio.transforms.BandrejectBiquad
- **sample_rate** (int) - 采样频率（单位：Hz），不能为零。
- **central_freq** (float) - 中心频率（单位：Hz）。
- **Q** (float, 可选) - `品质因子 <https://zh.wikipedia.org/wiki/%E5%93%81%E8%B3%AA%E5%9B%A0%E5%AD%90>`_ ，能够反映带宽与采样频率和中心频率的关系，取值范围为(0, 1]，默认值：0.707。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03],[9.246826171875e-03, 1.0894775390625e-02]])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.BandrejectBiquad(44100, 200.0)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.BassBiquad.rst
View File

@ -20,12 +20,3 @@ mindspore.dataset.audio.transforms.BassBiquad
- **gain** (float) - 期望提升（或衰减）的音频增益（单位：dB）。
- **central_freq** (float, 可选) - 中心频率（单位：Hz），默认值：100.0。
- **Q** (float, 可选) - `品质因子 <https://zh.wikipedia.org/wiki/%E5%93%81%E8%B3%AA%E5%9B%A0%E5%AD%90>`_ ，能够反映带宽与采样频率和中心频率的关系，取值范围为(0, 1]，默认值：0.707。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.BassBiquad(44100, 100.0)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.ComplexNorm.rst
View File

@ -10,12 +10,3 @@ mindspore.dataset.audio.transforms.ComplexNorm
**参数：**
- **power** (float, 可选) - 范数的幂，取值必须非负，默认值：1.0。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.random.random([2, 4, 2])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.ComplexNorm()]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.Contrast.rst
View File

@ -14,12 +14,3 @@ mindspore.dataset.audio.transforms.Contrast
**参数：**
- **enhancement_amount** (float, 可选) - 控制音频增益的量，取值范围为[0,100]，默认值：75.0。请注意当 `enhancement_amount` 等于0时，对比度增强效果仍然会很显著。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.array([[2.716064453125e-03, 6.34765625e-03], [9.246826171875e-03, 1.0894775390625e-02]])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.Contrast()]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.FrequencyMasking.rst
View File

@ -14,15 +14,6 @@ mindspore.dataset.audio.transforms.FrequencyMasking
- **mask_start** (int, 可选) - 添加掩码的起始位置，只有当 `iid_masks` 为True时，该值才会生效。取值范围为[0, freq_length - freq_mask_param]，其中 `freq_length` 为音频波形在频域的长度，默认值：0。
- **mask_value** (float, 可选) - 掩码填充值，默认值：0.0。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.random.random([1, 3, 2])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.FrequencyMasking(frequency_mask_param=1)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
.. image:: api_img/dataset/frequency_masking_original.png
.. image:: api_img/dataset/frequency_masking.png

10
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.LowpassBiquad.rst
View File

@ -19,13 +19,3 @@ mindspore.dataset.audio.transforms.LowpassBiquad
- **sample_rate** (int) - 采样频率（单位：Hz），不能为零。
- **cutoff_freq** (float) - 滤波器截止频率（单位：Hz）。
- **Q** (float, 可选) - `品质因子 <https://zh.wikipedia.org/wiki/%E5%93%81%E8%B3%AA%E5%9B%A0%E5%AD%90>`_ ，能够反映带宽与采样频率和中心频率的关系，取值范围(0, 1]，默认值：0.707。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.array([[0.8236, 0.2049, 0.3335], [0.5933, 0.9911, 0.2482],
... [0.3007, 0.9054, 0.7598], [0.5394, 0.2842, 0.5634], [0.6363, 0.2226, 0.2288]])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.LowpassBiquad(4000, 1500, 0.7)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.TimeMasking.rst
View File

@ -14,15 +14,6 @@ mindspore.dataset.audio.transforms.TimeMasking
- **mask_start** (int, 可选) - 添加掩码的起始位置，只有当 `iid_masks` 为True时，该值才会生效。取值范围为[0, time_length - time_mask_param]，其中 `time_length` 为音频波形在时域的长度，默认值：0。
- **mask_value** (float, 可选) - 掩码填充值，默认值：0.0。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.random.random([1, 3, 2])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.TimeMasking(time_mask_param=1)]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
.. image:: api_img/dataset/time_masking_original.png
.. image:: api_img/dataset/time_masking.png

9
docs/api/api_python/dataset_audio/mindspore.dataset.audio.transforms.TimeStretch.rst
View File

@ -13,15 +13,6 @@ mindspore.dataset.audio.transforms.TimeStretch
- **n_freq** (int, 可选) - STFT中的滤波器组数，默认值：201。
- **fixed_rate** (float, 可选) - 频谱在时域加快或减缓的比例，默认值：None，表示保持原始速率。
**样例：**
>>> import numpy as np
>>>
>>> waveform = np.random.random([1, 30])
>>> numpy_slices_dataset = ds.NumpySlicesDataset(data=waveform, column_names=["audio"])
>>> transforms = [audio.TimeStretch()]
>>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms, input_columns=["audio"])
.. image:: api_img/dataset/time_stretch_rate1.5.png
.. image:: api_img/dataset/time_stretch_original.png

71
docs/api/api_python/mindspore.common.initializer.rst
View File

@ -19,13 +19,6 @@ mindspore.common.initializer
**sigma** (float) - 截断正态分布的标准差，默认值为0.01。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, TruncatedNormal
>>> tensor1 = initializer(TruncatedNormal(), [1,2,3], mindspore.float32)
>>> tensor2 = initializer('truncatedNormal', [1,2,3], mindspore.float32)
.. py:class:: mindspore.common.initializer.Normal(sigma=0.01, mean=0.0)
生成一个服从正态分布N(sigma, mean)的随机数组用于初始化Tensor。
@ -38,13 +31,6 @@ mindspore.common.initializer
- **sigma** (float) - 正态分布的标准差，默认值为0.01。
- **mean** (float) - 正态分布的均值，默认值为0.0。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, Normal
>>> tensor1 = initializer(Normal(), [1,2,3], mindspore.float32)
>>> tensor2 = initializer('normal', [1,2,3], mindspore.float32)
.. py:class:: mindspore.common.initializer.Uniform(scale=0.07)
生成一个服从均匀分布U(-scale, scale)的随机数组用于初始化Tensor。
@ -53,13 +39,6 @@ mindspore.common.initializer
**scale** (float) - 均匀分布的边界，默认值为0.07。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, Uniform
>>> tensor1 = initializer(Uniform(), [1,2,3], mindspore.float32)
>>> tensor2 = initializer('uniform', [1,2,3], mindspore.float32)
.. py:class:: mindspore.common.initializer.HeUniform(negative_slope=0, mode="fan_in", nonlinearity="leaky_relu")
生成一个服从HeKaiming均匀分布U(-boundary, boundary)的随机数组用于初始化Tensor，其中：
@ -75,13 +54,6 @@ mindspore.common.initializer
- **mode** (str) - 可选"fan_in"或"fan_out"，"fan_in"会保留前向传递中权重方差的量级，"fan_out"会保留反向传递的量级，默认为"fan_in"。
- **nonlinearity** (str) - 非线性激活函数，推荐使用"relu"或"leaky_relu"，默认为"leaky_relu"。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, HeUniform
>>> tensor1 = initializer(HeUniform(), [1,2,3], mindspore.float32)
>>> tensor2 = initializer('he_uniform', [1,2,3], mindspore.float32)
.. py:class:: mindspore.common.initializer.HeNormal(negative_slope=0, mode="fan_in", nonlinearity="leaky_relu")
生成一个服从HeKaiming正态分布N(0, sigma^2)的随机数组用于初始化Tensor，其中：
@ -100,13 +72,6 @@ mindspore.common.initializer
- **mode** (str) - 可选"fan_in"或"fan_out"，"fan_in"会保留前向传递中权重方差的量级，"fan_out"会保留反向传递的量级，默认为"fan_in"。
- **nonlinearity** (str) - 非线性激活函数，推荐使用"relu"或"leaky_relu"，默认为"leaky_relu"。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, HeNormal
>>> tensor1 = initializer(HeNormal(), [1,2,3], mindspore.float32)
>>> tensor2 = initializer('he_normal', [1,2,3], mindspore.float32)
.. py:class:: mindspore.common.initializer.XavierUniform(gain=1)
生成一个服从Xarvier均匀分布U(-boundary, boundary)的随机数组用于初始化Tensor，均匀分布的取值范围为[-boundary, boundary]，其中：
@ -122,35 +87,14 @@ mindspore.common.initializer
**gain** (float) - 可选的缩放因子，默认值为1。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, XavierUniform
>>> tensor1 = initializer(XavierUniform(), [1,2,3], mindspore.float32)
>>> tensor2 = initializer('xavier_uniform', [1,2,3], mindspore.float32)
.. py:class:: mindspore.common.initializer.One(**kwargs)
生成一个值全为1的常量数组用于初始化Tensor。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, One
>>> tensor1 = initializer(One(), [1,2,3], mindspore.float32)
>>> tensor2 = initializer('ones', [1,2,3], mindspore.float32)
.. py:class:: mindspore.common.initializer.Zero(**kwargs)
生成一个值全为0的常量数组用于初始化Tensor。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, Zero
>>> tensor1 = initializer(Zero(), [1,2,3], mindspore.float32)
>>> tensor2 = initializer('zeros', [1,2,3], mindspore.float32)
.. py:class:: mindspore.common.initializer.Constant(value)
生成一个常量数组用于初始化Tensor。
@ -159,13 +103,6 @@ mindspore.common.initializer
**value** (Union[int, numpy.ndarray]) - 用于初始化的常数值或者数组。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer
>>> tensor1 = initializer(0, [1,2,3], mindspore.float32)
>>> tensor2 = initializer(5, [1,2,3], mindspore.float32)
@ -192,11 +129,3 @@ mindspore.common.initializer
- **TypeError** - 参数 `init` 的类型不正确。
- **ValueError** - 当 `init` 传入Tensor对象时， `init` 的shape与形参 `shape` 内的数值不一致。
**样例：**
>>> import mindspore
>>> from mindspore.common.initializer import initializer, One
>>> tensor = initializer('ones', [1, 2, 3], mindspore.float32)
>>> tensor = initializer(One(), [1, 2, 3], mindspore.float32)
>>> tensor = initializer(0, [1, 2, 3], mindspore.float32)

66
docs/api/api_python/mindspore.communication.rst
View File

@ -16,13 +16,6 @@ mindspore.communication
- BACKEND：使用的通信库，HCCL或者NCCL。
- WORLD_COMM_GROUP：全局通信域。
**样例：**
>>> from mindspore.context import set_context
>>> set_context(device_target="Ascend")
>>> init()
>>> GlobalComm.BACKEND
.. py:method:: mindspore.communication.init(backend_name=None)
初始化通信服务需要的分布式后端，例如‘HCCL’或‘NCCL’服务。
@ -39,12 +32,6 @@ mindspore.communication
- **RuntimeError** – 1）硬件设备类型无效；2）后台服务无效；3）分布式计算初始化失败；4）未设置环境变量 `RANK_ID` 或 `MINDSPORE_HCCL_CONFIG_PATH` 的情况下初始化HCCL服务。
- **ValueError** – 环境变量 `RANK_ID` 设置成非数字。
**样例：**
>>> from mindspore.context import set_context
>>> set_context(device_target="Ascend")
>>> init()
.. py:class:: mindspore.communication.release()
释放分布式资源，例如‘HCCL’或‘NCCL’服务。
@ -95,18 +82,6 @@ mindspore.communication
- **ValueError** – 在后台不可用时抛出。
- **RuntimeError** – 在‘HCCL’或‘NCCL’服务不可用时抛出。
**样例：**
>>> from mindspore.context import set_context
>>> set_context(device_target="Ascend")
>>> init()
>>> group = "0-4"
>>> rank_ids = [0,4]
>>> create_group(group, rank_ids)
>>> group_size = get_group_size(group)
>>> print("group_size is: ", group_size)
>>> group_size is:2
.. py:class:: mindspore.communication.get_world_rank_from_group_rank(group, group_rank_id)
由指定通信组中的设备序号获取通信集群中的全局设备序号。
@ -131,17 +106,6 @@ mindspore.communication
- **ValueError** – 参数 `group` 是 `hccl_world_group` 或后台不可用。
- **RuntimeError** – ‘HCCL’或‘NCCL’服务不可用，以及使用CPU版本的MindSpore。
**样例：**
>>> from mindspore.context import set_context
>>> set_context(device_target="Ascend")
>>> init()
>>> group = "0-4"
>>> rank_ids = [0,4]
>>> create_group(group, rank_ids)
>>> world_rank_id = get_world_rank_from_group_rank(group, 1)
>>> print("world_rank_id is: ", world_rank_id) # 全局设备序号为4
.. py:class:: mindspore.communication.get_group_rank_from_world_rank(world_rank_id, group)
由通信集群中的全局设备序号获取指定用户通信组中的rank ID。
@ -166,17 +130,6 @@ mindspore.communication
- **ValueError** – 在参数 `group` 是 `hccl_world_group` 或后台不可用时抛出。
- **RuntimeError** – 在‘HCCL’或‘NCCL’服务不可用，以及使用GPU版本的MindSpore时抛出。
**样例：**
>>> from mindspore.context import set_context
>>> set_context(device_target="Ascend")
>>> init()
>>> group = "0-4"
>>> rank_ids = [0,4]
>>> create_group(group, rank_ids)
>>> group_rank_id = get_group_rank_from_world_rank(4, group)
>>> print("group_rank_id is: ", group_rank_id) # 组内设备序号是1
.. py:class:: mindspore.communication.create_group(group, rank_ids)
创建用户自定义的通信组实例。
@ -198,15 +151,6 @@ mindspore.communication
- **ValueError** – 列表rank_ids的长度小于1，或列表rank_ids内有重复数据，以及后台无效。
- **RuntimeError** – 在‘HCCL’或‘NCCL’ 服务不可用，以及使用CPU版本的MindSpore。
**样例：**
>>> from mindspore.context import set_context
>>> set_context(device_target="Ascend")
>>> init()
>>> group = "0-8"
>>> rank_ids = [0,8]
>>> create_group(group, rank_ids)
.. py:class:: mindspore.communication.get_local_rank(group=GlobalComm.WORLD_COMM_GROUP)
获取指定通信组中当前设备的本地设备序号。
@ -269,13 +213,3 @@ mindspore.communication
- **TypeError** – 在参数 `group` 不是字符串时抛出。
- **ValueError** – 在参数 `group` 是 `hccl_world_group` 或后台不可用时抛出。
- **RuntimeError** – 在‘HCCL’或‘NCCL’服务不可用时抛出。
**样例：**
>>> from mindspore.context import set_context
>>> set_context(device_target="Ascend")
>>> init()
>>> group = "0-8"
>>> rank_ids = [0,8]
>>> create_group(group, rank_ids)
>>> destroy_group(group)

67
docs/api/api_python/mindspore.context.rst
View File

@ -143,34 +143,6 @@ MindSpore context，用于配置当前执行环境，包括执行模式、执行
**ValueError**：输入key不是上下文中的属性。
**样例：**
>>> context.set_context(mode=context.PYNATIVE_MODE)
>>> context.set_context(precompile_only=True)
>>> context.set_context(device_target="Ascend")
>>> context.set_context(device_id=0)
>>> context.set_context(save_graphs=True, save_graphs_path="./model.ms")
>>> context.set_context(enable_reduce_precision=True)
>>> context.set_context(enable_dump=True, save_dump_path=".")
>>> context.set_context(enable_graph_kernel=True)
>>> context.set_context(graph_kernel_flags="--opt_level=2 --dump_as_text")
>>> context.set_context(reserve_class_name_in_scope=True)
>>> context.set_context(variable_memory_max_size="6GB")
>>> context.set_context(enable_profiling=True,
... profiling_options='{"output":"/home/data/output","training_trace":"on"}')
>>> context.set_context(check_bprop=True)
>>> context.set_context(max_device_memory="3.5GB")
>>> context.set_context(mempool_block_size="1GB")
>>> context.set_context(print_file_path="print.pb")
>>> context.set_context(enable_sparse=True)
>>> context.set_context(max_call_depth=80)
>>> context.set_context(env_config_path="./env_config.json")
>>> context.set_context(auto_tune_mode="GA,RL")
>>> context.set_context(grad_for_scalar=True)
>>> context.set_context(save_compile_cache=True)
>>> context.set_context(load_compile_cache=True)
>>> context.set_context(pynative_synchronize=True)
.. py:function:: mindspore.context.get_context(attr_key)
根据输入key获取context中的属性值。如果该key没有设置，则会获取它们这些的默认值。
@ -187,11 +159,6 @@ MindSpore context，用于配置当前执行环境，包括执行模式、执行
**ValueError**：输入key不是context中的属性。
**样例：**
>>> context.get_context("device_target")
>>> context.get_context("device_id")
.. py:function:: mindspore.context.set_auto_parallel_context(**kwargs)
配置自动并行，仅在Ascend和GPU上有效。
@ -249,22 +216,6 @@ MindSpore context，用于配置当前执行环境，包括执行模式、执行
**ValueError**：输入key不是自动并行上下文中的属性。
**样例：**
>>> context.set_auto_parallel_context(device_num=8)
>>> context.set_auto_parallel_context(global_rank=0)
>>> context.set_auto_parallel_context(gradients_mean=True)
>>> context.set_auto_parallel_context(gradient_fp32_sync=False)
>>> context.set_auto_parallel_context(parallel_mode="auto_parallel")
>>> context.set_auto_parallel_context(auto_parallel_search_mode="dynamic_programming")
>>> context.set_auto_parallel_context(parameter_broadcast=False)
>>> context.set_auto_parallel_context(strategy_ckpt_load_file="./strategy_stage1.ckpt")
>>> context.set_auto_parallel_context(strategy_ckpt_save_file="./strategy_stage1.ckpt")
>>> context.set_auto_parallel_context(dataset_strategy=((1, 8), (1, 8)))
>>> context.set_auto_parallel_context(enable_parallel_optimizer=False)
>>> context.set_auto_parallel_context(all_reduce_fusion_config=[8, 160])
>>> context.set_auto_parallel_context(pipeline_stages=2)
.. py:function:: mindspore.context.get_auto_parallel_context(attr_key)
根据key获取自动并行的配置。
@ -281,12 +232,6 @@ MindSpore context，用于配置当前执行环境，包括执行模式、执行
**ValueError**：输入key不在自动并行的配置列表中。
**样例：**
>>> from mindspore import context
>>> parallel_mode = context.get_auto_parallel_context("parallel_mode")
>>> dataset_strategy = context.get_auto_parallel_context("dataset_strategy")
.. py:function:: mindspore.context.reset_auto_parallel_context()
重置自动并行的配置为默认值。
@ -347,10 +292,6 @@ MindSpore context，用于配置当前执行环境，包括执行模式、执行
**ValueError**：输入key不是参数服务器训练模式上下文中的属性。
**样例：**
>>> context.set_ps_context(enable_ps=True, enable_ssl=True, client_password='123456', server_password='123456')
.. py:function:: mindspore.context.get_ps_context(attr_key)
根据key获取参数服务器训练模式上下文中的属性值。
@ -374,14 +315,6 @@ MindSpore context，用于配置当前执行环境，包括执行模式、执行
**ValueError** - 输入key不是参数服务器训练模式上下文中的属性。
**样例：**
>>> context.get_ps_context(enable_ps)
.. py:function:: mindspore.context.reset_ps_context()
将参数服务器训练模式上下文中的属性重置为默认值。各字段的含义及其默认值见'set_ps_context'接口。
**样例：**
>>> context.reset_ps_context()

31
docs/api/api_python/mindspore.train/mindspore.train.SummaryCollector.rst
View File

@ -30,7 +30,7 @@
- **custom_lineage_data** (Union[dict, None]) - 允许您自定义数据并将数据显示在MindInsight的lineage页面上。在自定义数据中，key支持str类型，value支持str、int和float类型。默认值：None，表示不存在自定义数据。
- **collect_tensor_freq** (Optional[int]) - 语义与 `collect_freq` 的相同，但仅控制TensorSummary。由于TensorSummary数据太大，无法与其他summary数据进行比较，因此此参数用于降低收集量。默认情况下，收集TensorSummary数据的最大step数量为20，但不会超过收集其他summary数据的step数量。例如，给定 `collect_freq=10` ，当总step数量为600时，TensorSummary将收集20个step，而收集其他summary数据时会收集61个step。但当总step数量为20时，TensorSummary和其他summary将收集3个step。另外请注意，在并行模式下，会平均分配总的step数量，这会影响TensorSummary收集的step的数量。默认值：None，表示要遵循上述规则。
- **max_file_size** (Optional[int]) - 可写入磁盘的每个文件的最大大小（以字节为单位）。例如，如果不大于4GB，则设置 `max_file_size=4*1024**3` 。默认值：None，表示无限制。
- **export_options** (Union[None, dict]) - 表示对导出的数据执行自定义操作。注：导出的文件的大小不受 `max_file_size` 的限制。您可以使用字典自定义导出的数据。例如，您可以设置{'tensor_format':'npy'}将tensor导出为`npy`文件。支持控制的数据如下所示。默认值：None，表示不导出数据。
- **export_options** (Union[None, dict]) - 表示对导出的数据执行自定义操作。注：导出的文件的大小不受 `max_file_size` 的限制。您可以使用字典自定义导出的数据。例如，您可以设置{'tensor_format':'npy'}将tensor导出为 `npy` 文件。支持控制的数据如下所示。默认值：None，表示不导出数据。
- **tensor_format** (Union[str, None]) - 自定义导出的tensor的格式。支持["npy", None]。默认值：None，表示不导出tensor。
@ -39,32 +39,3 @@
**异常：**
- **ValueError：** ：编译MindSpore时，设置 `-s on` 关闭了维测功能。
**样例：**
>>> import mindspore.nn as nn
>>> from mindspore import context
>>> from mindspore.train.callback import SummaryCollector
>>> from mindspore import Model
>>> from mindspore.nn import Accuracy
>>>
>>> if __name__ == '__main__':
... # 如果device_target是GPU，则将device_target设为GPU。
... context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
... mnist_dataset_dir = '/path/to/mnist_dataset_directory'
... # model_zoo.office.cv.lenet.src.dataset.py中显示的create_dataset方法的详细信息
... ds_train = create_dataset(mnist_dataset_dir, 32)
... # model_zoo.official.cv.lenet.src.lenet.py中显示的LeNet5的详细信息
... network = LeNet5(10)
... net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
... net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
... model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()}, amp_level="O2")
...
... # 简单用法：
... summary_collector = SummaryCollector(summary_dir='./summary_dir')
... model.train(1, ds_train, callbacks=[summary_collector], dataset_sink_mode=False)
...
... # 不收集metric，收集第一层参数。默认收集其他数据。
... specified={'collect_metric': False, 'histogram_regular': '^conv1.*'}
... summary_collector = SummaryCollector(summary_dir='./summary_dir', collect_specified_data=specified)
... model.train(1, ds_train, callbacks=[summary_collector], dataset_sink_mode=False)

18
docs/api/api_python/mindspore.train/mindspore.train.callback.Callback.rst
View File

@ -7,24 +7,6 @@
要创建自定义Callback，需要继承Callback基类并重载它相应的方法，有关自定义Callback的详细信息，请查看
`Callback <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/custom_debugging_info.html>`_。
**样例：**
>>> from mindspore import Model, nn
>>> from mindspore.train.callback import Callback
>>> class Print_info(Callback):
... def step_end(self, run_context):
... cb_params = run_context.original_args()
... print("step_num: ", cb_params.cur_step_num)
>>>
>>> print_cb = Print_info()
>>> dataset = create_custom_dataset()
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
>>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
>>> model = Model(net, loss_fn=loss, optimizer=optim)
>>> model.train(1, dataset, callbacks=print_cb)
step_num：1
.. py:method:: begin(run_context)
在网络执行之前被调用一次。

36
docs/api/api_python/mindspore.train/mindspore.train.callback.CheckpointConfig.rst
View File

@ -23,42 +23,6 @@
- **ValueError** - 输入参数的类型不正确。
**样例：**
>>> from mindspore import Model, nn
>>> from mindspore.train.callback import ModelCheckpoint, CheckpointConfig
>>>
>>> class LeNet5(nn.Cell):
... def __init__(self):
... super(LeNet5, self).__init__()
... self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
... self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
... self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
... self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
... self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
... self.relu = nn.ReLU()
... self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
... self.flatten = nn.Flatten()
...
... def construct(self, x):
... x = self.max_pool2d(self.relu(self.conv1(x)))
... x = self.max_pool2d(self.relu(self.conv2(x)))
... x = self.flatten(x)
... x = self.relu(self.fc1(x))
... x = self.relu(self.fc2(x))
... x = self.fc3(x)
... return x
>>>
>>> net = LeNet5()
>>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
>>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
>>> model = Model(net, loss_fn=loss, optimizer=optim)
>>> data_path = './MNIST_Data'
>>> dataset = create_dataset(data_path)
>>> config = CheckpointConfig(saved_network=net)
>>> ckpoint_cb = ModelCheckpoint(prefix='LeNet5', directory='./checkpoint', config=config)
>>> model.train(10, dataset, callbacks=ckpoint_cb)
.. py:method:: append_dict
:property:

22
docs/api/api_python/mindspore.train/mindspore.train.callback.LearningRateScheduler.rst
View File

@ -6,28 +6,6 @@
- **learning_rate_function** (Function) - 在训练期间更改学习率的函数。
**样例：**
>>> from mindspore import Model
>>> from mindspore.train.callback import LearningRateScheduler
>>> import mindspore.nn as nn
...
>>> def learning_rate_function(lr, cur_step_num):
... if cur_step_num%1000 == 0:
... lr = lr*0.1
... return lr
...
>>> lr = 0.1
>>> momentum = 0.9
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = nn.Momentum(net.trainable_params(), learning_rate=lr, momentum=momentum)
>>> model = Model(net, loss_fn=loss, optimizer=optim)
...
>>> dataset = create_custom_dataset("custom_dataset_path")
>>> model.train(1, dataset, callbacks=[LearningRateScheduler(learning_rate_function)],
... dataset_sink_mode=False)
.. py:method:: step_end(run_context)
在step结束时更改学习率。

13
docs/api/api_python/mindspore.train/mindspore.train.callback.LossMonitor.rst
View File

@ -15,19 +15,6 @@
- **ValueError** - 当 `per_print_times` 不是整数或小于零。
**样例：**
>>> from mindspore import Model, nn
>>>
>>> net = LeNet5()
>>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
>>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
>>> model = Model(net, loss_fn=loss, optimizer=optim)
>>> data_path = './MNIST_Data'
>>> dataset = create_dataset(data_path)
>>> time_monitor = TimeMonitor()
>>> model.train(10, dataset, callbacks=time_monitor)
.. py:method:: step_end(run_context)

36
docs/api/api_python/mindspore.train/mindspore.train.callback.ModelCheckpoint.rst
View File

@ -19,42 +19,6 @@
- **ValueError** - 如果directory参数不是str类型。
- **TypeError** - config不是CheckpointConfig类型。
**样例：**
>>> from mindspore import Model, nn
>>> from mindspore.train.callback import ModelCheckpoint, CheckpointConfig
>>>
>>> class LeNet5(nn.Cell):
... def __init__(self):
... super(LeNet5, self).__init__()
... self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
... self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
... self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
... self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
... self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
... self.relu = nn.ReLU()
... self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
... self.flatten = nn.Flatten()
...
... def construct(self, x)：
... x = self.max_pool2d(self.relu(self.conv1(x)))
... x = self.max_pool2d(self.relu(self.conv2(x)))
... x = self.flatten(x)
... x = self.relu(self.fc1(x))
... x = self.relu(self.fc2(x))
... x = self.fc3(x)
... return x
>>>
>>> net = LeNet5()
>>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
>>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
>>> model = Model(net, loss_fn=loss, optimizer=optim)
>>> data_path = './MNIST_Data'
>>> dataset = create_dataset(data_path)
>>> config = CheckpointConfig(saved_network=net)
>>> ckpoint_cb = ModelCheckpoint(prefix='LeNet5', directory='./checkpoint', config=config)
>>> model.train(10, dataset, callbacks=ckpoint_cb)
.. py:method:: end(run_context)

3
docs/api/api_python/mindspore.train/mindspore.train.callback.RunContext.rst
View File

@ -4,9 +4,6 @@
在Model方法里提供模型的相关信息。
回调函数可以调用 `request_stop()` 方法来停止迭代。
该类需要与:class:`mindspore.train.callback.Callback`一起使用。
有关自定义Callback的详细信息，请查看
`Callback <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/custom_debugging_info.html>`_。
**参数：**

13
docs/api/api_python/mindspore.train/mindspore.train.callback.TimeMonitor.rst
View File

@ -10,19 +10,6 @@
- **ValueError** - `data_size` 不是正整数。
**样例：**
>>> from mindspore import Model, nn
>>>
>>> net = LeNet5()
>>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
>>> optim = nn.Momentum(net.trainable_params(), 0.01, 0.9)
>>> model = Model(net, loss_fn=loss, optimizer=optim)
>>> data_path = './MNIST_Data'
>>> dataset = create_dataset(data_path)
>>> time_monitor = TimeMonitor()
>>> model.train(10, dataset, callbacks=time_monitor)
.. py:method:: epoch_begin(run_context)

69
docs/api/api_python/mindspore.train/mindspore.train.summary.SummaryRecord.rst
View File

@ -15,12 +15,12 @@
**参数：**
- **log_dir** (str) - `log_dir` 是用来保存summary文件的目录。
- **file_prefix** (str) - 文件的前缀。默认值：`events`。
- **file_suffix** (str) - 文件的后缀。默认值：`_MS`。
- **file_prefix** (str) - 文件的前缀。默认值：`events` 。
- **file_suffix** (str) - 文件的后缀。默认值：`_MS` 。
- **network** (Cell) - 表示用于保存计算图的网络。默认值：None。
- **max_file_size** (int, 可选) - 可写入磁盘的每个文件的最大大小（以字节为单位）。例如，预期写入文件最大不超过4GB，则设置 `max_file_size=4*1024**3` 。默认值：None，表示无限制。
- **raise_exception** (bool, 可选) - 设置在记录数据中发生RuntimeError或OSError异常时是否抛出异常。默认值：False，表示打印错误日志，不抛出异常。
- **export_options** (Union[None, dict]) - 可以将保存在summary中的数据导出，并使用字典自定义所需的数据和文件格式。注：导出的文件大小不受 `max_file_size` 的限制。例如，您可以设置{'tensor_format':'npy'}将Tensor导出为`npy`文件。支持导出的数据类型如下所示。默认值：None，表示不导出数据。
- **export_options** (Union[None, dict]) - 可以将保存在summary中的数据导出，并使用字典自定义所需的数据和文件格式。注：导出的文件大小不受 `max_file_size` 的限制。例如，您可以设置{'tensor_format':'npy'}将Tensor导出为 `npy` 文件。支持导出的数据类型如下所示。默认值：None，表示不导出数据。
- **tensor_format** (Union[str, None]) - 自定义导出的Tensor的格式。支持["npy", None]。默认值：None，表示不导出Tensor。
@ -31,20 +31,6 @@
- **TypeError：** `max_file_size` 不是整型，或 `file_prefix` 和 `file_suffix` 不是字符串。
- **ValueError：** ：编译MindSpore时，设置 `-s on` 关闭了维测功能。
**样例：**
>>> from mindspore.train.summary import SummaryRecord
>>> if __name__ == '__main__':
... # 在with语句中使用以自动关闭
... with SummaryRecord(log_dir="./summary_dir") as summary_record:
... pass
...
... # 在try .. finally .. 语句中使用以确保关闭
... try:
... summary_record = SummaryRecord(log_dir="./summary_dir")
... finally:
... summary_record.close()
.. py:method:: add_value(plugin, name, value)
添加需要记录的值。
@ -78,40 +64,16 @@
- **ValueError：** `plugin` 的值不在可选值内。
- **TypeError：** `name` 不是非空字符串，或当 `plugin` 为"scalar"、"image"、"tensor"或"histogram"时，`value` 的数据类型不是"Tensor"对象。
**样例：**
>>> from mindspore import Tensor
>>> from mindspore.train.summary import SummaryRecord
>>> if __name__ == '__main__':
... with SummaryRecord(log_dir="./summary_dir", file_prefix="xx_", file_suffix="_yy") as summary_record:
... summary_record.add_value('scalar', 'loss', Tensor(0.1))
.. py:method:: close()
将缓冲区中的数据立刻写入文件并关闭SummaryRecord。请使用with语句或try…finally语句进行自动关闭。
**样例：**
>>> from mindspore.train.summary import SummaryRecord
>>> if __name__ == '__main__':
... try:
... summary_record = SummaryRecord(log_dir="./summary_dir")
... finally:
... summary_record.close()
.. py:method:: flush()
刷新缓冲区，将缓冲区中的数据立刻写入文件。
调用该函数以确保所有挂起事件都已写入到磁盘。
**样例：**
>>> from mindspore.train.summary import SummaryRecord
>>> if __name__ == '__main__':
... with SummaryRecord(log_dir="./summary_dir", file_prefix="xx_", file_suffix="_yy") as summary_record:
... summary_record.flush()
.. py:method:: log_dir
:property:
@ -121,13 +83,6 @@
str，日志文件的完整路径。
**样例：**
>>> from mindspore.train.summary import SummaryRecord
>>> if __name__ == '__main__':
... with SummaryRecord(log_dir="./summary_dir", file_prefix="xx_", file_suffix="_yy") as summary_record:
... log_dir = summary_record.log_dir
.. py:method:: record(step, train_network=None, plugin_filter=None)
记录summary。
@ -144,16 +99,7 @@
**异常：**
- **TypeError：** `step` 不为整型，或 `train_network` 的类型不为`mindspore.nn.Cell <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/nn/mindspore.nn.Cell.html?highlight=MindSpore.nn.cell#mindspore-nn-cell>`_ 。
**样例：**
>>> from mindspore.train.summary import SummaryRecord
>>> if __name__ == '__main__':
... with SummaryRecord(log_dir="./summary_dir", file_prefix="xx_", file_suffix="_yy") as summary_record:
... summary_record.record(step=2)
...
True
- **TypeError：** `step` 不为整型，或 `train_network` 的类型不为 `mindspore.nn.Cell <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/nn/mindspore.nn.Cell.html?highlight=MindSpore.nn.cell#mindspore-nn-cell>`_ 。
.. py:method:: set_mode(mode)
@ -169,10 +115,3 @@
**异常：**
**ValueError：** `mode` 的值不在可选值内。
**样例：**
>>> from mindspore.train.summary import SummaryRecord
>>> if __name__ == '__main__':
... with SummaryRecord(log_dir="./summary_dir", file_prefix="xx_", file_suffix="_yy") as summary_record:
... summary_record.set_mode('eval')

72
docs/api/api_python/mindspore/mindspore.Model.rst
View File

@ -13,7 +13,7 @@
- **metrics** (Union[dict, set]) - 用于模型评估的一组评价函数。例如：{'accuracy', 'recall'}。默认值：None。
- **eval_network** (Cell) - 用于评估的神经网络。未定义情况下，`Model` 会使用 `network` 和 `loss_fn` 封装一个 `eval_network` 。默认值：None。
- **eval_indexes** (list) - 在定义 `eval_network` 的情况下使用。如果 `eval_indexes` 为默认值None，`Model` 会将 `eval_network` 的所有输出传给 `metrics` 。如果配置 `eval_indexes` ，必须包含三个元素，分别为损失值、预测值和标签在 `eval_network` 输出中的位置，此时，损失值将传给损失评价函数，预测值和标签将传给其他评价函数。推荐使用评价函数的 `mindspore.nn.Metric.set_indexes` 代替 `eval_indexes` 。默认值：None。
- **amp_level** (str) - `mindspore.build_train_network` 的可选参数 `level`，`level` 为混合精度等级，该参数支持["O0", "O2", "O3", "auto"]。默认值："O0"。
- **amp_level** (str) - `mindspore.build_train_network` 的可选参数 `level` ， `level` 为混合精度等级，该参数支持["O0", "O2", "O3", "auto"]。默认值："O0"。
- "O0": 不变化。
- "O2": 将网络精度转为float16，BatchNorm保持float32精度，使用动态调整损失缩放系数（loss scale）的策略。
@ -21,8 +21,8 @@
- auto: 为不同处理器设置专家推荐的混合精度等级，如在GPU上设为"O2"，在Ascend上设为"O3"。该设置方式可能在部分场景下不适用，建议用户根据具体的网络模型自定义设置 `amp_level` 。
在GPU上建议使用"O2"，在Ascend上建议使用"O3"。
通过`kwargs`设置`keep_batchnorm_fp32`，可修改BatchNorm的精度策略，`keep_batchnorm_fp32`必须为bool类型；通过`kwargs`设置`loss_scale_manager`可修改损失缩放策略，`loss_scale_manager`必须为:class:`mindspore.LossScaleManager`的子类，
关于 `amp_level` 详见 `mindpore.build_train_network`。
通过 `kwargs` 设置 `keep_batchnorm_fp32` ，可修改BatchNorm的精度策略， `keep_batchnorm_fp32` 必须为bool类型；通过 `kwargs` 设置 `loss_scale_manager` 可修改损失缩放策略，`loss_scale_manager` 必须为:class:`mindspore.LossScaleManager` 的子类，
关于 `amp_level` 详见 `mindpore.build_train_network` 。
- **boost_level** (str) – `mindspore.boost` 的可选参数, 为boost模式训练等级。支持[“O0”, “O1”, “O2”]. 默认值: “O0”.
@ -30,7 +30,7 @@
- "O1": 启用boost模式, 性能将提升约20%, 准确率保持不变。
- "O2": 启用boost模式, 性能将提升约30%, 准确率下降小于3%。
如果你想设置boost模式, 可以将 `boost_config_dict` 设置为 `boost.py`。
如果你想设置boost模式, 可以将 `boost_config_dict` 设置为 `boost.py` 。
**样例:**
@ -83,21 +83,6 @@
- jit_level (string): 控制计算图编译优化级别。可选项: o0/o1。默认值: o1。如果设置为o0，则计算图编译将会传入类似于图阶段的组合。
**样例：**
>>> from mindspore import Model, nn, FixedLossScaleManager
>>>
>>> # 如何构建数据集，请参考官方网站的数据集相关章节
>>> dataset = create_custom_dataset()
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> loss_scale_manager = FixedLossScaleManager()
>>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None, loss_scale_manager=loss_scale_manager)
>>> model.build(dataset, epoch=2)
>>> model.train(2, dataset)
>>> model.train(2, dataset)
.. py:method:: eval(valid_dataset, callbacks=None, dataset_sink_mode=True)
模型评估接口。
@ -118,17 +103,6 @@
Dict，key是用户定义的评价指标名称，value是以推理模式运行的评估结果。
**样例：**
>>> from mindspore import Model, nn
>>>
>>> # 如何构建数据集，请参考官方网站的数据集相关章节
>>> dataset = create_custom_dataset()
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> model = Model(net, loss_fn=loss, optimizer=None, metrics={'acc'})
>>> acc = model.eval(dataset, dataset_sink_mode=False)
.. py:method:: eval_network
:property:
@ -156,22 +130,6 @@
- **RuntimeError** – 非图模式（GRAPH_MODE）将会抛出该异常。
**样例：**
>>> # 该例子需要在多设备上运行。请参考mindpore.cn上的教程 > 分布式训练。
>>> import numpy as np
>>> import mindspore as ms
>>> from mindspore import Model, context, Tensor
>>> from mindspore.context import ParallelMode
>>> from mindspore.communication import init
>>>
>>> context.set_context(mode=context.GRAPH_MODE)
>>> init()
>>> context.set_auto_parallel_context(full_batch=True, parallel_mode=ParallelMode.SEMI_AUTO_PARALLEL)
>>> input_data = Tensor(np.random.randint(0, 255, [1, 1, 32, 32]), ms.float32)
>>> model = Model(Net())
>>> model.infer_predict_layout(input_data)
.. py:method:: infer_train_layout(train_dataset, dataset_sink_mode=True, sink_size=-1)
在 `AUTO_PARALLEL` 或 `SEMI_AUTO_PARALLEL` 模式下为训练网络生成参数layout，当前仅支持在数据下沉模式下使用。
@ -190,28 +148,6 @@
Dict，用于加载分布式checkpoint的参数layout字典。
**样例：**
>>> # 该例子需要在多设备上运行。请参考mindpore.cn上的教程 > 分布式训练。
>>> import numpy as np
>>> import mindspore as ms
>>> from mindspore import Model, context, Tensor, nn, FixedLossScaleManager
>>> from mindspore.context import ParallelMode
>>> from mindspore.communication import init
>>>
>>> context.set_context(mode=context.GRAPH_MODE)
>>> init()
>>> context.set_auto_parallel_context(parallel_mode=ParallelMode.SEMI_AUTO_PARALLEL)
>>>
>>> # 如何构建数据集，请参考官方网站上关于[数据集]的章节。
>>> dataset = create_custom_dataset()
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> loss_scale_manager = FixedLossScaleManager()
>>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None, loss_scale_manager=loss_scale_manager)
>>> layout_dict = model.infer_train_layout(dataset)
.. py:method:: predict(*predict_data)
输入样本得到预测结果。

29
docs/api/api_python/mindspore/mindspore.Parameter.rst
View File

@ -3,10 +3,10 @@
.. py:class:: mindspore.Parameter(default_input, name=None, requires_grad=True, layerwise_parallel=False, parallel_optimizer=True)
`Parameter`是`Tensor`的子类，当它们被绑定为Cell的属性时，会自动添加到其参数列表中，并且可以通过Cell的某些方法获取，例如 `cell.get_parameters()` 。
`Parameter` 是 `Tensor` 的子类，当它们被绑定为Cell的属性时，会自动添加到其参数列表中，并且可以通过Cell的某些方法获取，例如 `cell.get_parameters()` 。
.. note::
在"semi_auto_parallel"和"auto_parallel"的并行模式下，如果使用 `Initializer` 模块初始化参数，参数的类型将为 `Tensor` ，:class:`mindspore.ops.AllGather`，`Tensor` 仅保存张量的形状和类型信息，而不占用内存来保存实际数据。并行场景下存在参数的形状发生变化的情况，用户可以调用 `Parameter` 的 `init_data` 方法得到原始数据。如果网络中存在需要部分输入为 `Parameter` 的算子，则不允许这部分输入的 `Parameter` 进行转换。如果在 `Cell` 里初始化一个 `Parameter` 作为 `Cell` 的属性时，建议使用默认值None，否则 `Parameter` 的 `name` 可能与预期不一致。
在"semi_auto_parallel"和"auto_parallel"的并行模式下，如果使用 `Initializer` 模块初始化参数，参数的类型将为 `Tensor` ，:class:`mindspore.ops.AllGather` ，`Tensor` 仅保存张量的形状和类型信息，而不占用内存来保存实际数据。并行场景下存在参数的形状发生变化的情况，用户可以调用 `Parameter` 的 `init_data` 方法得到原始数据。如果网络中存在需要部分输入为 `Parameter` 的算子，则不允许这部分输入的 `Parameter` 进行转换。如果在 `Cell` 里初始化一个 `Parameter` 作为 `Cell` 的属性时，建议使用默认值None，否则 `Parameter` 的 `name` 可能与预期不一致。
**参数：**
@ -16,31 +16,6 @@
- **layerwise_parallel** (bool) - 在数据/混合并行模式下，`layerwise_parallel` 配置为True时，参数广播和梯度聚合时会过滤掉该参数。默认值：False。
- **parallel_optimizer** (bool) - 用于在 `semi_auto_parallel` 或 `auto_parallel` 并行模式下区分参数是否进行优化器切分。仅在 `mindspore.context.set_auto_parallel_context()` 并行配置模块中设置 `enable_parallel_optimizer` 启用优化器并行时有效。默认值：True。
**样例：**
>>> import numpy as np
>>> from mindspore import Parameter, Tensor
>>> import mindspore.ops as ops
>>> import mindspore.nn as nn
>>> import mindspore
>>>
>>> class Net(nn.Cell)：
... def __init__(self)：
... super(Net, self).__init__()
... self.matmul = ops.MatMul()
... self.weight = Parameter(Tensor(np.ones((1, 2)), mindspore.float32), name="w", requires_grad=True)
...
... def construct(self, x)：
... out = self.matmul(self.weight, x)
... return out
>>> net = Net()
>>> x = Tensor(np.ones((2, 1)), mindspore.float32)
>>> print(net(x))
[[2.]]
>>> net.weight.set_data(Tensor(np.zeros((1, 2)), mindspore.float32))
>>> print(net(x))
[[0.]]
.. py:method:: cache_enable
:property:

3
docs/api/api_python/mindspore/mindspore.ParameterTuple.rst
View File

@ -5,7 +5,6 @@ mindspore.ParameterTuple
继承于tuple，用于管理多个Parameter。
.. note::
该类把网络参数存储到参数元组集合中。
@ -16,7 +15,7 @@ mindspore.ParameterTuple
**参数：**
- **prefix** (str) - Parameter的namespace，此前缀将会被添加到Parametertuple中的Parameter的name属性中。
- **init** (Union[Tensor, str, numbers.Number]) - 对Parametertuple中Parameter的shape和类型进行克隆，并根据传入的`init`设置数值。默认值：'same'。
- **init** (Union[Tensor, str, numbers.Number]) - 对Parametertuple中Parameter的shape和类型进行克隆，并根据传入的 `init` 设置数值。默认值：'same'。
如果 `init` 是 `Tensor` ，则新参数的数值与该Tensor相同；
如果 `init` 是 `numbers.Number` ，则设置新参数的数值为该值；
如果 `init` 是 `str` ，则按照 `Initializer` 模块中对应的同名的初始化方法进行数值设定；

23
docs/api/api_python/mindspore/mindspore.RowTensor.rst
View File

@ -25,26 +25,3 @@ mindspore.RowTensor
**返回：**
RowTensor，由 `indices` 、 `values` 和 `dense_shape` 组成。
**样例：**
>>> import mindspore as ms
>>> import mindspore.nn as nn
>>> from mindspore import RowTensor
>>> class Net(nn.Cell):
... def __init__(self, dense_shape)：
... super(Net, self).__init__()
... self.dense_shape = dense_shape
... def construct(self, indices, values)：
... x = RowTensor(indices, values, self.dense_shape)
... return x.values, x.indices, x.dense_shape
>>>
>>> indices = Tensor([0])
>>> values = Tensor([[1, 2]], dtype=ms.float32)
>>> out = Net((3, 2))(indices, values)
>>> print(out[0])
[[1.2.]]
>>> print(out[1])
[0]
>>> print(out[2])
(3, 2)

24
docs/api/api_python/mindspore/mindspore.SparseTensor.rst
View File

@ -21,27 +21,3 @@ mindspore.SparseTensor
**返回：**
SparseTensor，由 `indices` 、 `values` 和 `dense_shape` 组成。
**样例：**
>>> import mindspore as ms
>>> import mindspore.nn as nn
>>> from mindspore import SparseTensor
>>> class Net(nn.Cell)：
... def __init__(self, dense_shape)：
... super(Net, self).__init__()
... self.dense_shape = dense_shape
... def construct(self, indices, values)：
... x = SparseTensor(indices, values, self.dense_shape)
... return x.values, x.indices, x.dense_shape
>>>
>>> indices = Tensor([[0, 1], [1, 2]])
>>> values = Tensor([1, 2], dtype=ms.float32)
>>> out = Net((3, 4))(indices, values)
>>> print(out[0])
[1.2.]
>>> print(out[1])
[[0 1]
[1 2]]
>>> print(out[2])
(3, 4)

550
docs/api/api_python/mindspore/mindspore.Tensor.rst
View File

@ -8,37 +8,14 @@ mindspore.Tensor
**参数：**
- **input_data** (Union[Tensor, float, int, bool, tuple, list, numpy.ndarray]) - 被存储的数据，可以是其它Tensor，也可以是Python基本数据（如int，float，bool等），或是一个NumPy对象。默认值：None。
- **dtype** (:class:`mindspore.dtype`) - 用于定义该Tensor的数据类型，必须是 *mindSpore.dtype* 中定义的类型。如果该参数为None，则数据类型与`input_data`一致，默认值：None。
- **shape** (Union[tuple, list, int]) - 用于定义该Tensor的形状。如果指定了`input_data`，则无需设置该参数。默认值：None。
- **init** (Initializer) - 用于在并行模式中延迟Tensor的数据的初始化，如果指定该参数，则`dtype`和`shape`也必须被指定。不推荐在非自动并行之外的场景下使用该接口。只有当调用`Tensor.init_data`时，才会使用指定的`init`来初始化Tensor数据。默认值：None。
- **dtype** (:class:`mindspore.dtype`) - 用于定义该Tensor的数据类型，必须是 *mindSpore.dtype* 中定义的类型。如果该参数为None，则数据类型与 `input_data` 一致，默认值：None。
- **shape** (Union[tuple, list, int]) - 用于定义该Tensor的形状。如果指定了 `input_data` ，则无需设置该参数。默认值：None。
- **init** (Initializer) - 用于在并行模式中延迟Tensor的数据的初始化，如果指定该参数，则 `dtype` 和 `shape` 也必须被指定。不推荐在非自动并行之外的场景下使用该接口。只有当调用 `Tensor.init_data` 时，才会使用指定的 `init` 来初始化Tensor数据。默认值：None。
**输出：**
Tensor。
**样例：**
>>> import numpy as np
>>> import mindspore as ms
>>> from mindspore import Tensor
>>> from mindspore.common.initializer import One
>>> # 用numpy.ndarray初始化张量
>>> t1 = Tensor(np.zeros([1, 2, 3]), ms.float32)
>>> assert isinstance(t1, Tensor)
>>> assert t1.shape == (1, 2, 3)
>>> assert t1.dtype == ms.float32
>>>
>>> # 用float标量初始化张量
>>> t2 = Tensor(0.1)
>>> assert isinstance(t2, Tensor)
>>> assert t2.dtype == ms.float64
...
>>> # 用init初始化张量
>>> t3 = Tensor(shape = (1, 3), dtype=ms.float32, init=One())
>>> assert isinstance(t3, Tensor)
>>> assert t3.shape == (1, 3)
>>> assert t3.dtype == ms.float32
.. py:method:: T
:property:
@ -52,18 +29,6 @@ mindspore.Tensor
Tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> from mindspore import Tensor
>>> a = Tensor([1.1, -2.1]).astype("float32")
>>> output = a.abs()
>>> print(output)
[1.1 2.1]
.. py:method:: all(axis=(), keep_dims=False)
检查在指定轴上所有元素是否均为True。
@ -77,18 +42,6 @@ mindspore.Tensor
Tensor。如果在指定轴方向上所有数组元素都为True，则其值为True，否则其值为False。如果轴为None或空元组，则默认降维。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> from mindspore import Tensor
>>> a = Tensor([True, True, False])
>>> output = a.all()
>>> print(output)
False
.. py:method:: any(axis=(), keep_dims=False)
检查在指定轴方向上是否存在任意为True的Tensor元素。
@ -102,18 +55,6 @@ mindspore.Tensor
Tensor。如果在指定轴方向上所有Tensor元素都为True，则其值为True，否则其值为False。如果轴为None或空元组，则默认降维。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> from mindspore import Tensor
>>> a = Tensor([True, True, False])
>>> output = a.any()
>>> print(output)
True
.. py:method:: argmax(axis=None)
返回指定轴上最大值的索引。
@ -130,18 +71,6 @@ mindspore.Tensor
- **ValueError** - 入参axis的设定值超出了范围。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> a = Tensor(np.arange(10, 16).reshape(2, 3).astype("float32"))
>>> print(a.argmax())
5
.. py:method:: argmin(axis=None)
返回指定轴上最小值的索引。
@ -158,18 +87,6 @@ mindspore.Tensor
- **ValueError** - 入参axis的设定值超出了范围。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> a = Tensor(np.arange(10, 16).reshape(2, 3).astype("float32"))
>>> print(a.argmin())
0
.. py:method:: asnumpy()
将张量转换为NumPy数组。该方法会将Tensor本身转换为NumPy的ndarray。这个Tensor和函数返回的ndarray共享内存地址。对Tensor本身的修改会反映到相应的ndarray上。
@ -178,25 +95,13 @@ mindspore.Tensor
NumPy的ndarray，该ndarray与Tensor共享内存地址。
**样例：**
>>> from mindspore import Tensor
>>> import numpy as np
>>> x = Tensor(np.array([1,2], dtype=np.float32))
>>> y = x.asnumpy()
>>> y[0] = 11
>>> print(x)
[11. 2.]
>>> print(y)
[11. 2.]
.. py:method:: astype(dtype, copy=True)
将Tensor转为指定数据类型，可指定是否返回副本。
**参数：**
- **dtype** (Union[`mindspore.dtype`, str]) - 指定的Tensor数据类型，可以是: `mindspore.dtype.float32` 或 `float32` 的格式。默认值：`mindspore.dtype.float32` 。
- **dtype** (Union[`mindspore.dtype` , str]) - 指定的Tensor数据类型，可以是: `mindspore.dtype.float32` 或 `float32` 的格式。默认值：`mindspore.dtype.float32` 。
- **copy** (bool, optional) - 默认情况下，astype返回新拷贝的Tensor。如果该参数设为False，则返回输入Tensor而不是副本。默认值：True。
**返回：**
@ -207,19 +112,6 @@ mindspore.Tensor
- **TypeError** - 指定了无法解析的类型。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.ones((1,2,2,1), dtype=np.float32))
>>> x = x.astype("int32")
>>> print(x.dtype)
Int32
.. py:method:: choose(choices, mode='clip')
根据原始Tensor数组和一个索引数组构造一个新的Tensor。
@ -237,23 +129,10 @@ mindspore.Tensor
Tensor，合并后的结果。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**异常：**
- **ValueError** - 输入Tensor和任一 `choices` 无法广播。
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33]]
>>> x = Tensor(np.array([2, 3, 1, 0]))
>>> print(x.choose(choices))
[20 31 12 3]
.. py:method:: clip(xmin, xmax, dtype=None)
裁剪Tensor中的值。
@ -279,18 +158,6 @@ mindspore.Tensor
- **TypeError** - 输入的类型与Tensor不一致。
- **ValueError** - 输入与Tensor的shape不能广播，或者 `xmin` 和 `xmax` 都是 `None` 。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> from mindspore import Tensor
>>> x = Tensor([1, 2, 3, -4, 0, 3, 2, 0]).astype("float32")
>>> output = x.clip(0, 2)
>>> print(output)
[1.2.2.0.0.2.2.0.]
.. py:method:: copy()
复制一个Tensor并返回。
@ -302,21 +169,6 @@ mindspore.Tensor
复制的Tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> a = Tensor(np.ones((3,3)).astype("float32"))
>>> output = a.copy()
>>> print(output)
[[1.1.1.]
[1.1.1.]
[1.1.1.]]
.. py:method:: cumsum(axis=None, dtype=None)
返回指定轴方向上元素的累加值。
@ -327,7 +179,7 @@ mindspore.Tensor
**参数：**
- **axis** (int, optional) - 轴，在该轴方向上的累积和。默认情况下，计算所有元素的累加和。
- **dtype** (`mindspore.dtype`, optional) - 如果未指定参数值，则保持与原始Tensor相同，除非参数值是一个精度小于 `float32` 的整数。在这种情况下，使用 `float32` 。默认值：None。
- **dtype** (`mindspore.dtype` , optional) - 如果未指定参数值，则保持与原始Tensor相同，除非参数值是一个精度小于 `float32` 的整数。在这种情况下，使用 `float32` 。默认值：None。
**异常：**
@ -337,21 +189,6 @@ mindspore.Tensor
Tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> a = Tensor(np.ones((3,3)).astype("float32"))
>>> output = a.cumsum(axis=0)
>>> print(output)
[[1.1.1.]
[2.2.2.]
[3.3.3.]]
.. py:method:: diagonal(offset=0, axis1=0, axis2=1)
返回指定的对角线。
@ -370,22 +207,6 @@ mindspore.Tensor
- **ValueError** - 输入Tensor的维度少于2。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> a = Tensor(np.arange(4).reshape(2, 2))
>>> print(a)
[[0 1]
[2 3]]
>>> output = a.diagonal()
>>> print(output)
[0 3]
.. py:method:: dtype
:property:
@ -403,18 +224,6 @@ mindspore.Tensor
维度与输入张量的相同的Tensor。输出张量的维度必须遵守广播规则。广播规则指输出张量的维度需要扩展为输入张量的维度，如果目标张量的维度大于输入张量的维度，则不满足广播规则。
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore import dtype as mstype
>>> x = Tensor([1, 2, 3], dtype=mstype.float32)
>>> y = Tensor(np.ones((2, 3)), dtype=mstype.float32)
>>> output = x.expand_as(y)
>>> print(output)
[[1. 2. 3.]
[1. 2. 3.]]
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore import dtype as mstype
@ -443,19 +252,6 @@ mindspore.Tensor
- **TypeError** - 输入参数具有前面未指定的类型。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> a = Tensor(np.arange(4).reshape((2,2)).astype('float32'))
>>> print(a.fill(1.0))
[[1.1.]
[1.1.]]
.. py:method:: flatten(order='C')
返回展开成一维的Tensor的副本。
@ -468,37 +264,15 @@ mindspore.Tensor
Tensor，具有与输入相同的数据类型。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**异常：**
- **TypeError** - `order` 不是字符串类型。
- **ValueError** - `order` 是字符串类型，但不是'C'或'F'。
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.ones((2,3,4), dtype=np.float32))
>>> output = x.flatten()
>>> print(output.shape)
(24,)
.. py:method:: flush_from_cache()
如果Tensor开启缓存作用，则将缓存数据刷新到host侧。
**样例：**
>>> from mindspore import Tensor
>>> import numpy as np
>>> x = Tensor(np.array([1, 2], dtype=np.float32))
>>> y = x.flush_from_cache()
>>> print(y)
None
.. py:method:: from_numpy(array)
:staticmethod:
@ -512,15 +286,6 @@ mindspore.Tensor
与输入的张量具有相同的数据类型的Tensor。
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.array([1, 2])
>>> output = Tensor.from_numpy(x)
>>> print(output)
[1 2]
.. py:method:: has_init
:property:
@ -542,20 +307,6 @@ mindspore.Tensor
初始化的Tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import mindspore as ms
>>> import mindspore.common.initializer as init
>>> x = init.initializer(init.Constant(1), [2, 2], ms.float32)
>>> out = x.init_data()
>>> print(out)
[[1.1.]
[1.1.]]
.. py:method:: item(index=None)
获取Tensor中指定索引的元素。
@ -575,19 +326,6 @@ mindspore.Tensor
- **ValueError** - `index` 的长度不等于Tensor的ndim。
**支持平台：**
``Ascend`` ``GPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.array([[1,2,3],[4,5,6]], dtype=np.float32))
>>> x = x.item((0,1))
>>> print(x)
2.0
.. py:method:: itemset(*args)
将标量插入到Tensor（并将标量转换为Tensor的数据类型）。
@ -608,20 +346,6 @@ mindspore.Tensor
- **ValueError** - 第一个参数的长度不等于Tensor的ndim。
- **IndexError** - 只提供了一个参数，并且原来的Tensor不是标量。
**支持平台：**
``Ascend`` ``GPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.array([[1,2,3],[4,5,6]], dtype=np.float32))
>>> x = x.itemset((0,1), 4)
>>> print(x)
[[1.4.3.]
[4.5.6.]]
.. py:method:: itemsize
:property:
@ -646,19 +370,6 @@ mindspore.Tensor
- **TypeError** - 参数具有前面未指定的类型。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> a = Tensor(np.arange(4).reshape((2, 2)).astype('float32'))
>>> output = a.max()
>>> print(output)
3.0
.. py:method:: mean(axis=(), keep_dims=False)
返回指定维度上所有元素的均值，并降维。
@ -672,19 +383,6 @@ mindspore.Tensor
与输入的张量具有相同的数据类型的Tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> input_x = Tensor(np.array([1, 2, 3], dtype=np.float32))
>>> output = input_x.mean()
>>> print(output)
2.0
.. py:method:: min(axis=None, keepdims=False, initial=None, where=True)
返回Tensor的最小值或轴方向上的最小值。
@ -704,20 +402,6 @@ mindspore.Tensor
- **TypeError** - 参数具有前面未指定的类型。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> import mindspore.numpy as np
>>> a = Tensor(np.arange(4).reshape((2,2)).astype('float32'))
>>> output = a.min()
>>> print(output)
0.0
.. py:method:: nbytes
:property:
@ -748,19 +432,6 @@ mindspore.Tensor
- **TypeError** - `self` 不是Tensor，或者 `axis` 和 `keepdims` 具有前面未指定的类型。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> from mindspore import Tensor
>>> x = Tensor([[4.0, 9.0, 2.0, 10.0], [6.0, 9.0, 7.0, 12.0]]).astype("float32")
>>> print(x.ptp(axis=1))
[8.6.]
>>> print(x.ptp(axis=0))
[2.0.5.2.]
.. py:method:: ravel()
返回一个展开的一维Tensor。
@ -769,19 +440,6 @@ mindspore.Tensor
一维Tensor，含有与输入相同的元素。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.ones((2,3,4), dtype=np.float32))
>>> output = x.ravel()
>>> print(output.shape)
(24,)
.. py:method:: repeat(repeats, axis=None)
对数组中的元素进行重复复制。
@ -800,28 +458,6 @@ mindspore.Tensor
- **ValueError** - 维度超出范围。
- **TypeError** - 参数类型不匹配。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.array(3))
>>> print(x.repeat(4))
[3 3 3 3]
>>> x = Tensor(np.array([[1, 2],[3, 4]]))
>>> print(x.repeat(2))
[1 1 2 2 3 3 4 4]
>>> print(x.repeat(3, axis=1))
[[1 1 1 2 2 2]
[3 3 3 4 4 4]]
>>> print(x.repeat([1,2], axis=0))
[[1 2]
[3 4]
[3 4]]
.. py:method:: reshape(*shape)
不改变数据的情况下，将Tensor的shape改为输入的新shape。
@ -839,21 +475,6 @@ mindspore.Tensor
- **TypeError** - 新shape不是整数、列表或元组。
- **ValueError** - 新shape与原来Tensor的shape不兼容。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> from mindspore import Tensor
>>> from mindspore import dtype as mstype
>>> x = Tensor([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]], dtype=mstype.float32)
>>> output = x.reshape((3, 2))
>>> print(output)
[[-0.1 0.3]
[ 3.6 0.4]
[ 0.5 -3.2]]
.. py:method:: resize(*new_shape)
将Tensor改为输入的新shape, 并将不足的元素补0。
@ -869,20 +490,6 @@ mindspore.Tensor
Tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.array([[0, 1], [2, 3]]))
>>> x = x.resize(2, 3)
>>> print(x)
[[0 1 2]
[3 0 0]]
.. py:method:: searchsorted(v, side='left', sorter=None)
查找应插入元素以保存顺序的位置索引。
@ -901,18 +508,6 @@ mindspore.Tensor
- **ValueError** - `side` 或 `sorter` 的参数无效。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.array([1, 2, 3, 4, 5]))
>>> print(x.searchsorted(3))
2
.. py:method:: shape
:property:
@ -940,19 +535,6 @@ mindspore.Tensor
- **TypeError** - 输入的参数类型有误。
- **ValueError** - 指定维度的shape大于1。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.ones((1,2,2,1), dtype=np.float32))
>>> x = x.squeeze()
>>> print(x.shape)
(2, 2)
.. py:method:: std(axis=None, ddof=0, keepdims=False)
计算指定维度的标准差。
@ -973,19 +555,6 @@ mindspore.Tensor
含有标准差数值的Tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> input_x = Tensor(np.array([1, 2, 3, 4], dtype=np.float32))
>>> output = input_x.std()
>>> print(output)
1.118034
.. py:method:: strides
:property:
@ -1014,21 +583,6 @@ mindspore.Tensor
- **TypeError** - input不是Tensor，`axis` 不是整数或整数元组，`keepdims` 不是整数，或者 `initial` 不是标量。
- **ValueError** - 任意轴超出范围或存在重复的轴。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> input_x = Tensor(np.array([-1, 0, 1]).astype(np.float32))
>>> print(input_x.sum())
0.0
>>> input_x = Tensor(np.arange(10).reshape(2, 5).astype(np.float32))
>>> print(input_x.sum(axis=1))
[10.35.]
.. py:method:: swapaxes(axis1, axis2)
交换Tensor的两个维度。
@ -1047,19 +601,6 @@ mindspore.Tensor
- **TypeError** - `axis1` 或 `axis2` 不是整数。
- **ValueError** - `axis1` 或 `axis2` 不在 `[-ndim, ndim-1]` 范围内。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.ones((2,3,4), dtype=np.float32))
>>> output = x.swapaxes(0, 2)
>>> print(output.shape)
(4,3,2)
.. py:method:: take(indices, axis=None, mode='clip')
在指定维度上获取Tensor中的元素。
@ -1082,20 +623,6 @@ mindspore.Tensor
- **ValueError** - `axis` 超出范围，或 `mode` 被设置为'raise'、'wrap'和'clip'以外的值。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> a = Tensor(np.array([4, 3, 5, 7, 6, 8]))
>>> indices = Tensor(np.array([0, 1, 4]))
>>> output = a.take(indices)
>>> print(output)
[4 3 6]
.. py:method:: to_tensor(slice_index=None, shape=None, opt_shard_group=None)
返回init_data()的结果，并获取此Tensor的数据。
@ -1113,20 +640,6 @@ mindspore.Tensor
初始化的Tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import mindspore as ms
>>> import mindspore.common.initializer as init
>>> x = init.initializer(init.Constant(1), [2, 2], ms.float32)
>>> out = x.to_tensor()
>>> print(out)
[[1.1.]
[1.1.]]
.. py:method:: trace(offset=0, axis1=0, axis2=1, dtype=None)
在Tensor的对角线方向上的总和。
@ -1136,7 +649,7 @@ mindspore.Tensor
- **offset** (int, optional) - 对角线与主对角线的偏移。可以是正值或负值。默认为主对角线。
- **axis1** (int, optional) - 二维子数组的第一轴，对角线应该从这里开始。默认为第一轴(0)。
- **axis2** (int, optional) - 二维子数组的第二轴，对角线应该从这里开始。默认为第二轴。
- **dtype** (`mindspore.dtype`, optional) - 默认值为None。覆盖输出Tensor的dtype。
- **dtype** (`mindspore.dtype` , optional) - 默认值为None。覆盖输出Tensor的dtype。
**返回：**
@ -1146,18 +659,6 @@ mindspore.Tensor
**ValueError** - 输入Tensor的维度少于2。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.eye(3, dtype=np.float32))
>>> print(x.trace())
3.0
.. py:method:: transpose(*axes)
返回被转置后的Tensor。
@ -1181,24 +682,11 @@ mindspore.Tensor
- **TypeError** - 输入参数类型有误。
- **ValueError** - `axes` 的数量不等于Tensor.ndim。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> x = Tensor(np.ones((1,2,3), dtype=np.float32))
>>> x = x.transpose()
>>> print(x.shape)
(3, 2, 1)
.. py:method:: var(axis=None, ddof=0, keepdims=False)
在指定维度上的方差。
方差是平均值的平方偏差的平均值，即：:math:`var = mean(abs(x - x.mean())**2)`。
方差是平均值的平方偏差的平均值，即：:math:`var = mean(abs(x - x.mean())**2)` 。
返回方差值。默认情况下计算展开Tensor的方差，否则在指定维度上计算。
@ -1211,23 +699,10 @@ mindspore.Tensor
- **ddof** (int) - δ自由度。默认值：0。计算中使用的除数是 :math:`N - ddof` ，其中 :math:`N` 表示元素的数量。
- **keepdims** (bool) - 默认值：False。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**返回：**
含有方差值的Tensor。
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> input_x = Tensor(np.array([1., 2., 3., 4.], np.float32))
>>> output = input_x.var()
>>> print(output)
1.25
.. py:method:: view(*shape)
根据输入shape重新创建一个Tensor，与原Tensor数据相同。
@ -1239,14 +714,3 @@ mindspore.Tensor
**返回：**
Tensor，具有与输入shape相同的维度。
**样例：**
>>> from mindspore import Tensor
>>> import numpy as np
>>> a = Tensor(np.array([[1,2,3],[2,3,4]], dtype=np.float32))
>>> output = a.view((3,2))
>>> print(output)
[[1.2.]
[3.2.]
[3.4.]]

9
docs/api/api_python/mindspore/mindspore.export.rst
View File

@ -28,12 +28,3 @@ mindspore.export
- **enc_key** (str) - 用于加密的字节类型密钥，有效长度为16、24或者32。
- **enc_mode** (str) - 指定加密模式，当设置 `enc_key` 时，选项有："AES-GCM"，"AES-CBC"。默认值："AES-GCM"。
- **dataset** (Dataset) - 指定数据集的预处理方法，用于将数据集的预处理导入MindIR。
**样例：**
>>> import numpy as np
>>> from mindspore import export, Tensor
>>>
>>> net = LeNet()
>>> input = Tensor(np.ones([1, 1, 32, 32]).astype(np.float32))
>>> export(net, Tensor(input), file_name='lenet', file_format='MINDIR')

10
docs/api/api_python/mindspore/mindspore.get_level.rst
View File

@ -8,13 +8,3 @@ mindspore.get_level
**返回：**
string，日志级别包括4(EXCEPTION)、3(ERROR)、2(WARNING)、1(INFO)和0(DEBUG)。
**样例：**
>>> import os
>>> os.environ['GLOG_v'] = '0'
>>> from mindspore import log as logger
>>> level = logger.get_level()
>>> print(level)
'0'

16
docs/api/api_python/mindspore/mindspore.get_log_config.rst
View File

@ -8,19 +8,3 @@ mindspore.get_log_config
**返回：**
Dict，日志配置字典。
**样例：**
>>> import os
>>> os.environ['GLOG_v'] = '1'
>>> os.environ['GLOG_logtostderr'] = '0'
>>> os.environ['GLOG_log_dir'] = '/var/log'
>>> os.environ['logger_maxBytes'] = '5242880'
>>> os.environ['logger_backupCount'] = '10'
>>> os.environ['GLOG_stderrthreshold'] = '2'
>>> from mindspore import log as logger
>>> config= logger.get_log_config()
>>> print(config)
{'GLOG_v': '1', 'GLOG_logtostderr': '0', 'GLOG_log_dir': '/var/log',
'logger_maxBytes': '5242880', 'logger_backupCount': '10', 'GLOG_stderrthreshold': '2'}

21
docs/api/api_python/mindspore/mindspore.load.rst
View File

@ -5,7 +5,7 @@ mindspore.load
加载MindIR文件。
返回一个可以由 `GraphCell` 执行的对象，更多细节参见类 :class:`mindspore.nn.GraphCell`。
返回一个可以由 `GraphCell` 执行的对象，更多细节参见类 :class:`mindspore.nn.GraphCell` 。
**参数：**
@ -20,22 +20,5 @@ mindspore.load
**异常：**
- **ValueError** – MindIR 文件名不存在或`file_name`不是string类型。
- **ValueError** – MindIR 文件名不存在或 `file_name` 不是string类型。
- **RuntimeError** - 解析MindIR文件失败。
**样例：**
>>> import numpy as np
>>> import mindspore.nn as nn
>>> from mindspore import Tensor, export, load
>>>
>>> net = nn.Conv2d(1, 1, kernel_size=3, weight_init="ones")
>>> input_tensor = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
>>> export(net, input_tensor, file_name="net", file_format="MINDIR")
>>> graph = load("net.mindir")
>>> net = nn.GraphCell(graph)
>>> output = net(input_tensor)
>>> print(output)
[[[[4. 6. 4.]
[6. 9. 6.]
[4. 6. 4.]]]]

8
docs/api/api_python/mindspore/mindspore.load_checkpoint.rst
View File

@ -21,11 +21,3 @@ mindspore.load_checkpoint
**异常：**
- **ValueError** – checkpoint文件格式不正确。
**样例：**
>>> from mindspore import load_checkpoint
>>> ckpt_file_name = "./checkpoint/LeNet5-1_32.ckpt"
>>> param_dict = load_checkpoint(ckpt_file_name, filter_prefix="conv1")
>>> print(param_dict["conv2.weight"])
Parameter (name=conv2.weight, shape=(16, 6, 5, 5), dtype=Float32, requires_grad=True)

11
docs/api/api_python/mindspore/mindspore.load_param_into_net.rst
View File

@ -18,14 +18,3 @@ mindspore.load_param_into_net
**异常：**
- **TypeError** – 如果参数不是Cell，或者 `parameter_dict` 不是Parameter类型的字典。
**样例：**
>>> from mindspore import load_checkpoint, load_param_into_net
>>>
>>> net = Net()
>>> ckpt_file_name = "./checkpoint/LeNet5-1_32.ckpt"
>>> param_dict = load_checkpoint(ckpt_file_name, filter_prefix="conv1")
>>> param_not_load = load_param_into_net(net, param_dict)
>>> print(param_not_load)
['conv1.weight']

19
docs/api/api_python/mindspore/mindspore.merge_sliced_parameter.rst
View File

@ -19,22 +19,3 @@ mindspore.merge_sliced_parameter
- **ValueError** - 合并失败。
- **TypeError** - `sliced_parameters` 不正确或 `strategy` 不是dict。
- **KeyError** - 参数名称不在策略的key中。
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor, merge_sliced_parameter, Parameter
>>>
>>> sliced_parameters = [
... Parameter(Tensor(np.array([0.00023915, 0.00013939, -0.00098059])),
... "network.embedding_table"),
... Parameter(Tensor(np.array([0.00015815, 0.00015458, -0.00012125])),
... "network.embedding_table"),
... Parameter(Tensor(np.array([0.00042165, 0.00029692, -0.00007941])),
... "network.embedding_table"),
... Parameter(Tensor(np.array([0.00084451, 0.00089960, -0.00010431])),
... "network.embedding_table")]
>>> merged_parameter = merge_sliced_parameter(sliced_parameters)
>>> print(merged_parameter)
Parameter (name=network.embedding_table, shape=(12,), dtype=Float64, requires_grad=True)

39
docs/api/api_python/mindspore/mindspore.ms_function.rst
View File

@ -23,42 +23,3 @@ mindspore.ms_function
**异常：**
- **TypeError** – 如果指定了 `input_signature`，但是实际输入的shape和dtype与 `input_signature` 的不相同。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor
>>> from mindspore import ms_function
...
>>> x =tensor(np.ones([1,1,3,3]).astype(np.float32))
>>> y =tensor(np.ones([1,1,3,3]).astype(np.float32))
...
>>> # 通过调用ms_function创建可调用的MindSpore图
>>> def tensor_add(x, y):
... z = x + y
... return z
...
>>> tensor_add_graph = ms_function(fn=tensor_add)
>>> out = tensor_add_graph(x, y)
...
>>> # 通过装饰器@ms_function创建一个可调用的MindSpore图
>>> @ms_function
... def tensor_add_with_dec(x, y):
... z = x + y
... return z
...
>>> out = tensor_add_with_dec(x, y)
...
>>> # 通过带有input_signature参数的装饰器@ms_function创建一个可调用的MindSpore图
>>> @ms_function(input_signature=(Tensor(np.ones([1, 1, 3, 3]).astype(np.float32)),
... Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))))
... def tensor_add_with_sig(x, y):
... z = x + y
... return z
...
>>> out = tensor_add_with_sig(x, y)

16
docs/api/api_python/mindspore/mindspore.parse_print.rst
View File

@ -18,22 +18,6 @@ mindspore.parse_print
**ValueError** – 指定的文件不存在或为空。
**RuntimeError** - 解析文件失败。
**样例：**
>>> import numpy as np
>>> import mindspore.ops as ops
>>> from mindspore.nn as nn
>>> from mindspore import Tensor, context
>>> context.set_context(mode=context.GRAPH_MODE, print_file_path='log.data')
>>> class PrintInputTensor(nn.Cell):
... def __init__(self):
... super().__init__()
... self.print = ops.Print()
...
... def construct(self, input_pra):
... self.print('print:', input_pra)
... return input_pra
>>> x = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]).astype(np.float32)
>>> input_pra = Tensor(x)
>>> net = PrintInputTensor()

7
docs/api/api_python/mindspore/mindspore.save_checkpoint.rst
View File

@ -18,10 +18,3 @@ mindspore.save_checkpoint
**异常：**
- **TypeError** – 如果参数 `save_obj` 类型不为nn.Cell或者list，且如果参数 `integrated_save` 及 `async_save` 非bool类型。
**样例：**
>>> from mindspore import save_checkpoint
>>>
>>> net = Net()
>>> save_checkpoint(net, "lenet.ckpt")

15
docs/api/api_python/nn/mindspore.nn.Accuracy.rst
View File

@ -16,21 +16,6 @@ mindspore.nn.Accuracy
- **eval_type** (str) - 评估的数据集的类型，支持'classification'和'multilabel'。'classification'为单标签分类场景，'multilabel'为多标签分类场景。
默认值：'classification'。
**样例：**
>>> import numpy as np
>>> import mindspore
>>> from mindspore import nn, Tensor
>>>
>>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
>>> y = Tensor(np.array([1, 0, 1]), mindspore.float32)
>>> metric = nn.Accuracy('classification')
>>> metric.clear()
>>> metric.update(x, y)
>>> accuracy = metric.eval()
>>> print(accuracy)
0.6666666666666666
.. py:method:: clear()
内部评估结果清零。

24
docs/api/api_python/nn/mindspore.nn.Adagrad.rst
View File

@ -60,27 +60,3 @@ mindspore.nn.Adagrad
- **TypeError** - `weight_decay` 不是float或int。
- **ValueError** - `loss_scale` 小于或等于0。
- **ValueError** - `accum` 或 `weight_decay` 小于0。
**支持平台：**
``Ascend`` ``CPU`` ``GPU``
**样例：**
>>> net = Net()
>>> #1) 所有参数使用相同的学习率和权重衰减
>>> optim = nn.Adagrad(params=net.trainable_params())
>>>
>>> #2) 使用参数组并设置不同的值
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
... {'params': no_conv_params, 'lr': 0.01},
... {'order_params': net.trainable_params()}]
>>> optim = nn.Adagrad(group_params, learning_rate=0.1, weight_decay=0.0)
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0、梯度中心化使用默认值False。
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
>>>
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> model = Model(net, loss_fn=loss, optimizer=optim)

24
docs/api/api_python/nn/mindspore.nn.Adam.rst
View File

@ -66,29 +66,5 @@ mindspore.nn.Adam
- **ValueError** - `beta1` 、`beta2` 不在（0.0,1.0）范围内。
- **ValueError** - `weight_decay` 小于0。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = Net()
>>> #1) 所有参数使用相同的学习率和权重衰减
>>> optim = nn.Adam(params=net.trainable_params())
>>>
>>> #2) 使用参数组并设置不同的值
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
... {'params': no_conv_params, 'lr': 0.01},
... {'order_params': net.trainable_params()}]
>>> optim = nn.Adam(group_params, learning_rate=0.1, weight_decay=0.0)
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0、梯度中心化使用默认值False。
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
>>>
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> model = Model(net, loss_fn=loss, optimizer=optim)
.. include:: mindspore.nn.optim_target_unique_for_sparse.rst

24
docs/api/api_python/nn/mindspore.nn.AdamOffload.rst
View File

@ -68,27 +68,3 @@ mindspore.nn.AdamOffload
- **ValueError** - `loss_scale` 或 `eps` 不大于0。
- **ValueError** - `beta1` 、 `beta2` 不在（0.0,1.0）范围内。
- **ValueError** - `weight_decay` 小于0。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = Net()
>>> #1) 所有参数使用相同的学习率和权重衰减
>>> optim = nn.AdamOffload(params=net.trainable_params())
>>>
>>> #2) 使用参数分组并设置不同的值
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01},
... {'params': no_conv_params, 'lr': 0.01},
... {'order_params': net.trainable_params()}]
>>> optim = nn.AdamOffload(group_params, learning_rate=0.1, weight_decay=0.0)
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01。
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0。
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
>>>
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> model = Model(net, loss_fn=loss, optimizer=optim)

24
docs/api/api_python/nn/mindspore.nn.AdamWeightDecay.rst
View File

@ -65,27 +65,3 @@ mindspore.nn.AdamWeightDecay
- **ValueError** - `eps` 小于等于0。
- **ValueError** - `beta1` 、 `beta2` 不在（0.0,1.0）范围内。
- **ValueError** - `weight_decay` 小于0。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = Net()
>>> #1) 所有参数使用相同的学习率和权重衰减
>>> optim = nn.AdamWeightDecay(params=net.trainable_params())
>>>
>>> #2) 使用参数分组并设置不同的值
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01},
... {'params': no_conv_params, 'lr': 0.01},
... {'order_params': net.trainable_params()}]
>>> optim = nn.AdamWeightDecay(group_params, learning_rate=0.1, weight_decay=0.0)
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01。
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0。
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
>>>
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> model = Model(net, loss_fn=loss, optimizer=optim)

33
docs/api/api_python/nn/mindspore.nn.Cell.rst
View File

@ -12,10 +12,6 @@
- **auto_prefix** (bool) – 是否自动为Cell及其子Cell生成NameSpace。`auto_prefix` 的设置影响网络参数的命名，如果设置为True，则自动给网络参数的名称添加前缀，否则不添加前缀。默认值：True。
- **flags** (dict) - Cell的配置信息，目前用于绑定Cell和数据集。用户也通过该参数自定义Cell属性。默认值：None。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例** :
>>> import mindspore.nn as nn
@ -107,14 +103,6 @@
Iteration类型，当前Cell及输入 `cells` 的所有子Cell和相对应的名称。
**样例：**
>>> n = Net()
>>> names = []
>>> for m in n.cells_and_names():
... if m[0]:
... names.append(m[0])
.. py:method:: check_names()
检查Cell中的网络参数名称是否重复。
@ -183,13 +171,6 @@
Iteration类型，Cell的parameter。
**样例：**
>>> n = Net()
>>> parameters = []
>>> for item in net.get_parameters():
... parameters.append(item)
.. py:method:: get_scope()
返回Cell的作用域。
@ -292,14 +273,6 @@
迭代器，Cell的名称和Cell本身。
**样例：**
>>> n = Net()
>>> names = []
>>> for m in n.parameters_and_names():
... if m[0]:
... names.append(m[0])
.. py:method:: parameters_broadcast_dict(recurse=True)
获取这个Cell的参数广播字典。
@ -381,12 +354,6 @@
.. note:: 仅在全自动并行(AUTO_PARALLEL)模式下生效。
**样例：**
>>> import mindspore.nn as nn
>>> net = nn.Dense(3, 4)
>>> net.set_data_parallel()
.. py:method:: set_grad(requires_grad=True)
Cell的梯度设置。在PyNative模式下，该参数指定Cell是否需要梯度。如果为True，则在执行正向网络时，将生成需要计算梯度的反向网络。

16
docs/api/api_python/nn/mindspore.nn.CellList.rst
View File

@ -11,22 +11,6 @@ mindspore.nn.CellList
**args** (list，可选) - Cell列表。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import mindspore.nn as nn
>>>
>>> conv = nn.Conv2d(100, 20, 3)
>>> bn = nn.BatchNorm2d(20)
>>> relu = nn.ReLU()
>>> cell_ls = nn.CellList([bn])
>>> cell_ls.insert(0, conv)
>>> cell_ls.append(relu)
>>> cell_ls.extend([relu, relu])
.. py:method:: append(cell)
在列表末尾添加一个Cell。

13
docs/api/api_python/nn/mindspore.nn.Conv1d.rst
View File

@ -66,16 +66,3 @@ mindspore.nn.Conv1d
- **ValueError** - `in_channels` 、 `out_channels` 、 `kernel_size` 、 `stride` 或 `dilation` 小于1。
- **ValueError** - `padding` 小于0。
- **ValueError** - `pad_mode` 不是"same"，"valid"或"pad"。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = nn.Conv1d(120, 240, 4, has_bias=False, weight_init='normal')
>>> x = Tensor(np.ones([1, 120, 640]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 240, 640)

13
docs/api/api_python/nn/mindspore.nn.Conv1dTranspose.rst
View File

@ -59,16 +59,3 @@ mindspore.nn.Conv1dTranspose
- **ValueError** - `in_channels` 、 `out_channels` 、 `kernel_size` 、 `stride` 或 `dilation` 小于1。
- **ValueError** - `padding` 小于0。
- **ValueError** - `pad_mode` 不是"same"，"valid"或"pad"。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = nn.Conv1dTranspose(3, 64, 4, has_bias=False, weight_init='normal', pad_mode='pad')
>>> x = Tensor(np.ones([1, 3, 50]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 64, 53)

13
docs/api/api_python/nn/mindspore.nn.Conv3d.rst
View File

@ -75,16 +75,3 @@ mindspore.nn.Conv3d
- **ValueError** - `padding` 是长度不等于6的tuple。
- **ValueError** - `pad_mode` 不等于"pad"且 `padding` 不等于(0, 0, 0, 0, 0, 0)。
- **ValueError** - `data_format` 不是"NCDHW"。
**支持平台：**
``Ascend`` ``GPU``
**样例：**
>>> x = Tensor(np.ones([16, 3, 10, 32, 32]), mindspore.float32)
>>> conv3d = nn.Conv3d(in_channels=3, out_channels=32, kernel_size=(4, 3, 3))
>>> output = conv3d(x)
>>> print(output.shape)
(16, 32, 10, 32, 32)

14
docs/api/api_python/nn/mindspore.nn.Conv3dTranspose.rst
View File

@ -60,10 +60,6 @@ mindspore.nn.Conv3dTranspose
H_{out} ＝ \left \lfloor{\frac{H_{in} + padding[2] + padding[3] - (\text{dilation[1]} - 1) \times \text{kernel_size[1]} - 1 }{\text{stride[1]}} + 1} \right \rfloor
W_{out} ＝ \left \lfloor{\frac{W_{in} + padding[4] + padding[5] - (\text{dilation[2]} - 1) \times \text{kernel_size[2]} - 1 }{\text{stride[2]}} + 1} \right \rfloor
**支持平台：**
``Ascend`` ``GPU``
**异常：**
- **TypeError** - `in_channels` 、 `out_channels` 或 `group` 不是int。
@ -75,13 +71,3 @@ mindspore.nn.Conv3dTranspose
- **ValueError** - `padding` 是长度不等于6的tuple。
- **ValueError** - `pad_mode` 不等于"pad"且 `padding` 不等于(0, 0, 0, 0, 0, 0)。
- **ValueError** - `data_format` 不是"NCDHW"。
**样例：**
>>> x = Tensor(np.ones([32, 16, 10, 32, 32]), mindspore.float32)
>>> conv3d_transpose = nn.Conv3dTranspose(in_channels=16, out_channels=3, kernel_size=(4, 6, 2),
... pad_mode='pad')
>>> output = conv3d_transpose(x)
>>> print(output.shape)
(32, 3, 13, 37, 33)

18
docs/api/api_python/nn/mindspore.nn.CosineDecayLR.rst
View File

@ -32,21 +32,3 @@ mindspore.nn.CosineDecayLR
- **TypeError:** `decay_steps` 不是整数。
- **ValueError:** `min_lr` 小于0或 `decay_steps` 小于1。
- **ValueError:** `max_lr` 小于或等于0。
**支持平台：**
``Ascend`` ``GPU``
**样例：**
>>> import mindspore
>>> from mindspore import Tensor, nn
>>>
>>> min_lr = 0.01
>>> max_lr = 0.1
>>> decay_steps = 4
>>> global_steps = Tensor(2, mindspore.int32)
>>> cosine_decay_lr = nn.CosineDecayLR(min_lr, max_lr, decay_steps)
>>> result = cosine_decay_lr(global_steps)
>>> print(result)
0.055

73
docs/api/api_python/nn/mindspore.nn.DistributedGradReducer.rst
View File

@ -17,76 +17,3 @@ mindspore.nn.DistributedGradReducer
**异常：**
**ValueError**：如果degree不是int或小于0。
**支持平台：**
``Ascend`` ``GPU``
**样例：**
>>> #此示例应与多个进程一起运行。
>>> #请参考Mindpore.cn上的“教程>分布式训练”。
>>> import numpy as np
>>> from mindspore.communication import init
>>> from mindspore import ops
>>> from mindspore import context
>>> from mindspore.context import ParallelMode
>>> from mindspore import Parameter, Tensor
>>> from mindspore import nn
>>>
>>> context.set_context(mode=context.GRAPH_MODE)
>>> init()
>>> context.reset_auto_parallel_context()
>>> context.set_auto_parallel_context(parallel_mode=ParallelMode.DATA_PARALLEL)
>>>
>>> class TrainingWrapper(nn.Cell):
... def __init__(self, network, optimizer, sens=1.0):
... super(TrainingWrapper, self).__init__(auto_prefix=False)
... self.network = network
... self.network.add_flags(defer_inline=True)
... self.weights = optimizer.parameters
... self.optimizer = optimizer
... self.grad = ops.GradOperation(get_by_list=True, sens_param=True)
... self.sens = sens
... self.reducer_flag = False
... self.grad_reducer = None
... self.parallel_mode = context.get_auto_parallel_context("parallel_mode")
... if self.parallel_mode in [ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL]:
... self.reducer_flag = True
... if self.reducer_flag:
... mean = context.get_auto_parallel_context("gradients_mean")
... degree = context.get_auto_parallel_context("device_num")
... self.grad_reducer = nn.DistributedGradReducer(optimizer.parameters, mean, degree)
...
... def construct(self, *args):
... weights = self.weights
... loss = self.network(*args)
... sens = ops.Fill()(ops.DType()(loss), ops.Shape()(loss), self.sens)
... grads = self.grad(self.network, weights)(*args, sens)
... if self.reducer_flag:
... # apply grad reducer on grads
... grads = self.grad_reducer(grads)
... return ops.Depend(loss, self.optimizer(grads))
>>>
>>> class Net(nn.Cell):
... def __init__(self, in_features, out_features)：
... super(Net, self).__init__()
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
... name='weight')
... self.matmul = ops.MatMul()
...
... def construct(self, x)：
... output = self.matmul(x, self.weight)
... return output
>>>
>>> size, in_features, out_features = 16, 16, 10
>>> network = Net(in_features, out_features)
>>> loss = nn.MSELoss()
>>> net_with_loss = nn.WithLossCell(network, loss)
>>> optimizer = nn.Momentum(net_with_loss.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> train_cell = TrainingWrapper(net_with_loss, optimizer)
>>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
>>> grads = train_cell(inputs, label)
>>> print(grads)
256.0

32
docs/api/api_python/nn/mindspore.nn.DynamicLossScaleUpdateCell.rst
View File

@ -24,38 +24,6 @@ mindspore.nn.DynamicLossScaleUpdateCell
Bool，即输入 `overflow` 。
**支持平台：**
``Ascend`` ``GPU``
**样例：**
>>> import numpy as np
>>> from mindspore import Tensor, Parameter, nn
>>> import mindspore.ops as ops
>>>
>>> class Net(nn.Cell):
... def __init__(self, in_features, out_features)：
... super(Net, self).__init__()
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
... name='weight')
... self.matmul = ops.MatMul()
...
... def construct(self, x)：
... output = self.matmul(x, self.weight)
... return output
...
>>> in_features, out_features = 16, 10
>>> net = Net(in_features, out_features)
>>> loss = nn.MSELoss()
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> net_with_loss = nn.WithLossCell(net, loss)
>>> manager = nn.DynamicLossScaleUpdateCell(loss_scale_value=2**12, scale_factor=2, scale_window=1000)
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager)
>>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
>>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
>>> output = train_network(input, labels)
.. py:method:: get_loss_scale()

4
docs/api/api_python/nn/mindspore.nn.ELU.rst
View File

@ -36,10 +36,6 @@ mindspore.nn.ELU
- **TypeError** - `x` 的数据类型既不是float16也不是float32。
- **ValueError** - `alpha` 不等于1.0。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例** :
>>> x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float32)

18
docs/api/api_python/nn/mindspore.nn.ExponentialDecayLR.rst
View File

@ -41,21 +41,3 @@ mindspore.nn.ExponentialDecayLR
- **TypeError:** `decay_steps` 不是int或 `is_stair` 不是bool。
- **ValueError:** `decay_steps` 小于1。
- **ValueError:** `learning_rate` 或 `decay_rate` 小于或等于0。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> import mindspore
>>> from mindspore import Tensor, nn
>>>
>>> learning_rate = 0.1
>>> decay_rate = 0.9
>>> decay_steps = 4
>>> global_step = Tensor(2, mindspore.int32)
>>> exponential_decay_lr = nn.ExponentialDecayLR(learning_rate, decay_rate, decay_steps)
>>> result = exponential_decay_lr(global_step)
>>> print(result)
0.09486833

14
docs/api/api_python/nn/mindspore.nn.F1.rst
View File

@ -8,17 +8,3 @@ mindspore.nn.F1
.. math::
F_1=\frac{2\cdot true\_positive}{2\cdot true\_positive + false\_negative + false\_positive}
**样例：**
>>> import numpy as np
>>> from mindspore import nn, Tensor
>>>
>>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = Tensor(np.array([1, 0, 1]))
>>> metric = nn.F1()
>>> metric.update(x, y)
>>> result = metric.eval()
>>> print(result)
[0.66666667 0.66666667]

25
docs/api/api_python/nn/mindspore.nn.FTRL.rst
View File

@ -74,30 +74,5 @@ mindspore.nn.FTRL
- **ValueError** - `loss_scale` 小于等于0。
- **ValueError** - `initial_accum`、`l1` 或 `l2` 小于0。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = Net()
>>> #1) 所有参数使用相同的学习率和权重衰减
>>> optim = nn.FTRL(params=net.trainable_params())
>>>
>>> #2) 使用参数分组并设置不同的值
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
... {'params': no_conv_params},
... {'order_params': net.trainable_params()}]
>>> optim = nn.FTRL(group_params, learning_rate=0.1, weight_decay=0.0)
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
>>> # no_conv_params参数组使用优化器中的学习率0.1、优化器中的权重衰减0.0、梯度中心化使用默认值False。
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
>>>
>>>
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> model = Model(net, loss_fn=loss, optimizer=optim)
.. include:: mindspore.nn.optim_target_unique_for_sparse.rst

13
docs/api/api_python/nn/mindspore.nn.FastGelu.rst
View File

@ -26,16 +26,3 @@ mindspore.nn.FastGelu
**异常：**
- **TypeError** - `x` 的数据类型既不是float16也不是float32。
**支持平台：**
``Ascend``
**样例：**
>>> x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
>>> fast_gelu = nn.FastGelu()
>>> output = fast_gelu(x)
>>> print(output)
[[-1.5418735e-01 3.9921875e+00 -9.7473649e-06]
[ 1.9375000e+00 -1.0052517e-03 8.9824219e+00]]

14
docs/api/api_python/nn/mindspore.nn.Fbeta.rst
View File

@ -15,20 +15,6 @@ mindspore.nn.Fbeta
- **beta** (Union[float, int]) - F-measure中的beta系数 。
**样例：**
>>> import numpy as np
>>> from mindspore import nn, Tensor
...
>>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = Tensor(np.array([1, 0, 1]))
>>> metric = nn.Fbeta(1)
>>> metric.clear()
>>> metric.update(x, y)
>>> fbeta = metric.eval()
>>> print(fbeta)
[0.66666667 0.66666667]
.. py:method:: clear()
内部评估结果清零。

Some files were not shown because too many files have changed in this diff Show More