mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/functional.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
+# Copyright 2021-2024 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,22 +19,30 @@
 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.function.array_func import chunk_ext, zero_
+from mindspore.ops.function.math_func import all, argmax_ext
+from mindspore.ops.function.random_func import uniform_ext
 from mindspore.ops import operations as P
 from mindspore.ops.operations import array_ops
+from mindspore.ops.operations._sequence_ops import TensorToTuple
 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 import _grad_ops, _csr_ops, _inner_ops, linalg_ops, _sequence_ops, other_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
 from mindspore.ops.function.math_func import dot
+from mindspore.ops import auto_generate
+from mindspore.ops.auto_generate import cast
+from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum
+from mindspore.ops.operations.manually_defined.ops_def import scalar_div, scalar_mod, scalar_add, scalar_mul, \
+    scalar_sub, scalar_gt, scalar_ge, scalar_le, scalar_lt, scalar_eq, scalar_floordiv, scalar_log, scalar_pow, \
+    scalar_uadd, scalar_usub, flash_attention_score
 
 typeof = Primitive('typeof')
 hastype = Primitive('hastype')
-cast = P.Cast()
+_cast = P.Cast()
 dtype = P.DType()
 isconstant = _inner_ops.IsConstant()
 isconstant.set_const_prim(True)
@@ -48,6 +56,8 @@ tensor_range = P.Range()
 tensor_scatter_update = P.TensorScatterUpdate()
 scatter_nd_update = P.ScatterNdUpdate()
 mixed_precision_cast = _inner_ops.MixedPrecisionCast()
+_py_interpret = other_ops.PyInterpret()
+_dtype_to_enum = DtypeToEnum()
 
 # Dynamic shape
 is_sequence_value_unknown = Primitive("IsShapeUnKnown")
@@ -60,22 +70,6 @@ partial = P.Partial()
 depend = P.Depend()
 identity = P.identity()
 # tuple/list/scalar ops
-scalar_div = _scalar_ops.ScalarDiv()
-scalar_mod = _scalar_ops.ScalarMod()
-scalar_add = _scalar_ops.ScalarAdd()
-scalar_mul = _scalar_ops.ScalarMul()
-scalar_sub = _scalar_ops.ScalarSub()
-scalar_gt = _scalar_ops.scalar_gt()
-scalar_ge = _scalar_ops.scalar_ge()
-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)
 list_getitem = Primitive('list_getitem')
@@ -96,7 +90,7 @@ list_equal = Primitive("list_equal")
 scalar_ne = Primitive('scalar_ne')
 string_eq = Primitive('string_eq')
 string_concat = Primitive('string_concat')
-bool_not = Primitive("bool_not")
+bool_not = Primitive('BoolNot')
 bool_or = Primitive("bool_or")
 bool_and = Primitive("bool_and")
 bool_eq = Primitive("bool_eq")
