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

add cn api

This commit is contained in:
changzherui 2021-11-24 12:44:52 +08:00
parent de8b6db07c
commit d44e9a19c6
13 changed files with 1504 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

917
docs/api/api_python/mindspore.Tensor.txt Normal file
View File

@ -0,0 +1,917 @@
argmax(axis=None)
返回指定轴上最大值的索引。
参数：
axis (int, optional)：默认情况下，返回扁平化Tensor的最大值序号，否则返回指定轴方向上。
返回：
Tensor，最大值的索引。它具有与此Tensor相同的shape，但移除了轴方向上的维度。
异常：
ValueError：轴超出了范围。
支持平台：
``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
argmin(axis=None)
返回指定轴上最小值的索引。
参数：
axis (int, optional)：返回扁平化Tensor的最小值序号，否则返回指定轴方向上的最小值序号。默认值: None。
返回：
Tensor，最小Tensor的索引。它与Tensor的shape相同，但移除了轴方向上的维度。
异常：
ValueError：轴超出了范围。
支持平台：
``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
astype(dtype, copy=True)
返回Tensor的副本，并将其转换为指定类型。
参数：
dtype (Union[`mindspore.dtype`, str])：指定的Tensor数据类型，可以是:`mindspore.dtype.float32`或`float32`的格式。
默认值：:`mindspore.dtype.float32`。
copy (bool, optional)：默认情况下，astype返回新拷贝的Tensor。如果该参数设为false，则返回输入Tensor而不是副本。默认值：True。
返回：
Tensor，指定数据类型的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
choose(choices, mode='clip')
通过索引数组和Tensor数组中构造一个Tensor。
参数：
choices (Union[tuple, list, Tensor])：选择数组。输入的索引数组和`choose`广播维度必须相同。如果`choices`本身是一个数组，则其最外层的维度（即，对应于`choices.shape[0]`的维度）被用来定义长度。
mode ('raise', 'wrap', 'clip', optional)：指定如何处理`[0, n-1]`外部的索引：
'raise' – 引发异常（默认）；
'wrap' – 绕接；
'clip' – 裁剪到范围。'clip'模式意味着所有过大的索引都将替换为在轴方向上寻址最后一个元素的索引。注：这将禁用具有负数的索引。
返回：
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]
clip(xmin, xmax, dtype=None)
裁剪Tensor中的值。
给定一个区间，区间外的值将被裁剪到区间边缘。
例如，如果指定的间隔为:math:`[0, 1]`，则小于0的值将变为0，大于1的值将变为1。
注：
目前不支持裁剪`xmin=nan`或`xmax=nan`。
参数：
xmin (Tensor, scalar, None)：最小值。如果值为None，则不在间隔的下边缘执行裁剪操作。
`xmin`或`xmax`只能有一个为None。
xmax (Tensor, scalar, None)：最大值。如果值为None，则不在间隔的上边缘执行裁剪操作。
`xmin`或`xmax`只能有一个为None。
如果`xmin`或`xmax`是Tensor，则三个Tensor将被广播进行shape匹配。
dtype (`mindspore.dtype`, optional)：覆盖输出Tensor的dtype。默认值为None。
返回：
Tensor，含有输入Tensor的元素，其中values < `xmin`被替换为`xmin`，values > `xmax`被替换为`xmax`。
异常：
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.]
copy()
返回复制的Tensor。
注：
当前实现不支持类似NumPy的`order`参数。
返回：
复制的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.]]
cumsum(axis=None, dtype=None)
返回指定轴方向上元素的累加值。
注：
如果`dtype`为`int8`, `int16`或`bool`，则结果`dtype`将提升为`int32`，不支持`int64`。
参数：
axis (int, optional)：轴，在该轴方向上的累积和。其默认值（None）用来计算扁平轴上的累加和。
dtype (`mindspore.dtype`, optional)：如果未指定参数值，则保持与原始Tensor相同，除非参数值是一个精度小于：class:`float32`的整数。
在这种情况下，使用`float32`。默认值：None。
异常：
ValueError：轴超出范围。
返回：
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.]]
diagonal(offset=0, axis1=0, axis2=1)
返回指定的对角线。
参数：
offset (int, optional)：对角线与主对角线的偏移。可以是正值或负值。默认为主对角线。
axis1 (int, optional)：二维子数组的第一轴，对角线应该从这里开始。默认为第一轴(0)。
axis2 (int, optional)：二维子数组的第二轴，对角线应该从这里开始。默认为第二轴。
返回：
Tensor，如果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]
fill(value)
用标量值填充数组。
注：
与NumPy不同，Tensor.fill()将始终返回一个新的Tensor，而不是填充原来的Tensor。
参数：
value (Union[None, int, float, bool])：所有元素都被赋予这个值。
返回：
Tensor，与原来的dtype和shape相同的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.]]
flatten(order='C')
返回展开成一维的Tensor的副本。
参数：
order (str, optional)：可以在'C'和'F'之间进行选择。'C'表示按行优先（C风格）顺序展开。'F'表示按列优先顺序（Fortran风格）进行扁平化。
仅支持'C'和'F'。默认值：C。
返回：
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,)
flush_from_cache()
如果Tensor开启缓存作用，则将缓存数据刷新到host侧。
has_init
Tensor是否已经初始化。
init_data(slice_index=None, shape=None, opt_shard_group=None)
获取此Tensor的数据。
对于同一个Tensor，只可以调用一次init_data函数。
参数：
slice_index (int)：参数切片的索引。
在初始化参数切片的时候使用，保证使用相同切片的设备可以生成相同的Tensor。默认值：None。
shape (list[int])：切片的shape，在初始化参数切片时使用。默认值：None。
opt_shard_group(str)：优化器分片组，在自动或半自动并行模式下用于获取参数的切片。默认值：None。
返回：
初始化的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.]]
item(index=None)
使用索引从Tensor中获取值。
注：
Tensor.item返回的是Tensor标量，而不是Python标量。
参数：
index (Union[None, int, tuple(int)])：Tensor的索引。默认值：None。
返回：
Tensor标量，dtype与原始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
itemset(*args)
将标量插入到Tensor（并将标量转换为Tensor的数据类型）。
必须至少有1个参数，并且最后一个参数被定义为项。
Tensor.itemset(\*args)等同于:math:`Tensor[args] = item`。
参数：
args (Union[(numbers.Number), (int/tuple(int), numbers.Number)])：指定索引和值的参数。如果`args`包含一个参数（标量），则其仅在Tensor大小为1的情况下使用。如果`args`包含两个参数，则最后一个参数是要设置的值且必须是标量，而第一个参数指定单个Tensor元素的位置。
参数值是整数或者元组。
返回：
一个新的Tensor，其值为:math:`Tensor[args] = item`。
异常：
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.]]
itemsize
返回一个Tensor元素的长度（以字节为单位）。
max(axis=None, keepdims=False, initial=None, where=True)
返回Tensor的最大值或轴方向上的最大值。
参数：
axis (Union[None, int, tuple of ints], optional)：轴，在该轴方向上进行操作。默认情况下，使用扁平输入。如果该参数为整数元组，则在多个轴上选择最大值，而不是在单个轴或所有轴上进行选择。默认值：None。
keepdims (bool, optional)：
如果这个参数为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果就可以与输入数组进行正确的广播运算。默认值：False。
initial (scalar, optional)：
输出元素的最小值。该参数必须设置，才能对空切片进行计算。默认值：None。
where (bool Tensor, optional)：
一个bool数组，被广播以匹配数组维度和选择包含在降维中的元素。如果传递了一个非默认值，则还必须提供初始值。默认值：True。
返回：
Tensor或标量，输入Tensor的最大值。如果`axis`为None，则结果是一个标量值。如果提供了`axis`，则结果是Tensor ndim - 1维度的一个数组。
异常：
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
min(axis=None, keepdims=False, initial=None, where=True)
返回Tensor的最小值或轴方向上的最小值。
参数：
axis (Union[None, int, tuple of ints], optional)：轴，在该轴方向上进行操作。默认情况下，使用扁平输入。如果该参数为整数元组，则在多个轴上选择最小值，而不是在单个轴或所有轴上进行选择。默认值：None。
keepdims (bool, optional)：
如果这个参数为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果就可以与输入数组进行正确的广播运算。默认值：False。
initial (scalar, optional)：
输出元素的最大值。该参数必须设置，才能对空切片进行计算。默认值：None。
where (bool Tensor, optional)：
一个布尔数组，被广播以匹配数组维度和选择包含在降维中的元素。如果传递了一个非默认值，则还必须提供初始值。默认值：True。
返回：
Tensor或标量，输入Tensor的最小值。如果轴为None，则结果为一个标量值。如果提供了`axis`，则结果是Tensor.ndim - 1维度的一个数组。
异常：
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
nbytes
返回Tensor占用的总字节数。
ndim
返回Tensor维度的数量。
ptp(axis=None, keepdims=False)
该函数名称是"peak to peak"的缩写。
注：
不支持NumPy参数`dtype`和`out`。
参数：
axis (Union[None, int, tuple(int)])：轴，在轴方向上可以计算范围。
默认计算扁平数组的方差。默认值：None。
keepdims (bool)：如果设为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果将针对输入数组正确传递。
默认值为False。
返回：
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.]
ravel()
返回一个展开的一维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,)
repeat(repeats, axis=None)
对数组中的元素进行重复复制。
参数：
repeats (Union[int, tuple, list])：每个元素的重复次数，`repeats`被广播以适应指定轴的shape。
axis (int, optional)：轴方向上的重复值。默认情况下，使用展开的输入Tensor，并返回一个展开的输出Tensor。
返回：
Tensor，除了维度外，与输入Tensor具有相同的shape。
异常：
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]]
reshape(*shape)
不改变数据的情况下，为Tensor提供新的shape。
参数：
shape(Union[int, tuple(int), list(int)])：新的shape应与原来的shape兼容。如果参数值为整数，则结果是该长度的一维数组。shape的维度可以为-1。在这种情况下，将根据数组的长度和剩下的维度计算出该值。
返回：
Tensor，具有新shape的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]]
resize(*new_shape)
更改Tensor的shape。
注：
此方法不更改输入数组的大小，也不返回NumPy中的任何内容，而是返回一个具有输入大小的新Tensor。
不支持Numpy参数`refcheck`。
参数：
new_shape (Union[ints, tuple of ints])：指定Tensor的新shape。
返回：
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]]
searchsorted(v, side='left', sorter=None)
查找应插入元素以保存顺序的位置索引。
参数：
v (Union[int, float, bool, list, tuple, Tensor])：要插入元素的值。
side ('left', 'right', optional)：如果参数值为'left'，则给出找到的第一个合适位置的索引。如果参数值为'right'，则返回最后一个这样的索引。如果没有合适的索引，则返回0或N（其中N是Tensor的长度）。
默认值：`left`。
sorter (Union[int, float, bool, list, tuple, Tensor])：整数索引的可选一维数组，将Tensor按升序排序。它们通常是NumPy argsort方法的结果。
返回：
Tensor，shape与`v`相同的插入点数组。
异常：
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
shape
返回Tensor的shape。
size
返回Tensor中的元素总数。
squeeze(axis=None)
从Tensor中删除shape为1的维度。
参数：
axis (Union[None, int, list(int), tuple(int)], optional)：选择shape中长度为1的条目的子集。如果选择shape条目长度大于1的轴，则报错。默认值为None。
返回：
Tensor，删除了长度为1的维度的全部子集或一个子集。
异常：
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)
std(axis=None, ddof=0, keepdims=False)
计算指定维度的标准差。
标准差是方差的算术平方根，如：:math:`std = sqrt(mean(abs(x - x.mean())**2))`。
返回标准差。默认情况下计算展开数组的标准差，否则在指定维度上计算。
注：
不支持NumPy参数`dtype`、`out`和`where`。
参数：
axis (Union[None, int, tuple(int)])：在该维度上计算标准差。默认值：`None`。
如果为`None`，则计算展开数组的标准偏差。
ddof (int)：δ自由度。计算中使用的除数是:math:`N - ddof`，其中:math:`N`表示元素的数量。默认值：0。
keepdims：默认值：`False`。
返回：
含有标准差数值的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
strides
Tensor上每个维度跨度的字节元组。
sum(axis=None, dtype=None, keepdims=False, initial=None)
返回指定维度上数组元素的总和。
注：
不支持NumPy参数`out`、`where`、`casting`、`order`、`subok`、`signature`和`extobj`。
参数：
axis (Union[None, int, tuple(int)])：指定维度，在该维度方向上进行求和运算。默认值：None。
如果参数值为None，会计算输入数组中所有元素的和。
如果axis为负数，则从最后一维开始往第一维计算。
如果axis为整数元组，会对该元组指定的所有轴方向上的元素进行求和。
dtype (`mindspore.dtype`, optional)：默认值为None。会覆盖输出Tensor的dtype。
keepdims (bool)：如果这个参数为True，被删去的维度保留在结果中，且维度大小设为1。有了这个选项，结果就可以与输入数组进行正确的广播运算。
如果设为默认值，那么keepdims不会被传递给ndarray子类的sum方法。但是任何非默认值都会被传递。如果子类的方法未实现keepdims，则引发异常。默认值：`False`。
initial (scalar)：初始化的起始值。默认值：`None`。
返回：
Tensor。具有与输入相同shape的Tensor，删除了指定的轴。
如果输入Tensor是0维数组，或axis为None时，返回一个标量。
异常：
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.]
swapaxes(axis1, axis2)
交换Tensor的两个维度。
参数：
axis1 (int)：第一个维度。
axis2 (int)：第二个维度。
返回：
转化后的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)
T
返回被转置后的Tensor。
take(indices, axis=None, mode='clip')
在指定维度上获取Tensor中的元素。
参数：
indices (Tensor)：待提取的值的shape为`(Nj...)`的索引。
axis (int, optional)：在指定维度上选择值。默认情况下，使用展开的输入数组。默认值：`None`。
mode ('raise', 'wrap', 'clip', optional)：
- edge：填充Tensor的边缘值。
- raise：引发错误。
- wrap：绕接。
- clip：裁剪到范围。`clip`模式意味着所有过大的索引都会被在指定轴方向上指向最后一个元素的索引替换。注：这将禁用具有负数的索引。
默认值：`clip`。
返回：
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]
to_tensor(slice_index=None, shape=None, opt_shard_group=None)
返回init_data()的结果，并获取此Tensor的数据。
注：
不建议使用`to_tensor`。请使用`init_data`。
参数：
slice_index (int)：参数切片的索引。
在初始化参数切片的时候使用，保证使用相同切片的设备可以生成相同的Tensor。默认值：None。
shape (list[int])：切片的shape，在初始化参数切片时使用。默认值：None。
opt_shard_group(str)：优化器分片组，在自动或半自动并行模式下用于获取参数切片的分片。默认值：None。
返回：
初始化的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.]]
trace(offset=0, axis1=0, axis2=1, dtype=None)
在Tensor的对角线方向上的总和。
参数：
offset (int, optional)：对角线与主对角线的偏移。
可以是正值或负值。默认为主对角线。
axis1 (int, optional)：二维子数组的第一轴，对角线应该从这里开始。默认为第一轴(0)。
axis2 (int, optional)：二维子数组的第二轴，对角线应该从这里开始。默认为第二轴。
dtype (`mindspore.dtype`, optional)：默认值为None。覆盖输出Tensor的dtype。
返回：
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
transpose(*axes)
返回被转置后的Tensor。
- 对于一维Tensor，这没有影响，因为转置后的向量是相同的。
- 对于二维Tensor，是标准的矩阵转置。
- 对于n维Tensor，如果提供了维度，则它们的顺序代表维度的置换方式。
如果未提供轴，且Tensor.shape等于(i[0], i[1],...i[n-2], i[n-1])，则Tensor.transpose().shape等于(i[n-1], i[n-2], ... i[1], i[0])。
参数：
axes(Union[None, tuple(int), list(int), int], optional)：如果axes为None或未设置，则该方法将反转维度。如果axes为tuple(int)或list(int)，则Tensor.transpose()把Tensor转置为新的维度。
如果axes为整数，则此表单仅作为元组/列表表单的备选。
返回：
Tensor，具有与输入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)
var(axis=None, ddof=0, keepdims=False)
在指定维度上的方差。
方差是平均值的平方偏差的平均值，即：:math:`var = mean(abs(x - x.mean())**2)`。
返回方差值。默认情况下计算展开Tensor的方差，否则在指定维度上计算。
注：
不支持NumPy参数`dtype`、`out`和`where`。
参数：
axis (Union[None, int, tuple(int)])：维度，在指定维度上计算方差。
其默认值是展开Tensor的方差。默认值：`None`。
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
view(*shape)
根据输入shape重新创建一个Tensor，与原Tensor数据相同。
参数：
shape (Union[tuple(int), int])：输出Tensor的维度。
返回：
Tensor，具有与输入shape相同的维度。

