mindstudio-probe 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/dump_dispatch.py

@@ -0,0 +1,115 @@
+
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from collections import defaultdict
+from functools import wraps
+
+import torch
+from torch.utils._python_dispatch import TorchDispatchMode
+from msprobe.pytorch.api_accuracy_checker.common.utils import ApiData
+from msprobe.pytorch.common.utils import get_tensor_rank
+from msprobe.core.common.const import Const
+from msprobe.pytorch.common.log import logger
+from msprobe.core.common.file_utils import load_yaml
+
+
+def singleton(cls):
+    _instance = {}
+
+    @wraps(cls)
+    def inner():
+        if cls not in _instance:
+            _instance[cls] = cls()
+        return _instance[cls]
+    return inner
+
+
+@singleton
+class Counter:
+    def __init__(self) -> None:
+        self.index_dict = defaultdict(int)
+
+
+counter = Counter()
+yaml_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "torch_ops_config.yaml")
+yaml_file = load_yaml(yaml_path)
+
+
+class AccuracyCheckerDispatch(TorchDispatchMode):
+    def __init__(self, attl):
+        super(AccuracyCheckerDispatch, self).__init__()
+        self.attl = attl
+        self.counter = counter
+        self.aten_ops_blacklist = []
+        self.npu_adjust_autogard = []
+        self.aten_ops_blacklist = yaml_file.get('aten_ops_blacklist', [])
+        self.npu_adjust_autogard = yaml_file.get('npu_adjust_autogard', [])
+
+    def __torch_dispatch__(self, func, types, args=None, kwargs=None):
+        func_name_split_list = func.__name__.split(Const.SEP)
+        aten_api = func_name_split_list[0]
+        self.enable_autogard(aten_api)
+        if aten_api in self.aten_ops_blacklist:
+            npu_out = func(*args, **kwargs)
+            return npu_out
+
+        res = func(*args, **kwargs)
+        cur_rank = get_tensor_rank(args, res)
+        cur_api_number = self.counter.index_dict[aten_api]
+        api_name = f'{Const.ATEN}{Const.SEP}{aten_api}{Const.SEP}{cur_api_number}'
+        logger.info(f"tools is dumping api: {api_name}, rank: {cur_rank}")
+        api_data = ApiData(api_name, args, kwargs, res, 0, cur_rank)
+        if "device" in api_data.kwargs:
+            api_data.kwargs.pop("device")
+        if self.attl.nfs_path:
+            self.attl.upload(api_data)
+        else:
+            self.attl.send(api_data)
+        self.counter.index_dict[aten_api] += 1
+
+        return res
+    
+    def enable_autogard(self, aten_api):
+        if aten_api in self.npu_adjust_autogard:
+            torch._C._dispatch_tls_set_dispatch_key_excluded(torch._C.DispatchKey.AutogradFunctionality, False)
+
+
+def dispatch4data(func, attl, status):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if not status:
+            return func(*args, **kwargs)
+        with AccuracyCheckerDispatch(attl):
+            res = func(*args, **kwargs)
+            return res
+
+    return wrapper
+
+
+def run_ut_dispatch(attl, status, is_recompute=False):
+    """
+    This function called by online_run_ut.
+    It is used to enable or disable dispatch for torch.autograd.backward function.
+
+    Args:
+        attl (ATTL):  online_run_ut class ATTL, which is used to upload or send api data to server.
+        status (bool): True means enable dispatch, False means disable dispatch.
+        is_recompute (bool): Flag of recompute, which is conflicted with aten api, then skip dispatch4data.
+    """
+    if is_recompute:
+        return
+    torch.autograd.backward = dispatch4data(torch.autograd.backward, attl, status)

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/server.py

@@ -1,3 +1,18 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import os.path
 import struct
 import hashlib
@@ -8,7 +23,8 @@ from threading import Thread
 from twisted.internet import reactor, protocol, endpoints
 
 from msprobe.pytorch.common.utils import logger
-from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.ssl_config import cipher_list
+from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.utils import cipher_list, \
+    STRUCT_UNPACK_MODE as unpack_mode, STR_TO_BYTES_ORDER as bytes_order
 
 
 class TCPServer:
@@ -100,9 +116,9 @@ class ServerProtocol(protocol.Protocol):
     def send_ack(self, ack_info):
         ack_message = b"".join([
             ack_info,
-            self.sequence_number.to_bytes(8, byteorder='big'),
-            self.rank.to_bytes(8, byteorder='big'),
-            self.step.to_bytes(8, byteorder='big')
+            self.sequence_number.to_bytes(8, byteorder=bytes_order),
+            self.rank.to_bytes(8, byteorder=bytes_order),
+            self.step.to_bytes(8, byteorder=bytes_order)
         ])
         self.transport.write(ack_message)
 