@@ -123,333 +117,348 @@ 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', 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', abs)
-tensor_operator_registry.register('baddbmm', baddbmm)
-tensor_operator_registry.register('geqrf', geqrf)
-tensor_operator_registry.register('histc', histc)
-tensor_operator_registry.register('real', real)
-tensor_operator_registry.register('reciprocal', reciprocal)
-tensor_operator_registry.register('rsqrt', rsqrt)
-tensor_operator_registry.register('bincount', bincount)
-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)
-tensor_operator_registry.register('cosh', P.Cosh)
-tensor_operator_registry.register('cov', cov)
-tensor_operator_registry.register('asin', asin)
-tensor_operator_registry.register('sin', sin)
-tensor_operator_registry.register('sinc', sinc)
-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('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', reshape)
-tensor_operator_registry.register('reverse', P.ReverseV2)
-tensor_operator_registry.register('reverse_sequence', P.ReverseSequence)
-tensor_operator_registry.register('xlogy', P.Xlogy)
-tensor_operator_registry.register('flatten', flatten)
-tensor_operator_registry.register('transpose', P.Transpose)
-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', 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)
-tensor_operator_registry.register('nelement', numel)
-tensor_operator_registry.register('numel', numel)
-tensor_operator_registry.register('positive', positive)
-tensor_operator_registry.register('permute', permute)
-tensor_operator_registry.register('remainder', remainder)
-tensor_operator_registry.register('index_fill', index_fill)
-tensor_operator_registry.register('index_select', index_select)
-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)
-tensor_operator_registry.register('bitwise_or', bitwise_or)
-tensor_operator_registry.register('bitwise_xor', bitwise_xor)
-tensor_operator_registry.register('bitwise_left_shift', bitwise_left_shift)
-tensor_operator_registry.register('bitwise_right_shift', bitwise_right_shift)
-tensor_operator_registry.register('ger', ger)
-tensor_operator_registry.register('reduce_max', P.ReduceMax)
-tensor_operator_registry.register('reduce_min', P.ReduceMin)
-tensor_operator_registry.register('random_categorical', random_categorical)
-tensor_operator_registry.register('mirror_pad', P.MirrorPad)
-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('fillv2', P.FillV2)
-tensor_operator_registry.register('tile', tile)
-tensor_operator_registry.register('logit', logit)
-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)
-tensor_operator_registry.register('hsplit', hsplit)
-tensor_operator_registry.register('dsplit', dsplit)
-tensor_operator_registry.register('select', P.Select)
-tensor_operator_registry.register('zeros_like', P.ZerosLike)
-tensor_operator_registry.register('scalar_to_tensor', scalar_to_tensor)
-tensor_operator_registry.register('stop_gradient', stop_gradient)
-tensor_operator_registry.register('masked_fill', masked_fill)
-tensor_operator_registry.register('masked_select', masked_select)
-tensor_operator_registry.register('nonzero', nonzero)
-tensor_operator_registry.register('i0', i0)
-tensor_operator_registry.register('isclose', isclose)
-tensor_operator_registry.register('isneginf', isneginf)
-tensor_operator_registry.register('isposinf', isposinf)
-tensor_operator_registry.register('isreal', isreal)
-tensor_operator_registry.register('inv', inv)
-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)
-tensor_operator_registry.register('hardshrink', P.HShrink)
-tensor_operator_registry.register('heaviside', heaviside)
-tensor_operator_registry.register('hypot', hypot)
-tensor_operator_registry.register('soft_shrink', soft_shrink)
-tensor_operator_registry.register('svd', linalg_ops.Svd)
-tensor_operator_registry.register('diag', P.Diag)
-tensor_operator_registry.register('diagflat', diagflat)
-tensor_operator_registry.register('unique_consecutive', UniqueConsecutive)
-tensor_operator_registry.register('unique_with_pad', P.UniqueWithPad)
-tensor_operator_registry.register('inplace_update', P.InplaceUpdateV2)
-tensor_operator_registry.register('col2im', col2im)
-tensor_operator_registry.register('standard_laplace', P.StandardLaplace)
-tensor_operator_registry.register('erf', P.Erf)
-tensor_operator_registry.register('erfc', P.Erfc)
-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', exp)
-tensor_operator_registry.register('addbmm', addbmm)
-tensor_operator_registry.register('addmm', addmm)
-tensor_operator_registry.register('addmv', addmv)
-tensor_operator_registry.register('adjoint', adjoint)
-tensor_operator_registry.register('asinh', asinh)
-tensor_operator_registry.register('arcsinh', arcsinh)
-tensor_operator_registry.register('atan', atan)
-tensor_operator_registry.register('atanh', atanh)
-tensor_operator_registry.register('arctanh', arctanh)
-tensor_operator_registry.register('bmm', bmm)
-tensor_operator_registry.register('conj', conj)
-tensor_operator_registry.register('cross', cross)
-tensor_operator_registry.register('erfinv', erfinv)
-tensor_operator_registry.register('less_equal', less_equal)
-tensor_operator_registry.register('lcm', lcm)
-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)
+setattr(tensor_operator_registry, 'tuple_to_tensor',
+        _sequence_ops.TupleToTensor)
+setattr(tensor_operator_registry, 'add', add)
+setattr(tensor_operator_registry, 'softmax', softmax)
+setattr(tensor_operator_registry, 'addr', addr)
+setattr(tensor_operator_registry, 'addcdiv', addcdiv)
+setattr(tensor_operator_registry, 'addcmul', addcmul)
+setattr(tensor_operator_registry, 'all', all)
+setattr(tensor_operator_registry, 'angle', angle)
+setattr(tensor_operator_registry, 'any', any)
+setattr(tensor_operator_registry, 'atan2', atan2)
+setattr(tensor_operator_registry, 'abs', abs)
+setattr(tensor_operator_registry, 'baddbmm', baddbmm)
+setattr(tensor_operator_registry, 'geqrf', geqrf)
+setattr(tensor_operator_registry, 'histc', histc)
+setattr(tensor_operator_registry, 'real', real)
+setattr(tensor_operator_registry, 'reciprocal', reciprocal)
+setattr(tensor_operator_registry, 'rsqrt', rsqrt)
+setattr(tensor_operator_registry, 'bincount', bincount)
+setattr(tensor_operator_registry, 'slogdet', slogdet)
+setattr(tensor_operator_registry, 'trace', trace)
+setattr(tensor_operator_registry, 'tracev2', auto_generate.trace_v2_op)
+setattr(tensor_operator_registry, 'tril', tril)
+setattr(tensor_operator_registry, 'chunk', chunk)
+setattr(tensor_operator_registry, 'count_nonzero', count_nonzero)
+setattr(tensor_operator_registry, 'sqrt', sqrt)
+setattr(tensor_operator_registry, 'square', square)
+setattr(tensor_operator_registry, 'sub', sub)
+setattr(tensor_operator_registry, 'triu', triu)
+setattr(tensor_operator_registry, 'tan', tan)
+setattr(tensor_operator_registry, 't', t)
+setattr(tensor_operator_registry, 'cauchy', P.Cauchy)
+setattr(tensor_operator_registry, 'log_normal', P.LogNormalReverse)
+setattr(tensor_operator_registry, 'acos', acos)
+setattr(tensor_operator_registry, 'cos', cos)
+setattr(tensor_operator_registry, 'acosh', acosh)
+setattr(tensor_operator_registry, 'cosh', cosh)
+setattr(tensor_operator_registry, 'cov', cov)
+setattr(tensor_operator_registry, 'asin', asin)
+setattr(tensor_operator_registry, 'sin', sin)
+setattr(tensor_operator_registry, 'sinc', sinc)
+setattr(tensor_operator_registry, 'pow', pow)
+setattr(tensor_operator_registry, 'negative', neg)
+setattr(tensor_operator_registry, 'amin', amin)
+setattr(tensor_operator_registry, 'amax', amax)
+setattr(tensor_operator_registry, 'aminmax', aminmax)
+setattr(tensor_operator_registry, 'mean', mean)
+setattr(tensor_operator_registry, 'prod', prod)
+setattr(tensor_operator_registry, 'round', round)
+setattr(tensor_operator_registry, 'reshape', reshape)
+setattr(tensor_operator_registry, 'reverse', reverse)
+setattr(tensor_operator_registry, 'reverse_sequence', reverse_sequence)
+setattr(tensor_operator_registry, 'xlogy', xlogy)
+setattr(tensor_operator_registry, 'flatten', flatten)
+setattr(tensor_operator_registry, 'transpose', transpose)
+setattr(tensor_operator_registry, 'broadcast_to', broadcast_to)
+setattr(tensor_operator_registry, 'matmul', matmul)
+setattr(tensor_operator_registry, 'inner', inner)
+setattr(tensor_operator_registry, 'xdivy', xdivy)
+setattr(tensor_operator_registry, 'argmax', argmax)
+setattr(tensor_operator_registry, 'argmin', argmin)
+setattr(tensor_operator_registry, 'cumsum', P.CumSum)
+setattr(tensor_operator_registry, 'cummin', cummin)
+setattr(tensor_operator_registry, 'cummax', cummax)
+setattr(tensor_operator_registry, 'nelement', numel)
+setattr(tensor_operator_registry, 'numel', numel)
+setattr(tensor_operator_registry, 'positive', positive)
+setattr(tensor_operator_registry, 'permute', permute)
+setattr(tensor_operator_registry, 'remainder', remainder)
+setattr(tensor_operator_registry, 'index_fill', index_fill)
+setattr(tensor_operator_registry, 'index_select', index_select)
+setattr(tensor_operator_registry, 'flip', flip)
+setattr(tensor_operator_registry, 'fliplr', fliplr)
+setattr(tensor_operator_registry, 'flipud', flipud)
+setattr(tensor_operator_registry, 'float_power', float_power)
+setattr(tensor_operator_registry, 'fmax', fmax)
+setattr(tensor_operator_registry, 'fmin', fmin)
+setattr(tensor_operator_registry, 'fmod', fmod)
+setattr(tensor_operator_registry, 'is_floating_point', is_floating_point)
+setattr(tensor_operator_registry, 'bitwise_and', bitwise_and)
+setattr(tensor_operator_registry, 'bitwise_or', bitwise_or)
+setattr(tensor_operator_registry, 'bitwise_xor', bitwise_xor)
+setattr(tensor_operator_registry, 'bitwise_left_shift', bitwise_left_shift)
+setattr(tensor_operator_registry, 'bitwise_right_shift', bitwise_right_shift)
+setattr(tensor_operator_registry, 'ger', ger)
+setattr(tensor_operator_registry, 'reduce_max', P.ReduceMax)
+setattr(tensor_operator_registry, 'reduce_min', P.ReduceMin)
+setattr(tensor_operator_registry, 'random_categorical', random_categorical)
+setattr(tensor_operator_registry, 'mirror_pad', P.MirrorPad)
+setattr(tensor_operator_registry, 'minimum', minimum)
+setattr(tensor_operator_registry, 'matrix_power', matrix_power)
+setattr(tensor_operator_registry, 'det', det)
+setattr(tensor_operator_registry, 'dot', dot)
+setattr(tensor_operator_registry, 'outer', outer)
+setattr(tensor_operator_registry, 'log1p', log1p)
+setattr(tensor_operator_registry, 'logdet', logdet)
+setattr(tensor_operator_registry,
+        'log_matrix_determinant', log_matrix_determinant)
+setattr(tensor_operator_registry, 'matrix_determinant', matrix_determinant)
+setattr(tensor_operator_registry, 'ceil', ceil)
+setattr(tensor_operator_registry, 'fillv2', P.FillV2)
+setattr(tensor_operator_registry, 'tile', tile)
+setattr(tensor_operator_registry, 'logit', logit)
+setattr(tensor_operator_registry, 'sum', sum)
+setattr(tensor_operator_registry, 'split', split)
+setattr(tensor_operator_registry, 'tensor_split', tensor_split)
+setattr(tensor_operator_registry, 'vsplit', vsplit)
+setattr(tensor_operator_registry, 'hsplit', hsplit)
+setattr(tensor_operator_registry, 'dsplit', dsplit)
+setattr(tensor_operator_registry, 'zeros_like', zeros_like)
+setattr(tensor_operator_registry, 'zero_', zero_)
+setattr(tensor_operator_registry, 'scalar_to_tensor', scalar_to_tensor)
+setattr(tensor_operator_registry, 'stop_gradient', stop_gradient)
+setattr(tensor_operator_registry, 'masked_fill', masked_fill)
+setattr(tensor_operator_registry, 'masked_select', masked_select)
+setattr(tensor_operator_registry, 'nonzero', nonzero)
+setattr(tensor_operator_registry, 'i0', i0)
+setattr(tensor_operator_registry, 'isclose', isclose)
+setattr(tensor_operator_registry, 'isneginf', isneginf)
+setattr(tensor_operator_registry, 'isposinf', isposinf)
+setattr(tensor_operator_registry, 'isreal', isreal)
+setattr(tensor_operator_registry, 'inv', inv)
+setattr(tensor_operator_registry, 'digamma', digamma)
+setattr(tensor_operator_registry, 'lgamma', lgamma)
+setattr(tensor_operator_registry, 'logaddexp', logaddexp)
+setattr(tensor_operator_registry, 'logaddexp2', logaddexp2)
+setattr(tensor_operator_registry, 'logcumsumexp', logcumsumexp)
+setattr(tensor_operator_registry, 'logsumexp', logsumexp)
+setattr(tensor_operator_registry, 'inverse', inverse)
+setattr(tensor_operator_registry, 'invert', invert)
+setattr(tensor_operator_registry, 'hardshrink', hardshrink)
+setattr(tensor_operator_registry, 'heaviside', heaviside)
+setattr(tensor_operator_registry, 'hypot', hypot)
+setattr(tensor_operator_registry, 'searchsorted', P.SearchSorted)
+setattr(tensor_operator_registry, 'soft_shrink', soft_shrink)
+setattr(tensor_operator_registry, 'svd', linalg_ops.Svd)
+setattr(tensor_operator_registry, 'diag', diag)
+setattr(tensor_operator_registry, 'diagflat', diagflat)
+setattr(tensor_operator_registry, 'unique_consecutive', UniqueConsecutive)
+setattr(tensor_operator_registry, 'unique_with_pad', unique_with_pad)
+setattr(tensor_operator_registry, 'inplace_update', inplace_update)
+setattr(tensor_operator_registry, 'col2im', col2im)
+setattr(tensor_operator_registry, 'standard_laplace', P.StandardLaplace)
+setattr(tensor_operator_registry, 'erf', erf)
+setattr(tensor_operator_registry, 'erfc', erfc)
+setattr(tensor_operator_registry, 'standard_normal', P.StandardNormal)
+setattr(tensor_operator_registry, 'sigmoid', sigmoid)
+setattr(tensor_operator_registry, 'median', Median)
+setattr(tensor_operator_registry, 'tanh', tanh)
+setattr(tensor_operator_registry, 'exp', exp)
+setattr(tensor_operator_registry, 'addbmm', addbmm)
+setattr(tensor_operator_registry, 'addmm', addmm)
+setattr(tensor_operator_registry, 'addmm_', auto_generate.inplace_addmm_op)
+setattr(tensor_operator_registry, 'addmv', addmv)
+setattr(tensor_operator_registry, 'adjoint', adjoint)
+setattr(tensor_operator_registry, 'asinh', asinh)
+setattr(tensor_operator_registry, 'arcsinh', arcsinh)
+setattr(tensor_operator_registry, 'atan', atan)
+setattr(tensor_operator_registry, 'atanh', atanh)
+setattr(tensor_operator_registry, 'arctanh', arctanh)
+setattr(tensor_operator_registry, 'bmm', bmm)
+setattr(tensor_operator_registry, 'conj', conj)
+setattr(tensor_operator_registry, 'cross', cross)
+setattr(tensor_operator_registry, 'erfinv', erfinv)
+setattr(tensor_operator_registry, 'less_equal', less_equal)
+setattr(tensor_operator_registry, 'lcm', lcm)
+setattr(tensor_operator_registry, 'ldexp', ldexp)
+setattr(tensor_operator_registry, 'clamp', clamp)
+setattr(tensor_operator_registry, 'fold', fold)
+setattr(tensor_operator_registry, 'unfold', unfold)
+setattr(tensor_operator_registry, 'diagonal', diagonal)
+setattr(tensor_operator_registry, 'diagonal_scatter', diagonal_scatter)
+setattr(tensor_operator_registry, 'index_add', index_add)
+setattr(tensor_operator_registry, 'greater', greater)
+setattr(tensor_operator_registry, 'greater_equal', greater_equal)
+setattr(tensor_operator_registry, 'igamma', igamma)
+setattr(tensor_operator_registry, 'igammac', igammac)
+setattr(tensor_operator_registry, 'lu_solve', lu_solve)
+setattr(tensor_operator_registry, 'nextafter', nextafter)
+setattr(tensor_operator_registry, 'qr', qr)
+setattr(tensor_operator_registry, 'ormqr', ormqr)
+setattr(tensor_operator_registry, 'masked_scatter', array_ops.MaskedScatter)
+setattr(tensor_operator_registry, 'index_put', array_ops.IndexPut)
+setattr(tensor_operator_registry, 'quantile', quantile)
+setattr(tensor_operator_registry, 'nanquantile', nanquantile)
+setattr(tensor_operator_registry, 'orgqr', orgqr)
 # ms cannot support Tensor(True) compare
