mindspore 2.2.14__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc2__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/functional.py

@@ -20,17 +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.function.math_func import all, argmax
 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_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')
@@ -48,6 +54,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 +68,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 +88,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")
@@ -124,13 +116,14 @@ reduced_shape = Primitive("reduced_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('add', add)
+tensor_operator_registry.register('softmax', softmax)
 tensor_operator_registry.register('addr', addr)
-tensor_operator_registry.register('addcdiv', P.Addcdiv)
-tensor_operator_registry.register('addcmul', P.Addcmul)
+tensor_operator_registry.register('addcdiv', addcdiv)
+tensor_operator_registry.register('addcmul', addcmul)
 tensor_operator_registry.register('all', all)
 tensor_operator_registry.register('angle', angle)
-tensor_operator_registry.register('any', P.ReduceAny)
+tensor_operator_registry.register('any', any)
 tensor_operator_registry.register('atan2', atan2)
 tensor_operator_registry.register('abs', abs)
 tensor_operator_registry.register('baddbmm', baddbmm)
@@ -149,36 +142,36 @@ 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('tan', 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('cosh', 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('pow', 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('round', 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('reverse', reverse)
+tensor_operator_registry.register('reverse_sequence', reverse_sequence)
+tensor_operator_registry.register('xlogy', 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('transpose', transpose)
+tensor_operator_registry.register('broadcast_to', broadcast_to)
 tensor_operator_registry.register('matmul', matmul)
 tensor_operator_registry.register('inner', inner)
-tensor_operator_registry.register('xdivy', P.Xdivy)
+tensor_operator_registry.register('xdivy', xdivy)
 tensor_operator_registry.register('argmax', argmax)
 tensor_operator_registry.register('argmin', argmin)
 tensor_operator_registry.register('cumsum', P.CumSum)
@@ -209,7 +202,7 @@ 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('minimum', minimum)
 tensor_operator_registry.register('matrix_power', matrix_power)
 tensor_operator_registry.register('det', det)
 tensor_operator_registry.register('dot', dot)
@@ -218,19 +211,17 @@ 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('ceil', 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('zeros_like', zeros_like)
 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)
@@ -250,22 +241,22 @@ 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('hardshrink', hardshrink)
 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('diag', 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('unique_with_pad', unique_with_pad)
+tensor_operator_registry.register('inplace_update', inplace_update)
 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('erf', erf)
+tensor_operator_registry.register('erfc', erfc)
 tensor_operator_registry.register('standard_normal', P.StandardNormal)
-tensor_operator_registry.register('sigmoid', P.Sigmoid)
+tensor_operator_registry.register('sigmoid', sigmoid)
 tensor_operator_registry.register('median', Median)
 tensor_operator_registry.register('tanh', tanh)
 tensor_operator_registry.register('exp', exp)
@@ -307,28 +298,30 @@ 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)
-tensor_operator_registry.register('__neg__', neg_tensor)
+tensor_operator_registry.register('__neg__', neg)
 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('gt', gt)
+tensor_operator_registry.register('ge', ge)
 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)
+tensor_operator_registry.register('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('concatenate', 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('reducesum', P.ReduceSum)
 tensor_operator_registry.register('tensor_slice', tensor_slice)
 tensor_operator_registry.register('select', select)
 tensor_operator_registry.register('gather', gather)
@@ -337,7 +330,7 @@ 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('unbind', unstack)
 tensor_operator_registry.register('log', log)
 tensor_operator_registry.register('log10', log10)
 tensor_operator_registry.register('log2', log2)
@@ -376,8 +369,8 @@ 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_min', tensor_scatter_min)
+tensor_operator_registry.register('tensor_scatter_max', tensor_scatter_max)
 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)
@@ -395,17 +388,18 @@ 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('isfinite', isfinite)
+tensor_operator_registry.register('to', cast)
+tensor_operator_registry.register('bool', cast)
+tensor_operator_registry.register('float', cast)
+tensor_operator_registry.register('half', cast)
+tensor_operator_registry.register('int', cast)
+tensor_operator_registry.register('long', cast)
+tensor_operator_registry.register('cholesky', cholesky)
+tensor_operator_registry.register('cholesky_inverse', cholesky_inverse)
 tensor_operator_registry.register('cholesky_solve', cholesky_solve)
-tensor_operator_registry.register('expand', expand)
+tensor_operator_registry.register('expand', broadcast_to)
+tensor_operator_registry.register('tensortotuple', TensorToTuple)
 tensor_operator_registry.register('cumprod', cumprod)
 tensor_operator_registry.register('diff', diff)
 tensor_operator_registry.register('div', div)
@@ -449,7 +443,7 @@ 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)
+tensor_operator_registry.register('top_k', top_k)
 
 __all__ = [name for name in dir() if name[0] != "_"]
 __all__.remove('Primitive')

mindspore/ops/op_info_register.py

@@ -235,7 +235,7 @@ class _CustomInstaller:
             # generate and copy reg info file
             op_info = self._gen_ai_core_reg_info(imply_path, self.func.__name__)
             self._copy_file(imply_path, self.ai_core_impl_dir)
-            for arc_name in ["ascend910", "ascend910b"]:
+            for arc_name in ["ascend910", "ascend910b", "ascend910c", "ascend310p"]:
                 arc_dir = os.path.join(self.ai_core_config_dir, arc_name)
                 _CustomInstaller._create_dir(arc_dir)
                 self._save_op_info(arc_dir, "aic-{}-ops-info.json".format(arc_name), op_info)
@@ -384,6 +384,7 @@ class RegOp:
         """
         if not isinstance(value, str):
             raise TypeError("%s value must be str" % str(value))
+        return True
 
     def _is_int(self, value):
         """
@@ -397,6 +398,7 @@ class RegOp:
         """
         if not isinstance(value, int):
             raise TypeError("%s value must be int" % str(value))
+        return True
 
     def _is_bool(self, value):
         """
@@ -410,6 +412,7 @@ class RegOp:
         """
         if not isinstance(value, bool):
             raise TypeError("%s value must be bool" % str(value))
+        return True
 
     @staticmethod
     def _is_list(value):
@@ -424,6 +427,7 @@ class RegOp:
         """
         if not isinstance(value, list):
             raise TypeError("%s value must be list" % str(value))
+        return True
 
     def _check_param(self, param_list, key_list, fn_list, kwargs):
         """
@@ -490,8 +494,8 @@ class RegOp:
             self._is_string(arg[0])
             self._is_string(arg[1])
             if len(arg) == 3:
-                self._is_string(arg[2])
-                dtype_format.append(arg)
+                if self._is_string(arg[2]):
+                    dtype_format.append(arg)
             else:
                 dtype_format.append(arg)
         self.dtype_format_.append(tuple(dtype_format))
@@ -775,8 +779,8 @@ class TBERegOp(RegOp):
                                          False: indicates that the operator does not support dynamic rank.
                                          Default: ``False`` .
         """
-        self._is_bool(dynamic_rank_support)
-        self.dynamic_rank_support_ = dynamic_rank_support
+        if self._is_bool(dynamic_rank_support):
+            self.dynamic_rank_support_ = dynamic_rank_support
         return self
 
     def real_input_index(self, real_input_index):
@@ -889,8 +893,8 @@ class TBERegOp(RegOp):
         Args:
             dynamic_compile_static (bool): Value of dynamic compile static. Default: ``False`` .
         """
-        self._is_bool(dynamic_compile_static)
-        self.dynamic_compile_static_ = dynamic_compile_static
+        if self._is_bool(dynamic_compile_static):
+            self.dynamic_compile_static_ = dynamic_compile_static
         return self
 
     def need_check_supported(self, need_check_supported=False):
@@ -900,8 +904,8 @@ class TBERegOp(RegOp):
         Args:
             need_check_supported (bool): Value of need_check_supported. Default: ``False`` .
         """
-        self._is_bool(need_check_supported)
-        self.need_check_support_ = need_check_supported
+        if self._is_bool(need_check_supported):
+            self.need_check_support_ = need_check_supported
         return self
 
     def is_dynamic_format(self, is_dynamic_format=False):
@@ -911,8 +915,8 @@ class TBERegOp(RegOp):
         Args:
             is_dynamic_format (bool): Value of is_dynamic_format. Default: ``False`` .
         """
-        self._is_bool(is_dynamic_format)
-        self.dynamic_format_ = is_dynamic_format
+        if self._is_bool(is_dynamic_format):
+            self.dynamic_format_ = is_dynamic_format
         return self
 
     def op_pattern(self, pattern=None):
@@ -922,8 +926,7 @@ class TBERegOp(RegOp):
         Args:
             pattern (str): Value of op pattern, e.g. "broadcast", "reduce". Default: ``None`` .
         """
-        if pattern is not None:
-            self._is_string(pattern)
+        if pattern is not None and self._is_string(pattern):
             self.op_pattern_ = pattern
         return self
 
@@ -1044,11 +1047,6 @@ class CustomRegOp(RegOp):
             TypeError: If `index` is neither int nor None.
             TypeError: If `name` is neither str nor None.
             TypeError: If `param_type` is neither str nor None.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [index, name, param_type]
         key_list = ["index", "name", "paramType"]
@@ -1084,11 +1082,6 @@ class CustomRegOp(RegOp):
             TypeError: If `index` is neither int nor None.
             TypeError: If `name` is neither str nor None.
             TypeError: If `param_type` is neither str nor None.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [index, name, param_type]
         key_list = ["index", "name", "paramType"]
@@ -1112,11 +1105,6 @@ class CustomRegOp(RegOp):
 
         Raises:
             ValueError: If the size of `args` not equal to the sum of input tensors and output tensors.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         io_nums = len(self.inputs) + len(self.outputs)
         if len(args) != io_nums:
@@ -1169,11 +1157,6 @@ class CustomRegOp(RegOp):
             TypeError: If `param_type` is neither str nor None.
             TypeError: If `value_type` is neither str nor None.
             TypeError: If `default_value` is neither str nor None.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         param_list = [name, param_type, value_type, default_value]
         key_list = ["name", "paramType", "type", "defaultValue"]
@@ -1195,11 +1178,6 @@ class CustomRegOp(RegOp):
 
         Raises:
             TypeError: If `target` is neither str nor None.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         if target is not None:
             self._is_string(target)
@@ -1210,11 +1188,6 @@ class CustomRegOp(RegOp):
         """
         Return the generated registration information as a dict. This function should be invoked at last on the
         `CustomRegOp` instance as shown in the above example.
-
-        Tutorial Examples:
-            - `Custom Operators (Custom-based) - Defining Custom Operator of aicpu Type
-              <https://mindspore.cn/tutorials/experts/en/r2.2/operation/op_custom.html#
-              defining-custom-operator-of-aicpu-type>`_
         """
         op_info = {}
         for k, v in self.__dict__.items():

mindspore/ops/operations/__init__.py

@@ -1,4 +1,4 @@
-# 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.
@@ -22,17 +22,17 @@ A collection of operators to build neural networks or to compute functions.
 from ._embedding_cache_ops import (CacheSwapTable, UpdateCache, MapCacheIdx, SubAndFilter,
                                    MapUniform, DynamicAssign, PadAndShift)
 from ._inner_ops import (MatmulDDS, DSDMatmul, Cummin, ExtractImagePatches, SelectView, CopyWithSlice)
+from ._ms_kernel import (ms_kernel, kernel)
 from ._quant_ops import *
 from ._thor_ops import (CusBatchMatMul, CusCholeskyTrsm, CusFusedAbsMax1, CusImg2Col, CusMatMulCubeDenseLeft,
                         CusMatMulCubeFraczRightMul, CusMatMulCube, CusMatrixCombine, CusTranspose02314,
                         CusMatMulCubeDenseRight, CusMatMulCubeFraczLeftCast, NewIm2Col,
                         LoadIm2Col, UpdateThorGradient, CholeskyTrsm,
                         DetTriangle, ProdForceSeA)
-from ._ms_kernel import (ms_kernel, kernel)
 from .array_ops import (ArgMaxWithValue, ArgMinWithValue, Argmax, Argmin, BatchToSpace,
                         BatchToSpaceNDV2, BroadcastTo, Cast, Coalesce, Concat, Cummax, DType, DepthToSpace, Diag,
                         DiagPart, EditDistance, EmbeddingLookup, ExpandDims, ExtractVolumePatches,
-                        Eye, Fill, Gather, GatherD, GatherNd, Identity, Im2Col, InvertPermutation,
+                        Eye, Fill, Gather, GatherD, GatherNd, Im2Col, InvertPermutation,
                         LowerBound, Lstsq, MaskedFill, MaskedSelect, Meshgrid, Mvlgamma, Ones, OnesLike,
                         Padding, ParallelConcat, PopulationCount, Range, Rank, Reshape, ResizeNearestNeighbor,
                         ReverseSequence, ReverseV2, Rint, ScalarToTensor, ScatterAdd,
@@ -44,7 +44,7 @@ from .array_ops import (ArgMaxWithValue, ArgMinWithValue, Argmax, Argmin, BatchT
                         TensorScatterUpdate, TensorShape, Tile, TopK, TransShape, Transpose, TupleToArray, Unique,
                         UniqueWithPad, UnsortedSegmentMax, UnsortedSegmentMin, UnsortedSegmentProd,
                         UnsortedSegmentSum, Unstack, UpperBound, Zeros, ZerosLike, AffineGrid, Bincount, CheckNumerics,
-                        HammingWindow, IdentityN, IndexFill, LeftShift, ListDiff, LogSpace, MatrixBandPart,
+                        HammingWindow, Identity, IdentityN, IndexFill, LeftShift, ListDiff, LogSpace, MatrixBandPart,
                         MatrixDiagPartV3, MatrixDiagV3, MatrixSetDiagV3, NonZero, Expand, Col2Im, ConjugateTranspose,
                         FillDiagonal, Fills, ResizeNearestNeighborV2, RightShift, ScatterAddWithAxis,
                         ScatterNdMul, SegmentMean, SegmentProd, SegmentSum, SegmentMax, SegmentMin, Tril, Triu,
@@ -59,11 +59,11 @@ from .comm_ops import (AllGather, AllReduce, NeighborExchange, NeighborExchangeV
 from .control_ops import GeSwitch, Merge
 from .custom_ops import (Custom)
 from .debug_ops import (ImageSummary, InsertGradientOf, HookBackward, ScalarSummary,
-                        TensorSummary, HistogramSummary, Print, Assert)
+                        TensorSummary, HistogramSummary, TensorDump, Print, Assert)
 from .image_ops import (CropAndResize, NonMaxSuppressionV3, HSVToRGB, AdjustHue, AdjustSaturation,
                         NonMaxSuppressionWithOverlaps, ResizeArea, ResizeBilinearV2, ExtractGlimpse,
                         CombinedNonMaxSuppression, RGBToHSV, ScaleAndTranslate, ResizeLinear1D, ResizeBicubic)
-from .inner_ops import (ScalarCast, Randperm, NoRepeatNGram, LambApplyOptimizerAssign, LambApplyWeightAssign,
+from .inner_ops import (Randperm, NoRepeatNGram, LambApplyOptimizerAssign, LambApplyWeightAssign,
                         FusedWeightScaleApplyMomentum, FusedCastAdamWeightDecay, FusedAdaFactor,
                         FusedAdaFactorWithGlobalNorm)
 from .linalg_ops import (Svd, Geqrf)
@@ -99,9 +99,8 @@ from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSpa
                      LogSoftmax, MaxPool3D, AvgPool3D,
                      MaxPool, DataFormatDimMap,
                      AvgPool, Conv2DBackpropInput, ComputeAccidentalHits,
-                     MaxPoolWithArgmaxV2, OneHot, Pad, MirrorPad, Mish, PReLU, ReLU, ReLU6, ReLUV2,
-                     HSwish, HSigmoid,
-                     ResizeBilinear, Sigmoid, SeLU, HShrink, ApplyKerasMomentum,
+                     MaxPoolWithArgmaxV2, OneHot, Pad, MirrorPad, Mish, PReLU, ReLU, ReLU6,
+                     HSwish, HSigmoid, Sigmoid, SeLU, HShrink, ApplyKerasMomentum,
                      SigmoidCrossEntropyWithLogits, NLLLoss, BCEWithLogitsLoss,
                      SmoothL1Loss, SoftMarginLoss, Softmax, Softsign, Softplus, LRN, RNNTLoss, DynamicRNN, DynamicGRUV2,
                      SoftmaxCrossEntropyWithLogits, ROIAlign,
@@ -118,9 +117,10 @@ from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSpa
                      Dilation2D, DataFormatVecPermute, DeformableOffsets, Dense, FractionalAvgPool,
                      FractionalMaxPool, FractionalMaxPool3DWithFixedKsize, FractionalMaxPoolWithFixedKsize,
                      GridSampler2D, TripletMarginLoss, UpsampleNearest3D, UpsampleTrilinear3D, PadV3, ChannelShuffle,
-                     GLU, MaxUnpool3D, Pdist, RmsNorm, PagedAttention, PagedAttentionMask, ReshapeAndCache)
+                     GLU, MaxUnpool3D, Pdist, RmsNorm, PagedAttention, PagedAttentionMask, ReshapeAndCache,
+                     ApplyRotaryPosEmb)
 from .other_ops import (Assign, IOU, BoundingBoxDecode, BoundingBoxEncode,
-                        ConfusionMatrix, UpdateState, Load, StopGradient,
+                        ConfusionMatrix, UpdateState, Load, StopGradient, Reusing,
                         CheckValid, Partial, Depend, Push, Pull, PyExecute, PyFunc, _DynamicLossScale,
                         SampleDistortedBoundingBoxV2)
 from .random_ops import (RandomChoiceWithMask, StandardNormal, Gamma, RandomGamma, Poisson, UniformInt, UniformReal,
@@ -132,16 +132,17 @@ from .rl_ops import (BufferAppend, BufferGetItem, BufferSample)
 from .sparse_ops import (
     SparseToDense, SparseTensorDenseMatmul, SparseTensorDenseAdd, SparseSlice)
 from .spectral_ops import (BartlettWindow, BlackmanWindow)
-from ..deprecated import (identity, DropoutDoMask, MaxPoolWithArgmax,
-                          BNTrainingReduce, BNTrainingUpdate, DropoutGenMask, Gelu, FastGelu,
+from ..deprecated import (identity, DropoutDoMask, MaxPoolWithArgmax, DropoutGenMask, Gelu, FastGelu,
                           TensorAdd, InplaceUpdate, ScatterNonAliasingAdd,
                           BatchToSpaceND, Unpack, GatherV2, DynamicShape, ScalarToArray, Pack)
+from .manually_defined._inner import ScalarCast
 
 __all__ = [
     'HSVToRGB',
     'CeLU',
     'Ger',
     'Unique',
+    'Reusing',
     'ReverseSequence',
     'Sort',
     'EditDistance',
@@ -185,8 +186,6 @@ __all__ = [
     'Flatten',
     'MaxPoolWithArgmax',
     'MaxPoolWithArgmaxV2',
-    'BNTrainingReduce',
-    'BNTrainingUpdate',
     'BatchNorm',
     'MaxPool',
     'TopK',
@@ -226,7 +225,6 @@ __all__ = [
     'EmbeddingLookup',
     'Padding',
     'GatherD',
-    'Identity',
     'UniqueWithPad',
     'Concat',
     'Pack',
@@ -292,11 +290,11 @@ __all__ = [
     'UniformReal',
     'StandardLaplace',
     'RandomCategorical',
-    'ResizeBilinear',
     'ScalarSummary',
     'ImageSummary',
     'TensorSummary',
     'HistogramSummary',
+    'TensorDump',
     "Print",
     "Assert",
     'InsertGradientOf',
@@ -495,7 +493,6 @@ __all__ = [
     "ParallelConcat",
     "Push",
     "Pull",
-    "ReLUV2",
     "SparseToDense",
     "SparseTensorDenseAdd",
     "SparseTensorDenseMatmul",
@@ -563,6 +560,7 @@ __all__ = [
     "Heaviside",
     "Histogram",
     "Hypot",
+    "Identity",
     "IdentityN",
     "IndexFill",
     "IsClose",
@@ -692,10 +690,11 @@ __all__ = [
     "MaskedScatter",
     "Ormqr",
     "RandpermV2",
-    "RmsNorm",
     "PagedAttention",
     "PagedAttentionMask",
-    "ReshapeAndCache"
+    "ReshapeAndCache",
+    "ApplyRotaryPosEmb",
+    "RmsNorm",
 ]
 
 __custom__ = [