@@ -168,10 +184,10 @@ class ServerProtocol(protocol.Protocol):
         # The first data packet is packet header, it contains obj_length, sequence_number, rank, step
         if self.obj_length is None and len(self.buffer.getvalue()) >= self.length_width * 4:
             self.start_time = time.time()
-            self.obj_length = struct.unpack('!Q', self.buffer.read(self.length_width))[0]
-            self.sequence_number = struct.unpack('!Q', self.buffer.read(self.length_width))[0]
-            self.rank = struct.unpack('!Q', self.buffer.read(self.length_width))[0]
-            self.step = struct.unpack('!Q', self.buffer.read(self.length_width))[0]
+            self.obj_length = struct.unpack(unpack_mode, self.buffer.read(self.length_width))[0]
+            self.sequence_number = struct.unpack(unpack_mode, self.buffer.read(self.length_width))[0]
+            self.rank = struct.unpack(unpack_mode, self.buffer.read(self.length_width))[0]
+            self.step = struct.unpack(unpack_mode, self.buffer.read(self.length_width))[0]
             self.tell += self.length_width * 4
             logger.debug(
                 f"流水号: {self.sequence_number}; RANK: {self.rank}; STEP: {self.step}; Length: {self.obj_length}")
@@ -210,7 +226,8 @@ class MessageServerFactory(protocol.ServerFactory):
     def __init__(self) -> None:
         """
         transport_dict: links that have not completed data transmission.
-        transport_list: Records all TCP links. Appends TCP link to the transport list when a new TCP link is established.
+        transport_list: Records all TCP links. Appends TCP link to the transport list
+                        when a new TCP link is established.
         """
         self.transport_dict = {}
         self.transport_list = []

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/torch_ops_config.yaml

@@ -0,0 +1,63 @@
+aten_ops_blacklist:
+  - npu_binary_cross_entropy_with_logits_backward
+  - npu_ciou_backward
+  - _cudnn_rnn
+  - _local_scalar_dense
+  - _pin_memory
+  - _to_copy
+  - _unsafe_view
+  - clone
+  - contiguous
+  - copy_
+  - cudnn_batch_norm
+  - cudnn_batch_norm_backward
+  - detach
+  - empty
+  - index_put_
+  - lift_fresh
+  - max_pool2d_with_indices_backward # shape unmatch
+  - native_batch_norm_backward
+  - new_empty
+  - new_empty_strided
+  - new_full
+  - new_ones
+  - new_zeros
+  - ones
+  - ones_like
+  - permute
+  - rand
+  - rand_like
+  - randint
+  - randint_like
+  - randn
+  - randn_like
+  - randperm
+  - scalar_tensor
+  - select
+  - to
+  - transpose
+  - unbind
+  - view
+  - zero
+  - zero_
+  - zeros
+  - zeros_like
+  - _record_function_enter_new
+  - _record_function_exit
+  - broadcast_
+  - allreduce_
+  - npu_clear_float_status
+  - npu_format_cast
+  - npu_dtype_cast
+  - npu_dtype_cast_backward
+  - _allgather_base_
+  - _reduce_scatter_base_
+  - is_same_size
+
+npu_adjust_autogard:
+  - adaptive_avg_pool2d
+  - batch_norm
+  - log_softmax
+  - nll_loss
+  - to
+  

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/utils.py

@@ -0,0 +1,44 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+cipher_list = ":".join(
+    ["TLS_DHE_RSA_WITH_AES_128_GCM_SHA256",
+     "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384",
+     "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256",
+     "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384",
+     "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256",
+     "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384",
+     "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256",
+     "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+     "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+     "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+     "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
+     "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
+     "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256",
+     "TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256",
+     "TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384",
+     "TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256",
+     "TLS_DHE_RSA_WITH_AES_128_CCM",
+     "TLS_DHE_RSA_WITH_AES_256_CCM",
+     "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
+     "TLS_DHE_PSK_WITH_AES_128_CCM",
+     "TLS_DHE_PSK_WITH_AES_256_CCM",
+     "TLS_ECDHE_ECDSA_WITH_AES_128_CCM",
+     "TLS_ECDHE_ECDSA_WITH_AES_256_CCM",
+     "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"]
+).encode()
+
+STRUCT_UNPACK_MODE = "!Q"
+STR_TO_BYTES_ORDER = "big"

msprobe/pytorch/bench_functions/__init__.py

@@ -1,11 +1,26 @@
-import os
-from pkgutil import iter_modules
-from importlib import import_module
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 """
 gpu and cpu not implement benchmark function, supplementary benchmarking function implementation
 """
 
+import os
+from pkgutil import iter_modules
+from importlib import import_module
+
 package_path = os.path.dirname(os.path.realpath(__file__))
 for _, module_name, _ in iter_modules([package_path]):
     module = import_module(f"{__name__}.{module_name}")

msprobe/pytorch/bench_functions/apply_adam_w.py

@@ -1,3 +1,18 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import torch
 
 

msprobe/pytorch/bench_functions/confusion_transpose.py