52
docs/api/api_python/mindspore.export.rst Normal file
View File

@ -0,0 +1,52 @@
mindspore.export
=================
.. py:class:: mindspore.export(net, *inputs, file_name, file_format="AIR", **kwargs)
将MindSpore网络模型导出为指定格式的文件。
.. note::
1. 当导出文件格式为AIR、ONNX时，单个Tensor的大小不能超过2GB。
2. 当file_name 没有后缀时，系统会根据file_format 自动添加后缀。
**参数：**
- **net** (Cell) – MindSpore网络结构。
- **inputs** (Tensor) – 网络的输入，如果网络有多个输入，需要将张量组成元组。
- **file_name** (str) – 导出模型的文件名称。
- **file_format** (str) – MindSpore目前支持导出"AIR"，"ONNX"和"MINDIR"格式的模型。
- **AIR:** Ascend Intermediate Representation。一种Ascend模型的中间表示格式。推荐的输出文件后缀是".air"。
- **ONNX:** Open Neural Network eXchange。一种针对机器学习所设计的开放式的文件格式。推荐的输出文件后缀是“.onnx”。
- **MINDIR:** MindSpore Native Intermediate Representation for Anf。一种MindSpore模型的中间表示格式。推荐的输出文件后缀是".mindir"。
- **kwargs** (dict) – 配置选项字典。
- **quant_mode** (str): 如果网络是量化感知训练网络，那么quant_mode需要设置为"QUANT"，否则quant_mode需要设置为"NONQUANT"。
- **mean** (float): 预处理后输入数据的平均值，用于量化网络的第一层。默认值：127.5。
- **std_dev** (float): 预处理后输入数据的方差，用于量化网络的第一层。默认值：127.5。
- **enc_key** (str): 用于加密的字节类型密钥，有效长度为16、24或者32。
- **enc_mode** (str): 指定加密模式，当设置enc_key时，选项有："AES-GCM"，"AES-CBC"。默认值："AES-GCM"。
- **dataset** (Dataset): 指定数据集的预处理方法，用于将数据集的预处理导入MindIR。
**样例：**
.. code-block::
>>> 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')