-tensor_operator_registry.register('__eq__', equal)
-tensor_operator_registry.register('__ne__', not_equal)
-tensor_operator_registry.register('__neg__', neg_tensor)
-tensor_operator_registry.register('__lt__', tensor_lt)
-tensor_operator_registry.register('__le__', tensor_le)
-tensor_operator_registry.register('__gt__', tensor_gt)
-tensor_operator_registry.register('__ge__', tensor_ge)
-tensor_operator_registry.register('__logical_not__', logical_not)
-tensor_operator_registry.register('gt', P.Greater)
-tensor_operator_registry.register('ge', P.GreaterEqual)
-tensor_operator_registry.register('shape', shape)
-tensor_operator_registry.register('squeeze', squeeze)
-tensor_operator_registry.register('unsqueeze', unsqueeze)
-tensor_operator_registry.register('expand_dims', expand_dims)
+setattr(tensor_operator_registry, '__eq__', equal)
+setattr(tensor_operator_registry, '__ne__', not_equal)
+setattr(tensor_operator_registry, '__neg__', neg)
+setattr(tensor_operator_registry, '__lt__', tensor_lt)
+setattr(tensor_operator_registry, '__le__', tensor_le)
+setattr(tensor_operator_registry, '__gt__', tensor_gt)
+setattr(tensor_operator_registry, '__ge__', tensor_ge)
+setattr(tensor_operator_registry, '__logical_not__', logical_not)
+setattr(tensor_operator_registry, 'gt', gt)
+setattr(tensor_operator_registry, 'ge', ge)
+setattr(tensor_operator_registry, 'shape', shape)
+setattr(tensor_operator_registry, 'squeeze', squeeze)
+setattr(tensor_operator_registry, 'unsqueeze', unsqueeze)
+setattr(tensor_operator_registry, 'expand_dims', expand_dims)
+setattr(tensor_operator_registry, 'contiguous', auto_generate.contiguous)
 # support GE backend for no compare operators