@@ -1,3 +1,18 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 def npu_confusion_transpose(data, perm, shape, transpose_first):
     if transpose_first:
         output = data.permute(*perm).contiguous().view(shape)
@@ -7,7 +22,11 @@ def npu_confusion_transpose(data, perm, shape, transpose_first):
 
 
 def npu_confusion_transpose_backward(grad, perm, shape, transpose_first):
-    shape_cal = shape if transpose_first else [shape[perm_dim] for perm_dim in perm]
+    try:
+        shape_cal = shape if transpose_first else [shape[perm_dim] for perm_dim in perm]
+    except IndexError as e:
+        raise IndexError("npu_confusion_transpose_backward: Invalid perm index for shape") from e
+
     perm_cal = [0] * len(perm)
     for i, perm_dim in enumerate(perm):
         perm_cal[perm_dim] = i

msprobe/pytorch/bench_functions/fast_gelu.py

@@ -1,3 +1,18 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import torch
 
 

msprobe/pytorch/bench_functions/layer_norm_eval.py

@@ -1,3 +1,18 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import torch
 
 

msprobe/pytorch/bench_functions/linear.py

@@ -1,3 +1,18 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import torch
 
 

msprobe/pytorch/bench_functions/matmul_backward.py

@@ -1,7 +1,25 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import torch
 
 
 def matmul_backward(grad, self, other, mask):
+    if len(mask) < 2:
+        raise RuntimeError("Mask size at least 2")
+
     grad_self, grad_other = None, None
     dim_self = self.dim()
     dim_other = other.dim()
@@ -9,6 +27,7 @@ def matmul_backward(grad, self, other, mask):
     size_grad = list(grad.size())
     size_self = list(self.size())
     size_other = list(other.size())
+
     if dim_self == 1 and dim_other == 1:
         grad_self = other.mul(grad) if mask[0] else grad_self
         grad_other = self.mul(grad) if mask[1] else grad_other
@@ -19,28 +38,36 @@ def matmul_backward(grad, self, other, mask):
         grad_self = grad.unsqueeze(0).mm(other.transpose(-1, -2)).squeeze_(0) if mask[0] else grad_self
         grad_other = self.unsqueeze(1).mm(grad.unsqueeze(0)) if mask[1] else grad_other
     elif dim_self >= 3 and (dim_other == 1 or dim_other == 2):
+        if len(size_grad) < 1:
+            raise RuntimeError("size_grad's length at least 1")
         view_size = 1 if dim_other == 1 else size_grad[-1]
         unfolded_grad = (grad.unsqueeze(-1) if dim_other == 1 else grad).contiguous().view(-1, view_size)
         if mask[0]:
             grad_self = unfolded_grad.mm(other.unsqueeze(0) if dim_other == 1 else other.transpose(-1, -2)) \
                 .view(size_self)
         if mask[1]:
+            if len(size_self) < 1:
+                raise RuntimeError("size_self's length at least 1")
             unfolded_self = self.contiguous().view([-1, size_self[-1]])
             grad_other = unfolded_self.transpose(-1, -2).mm(unfolded_grad).view(size_other)
     elif (dim_self == 1 or dim_self == 2) and dim_other >= 3:
+        if len(size_grad) < 2:
+            raise RuntimeError("size_grad's length at least 2")
         view_size = 1 if dim_self == 1 else size_grad[-2]
-        unfolded_grad_T = grad.view([-1, view_size]) \
+        unfolded_grad_t = grad.view([-1, view_size]) \
             if dim_self == 1 else grad.transpose(-1, -2).contiguous().view([-1, view_size])
         if mask[0]:
+            if len(size_other) < 2:
+                raise RuntimeError("size_other's length at least 2")
             # create a 2D-matrix from other
-            unfolded_other_T = \
+            unfolded_other_t = \
                 other.transpose(-1, -2).contiguous().view([-1, size_other[-2]]).transpose(-1, -2)
-            grad_self = unfolded_other_T.mm(unfolded_grad_T).transpose(-1, -2).view(size_self)
+            grad_self = unfolded_other_t.mm(unfolded_grad_t).transpose(-1, -2).view(size_self)
         if mask[1]:
-            size_other_T = size_other[:-2]
-            size_other_T.extend(size_other[::-1][:2])
+            size_other_t = size_other[:-2]
+            size_other_t.extend(size_other[::-1][:2])
             grad_other = \
-                unfolded_grad_T.mm(self.unsqueeze(0) if dim_self == 1 else self).view(size_other_T).transpose(-1, -2)
+                unfolded_grad_t.mm(self.unsqueeze(0) if dim_self == 1 else self).view(size_other_t).transpose(-1, -2)
     else:
         grad_self = torch.matmul(grad, other.transpose(-1, -2)) if mask[0] else grad_self
         grad_other = torch.matmul(self.transpose(-1, -2), grad) if mask[1] else grad_other