38
docs/api/api_python/mindspore.load_checkpoint.rst Normal file
View File

@ -0,0 +1,38 @@
mindspore.load_checkpoint
==========================
.. py:class:: mindspore.load_checkpoint(ckpt_file_name, net=None, strict_load=False, filter_prefix=None, dec_key=None, dec_mode="AES-GCM")
加载checkpoint文件。
**参数：**
- **ckpt_file_name** (str) – checkpoint的文件名称。
- **net** (Cell) – 加载checkpoint参数的网络。默认值：None。
- **strict_load** (bool) – 是否将严格加载参数到网络中。如果是False, 它将根据相同的后缀名将参数字典中的参数加载到网络中，并会在精度不匹配时，进行强制精度转换，比如将float32转换为float16。默认值：False。
- **filter_prefix** (Union[str, list[str], tuple[str]]) – 以filter_prefix开头的参数将不会被加载。默认值：None。
- **dec_key** (Union[None, bytes]) – 用于解密的字节类型密钥，如果值为None，则不需要解密。默认值：None。
- **dec_mode** (str) – 该参数仅当dec_key不为None时有效。指定解密模式，目前支持“AES-GCM”和“AES-CBC”。默认值：“AES-GCM”。
**返回：**
字典，key是参数名称，value是Parameter类型。
**异常：**
**ValueError** – checkpoint文件格式正确。
**样例：**
.. code-block::
>>> 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)