-tensor_operator_registry.register('cast', cast)
-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)
-tensor_operator_registry.register('gather', gather)
-tensor_operator_registry.register('gather_d', gather_d)
-tensor_operator_registry.register('gather_elements', gather_elements)
-tensor_operator_registry.register('gather_nd', gather_nd)
-tensor_operator_registry.register('stack', stack)
-tensor_operator_registry.register('unstack', unstack)
-tensor_operator_registry.register('unbind', P.Unstack)
-tensor_operator_registry.register('log', log)
-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)
+setattr(tensor_operator_registry, 'cast', _cast)
+setattr(tensor_operator_registry, 'shape_mul', shape_mul)
+setattr(tensor_operator_registry, 'concatenate', concat)
+setattr(tensor_operator_registry, 'fill', fill)
+setattr(tensor_operator_registry, 'fills', fills)
+setattr(tensor_operator_registry, 'fill_diagonal', P.FillDiagonal)
+setattr(tensor_operator_registry, 'eye', eye)
+setattr(tensor_operator_registry, 'eigvals', eigvals)
+setattr(tensor_operator_registry, 'reduce_sum', reduce_sum)
+setattr(tensor_operator_registry, 'reducesum', P.ReduceSum)
+setattr(tensor_operator_registry, 'tensor_slice', tensor_slice)
+setattr(tensor_operator_registry, 'select', select)
+setattr(tensor_operator_registry, 'uniform', uniform_ext)
+setattr(tensor_operator_registry, 'gather', gather)
+setattr(tensor_operator_registry, 'gather_d', gather_d)
+setattr(tensor_operator_registry, 'gather_elements', gather_elements)
+setattr(tensor_operator_registry, 'gather_nd', gather_nd)
+setattr(tensor_operator_registry, 'stack', stack)
+setattr(tensor_operator_registry, 'unstack', unstack)
+setattr(tensor_operator_registry, 'unbind', unstack)
+setattr(tensor_operator_registry, 'log', log)
+setattr(tensor_operator_registry, 'log10', log10)
+setattr(tensor_operator_registry, 'log2', log2)
+setattr(tensor_operator_registry, 'lerp', lerp)
+setattr(tensor_operator_registry, 'floor', floor)
+setattr(tensor_operator_registry, 'floor_divide', floor_divide)
 # support sparse tensor operators
