mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0__cp39-cp39-win_amd64.whl

mindspore/ops/op_info_register.py

@@ -21,16 +21,9 @@ import inspect
 import json
 import os
 import functools
-import platform
-import hashlib
-import shutil
 
 from mindspore._c_expression import Oplib
 from mindspore import _checkparam as validator
-from mindspore import log as logger
-
-if platform.system() == "Linux":
-    import fcntl
 
 # path of built-in op info register.
 BUILT_IN_OPS_REGISTER_PATH = "mindspore/ops/_op_impl"
@@ -40,207 +33,6 @@ KEY_NAME = "name"
 ASCEND_CUSTOM_OPP_PATH = "ASCEND_CUSTOM_OPP_PATH"
 
 
-def _get_reg_info_attr(op_info, attr_name, default_value=None):
-    """get attr value"""
-    for _, item in enumerate(op_info.get("attr", [])):
-        if item.get(KEY_NAME) == attr_name:
-            return item.get("defaultValue")
-    return default_value
-
-
-class _CustomInstaller:
-    """save custom op registration information to a json file which will be used by GE"""
-    reg_info_hash = []  # used to avoid writing the same reg info to file multiple times
-    copied_paths = []  # used to avoid copying the same file multiple times
-
-    def __init__(self, op_info, func=None):
-        self.op_info = op_info
-        self.func = func
-        self.op_type = op_info.get("op_name") if not func else func.__name__
-        vendor_name = "ms"
-        custom_dir = os.path.join(os.path.realpath("./"), "vendors", vendor_name)
-        self._set_env(custom_dir)
-        op_impl_dir = os.path.join(custom_dir, "op_impl")
-        self.ai_core_config_dir = os.path.join(op_impl_dir, "ai_core", "tbe", "config")
-        self.ai_core_impl_dir = os.path.join(op_impl_dir, "ai_core", "tbe", vendor_name + "_impl")
-        self.ai_cpu_config_dir = os.path.join(op_impl_dir, "cpu", "config")
-        self.ai_cpu_impl_dir = os.path.join(op_impl_dir, "cpu", "aicpu_kernel", "impl")
-
-    @staticmethod
-    def _set_env(custom_opp_path):
-        """set custom file path to env"""
-        if not os.environ.get(ASCEND_CUSTOM_OPP_PATH):
-            os.environ[ASCEND_CUSTOM_OPP_PATH] = custom_opp_path
-        else:
-            paths = os.environ[ASCEND_CUSTOM_OPP_PATH].split(':')
-            if custom_opp_path not in paths:
-                os.environ[ASCEND_CUSTOM_OPP_PATH] = custom_opp_path + ':' + os.environ[ASCEND_CUSTOM_OPP_PATH]
-
-    @staticmethod
-    def _create_dir(*dir_names):
-        """create directory"""
-        for dir_name in dir_names:
-            if not os.path.isdir(dir_name):
-                try:
-                    os.makedirs(dir_name, mode=0o700, exist_ok=True)
-                except OSError as err:
-                    if err.errno == 17:  # File exists
-                        pass
-                    else:
-                        raise err
-
-    @staticmethod
-    def _copy_file(src_path, dst_dir):
-        """copy file"""
-        if not os.path.exists(src_path) or src_path in _CustomInstaller.copied_paths:
-            return
-        _CustomInstaller.copied_paths.append(src_path)
-        if os.path.isfile(src_path):
-            lock_file = os.path.join(dst_dir, "file.lock")
-            with os.fdopen(os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as f:
-                fcntl.flock(f.fileno(), fcntl.LOCK_EX)
-                shutil.copy(src_path, dst_dir)
-
-    def check(self):
-        """check if the reg info need written"""
-        if platform.system() != "Linux":
-            return False
-        if not os.environ.get("MS_DEV_CUSTOM_OPP_PATH"):
-            # only process the first time import the mindspore module
-            return False
-        if self.op_info.get("target") in ["GPU", "CPU"]:
-            return False
-        sha256 = hashlib.sha256()
-        value = json.dumps(self.op_info, sort_keys=True).encode()
-        sha256.update(value)
-        hash_value = sha256.hexdigest()
-        if hash_value in _CustomInstaller.reg_info_hash:
-            return False
-        _CustomInstaller.reg_info_hash.append(hash_value)
-        return True
-
-    def _find_ai_cpu_so_path(self, so_file):
-        """find the absolute path of so"""
-        current_path = os.path.dirname(os.path.realpath(__file__))
-        search_paths = [current_path + "/../lib", current_path + "/../lib/plugin/ascend"]
-        for path in search_paths:
-            so_path = os.path.join(path, so_file)
-            if os.path.exists(so_path):
-                return so_path
-        logger.warning("For Custom op '{}', can not find the aicpu so file '{}' in the following directories:\n{}"
-                       .format(self.op_type, so_file, "\n".join(search_paths)))
-        return ""
-
-    def _gen_ai_core_reg_info(self, imply_path, func_name):
-        """generate reg info"""
-
-        def _get_dtype_format(idx):
-            data_type = []
-            data_format = []
-            for _, dtype_format in enumerate(self.op_info.get("dtype_format", [])):
-                if not dtype_format[idx][0]:
-                    data_type = None
-                else:
-                    data_type.append(dtype_format[idx][0])
-                if not dtype_format[idx][1]:
-                    data_format = None
-                else:
-                    if dtype_format[idx][1] == "DefaultFormat":
-                        data_format.append("ND")
-                    else:
-                        data_format.append(dtype_format[idx][1])
-            return data_type, data_format
-
-        op_info = {"opFile": {"value": os.path.splitext(os.path.basename(imply_path))[0]},
-                   "opInterface": {"value": func_name}}
-        # attr
-        attrs_name = []
-        for _, item in enumerate(self.op_info.get("attr", [])):
-            attr_name = item.get(KEY_NAME)
-            attrs_name.append(attr_name)
-            key = "attr_" + attr_name
-            op_info[key] = {}
-            for k, v in item.items():
-                if k != KEY_NAME:
-                    op_info[key][k] = v
-        if attrs_name:
-            op_info["attr"] = {"list": ",".join(attrs_name)}
-        # input and output
-        inputs = self.op_info.get("inputs", [])
-        outputs = self.op_info.get("outputs", [])
-        input_num = len(inputs)
-        output_num = len(outputs)
-        for i in range(input_num + output_num):
-            item = inputs[i] if i < input_num else outputs[i - input_num]
-            key = "input" if i < input_num else "output"
-            key += str(item.get("index"))
-            op_info[key] = {KEY_NAME: item.get(KEY_NAME),
-                            "paramType": item.get("paramType", "required"),
-                            "shape": item.get("shape", "all")}
-            dtype, formats = _get_dtype_format(i)
-            if dtype:
-                op_info[key]["dtype"] = ",".join(dtype)
-            if formats:
-                op_info[key]["format"] = ",".join(formats)
-        return op_info
-
-    @staticmethod
-    def _gen_ai_cpu_reg_info(so_file):
-        """generate reg info"""
-        op_info = {"opInfo": {"computeCost": "100",
-                              "engine": "DNN_VM_AICPU",
-                              "flagAsync": "False",
-                              "flagPartial": "False",
-                              "functionName": "RunCpuKernel",
-                              "kernelSo": so_file,
-                              "opKernelLib": "CUSTAICPUKernel",
-                              "userDefined": "True"}}
-        return op_info
-
-    def _save_op_info(self, dst_dir, file_name, op_info):
-        """save op info file"""
-        repo = {}
-        save_path = os.path.join(dst_dir, file_name)
-        lock_file = os.path.join(dst_dir, "file.lock")
-        with os.fdopen(os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as f:
-            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
-            if os.path.isfile(save_path):
-                with open(save_path, 'r') as fr:
-                    json_str = fr.read()
-                json_str = "{}" if json_str == "" else json_str
-                repo = json.loads(json_str)
-            repo.update({self.op_type: op_info})
-            with os.fdopen(os.open(save_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as fw:
-                json.dump(repo, fw, sort_keys=True, indent=4, separators=(',', ':'))
-
-    def run(self):
-        """save reg info to file"""
-        if not self.check():
-            return
-        so_name = _get_reg_info_attr(self.op_info, "cust_aicpu")
-        if so_name:
-            _CustomInstaller._create_dir(self.ai_cpu_config_dir, self.ai_cpu_impl_dir)
-            # copy so file
-            so_file = "lib" + so_name + ".so"
-            imply_path = self._find_ai_cpu_so_path(so_file)
-            self._copy_file(imply_path, self.ai_cpu_impl_dir)
-            # generate and copy reg info file
-            op_info = self._gen_ai_cpu_reg_info(so_file)
-            self._save_op_info(self.ai_cpu_config_dir, "cust_aicpu_kernel.json", op_info)
-        else:
-            _CustomInstaller._create_dir(self.ai_core_config_dir, self.ai_core_impl_dir)
-            # copy dsl file
-            imply_path = os.path.realpath(inspect.getfile(self.func))
-            self._copy_file(imply_path, self.ai_core_impl_dir)
-            # 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", "ascend910_93", "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)
-
-
 def op_info_register(op_info):
     r"""
     A decorator which is used to register an operator.
@@ -319,6 +111,9 @@ def custom_info_register(*reg_info):
     Raises:
         TypeError: If `reg_info` is not a tuple.
 
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
     Examples:
         >>> from mindspore.ops import custom_info_register, CustomRegOp, DataType
         >>> custom_func_ascend_info = CustomRegOp() \
@@ -336,12 +131,6 @@ def custom_info_register(*reg_info):
 
     def decorator(func):
         setattr(func, "reg_info", reg_info)
-        if reg_info:
-            used_reg_info = reg_info[0]
-            if isinstance(used_reg_info, dict):
-                # ai_cpu should be parsed inside CustomRegOp, skip it here
-                if not _get_reg_info_attr(used_reg_info, "cust_aicpu"):
-                    _CustomInstaller(used_reg_info, func).run()
 
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
@@ -773,9 +562,9 @@ class TBERegOp(RegOp):
         Description whether the operator supports dynamic rank (dynamic dimension).
 
         Args:
-            dynamic_rank_support (bool): Description whether the operator supports dynamic rank (dynamic dimension).
-                                         True: indicates that dynamic rank is supported, and the operator supports
-                                         shape (- 2), which is used to determine whether dynamic is performed.
+            dynamic_rank_support (bool, optional): Description whether the operator
+                                         supports dynamic rank (dynamic dimension).
+                                         True: indicates that dynamic rank is supported.
                                          False: indicates that the operator does not support dynamic rank.
                                          Default: ``False`` .
         """
@@ -810,7 +599,7 @@ class TBERegOp(RegOp):
         Define the calculation efficiency of the operator, whether the asynchronous calculation is supported.
 
         Args:
-            async_flag (bool): Value of async flag. Default: ``False`` .
+            async_flag (bool, optional): Value of async flag. Default: ``False`` .
         """
         self._is_bool(async_flag)
         self.async_flag_ = async_flag
@@ -833,7 +622,7 @@ class TBERegOp(RegOp):
         in the tiling module.
 
         Args:
-            compute_cost (int): Value of compute cost. Default: ``10`` .
+            compute_cost (int, optional): Value of compute cost. Default: ``10`` .
         """
         self._is_int(compute_cost)
         self.compute_cost_ = compute_cost
@@ -855,7 +644,7 @@ class TBERegOp(RegOp):
         Define the calculation efficiency of operator, whether the partial calculation is supported.
 
         Args:
-            partial_flag (bool): Value of partial flag. Default: ``True`` .
+            partial_flag (bool, optional): Value of partial flag. Default: ``True`` .
         """
         self._is_bool(partial_flag)
         self.partial_flag_ = partial_flag
@@ -880,7 +669,7 @@ class TBERegOp(RegOp):
         Whether the operator supports dynamic shape.
 
         Args:
-            dynamic_shape (bool): Value of dynamic shape. Default: ``False`` .
+            dynamic_shape (bool, optional): Value of dynamic shape. Default: ``False`` .
         """
         self._is_bool(dynamic_shape)
         self.dynamic_shape_support_ = dynamic_shape
@@ -891,7 +680,8 @@ class TBERegOp(RegOp):
         Whether the operator supports dynamic compile static.
 
         Args:
-            dynamic_compile_static (bool): Value of dynamic compile static. Default: ``False`` .
+            dynamic_compile_static (bool, optional): An identifier that indicates
+                whether the operator supports dynamic compile static. Default: ``False`` .
         """
         if self._is_bool(dynamic_compile_static):
             self.dynamic_compile_static_ = dynamic_compile_static
@@ -902,7 +692,7 @@ class TBERegOp(RegOp):
         Whether the operator needs check supports.
 
         Args:
-            need_check_supported (bool): Value of need_check_supported. Default: ``False`` .
+            need_check_supported (bool, optional): Value of need_check_supported. Default: ``False`` .
         """
         if self._is_bool(need_check_supported):
             self.need_check_support_ = need_check_supported
@@ -913,7 +703,7 @@ class TBERegOp(RegOp):
         Whether the operator needs calop_select_format api.
 
         Args:
-            is_dynamic_format (bool): Value of is_dynamic_format. Default: ``False`` .
+            is_dynamic_format (bool, optional): Value of is_dynamic_format. Default: ``False`` .
         """
         if self._is_bool(is_dynamic_format):
             self.dynamic_format_ = is_dynamic_format
@@ -924,7 +714,7 @@ class TBERegOp(RegOp):
         The behavior type of operator, such as broadcast, reduce and so on.
 
         Args:
-            pattern (str): Value of op pattern, e.g. "broadcast", "reduce". Default: ``None`` .
+            pattern (str, optional): Value of op pattern, e.g. "broadcast", "reduce". Default: ``None`` .
         """
         if pattern is not None and self._is_string(pattern):
             self.op_pattern_ = pattern
@@ -935,11 +725,11 @@ class TBERegOp(RegOp):
         Register TBE op attribute information.
 
         Args:
-            name (str): Name of the attribute. Default: ``None`` .
-            param_type (str): Param type of the attribute. Default: ``None`` .
-            value_type (str): Type of the attribute. Default: ``None`` .
-            value (str): Value of the attribute. Default: ``None`` .
-            default_value (str): Default value of attribute. Default: ``None`` .
+            name (str, optional): Name of the attribute. Default: ``None`` .
+            param_type (str, optional): Param type of the attribute. Default: ``None`` .
+            value_type (str, optional): Type of the attribute. Default: ``None`` .
+            value (str, optional): Value of the attribute. Default: ``None`` .
+            default_value (str, optional): Default value of attribute. Default: ``None`` .
             kwargs (dict): Other information of the attribute.
         """
         param_list = [name, param_type, value_type, value, default_value]
@@ -954,12 +744,12 @@ class TBERegOp(RegOp):
         Register TBE op input information.
 
         Args:
-            index (int): Order of the input. Default: ``None`` .
-            name (str): Name of the input. Default: ``None`` .
-            need_compile (bool): Whether the input needs to be compiled or not. Default: ``None`` .
-            param_type (str): Type of the input. Default: ``None`` .
-            shape (str): Shape of the input. Default: ``None`` .
-            value_depend (str): Whether the input is constant value depend. Default: ``None`` .
+            index (int, optional): Order of the input. Default: ``None`` .
+            name (str, optional): Name of the input. Default: ``None`` .
+            need_compile (bool, optional): Whether the input needs to be compiled or not. Default: ``None`` .
+            param_type (str, optional): Type of the input. Default: ``None`` .
+            shape (str, optional): Shape of the input. Default: ``None`` .
+            value_depend (str, optional): Whether the input is constant value depend. Default: ``None`` .
             kwargs (dict): Other information of the input.
         """
         param_list = [index, name, need_compile, param_type, shape, value_depend]
@@ -978,11 +768,11 @@ class TBERegOp(RegOp):
         Register TBE op output information.
 
         Args:
-            index (int): Order of the output. Default: ``None`` .
-            name (str): Name of the output. Default: ``None`` .
-            need_compile (bool): Whether the output needs to be compiled or not. Default: ``None`` .
-            param_type (str): Type of the output. Default: ``None`` .
-            shape (str): Shape of the output. Default: ``None`` .
+            index (int, optional): Order of the output. Default: ``None`` .
+            name (str, optional): Name of the output. Default: ``None`` .
+            need_compile (bool, optional): Whether the output needs to be compiled or not. Default: ``None`` .
+            param_type (str, optional): Type of the output. Default: ``None`` .
+            shape (str, optional): Shape of the output. Default: ``None`` .
             kwargs (dict): Other information of the output.
         """
         param_list = [index, name, need_compile, param_type, shape]
@@ -1000,7 +790,7 @@ class CustomRegOp(RegOp):
     attributes and target of `func`.
 
     Args:
-        op_name (str): kernel name. The name will be record in the reg_op_name attr of the kernel node.
+        op_name (str, optional): kernel name. The name will be record in the reg_op_name attr of the kernel node.
             Besides, the operator will generate a unique name automatically to identify the reg info.
             Default: ``"Custom"`` .
 
@@ -1194,8 +984,6 @@ class CustomRegOp(RegOp):
             if isinstance(k, str) and k.endswith('_'):
                 k = k.rstrip('_')
             op_info[k] = v
-        if _get_reg_info_attr(op_info, "cust_aicpu"):
-            _CustomInstaller(op_info).run()
         return op_info
 
 

mindspore/ops/operations/__init__.py

@@ -21,7 +21,8 @@ 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 ._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,
@@ -41,15 +42,15 @@ from .array_ops import (ArgMaxWithValue, ArgMinWithValue, Argmax, Argmin, BatchT
                         ScatterUpdate, SearchSorted, Select, Shape, Size, Slice, Sort, SpaceToBatch, SpaceToBatchND,
                         SpaceToDepth, SparseGatherV2, Split, SplitV, Squeeze, Stack, StridedSlice, TensorScatterAdd,
                         TensorScatterDiv, TensorScatterMax, TensorScatterMin, TensorScatterMul, TensorScatterSub,
-                        TensorScatterUpdate, TensorShape, Tile, TopK, TransShape, Transpose, TupleToArray, Unique,
-                        UniqueWithPad, UnsortedSegmentMax, UnsortedSegmentMin, UnsortedSegmentProd,
-                        UnsortedSegmentSum, Unstack, UpperBound, Zeros, ZerosLike, AffineGrid, Bincount, CheckNumerics,
-                        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,
-                        UniqueConsecutive, UnravelIndex, FillV2, CountNonZero, TensorScatterElements, IndexPut,
-                        MaskedScatter)
+                        TensorScatterUpdate, TensorShape, Tile, TopK, TransShape, Transpose, TransposeView,
+                        TupleToArray, Unique, UniqueWithPad, UnsortedSegmentMax, UnsortedSegmentMin,
+                        UnsortedSegmentProd, UnsortedSegmentSum, Unstack, UpperBound, Zeros, ZerosLike, AffineGrid,
+                        Bincount, CheckNumerics, 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, UniqueConsecutive, UnravelIndex, FillV2, CountNonZero, TensorScatterElements,
+                        IndexPut, MaskedScatter, TypeAs, TransposeExtView)
 from .comm_ops import (AllGather, AllReduce, Reduce, NeighborExchange, NeighborExchangeV2, AlltoAll, _AllSwap,
                        Broadcast, CollectiveGather, CollectiveScatter, Barrier, Send, Receive, BatchISendIRecv,
                        _MirrorOperator, _MirrorMiniStepOperator, _MiniStepAllGather, ReduceOp, _VirtualDataset,
@@ -57,8 +58,8 @@ from .comm_ops import (AllGather, AllReduce, Reduce, NeighborExchange, NeighborE
                        _HostAllGather, _HostReduceScatter, _MirrorMicroStepOperator, _MicroStepAllGather,
                        _VirtualPipelineEnd, AlltoAllV, ReduceScatter, _VirtualAssignKvCache)
 from .control_ops import GeSwitch, Merge
-from .custom_ops import (Custom)
-from .debug_ops import (ImageSummary, InsertGradientOf, HookBackward, ScalarSummary,
+from .custom_ops import (Custom, CustomOpBuilder)
+from .debug_ops import (ImageSummary, InsertGradientOf, Morph, HookBackward, ScalarSummary,
                         TensorSummary, HistogramSummary, TensorDump, Print, Assert)
 from .image_ops import (CropAndResize, NonMaxSuppressionV3, HSVToRGB, AdjustHue, AdjustSaturation,
                         NonMaxSuppressionWithOverlaps, ResizeArea, ResizeBilinearV2, ExtractGlimpse,
@@ -88,7 +89,7 @@ from .math_ops import (Abs, ACos, Asin, Asinh, AddN, AccumulateNV2, AssignAdd, A
                        NextAfter, Orgqr, Qr, RaggedRange, Digamma, Eig, EuclideanNorm, CompareAndBitpack, ComplexAbs,
                        CumulativeLogsumexp, Gcd, Polygamma, Trace, TridiagonalMatMul, TrilIndices, TriuIndices, Zeta,
                        Roll, Lgamma, Logit, MatrixSolveLs, Polar, Fmax, Fmin, Quantile, Sinc, Angle, Bernoulli,
-                       NanToNum, Igamma, BesselI0, BesselI1, InplaceIndexAdd, Igammac, Ormqr)
+                       NanToNum, Igamma, BesselI0, BesselI1, InplaceIndexAdd, Igammac, Ormqr, LerpScalar)
 from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSparseLazyAdam, AdamNoUpdateParam,
                      ApplyMomentum, BatchNorm, BiasAdd, Conv2D, Conv3D, Conv2DTranspose, Conv3DTranspose,
                      DepthwiseConv2dNative,
@@ -118,10 +119,10 @@ from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSpa
                      FractionalMaxPool, FractionalMaxPool3DWithFixedKsize, FractionalMaxPoolWithFixedKsize,
                      GridSampler2D, TripletMarginLoss, UpsampleNearest3D, UpsampleTrilinear3D, PadV3, ChannelShuffle,
                      GLU, MaxUnpool3D, Pdist, RmsNorm, PagedAttention, PagedAttentionMask, ReshapeAndCache,
-                     ApplyRotaryPosEmb)
+                     ApplyRotaryPosEmb, GroupTopk)
 from .other_ops import (Assign, IOU, BoundingBoxDecode, BoundingBoxEncode,
                         ConfusionMatrix, UpdateState, Load, StopGradient, Reusing,
-                        CheckValid, Partial, Depend, Push, Pull, PyExecute, PyFunc, _DynamicLossScale,
+                        CheckValid, Partial, Depend, MoveTo, Push, Pull, PyExecute, PyFunc, _DynamicLossScale,
                         SampleDistortedBoundingBoxV2)
 from .random_ops import (RandomChoiceWithMask, StandardNormal, Gamma, RandomGamma, Poisson, UniformInt, UniformReal,
                          RandomCategorical, StandardLaplace, Multinomial, UniformCandidateSampler,
@@ -221,6 +222,8 @@ __all__ = [
     'Reshape',
     'Squeeze',
     'Transpose',
+    'TransposeView',
+    'TransposeExtView',
     'OneHot',
     'GatherV2',
     'Gather',
@@ -250,6 +253,7 @@ __all__ = [
     'LayerNorm',
     'Rank',
     'Lerp',
+    'LerpScalar',
     'Less',
     'LessEqual',
     'LowerBound',
@@ -301,6 +305,7 @@ __all__ = [
     "Print",
     "Assert",
     'InsertGradientOf',
+    "Morph",
     'HookBackward',
     'InvertPermutation',
     'Shape',
@@ -375,6 +380,7 @@ __all__ = [
     'IOU',
     'Partial',
     'Depend',
+    'MoveTo',
     'UpdateState',
     'StopGradient',
     'identity',
@@ -543,6 +549,7 @@ __all__ = [
     "Send",
     "Receive",
     "Custom",
+    "CustomOpBuilder",
     "LuSolve",
     "CholeskyInverse",
     "Cummax",
@@ -708,6 +715,7 @@ __all__ = [
     "PagedAttentionMask",
     "ReshapeAndCache",
     "ApplyRotaryPosEmb",
+    "GroupTopk",
     "RmsNorm",
     "Reshard",
 ]