35
docs/api/api_python/mindspore.load_param_into_net.rst Normal file
View File

@ -0,0 +1,35 @@
mindspore.load_param_into_net
=============================
.. py:class:: mindspore.load_param_into_net(net, parameter_dict, strict_load=False)
将参数加载到网络中。
**参数：**
- **net** (Cell) – 将要加载参数的网络。
- **parameter_dict** (dict) – 加载checkpoint文件得到的字典。
- **strict_load** (bool) – 是否将参数严格加载到网络中。如果是False, 它将以相同的后缀名将参数字典中的参数加载到网络中，并会在精度不匹配时，进行精度转换，比如将float32转换为float16。默认值：False。
**返回：**
List，网络中没有被加载的参数。
**异常：**
TypeError – 如果参数不是Cell或者parameter_dict不是Parameter类型的字典。
**样例：**
.. code-block::
>>> 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']

35
docs/api/api_python/mindspore.save_checkpoint.rst Normal file
View File

@ -0,0 +1,35 @@
mindspore.save_checkpoint
=========================
.. py:class:: mindspore.save_checkpoint(save_obj, ckpt_file_name, integrated_save=True, async_save=False, append_dict=None, enc_key=None, enc_mode="AES-GCM")
将网络权重保存到checkpoint文件中。
**参数：**
- **save_obj** (Union[Cell, list]) – Cell对象或者数据列表（列表的每个元素为字典类型，比如[{"name": param_name, “data”: param_data},…]，*param_name* 的类型必须是str，*param_data* 的类型必须是Parameter或者Tensor）。
- **ckpt_file_name** (str) – checkpoint文件名称。如果文件已存在，将会覆盖原有文件。
- **integrated_save** (bool) – 在并行场景下是否合并保存拆分的Tensor。默认值：True。
- **async_save** (bool) – 是否异步执行保存checkpoint文件。默认值：False。
- **append_dict** (dict) – 需要保存的其他信息。dict的键必须为str类型，dict的值类型必须是float或者bool类型。默认值：None。
- **enc_key** (Union[None, bytes]) – 用于加密的字节类型密钥。如果值为None，那么不需要加密。默认值：None。
- **enc_mode** (str) – 该参数在 *enc_key* 不为None时有效，指定加密模式，目前仅支持"AES-GCM"和"AES-CBC"。 默认值：“AES-GCM”。
**异常：**
**TypeError** – 如果参数 *save_obj* 类型不为nn.Cell或者list，且如果参数 *integrated_save* 及 *async_save* 非bool类型。
**样例：**
.. code-block::
>>> from mindspore import save_checkpoint
>>>
>>> net = Net()
>>> save_checkpoint(net, "lenet.ckpt")