-tensor_operator_registry.register('csr_add', csr_add)
-tensor_operator_registry.register('csr_mul', csr_mul)
-tensor_operator_registry.register('csr2coo', csr2coo)
-tensor_operator_registry.register('coo2csr', coo2csr)
-tensor_operator_registry.register('csr_div', csr_div)
-tensor_operator_registry.register('csr_mv', csr_mv)
-tensor_operator_registry.register('csr_mm_akg', _csr_ops.CSRMM)
-tensor_operator_registry.register('csr_mm', csr_mm)
-tensor_operator_registry.register('csr_reduce_sum', csr_reduce_sum)
-tensor_operator_registry.register('dense_to_sparse_csr', dense_to_sparse_csr)
-tensor_operator_registry.register('dense_to_sparse_coo', dense_to_sparse_coo)
-tensor_operator_registry.register('csr_to_dense', csr_to_dense)
-tensor_operator_registry.register('narrow', narrow)
-tensor_operator_registry.register('sort', sort)
-tensor_operator_registry.register('argsort', argsort)
-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)
-tensor_operator_registry.register('unsorted_segment_min', unsorted_segment_min)
-tensor_operator_registry.register('unsorted_segment_max', unsorted_segment_max)
-tensor_operator_registry.register('unsorted_segment_prod', unsorted_segment_prod)
-tensor_operator_registry.register('scatter', scatter)
-tensor_operator_registry.register('tensor_scatter_update', tensor_scatter_update)
-tensor_operator_registry.register('tensor_scatter_mul', tensor_scatter_mul)
-tensor_operator_registry.register('tensor_scatter_div', tensor_scatter_div)
-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)
-tensor_operator_registry.register('multinomial', multinomial)
-tensor_operator_registry.register('norm', norm)
-tensor_operator_registry.register('renorm', renorm)
-tensor_operator_registry.register('adaptive_max_pool2d', AdaptiveMaxPool2D)
-tensor_operator_registry.register('coalesce', coalesce)
-tensor_operator_registry.register('argmax_with_value', max)
-tensor_operator_registry.register('argmin_with_value', min)
-tensor_operator_registry.register('argwhere', argwhere)
-tensor_operator_registry.register('coo_add', coo_add)
-tensor_operator_registry.register('topk', topk)
-tensor_operator_registry.register('isfinite', P.IsFinite)
-tensor_operator_registry.register('to', P.Cast)
-tensor_operator_registry.register('bool', P.Cast)
-tensor_operator_registry.register('float', P.Cast)
-tensor_operator_registry.register('half', P.Cast)
-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)
-tensor_operator_registry.register('div', div)
-tensor_operator_registry.register('equal', equal)
-tensor_operator_registry.register('expm1', expm1)
-tensor_operator_registry.register('frac', frac)
-tensor_operator_registry.register('isinf', isinf)
-tensor_operator_registry.register('isnan', isnan)
-tensor_operator_registry.register('is_complex', is_complex)
-tensor_operator_registry.register('le', le)
-tensor_operator_registry.register('less', less)
-tensor_operator_registry.register('logical_and', logical_and)
-tensor_operator_registry.register('logical_not', logical_not)
-tensor_operator_registry.register('logical_or', logical_or)
-tensor_operator_registry.register('logical_xor', logical_xor)
-tensor_operator_registry.register('lstsq', lstsq)
-tensor_operator_registry.register('mvlgamma', mvlgamma)
-tensor_operator_registry.register('maximum', maximum)
-tensor_operator_registry.register('max', max)
-tensor_operator_registry.register('min', min)
-tensor_operator_registry.register('mul', mul)
-tensor_operator_registry.register('multiply', multiply)
-tensor_operator_registry.register('moveaxis', moveaxis)
-tensor_operator_registry.register('movedim', movedim)
-tensor_operator_registry.register('neg', neg)
-tensor_operator_registry.register('ne', ne)
-tensor_operator_registry.register('not_equal', not_equal)
-tensor_operator_registry.register('sgn', sgn)
-tensor_operator_registry.register('sign', sign)
-tensor_operator_registry.register('signbit', signbit)
-tensor_operator_registry.register('sinh', sinh)
-tensor_operator_registry.register('trunc', trunc)
-tensor_operator_registry.register('where', where)
-tensor_operator_registry.register('imag', imag)
-tensor_operator_registry.register('repeat_interleave', repeat_interleave)
-tensor_operator_registry.register('rad2deg', rad2deg)
-tensor_operator_registry.register('deg2rad', deg2rad)
-tensor_operator_registry.register('copysign', copysign)
-tensor_operator_registry.register('roll', Roll)
-tensor_operator_registry.register('rot90', rot90)
-tensor_operator_registry.register('swapaxes', swapaxes)
-tensor_operator_registry.register('swapdims', swapdims)
-tensor_operator_registry.register('repeat_elements', repeat_elements)
-tensor_operator_registry.register('top_k', P.TopK)
+setattr(tensor_operator_registry, 'csr_add', csr_add)
+setattr(tensor_operator_registry, 'csr_mul', csr_mul)
+setattr(tensor_operator_registry, 'csr2coo', csr2coo)
+setattr(tensor_operator_registry, 'coo2csr', coo2csr)
+setattr(tensor_operator_registry, 'csr_div', csr_div)
+setattr(tensor_operator_registry, 'csr_mv', csr_mv)
+setattr(tensor_operator_registry, 'csr_mm_akg', _csr_ops.CSRMM)
+setattr(tensor_operator_registry, 'csr_mm', csr_mm)
+setattr(tensor_operator_registry, 'csr_reduce_sum', csr_reduce_sum)
+setattr(tensor_operator_registry, 'dense_to_sparse_csr', dense_to_sparse_csr)
+setattr(tensor_operator_registry, 'dense_to_sparse_coo', dense_to_sparse_coo)
+setattr(tensor_operator_registry, 'csr_to_dense', csr_to_dense)
+setattr(tensor_operator_registry, 'narrow', narrow)
+setattr(tensor_operator_registry, 'sort', sort)
+setattr(tensor_operator_registry, 'argsort', argsort)
+setattr(tensor_operator_registry, 'msort', msort)
+setattr(tensor_operator_registry, 'mm', mm)
+setattr(tensor_operator_registry, 'nan_to_num', nan_to_num)
+setattr(tensor_operator_registry, 'nansum', nansum)
+setattr(tensor_operator_registry, 'nanmean', nanmean)
+setattr(tensor_operator_registry, 'nanmedian', nanmedian)
+setattr(tensor_operator_registry, 'csr_to_coo', csr_to_coo)
+setattr(tensor_operator_registry, 'zeros', zeros)
+setattr(tensor_operator_registry, 'ones', ones)
+setattr(tensor_operator_registry, 'unsorted_segment_min', unsorted_segment_min)
+setattr(tensor_operator_registry, 'unsorted_segment_max', unsorted_segment_max)
+setattr(tensor_operator_registry, 'unsorted_segment_prod', unsorted_segment_prod)
+setattr(tensor_operator_registry, 'scatter', scatter)
+setattr(tensor_operator_registry, 'tensor_scatter_update', tensor_scatter_update)
+setattr(tensor_operator_registry, 'tensor_scatter_mul', tensor_scatter_mul)
+setattr(tensor_operator_registry, 'tensor_scatter_div', tensor_scatter_div)
+setattr(tensor_operator_registry, 'tensor_scatter_min', tensor_scatter_min)
+setattr(tensor_operator_registry, 'tensor_scatter_max', tensor_scatter_max)
+setattr(tensor_operator_registry, 'tensor_scatter_sub', tensor_scatter_sub)
+setattr(tensor_operator_registry, 'tensor_scatter_add', tensor_scatter_add)
+setattr(tensor_operator_registry, 'slice_scatter', slice_scatter)
+setattr(tensor_operator_registry, 'select_scatter', select_scatter)
+setattr(tensor_operator_registry, 'bernoulli', bernoulli)
+setattr(tensor_operator_registry, 'poisson', P.Poisson)
+setattr(tensor_operator_registry, 'randperm', P.Randperm)
+setattr(tensor_operator_registry, 'multinomial', multinomial)
+setattr(tensor_operator_registry, 'norm', norm)
+setattr(tensor_operator_registry, 'renorm', renorm)
+setattr(tensor_operator_registry, 'adaptive_max_pool2d', AdaptiveMaxPool2D)
+setattr(tensor_operator_registry, 'coalesce', coalesce)
+setattr(tensor_operator_registry, 'argmax_with_value', max)
+setattr(tensor_operator_registry, 'argmin_with_value', min)
+setattr(tensor_operator_registry, 'argwhere', argwhere)
+setattr(tensor_operator_registry, 'coo_add', coo_add)
+setattr(tensor_operator_registry, 'topk', topk)
+setattr(tensor_operator_registry, 'isfinite', isfinite)
+setattr(tensor_operator_registry, 'to', _cast)
+setattr(tensor_operator_registry, 'bool', _cast)
+setattr(tensor_operator_registry, 'float', _cast)
+setattr(tensor_operator_registry, 'half', _cast)
+setattr(tensor_operator_registry, 'int', _cast)
+setattr(tensor_operator_registry, 'long', _cast)
+setattr(tensor_operator_registry, 'byte', _cast)
+setattr(tensor_operator_registry, 'cholesky', cholesky)
+setattr(tensor_operator_registry, 'cholesky_inverse', cholesky_inverse)
+setattr(tensor_operator_registry, 'cholesky_solve', cholesky_solve)
+setattr(tensor_operator_registry, 'expand', broadcast_to)
+setattr(tensor_operator_registry, 'tensortotuple', TensorToTuple)
+setattr(tensor_operator_registry, 'cumprod', cumprod)
+setattr(tensor_operator_registry, 'diff', diff)
+setattr(tensor_operator_registry, 'div', div)
+setattr(tensor_operator_registry, 'equal', equal)
+setattr(tensor_operator_registry, 'expm1', expm1)
+setattr(tensor_operator_registry, 'frac', frac)
+setattr(tensor_operator_registry, 'isinf', isinf)
+setattr(tensor_operator_registry, 'isnan', isnan)
+setattr(tensor_operator_registry, 'is_complex', is_complex)
+setattr(tensor_operator_registry, 'le', le)
+setattr(tensor_operator_registry, 'less', less)
+setattr(tensor_operator_registry, 'logical_and', logical_and)
+setattr(tensor_operator_registry, 'logical_not', logical_not)
+setattr(tensor_operator_registry, 'logical_or', logical_or)
+setattr(tensor_operator_registry, 'logical_xor', logical_xor)
+setattr(tensor_operator_registry, 'lstsq', lstsq)
+setattr(tensor_operator_registry, 'mvlgamma', mvlgamma)
+setattr(tensor_operator_registry, 'maximum', maximum)
+setattr(tensor_operator_registry, 'max', max)
+setattr(tensor_operator_registry, 'min', min)
+setattr(tensor_operator_registry, 'mul', mul)
+setattr(tensor_operator_registry, 'multiply', multiply)
+setattr(tensor_operator_registry, 'moveaxis', moveaxis)
+setattr(tensor_operator_registry, 'movedim', movedim)
+setattr(tensor_operator_registry, 'neg', neg)
+setattr(tensor_operator_registry, 'ne', ne)
+setattr(tensor_operator_registry, 'not_equal', not_equal)
+setattr(tensor_operator_registry, 'sgn', sgn)
+setattr(tensor_operator_registry, 'sign', sign)
+setattr(tensor_operator_registry, 'signbit', signbit)
+setattr(tensor_operator_registry, 'sinh', sinh)
+setattr(tensor_operator_registry, 'trunc', trunc)
+setattr(tensor_operator_registry, 'where', where)
+setattr(tensor_operator_registry, 'imag', imag)
+setattr(tensor_operator_registry, 'repeat_interleave', repeat_interleave)
+setattr(tensor_operator_registry, 'rad2deg', rad2deg)
+setattr(tensor_operator_registry, 'deg2rad', deg2rad)
+setattr(tensor_operator_registry, 'copy_', auto_generate.copy_ext)
+setattr(tensor_operator_registry, 'add_', auto_generate.inplace_add_ext)
+setattr(tensor_operator_registry, 'adds_', auto_generate.inplace_adds_ext)
+setattr(tensor_operator_registry, 'copysign', copysign)
+setattr(tensor_operator_registry, 'roll', Roll)
+setattr(tensor_operator_registry, 'rot90', rot90)
+setattr(tensor_operator_registry, 'swapaxes', swapaxes)
+setattr(tensor_operator_registry, 'swapdims', swapdims)
+setattr(tensor_operator_registry, 'repeat_elements', repeat_elements)
+setattr(tensor_operator_registry, 'top_k', top_k)
 
 __all__ = [name for name in dir() if name[0] != "_"]
 __all__.remove('Primitive')
+__all__.remove('argmax_ext')
+__all__.remove('uniform_ext')