mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/function/spectral_func.py

@@ -42,11 +42,11 @@ def blackman_window(window_length, periodic=True, *, dtype=None):
         window_length (Tensor): The size of returned window, with data type int32, int64.
             The input data should be an integer with a value of [0, 1000000].
         periodic (bool, optional): Indicates whether to returns a window to be used as periodic function or
-            a symmetric window. Default: True.
+            a symmetric window. Default: ``True`` .
 
     Keyword Args:
         dtype (mindspore.dtype, optional): The data type of returned tensor.
-            Only float16, float32 and float64 is allowed. Default: None.
+            Only float16, float32 and float64 is allowed. Default: ``None`` .
 
     Returns:
         A 1-D tensor of size `window_length` containing the window. Its datatype is set by the attr `dtype`.
@@ -64,6 +64,8 @@ def blackman_window(window_length, periodic=True, *, dtype=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> window_length = Tensor(10, mindspore.int32)
         >>> output = ops.blackman_window(window_length, periodic=True, dtype=mindspore.float32)
         >>> print(output)
@@ -104,11 +106,11 @@ def bartlett_window(window_length, periodic=True, *, dtype=None):
         window_length (Tensor): The size of returned window, with data type int32, int64.
             The input data should be an integer with a value of [0, 1000000].
         periodic (bool, optional): Indicates whether to returns a window to be used as periodic function or
-            a symmetric window. Default: True.
+            a symmetric window. Default: ``True`` .
 
     Keyword Args:
         dtype (mindspore.dtype, optional): The datatype of returned tensor.
-            Only float16, float32 and float64 are allowed. Default: None.
+            Only float16, float32 and float64 are allowed. Default: ``None`` .
 
     Returns:
         A 1-D tensor of size `window_length` containing the window. Its datatype is set by the attr `dtype`.
@@ -126,6 +128,8 @@ def bartlett_window(window_length, periodic=True, *, dtype=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> window_length = Tensor(5, mstype.int32)
         >>> output = ops.bartlett_window(window_length, periodic=True, dtype=mstype.float32)
         >>> print(output)

mindspore/ops/function/vmap_func.py

@@ -26,9 +26,11 @@ def vmap(fn, in_axes=0, out_axes=0):
 
     Vmap is pioneered by Jax and it removes the restriction of batch dimension on the operator, and provides a
     more convenient and unified operator expression. Moreover, it allows users to composite with other functional
-    modules such as :func:`mindspore.grad`, to improve the development efficiency. In addition, the vectorizing
-    map does not execute loops outside the function, but sinks loops into the primitive operations of the function
-    for better performance. When combined with `Graph Kernel Fusion`, operational efficiency would be further improved.
+    modules such as :func:`mindspore.grad`, to improve the development efficiency, please refer to the
+    `Automatic Vectorization (Vmap) <https://www.mindspore.cn/tutorials/experts/en/r2.2/vmap/vmap.html>`_ tutorial
+    for more detail. In addition, the vectorizing map does not execute loops outside the function, but sinks loops
+    into the primitive operations of the function for better performance. When combined with `Graph Kernel Fusion`,
+    operational efficiency would be further improved.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -36,8 +38,7 @@ def vmap(fn, in_axes=0, out_axes=0):
     Note:
         1. The power of vmap comes from the implementation of VmapRules of primitives. Although we have designed a
         generalized rule for user custom operators, we can not guarantee that it works well for all operators,
-        please be aware the risk of use. If you want to achieve a better performance, please refer to the tutorial to
-        implement the specific VmapRule for the custom operator, which won't take too much time.
+        unknown exceptions may occur, please be aware the risk of use.
         2. When calling the random number generation methods within the scope of vmap, the same random number is
         generated among vector functions each time. If you expect each vector branch to use different random numbers,
         you need to generate batch random numbers externally in advance and then transfer them to vmap.
@@ -54,14 +55,14 @@ def vmap(fn, in_axes=0, out_axes=0):
             Note that, axis integers must be in range :math:`[-ndim, ndim)` for each argument, where `ndim` is the
             number of dimensions of the corresponding argument.  None means not mapping along any axis. Also the
             mapping axis index of the `in_axes` must have at least one positional parameter not None. The sizes of
-            the mapped axes (`axis_size`) for all arguments must be equal. Default: 0.
+            the mapped axes (`axis_size`) for all arguments must be equal. Default: ``0`` .
         out_axes (Union[int, list, tuple]): Specifies where the mapped dimensions (axes) should appear in the
             outputs. If `out_axes` is an integer, all outputs of `fn` are specified according to this axis. If
             `out_axes` is a tuple or list, which only composed of integers or Nones. And its length also should be equal
             to the number of outputs of `fn`. Note that, axis integers must be in range :math:`[-ndim, ndim)` for each
             output, where `ndim` is the dimension of the output of the `vmap`-mapped function. All outputs with a
             non-None mapped axis must specify a non-None `out_axes`, and if outputs with None mapped axis specifies
-            a non-None `out_axes`, the result broadcasts across the mapped axis. Default: 0.
+            a non-None `out_axes`, the result broadcasts across the mapped axis. Default: ``0`` .
 
     Returns:
         Function, returns the Vectorized/Batched version function of `fn`. The arguments and outputs of this function

mindspore/ops/functional.py

@@ -20,20 +20,23 @@ from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.ops import _constants
 from mindspore.ops.function import *
 from mindspore.ops.function.array_func import narrow, flatten
+from mindspore.ops.function.math_func import all
 from mindspore.ops import operations as P
+from mindspore.ops.operations import array_ops
 from mindspore.ops.primitive import Primitive
 from mindspore.ops.operations import _grad_ops, _csr_ops, _inner_ops, linalg_ops, _scalar_ops, _sequence_ops
 from mindspore.ops.operations.math_ops import Median
 from mindspore.ops.operations.array_ops import UniqueConsecutive
 from mindspore.ops.operations.nn_ops import AdaptiveMaxPool2D
 from mindspore.ops.operations.math_ops import Roll
-from mindspore.ops.composite.math_ops import mm, dot
+from mindspore.ops.composite.math_ops import mm
+from mindspore.ops.function.math_func import dot
 
 typeof = Primitive('typeof')
 hastype = Primitive('hastype')
 cast = P.Cast()
 dtype = P.DType()
-isconstant = Primitive('is_constant')
+isconstant = _inner_ops.IsConstant()
 isconstant.set_const_prim(True)
 merge = P.Merge()
 geswitch = P.GeSwitch()
@@ -50,6 +53,7 @@ mixed_precision_cast = _inner_ops.MixedPrecisionCast()
 is_sequence_value_unknown = Primitive("IsShapeUnKnown")
 is_sequence_shape_unknown = Primitive("IsDimUnKnown")
 is_dynamic_sequence_element_unknown = Primitive("IsElementUnknown")
+is_tensor_bool_cond = Primitive("IsTensorBoolCond")
 
 partial = P.Partial()
 # depend: mount a node to another node
@@ -67,6 +71,10 @@ scalar_le = _scalar_ops.scalar_le()
 scalar_lt = _scalar_ops.scalar_lt()
 scalar_eq = _scalar_ops.scalar_eq()
 scalar_floordiv = _scalar_ops.ScalarFloordiv()
+scalar_log = _scalar_ops.ScalarLog()
+scalar_pow = _scalar_ops.ScalarPow()
+scalar_uadd = _scalar_ops.ScalarUadd()
+scalar_usub = _scalar_ops.ScalarUsub()
 
 tuple_setitem = Primitive('tuple_setitem')
 tuple_getitem = Primitive(_constants.kTupleGetItem)
@@ -85,11 +93,7 @@ make_list = Primitive('make_list')
 make_slice = Primitive('make_slice')
 tuple_equal = Primitive("tuple_equal")
 list_equal = Primitive("list_equal")
-scalar_log = Primitive('scalar_log')
-scalar_pow = Primitive(_constants.kScalarPow)
 scalar_ne = Primitive('scalar_ne')
-scalar_uadd = Primitive(_constants.kScalarUadd)
-scalar_usub = Primitive(_constants.kScalarUsub)
 string_eq = Primitive('string_eq')
 string_concat = Primitive('string_concat')
 bool_not = Primitive("bool_not")
@@ -119,15 +123,16 @@ reduced_shape = Primitive("reduced_shape")
 # shape_mul:input must be shape multiply elements in tuple(shape)
 shape_mul = _sequence_ops.shape_mul()
 
+tensor_operator_registry.register('tuple_to_tensor', _sequence_ops.TupleToTensor)
 tensor_operator_registry.register('add', P.Add)
 tensor_operator_registry.register('addr', addr)
 tensor_operator_registry.register('addcdiv', P.Addcdiv)
 tensor_operator_registry.register('addcmul', P.Addcmul)
-tensor_operator_registry.register('all', P.ReduceAll)
+tensor_operator_registry.register('all', all)
 tensor_operator_registry.register('angle', angle)
 tensor_operator_registry.register('any', P.ReduceAny)
 tensor_operator_registry.register('atan2', atan2)
-tensor_operator_registry.register('abs', P.Abs)
+tensor_operator_registry.register('abs', abs)
 tensor_operator_registry.register('baddbmm', baddbmm)
 tensor_operator_registry.register('geqrf', geqrf)
 tensor_operator_registry.register('histc', histc)
@@ -139,12 +144,15 @@ tensor_operator_registry.register('slogdet', slogdet)
 tensor_operator_registry.register('trace', trace)
 tensor_operator_registry.register('tril', tril)
 tensor_operator_registry.register('chunk', chunk)
+tensor_operator_registry.register('count_nonzero', count_nonzero)
 tensor_operator_registry.register('sqrt', sqrt)
 tensor_operator_registry.register('square', square)
 tensor_operator_registry.register('sub', sub)
 tensor_operator_registry.register('triu', triu)
 tensor_operator_registry.register('tan', P.Tan)
 tensor_operator_registry.register('t', t)
+tensor_operator_registry.register('cauchy', P.Cauchy)
+tensor_operator_registry.register('log_normal', P.LogNormalReverse)
 tensor_operator_registry.register('acos', acos)
 tensor_operator_registry.register('cos', cos)
 tensor_operator_registry.register('acosh', acosh)
@@ -157,10 +165,11 @@ tensor_operator_registry.register('pow', P.Pow)
 tensor_operator_registry.register('negative', neg)
 tensor_operator_registry.register('amin', amin)
 tensor_operator_registry.register('amax', amax)
-tensor_operator_registry.register('mean', P.ReduceMean)
+tensor_operator_registry.register('aminmax', aminmax)
+tensor_operator_registry.register('mean', mean)
 tensor_operator_registry.register('prod', prod)
 tensor_operator_registry.register('round', P.Round)
-tensor_operator_registry.register('reshape', P.Reshape)
+tensor_operator_registry.register('reshape', reshape)
 tensor_operator_registry.register('reverse', P.ReverseV2)
 tensor_operator_registry.register('reverse_sequence', P.ReverseSequence)
 tensor_operator_registry.register('xlogy', P.Xlogy)
@@ -170,8 +179,8 @@ tensor_operator_registry.register('broadcast_to', P.BroadcastTo)
 tensor_operator_registry.register('matmul', matmul)
 tensor_operator_registry.register('inner', inner)
 tensor_operator_registry.register('xdivy', P.Xdivy)
-tensor_operator_registry.register('argmax', P.Argmax)
-tensor_operator_registry.register('argmin', P.Argmin)
+tensor_operator_registry.register('argmax', argmax)
+tensor_operator_registry.register('argmin', argmin)
 tensor_operator_registry.register('cumsum', P.CumSum)
 tensor_operator_registry.register('cummin', cummin)
 tensor_operator_registry.register('cummax', cummax)
@@ -186,6 +195,8 @@ tensor_operator_registry.register('flip', flip)
 tensor_operator_registry.register('fliplr', fliplr)
 tensor_operator_registry.register('flipud', flipud)
 tensor_operator_registry.register('float_power', float_power)
+tensor_operator_registry.register('fmax', fmax)
+tensor_operator_registry.register('fmin', fmin)
 tensor_operator_registry.register('fmod', fmod)
 tensor_operator_registry.register('is_floating_point', is_floating_point)
 tensor_operator_registry.register('bitwise_and', bitwise_and)
@@ -202,15 +213,17 @@ tensor_operator_registry.register('minimum', P.Minimum)
 tensor_operator_registry.register('matrix_power', matrix_power)
 tensor_operator_registry.register('det', det)
 tensor_operator_registry.register('dot', dot)
+tensor_operator_registry.register('outer', outer)
 tensor_operator_registry.register('log1p', log1p)
 tensor_operator_registry.register('logdet', logdet)
 tensor_operator_registry.register('log_matrix_determinant', log_matrix_determinant)
 tensor_operator_registry.register('matrix_determinant', matrix_determinant)
 tensor_operator_registry.register('ceil', P.Ceil)
-tensor_operator_registry.register('fill', P.Fill)
-tensor_operator_registry.register('tile', P.Tile)
+tensor_operator_registry.register('fillv2', P.FillV2)
+tensor_operator_registry.register('tile', tile)
 tensor_operator_registry.register('logit', logit)
-tensor_operator_registry.register('sum', P.ReduceSum)
+tensor_operator_registry.register('sum', sum)
+tensor_operator_registry.register('reducesum', P.ReduceSum)
 tensor_operator_registry.register('split', split)
 tensor_operator_registry.register('tensor_split', tensor_split)
 tensor_operator_registry.register('vsplit', vsplit)
@@ -233,6 +246,7 @@ tensor_operator_registry.register('digamma', digamma)
 tensor_operator_registry.register('lgamma', lgamma)
 tensor_operator_registry.register('logaddexp', logaddexp)
 tensor_operator_registry.register('logaddexp2', logaddexp2)
+tensor_operator_registry.register('logcumsumexp', logcumsumexp)
 tensor_operator_registry.register('logsumexp', logsumexp)
 tensor_operator_registry.register('inverse', inverse)
 tensor_operator_registry.register('invert', invert)
@@ -254,7 +268,7 @@ tensor_operator_registry.register('standard_normal', P.StandardNormal)
 tensor_operator_registry.register('sigmoid', P.Sigmoid)
 tensor_operator_registry.register('median', Median)
 tensor_operator_registry.register('tanh', tanh)
-tensor_operator_registry.register('exp', P.Exp)
+tensor_operator_registry.register('exp', exp)
 tensor_operator_registry.register('addbmm', addbmm)
 tensor_operator_registry.register('addmm', addmm)
 tensor_operator_registry.register('addmv', addmv)
@@ -274,13 +288,22 @@ tensor_operator_registry.register('ldexp', ldexp)
 tensor_operator_registry.register('clamp', clamp)
 tensor_operator_registry.register('fold', fold)
 tensor_operator_registry.register('unfold', unfold)
+tensor_operator_registry.register('diagonal', diagonal)
+tensor_operator_registry.register('diagonal_scatter', diagonal_scatter)
 tensor_operator_registry.register('index_add', index_add)
 tensor_operator_registry.register('greater', greater)
 tensor_operator_registry.register('greater_equal', greater_equal)
 tensor_operator_registry.register('igamma', igamma)
 tensor_operator_registry.register('igammac', igammac)
+tensor_operator_registry.register('lu_solve', lu_solve)
 tensor_operator_registry.register('nextafter', nextafter)
 tensor_operator_registry.register('qr', qr)
+tensor_operator_registry.register('ormqr', ormqr)
+tensor_operator_registry.register('masked_scatter', array_ops.MaskedScatter)
+tensor_operator_registry.register('index_put', array_ops.IndexPut)
+tensor_operator_registry.register('quantile', quantile)
+tensor_operator_registry.register('nanquantile', nanquantile)
+tensor_operator_registry.register('orgqr', orgqr)
 # ms cannot support Tensor(True) compare
 tensor_operator_registry.register('__eq__', equal)
 tensor_operator_registry.register('__ne__', not_equal)
@@ -302,7 +325,9 @@ tensor_operator_registry.register('shape_mul', shape_mul)
 tensor_operator_registry.register('concatenate', P.Concat)
 tensor_operator_registry.register('fill', fill)
 tensor_operator_registry.register('fills', fills)
+tensor_operator_registry.register('fill_diagonal', P.FillDiagonal)
 tensor_operator_registry.register('eye', eye)
+tensor_operator_registry.register('eigvals', eigvals)
 tensor_operator_registry.register('reduce_sum', reduce_sum)
 tensor_operator_registry.register('tensor_slice', tensor_slice)
 tensor_operator_registry.register('select', select)
@@ -318,6 +343,7 @@ tensor_operator_registry.register('log10', log10)
 tensor_operator_registry.register('log2', log2)
 tensor_operator_registry.register('lerp', lerp)
 tensor_operator_registry.register('floor', floor)
+tensor_operator_registry.register('floor_divide', floor_divide)
 # support sparse tensor operators
 tensor_operator_registry.register('csr_add', csr_add)
 tensor_operator_registry.register('csr_mul', csr_mul)
@@ -338,6 +364,8 @@ tensor_operator_registry.register('msort', msort)
 tensor_operator_registry.register('mm', mm)
 tensor_operator_registry.register('nan_to_num', nan_to_num)
 tensor_operator_registry.register('nansum', nansum)
+tensor_operator_registry.register('nanmean', nanmean)
+tensor_operator_registry.register('nanmedian', nanmedian)
 tensor_operator_registry.register('csr_to_coo', csr_to_coo)
 tensor_operator_registry.register('zeros', zeros)
 tensor_operator_registry.register('ones', ones)
@@ -352,6 +380,8 @@ tensor_operator_registry.register('tensor_scatter_min', P.TensorScatterMin)
 tensor_operator_registry.register('tensor_scatter_max', P.TensorScatterMax)
 tensor_operator_registry.register('tensor_scatter_sub', tensor_scatter_sub)
 tensor_operator_registry.register('tensor_scatter_add', tensor_scatter_add)
+tensor_operator_registry.register('slice_scatter', slice_scatter)
+tensor_operator_registry.register('select_scatter', select_scatter)
 tensor_operator_registry.register('bernoulli', bernoulli)
 tensor_operator_registry.register('poisson', P.Poisson)
 tensor_operator_registry.register('randperm', P.Randperm)
@@ -374,6 +404,7 @@ tensor_operator_registry.register('int', P.Cast)
 tensor_operator_registry.register('long', P.Cast)
 tensor_operator_registry.register('cholesky', P.Cholesky)
 tensor_operator_registry.register('cholesky_inverse', P.CholeskyInverse)
+tensor_operator_registry.register('cholesky_solve', cholesky_solve)
 tensor_operator_registry.register('expand', expand)
 tensor_operator_registry.register('cumprod', cumprod)
 tensor_operator_registry.register('diff', diff)