74
docs/api/api_python/mindspore.train/mindspore.train.callback.Callback.txt Normal file
View File

@ -0,0 +1,74 @@
Class mindspore.train.callback.Callback
用于构建回调函数的基类。回调函数是一个上下文管理器，在运行模型时被调用。
可以使用此机制进行初始化和释放资源等操作。
回调函数可以在step或epoch中的执行一些操作。
它保存模型相关信息。例如`network`、`train_network`、`epoch_num`、`batch_num`、`loss_fn`、`optimizer`、`parallel_mode`、`device_number`、`list_callback`、`cur_epoch_num`、`cur_step_num`、`dataset_sink_mode`、`net_outputs`等。
示例：
>>> 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
begin(run_context)
在网络执行之前被调用一次。
参数：
run_context (RunContext)：包含模型的一些基本信息。
end(run_context)
网络执行后被调用一次。
参数：
run_context (RunContext)：包含模型的一些基本信息。
epoch_begin(run_context)
在每个epoch开始之前被调用。
参数：
run_context (RunContext)：包含模型的一些基本信息。
epoch_end(run_context)
在每个epoch结束后被调用。
参数：
run_context (RunContext)：包含模型的一些基本信息。
step_begin(run_context)
在每个step开始之前被调用。
参数：
run_context (RunContext)：包含模型的一些基本信息。
step_end(run_context)
在每个step完成后被调用。
参数：
run_context (RunContext)：包含模型的一些基本信息。

98
docs/api/api_python/mindspore.train/mindspore.train.callback.CheckpointConfig.txt Normal file
View File

@ -0,0 +1,98 @@
Class mindspore.train.callback.CheckpointConfig(save_checkpoint_steps=1, save_checkpoint_seconds=0, keep_checkpoint_max=5, keep_checkpoint_per_n_minutes=0, integrated_save=True, async_save=False, saved_network=None, append_info=None, enc_key=None, enc_mode='AES-GCM')
保存checkpoint时的配置策略。
注：
在训练过程中，如果数据集是通过数据通道传输的，建议将save_checkpoint_steps设为循环下沉step数量的整数倍数，
否则，保存checkpoint的时机可能会有偏差。
建议同时只设置一种触发保存checkpoint策略和一种保留checkpoint文件总数策略。
如果同时设置了`save_checkpoint_steps`和`save_checkpoint_seconds`，则`save_checkpoint_seconds`无效。
如果同时设置了`keep_checkpoint_max`和`keep_checkpoint_per_n_minutes`，则`keep_checkpoint_per_n_minutes`无效。
参数：
save_checkpoint_steps (int)：每隔多少个step保存一次checkpoint。默认值：1。
save_checkpoint_seconds (int)：每隔多少秒保存一次checkpoint。
不能同时与save_checkpoint_steps一起使用。默认值：0。
keep_checkpoint_max (int)：最多保存多少个checkpoint文件。默认值：5。
keep_checkpoint_per_n_minutes (int)：每隔多少分钟保存一个checkpoint文件。
不能同时与keep_checkpoint_max一起使用。默认值：0。
integrated_save (bool)：在自动并行场景下，是否合并保存拆分后的Tensor。
合并保存功能仅支持在自动并行场景中使用，在手动并行场景中不支持。默认值：True。
async_save (bool)：是否异步执行保存checkpoint文件。默认值：False。
saved_network (Cell)：保存在checkpoint文件中的网络。如果`saved_network`没有被训练，则保存`saved_network`的初始值。默认值：None。
append_info (list)：保存在checkpoint文件中的信息。支持"epoch_num"、"step_num"和dict类型。
dict的key必须是str，dict的value必须是int、float或bool中的一个。默认值：None。
enc_key (Union[None, bytes])：用于加密的字节类型key。如果值为None，则不需要加密。默认值：None。
enc_mode (str)：仅当enc_key不设为None时，该参数有效。指定了加密模式，目前支持AES-GCM和AES-CBC。默认值：AES-GCM。
异常：
ValueError：输入参数的类型不正确。
示例：
>>> from mindspore import Model, nn
>>> from mindspore.train.callback import ModelCheckpoint, CheckpointConfig
>>>
>>> class LeNet5(nn.Cell)：
... def __init__(self, num_class=10, num_channel=1)：
... 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)
append_dict
获取checkpoint中添加字典里面的值。
async_save
获取是否异步保存checkpoint。
enc_key
获取加密的key值。
enc_mode
获取加密模式。
get_checkpoint_policy()
获取checkpoint的保存策略。
integrated_save
获取是否合并保存拆分后的Tensor。
keep_checkpoint_max
获取最多保存checkpoint文件的数量。
keep_checkpoint_per_n_minutes
获取每隔多少分钟保存一个checkpoint文件。
saved_network
获取_保存的网络。
save_checkpoint_seconds
获取每隔多少秒保存一次checkpoint文件。。
save_checkpoint_steps
获取每隔多少个step保存一次checkpoint文件。

36
docs/api/api_python/mindspore.train/mindspore.train.callback.LearningRateScheduler.txt Normal file
View File

@ -0,0 +1,36 @@
Class mindspore.train.callback.LearningRateScheduler(learning_rate_function)
在训练期间更改学习率。
参数：
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)
step_end(run_context)
在step结束时更改学习率。
参数：
run_context (RunContext)：包含模型的一些基本信息。

23
docs/api/api_python/mindspore.train/mindspore.train.callback.LossMonitor.txt Normal file
View File

@ -0,0 +1,23 @@
Class mindspore.train.callback.LossMonitor(per_print_times=1)
监控训练的loss。
如果loss是NAN或INF，则终止训练。
注：
如果per_print_times为0，则不打印loss。
参数：
per_print_times (int)：表示每隔多少个step打印一次loss。默认值：1。
异常：
ValueError：当per_print_times 不是整数或小于零。
step_end(run_context)
step结束时打印训练loss。
参数：
run_context (RunContext)：包含模型的一些基本信息。

38
docs/api/api_python/mindspore.train/mindspore.train.callback.ModelCheckpoint.txt Normal file
View File

@ -0,0 +1,38 @@
Class mindspore.train.callback.ModelCheckpoint(prefix='CKP', directory=None, config=None)
checkpoint的回调函数。
在训练过程中调用该方法可以保存训练后的网络参数。
注：
在分布式训练场景下，请为每个训练进程指定不同的目录来保存checkpoint文件。否则，可能会训练失败。
参数：
prefix (str)：checkpoint文件的前缀名称。默认值：CKP。
directory (str)：保存checkpoint文件的文件夹路径。
默认情况下，文件保存在当前目录下。默认值：None。
config (CheckpointConfig)：checkpoint策略配置。默认值：None。
异常：
ValueError：如果前缀无效。
TypeError：config不是CheckpointConfig类型。
end(run_context)
在训练结束后，会保存最后一个step的checkpoint。
参数：
run_context (RunContext)：包含模型的一些基本信息。
latest_ckpt_file_name
返回最新的checkpoint路径和文件名。
step_end(run_context)
在step结束时保存checkpoint。
参数：
run_context (RunContext)：包含模型的一些基本信息。

34
docs/api/api_python/mindspore.train/mindspore.train.callback.RunContext.txt Normal file
View File

@ -0,0 +1,34 @@
Class mindspore.train.callback.RunContext(original_args)
提供模型的相关信息。
在Model方法里提供模型的相关信息。
回调函数可以通过调用request_stop()方法来停止循环。
参数：
original_args (dict)：模型的相关信息。
get_stop_requested()
获取是否停止训练标志。
返回：
bool，如果为True，则Model.train()停止迭代。
original_args()
获取模型的相关信息。
返回：
dict，模型的相关信息。
request_stop()
在训练期间设置停止请求。
可以使用此函数请求停止训练。
Model.train()会检查是否调用此函数。

27
docs/api/api_python/mindspore.train/mindspore.train.callback.TimeMonitor.txt Normal file
View File

@ -0,0 +1,27 @@
Class mindspore.train.callback.TimeMonitor(data_size=None)
监控训练时间。
参数：
data_size (int)：表示每隔多少个step打印一次信息。
如果程序在训练期间获取到Model的`batch_num`，则将把`data_size`设为`batch_num`，否则将使用`data_size`。默认值：None。
异常：
ValueError：data_size不是正整数。
epoch_begin(run_context)
在epoch开始时记录时间。
参数：
run_context (RunContext)：包含模型的一些基本信息。
epoch_end(run_context)
在epoch结束时打印epoch的耗时。
参数：
run_context (RunContext)：包含模型的一些基本信息。

97
docs/api/api_python/mindspore.train/mindspore.train.callback.txt Normal file
View File

@ -0,0 +1,97 @@
Class mindspore.train.callback.SummaryCollector(summary_dir, collect_freq=10, collect_specified_data=None, keep_default_action=True, custom_lineage_data=None, collect_tensor_freq=None, max_file_size=None, export_options=None)
SummaryCollector可以收集一些常用信息。
它可以帮助收集loss、学习率、计算图等。
SummaryCollector还可以允许summary算子将数据收集到summary文件中。
注：
1. 不允许在回调列表中存在多个SummaryCollector实例。
2. 并非所有信息都可以在训练阶段或评估阶段收集的。
3. SummaryCollector始终记录summary算子收集的数据。
4. SummaryCollector仅支持Linux系统。
参数：
summary_dir (str)：收集的数据将存储到此目录。
如果目录不存在，将自动创建。
collect_freq (int)：设置数据收集的频率，频率应大于零，单位为`step`。如果设置了频率，将在(current steps % freq)等于0时收集数据，并且将随时收集第一个step。
需要注意的是，如果使用数据下沉模式，单位将变成`epoch`。
不建议过于频繁地收集数据，因为这可能会影响性能。默认值：10。
collect_specified_data (Union[None, dict])：对收集的数据进行自定义操作。
默认情况下，如果该参数设为None，则默认收集所有数据。
您可以使用字典自定义需要收集的数据类型。
例如，您可以设置{'collect_metric':False}不去收集metrics。
支持控制的数据如下。默认值：None。
- collect_metric (bool)：表示是否收集训练metrics，目前只收集loss。
把第一个输出视为loss，并且算出其平均数。
可选值：True/False。默认值：True。
- collect_graph (bool)：表示是否收集计算图。目前只收集训练计算图。可选值：True/False。默认值：True。
- collect_train_lineage (bool)：表示是否收集训练阶段的lineage数据，该字段将显示在MindInsight的lineage页面上。可选值：True/False。默认值：True。
- collect_eval_lineage (bool)：表示是否收集评估阶段的lineage数据，该字段将显示在MindInsight的lineage页面上。可选值：True/False。默认值：True。
- collect_input_data (bool)：表示是否为每次训练收集数据集。
目前仅支持图像数据。
如果数据集中有多列数据，则第一列应为图像数据。
可选值：True/False。默认值：True。
- collect_dataset_graph (bool)：表示是否收集训练阶段的数据集图。
可选值：True/False。默认值：True。
- histogram_regular (Union[str, None])：收集参数分布页面的权重和偏置，并在MindInsight中展示。此字段允许常规字符串控制要收集的参数。
不建议一次收集太多参数，因为这会影响性能。
注：如果收集的参数太多并且内存不足，训练将会失败。
默认值：None，表示只收集前五个参数。
keep_default_action (bool)：此字段影响collect_specified_data字段的收集行为。
True：表示设置指定数据后，默认收集非指定数据。
False：表示设置指定数据后，只收集指定数据，不收集其他数据。可选值：True/False，默认值：True。
custom_lineage_data (Union[dict, None])：允许您自定义数据并将数据显示在MingInsight的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，表示不导出数据。
- tensor_format (Union[str, None])：自定义导出的tensor的格式。支持["npy", None]。
默认值：None，表示不导出tensor。
- npy：将tensor导出为NPY文件。
异常：
ValueError：参数值与预期的不同。
TypeError：参数类型与预期的不同。
RuntimeError：数据采集过程中出现错误。
示例：
>>> 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)