mindstudio-probe 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

msprobe/pytorch/bench_functions/apply_adam_w.py

@@ -1,28 +1,43 @@
-import torch
-
-
-def npu_apply_adam_w(beta1_power, beta2_power, lr, weight_decay,
-                     beta1, beta2, eps, grad, max_grad_norm, amsgrad, maximize, out):
-    var, m, v = out
-    if amsgrad:
-        max_grad_norm = (torch.rand(var.shape) * 10.0 - 5.0).to(var.dtype)
-    beta1_power_out = beta1_power * beta1
-    beta2_power_out = beta2_power * beta2
-    var_t = var * (1 + (-lr * weight_decay))
-    gt = -grad if maximize else grad
-    m_out = m * beta1 - (beta1 + (-1)) * gt
-    v_out = v * beta2 - (beta2 + (-1)) * gt * gt
-
-    if amsgrad:
-        max_grad_norm_out = torch.max(max_grad_norm, v_out)
-        if (1 - beta2_power_out) == 0:
-            beta2_power_out -= eps
-        denom = torch.sqrt(torch.div(max_grad_norm_out, (1 - beta2_power_out))) + eps
-    else:
-        vraintain = torch.div(v_out, (1 - beta2_power_out))
-        denom = torch.sqrt(vraintain) + eps
-
-    if (1 - beta1_power_out) == 0:
-        beta1_power_out -= eps
-    var_out = var_t + torch.div(-lr * m_out, (1 - beta1_power_out)).div(denom)
-    return var_out.cpu(), m_out.cpu(), v_out.cpu()
+# 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 npu_apply_adam_w(beta1_power, beta2_power, lr, weight_decay,
+                     beta1, beta2, eps, grad, max_grad_norm, amsgrad, maximize, out):
+    var, m, v = out
+    if amsgrad:
+        max_grad_norm = (torch.rand(var.shape) * 10.0 - 5.0).to(var.dtype)
+    beta1_power_out = beta1_power * beta1
+    beta2_power_out = beta2_power * beta2
+    var_t = var * (1 + (-lr * weight_decay))
+    gt = -grad if maximize else grad
+    m_out = m * beta1 - (beta1 + (-1)) * gt
+    v_out = v * beta2 - (beta2 + (-1)) * gt * gt
+
+    if amsgrad:
+        max_grad_norm_out = torch.max(max_grad_norm, v_out)
+        if (1 - beta2_power_out) == 0:
+            beta2_power_out -= eps
+        denom = torch.sqrt(torch.div(max_grad_norm_out, (1 - beta2_power_out))) + eps
+    else:
+        vraintain = torch.div(v_out, (1 - beta2_power_out))
+        denom = torch.sqrt(vraintain) + eps
+
+    if (1 - beta1_power_out) == 0:
+        beta1_power_out -= eps
+    var_out = var_t + torch.div(-lr * m_out, (1 - beta1_power_out)).div(denom)
+    return var_out, m_out, v_out

msprobe/pytorch/bench_functions/confusion_transpose.py

@@ -1,19 +1,34 @@
-def npu_confusion_transpose(data, perm, shape, transpose_first):
-    if transpose_first:
-        output = data.permute(*perm).contiguous().view(shape)
-    else:
-        output = data.view(shape).permute(*perm)
-    return output.cpu()
-
-
-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]
-    perm_cal = [0] * len(perm)
-    for i, perm_dim in enumerate(perm):
-        perm_cal[perm_dim] = i
-
-    if transpose_first:
-        result = grad.permute(*perm_cal).reshape(shape_cal)
-    else:
-        result = grad.reshape(shape_cal).permute(*perm_cal)
-    return result.cpu()
+# 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)
+    else:
+        output = data.view(shape).permute(*perm)
+    return output
+
+
+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]
+    perm_cal = [0] * len(perm)
+    for i, perm_dim in enumerate(perm):
+        perm_cal[perm_dim] = i
+
+    if transpose_first:
+        result = grad.permute(*perm_cal).reshape(shape_cal)
+    else:
+        result = grad.reshape(shape_cal).permute(*perm_cal)
+    return result.cpu()

msprobe/pytorch/bench_functions/fast_gelu.py

@@ -1,55 +1,70 @@
-import torch
-
-
-def fast_gelu(input0):
-    attr = 1.702
-    const_0 = 0 - attr
-    const_1 = 1
-    const_2 = attr / 2
-
-    abs_x = torch.abs(input0)
-    mul_abs_x = abs_x * const_0
-    exp_abs_x = torch.exp(mul_abs_x)
-    div_down = exp_abs_x + const_1
-
-    pn_x = input0 - abs_x
-    mul_pn_x = pn_x * const_2
-    exp_pn_x = torch.exp(mul_pn_x)
-    div_up = input0 * exp_pn_x
-    div_down_rec = torch.reciprocal(div_down)
-    result = div_up * div_down_rec
-
-    return result.cpu()
-
-
-def npu_fast_gelu_backward(grad, input_x):
-    const_2 = 1.702
-    const_3 = 1.0
-    const_1 = 0.0 - const_2
-
-    # e^(-1.702x)
-    abs_x = torch.abs(input_x)
-    mul_abs_x = abs_x * const_1
-    exp_x = torch.exp(mul_abs_x)
-
-    # 1.702xe^(-1.702x)
-    add_2 = input_x * exp_x
-    add_2 = add_2 * const_2
-
-    # e^(1.702(x-|x|))
-    pn_x = input_x - abs_x
-    mul_pn_x = pn_x * const_2
-    exp_pn_x = torch.exp(mul_pn_x)
-
-    #  e^(-1.702x) + 1.702xe^(-1.702x) + e^(1.702(x-|x|))
-    div_up = exp_x + add_2
-    div_up = div_up + exp_pn_x
-
-    # (e^(-1.702x)+1)^2
-    div_down_i = exp_x + const_3
-    div_down = div_down_i * div_down_i
-    div_down_rec = torch.reciprocal(div_down)
-    result_temp = div_up * div_down_rec
-    result = grad * result_temp
-
-    return result.cpu()
+# 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 npu_fast_gelu(input0):
+    attr = 1.702
+    const_0 = 0 - attr
+    const_1 = 1
+    const_2 = attr / 2
+
+    abs_x = torch.abs(input0)
+    mul_abs_x = abs_x * const_0
+    exp_abs_x = torch.exp(mul_abs_x)
+    div_down = exp_abs_x + const_1
+
+    pn_x = input0 - abs_x
+    mul_pn_x = pn_x * const_2
+    exp_pn_x = torch.exp(mul_pn_x)
+    div_up = input0 * exp_pn_x
+    div_down_rec = torch.reciprocal(div_down)
+    result = div_up * div_down_rec
+
+    return result
+
+
+def npu_fast_gelu_backward(grad, input_x):
+    const_2 = 1.702
+    const_3 = 1.0
+    const_1 = 0.0 - const_2
+
+    # e^(-1.702x)
+    abs_x = torch.abs(input_x)
+    mul_abs_x = abs_x * const_1
+    exp_x = torch.exp(mul_abs_x)
+
+    # 1.702xe^(-1.702x)
+    add_2 = input_x * exp_x
+    add_2 = add_2 * const_2
+
+    # e^(1.702(x-|x|))
+    pn_x = input_x - abs_x
+    mul_pn_x = pn_x * const_2
+    exp_pn_x = torch.exp(mul_pn_x)
+
+    #  e^(-1.702x) + 1.702xe^(-1.702x) + e^(1.702(x-|x|))
+    div_up = exp_x + add_2
+    div_up = div_up + exp_pn_x
+
+    # (e^(-1.702x)+1)^2
+    div_down_i = exp_x + const_3
+    div_down = div_down_i * div_down_i
+    div_down_rec = torch.reciprocal(div_down)
+    result_temp = div_up * div_down_rec
+    result = grad * result_temp
+
+    return result.cpu()

msprobe/pytorch/bench_functions/layer_norm_eval.py

@@ -1,6 +1,21 @@
-import torch
-
-
-def npu_layer_norm_eval(data, normalized_shape):
-    result = torch.nn.functional.layer_norm(data, normalized_shape)
-    return result.cpu()
+# 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 npu_layer_norm_eval(data, normalized_shape, weight=None, bias=None, eps=1e-5):
+    result = torch.nn.functional.layer_norm(data, normalized_shape)
+    return result

msprobe/pytorch/bench_functions/linear.py

@@ -1,12 +1,27 @@
-import torch
-
-
-def npu_linear(x, weight, bias):
-    output = torch.nn.functional.linear(x, weight, bias)
-    return output.cpu()
-
-
-def npu_linear_backward(grad, input_data, weight):
-    input_grad = torch.matmul(grad, weight)
-    weight_grad = torch.matmul(grad.t(), input_data)
-    return input_grad.cpu(), weight_grad.cpu()
+# 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 npu_linear(x, weight, bias):
+    output = torch.nn.functional.linear(x, weight, bias)
+    return output
+
+
+def npu_linear_backward(grad, input_data, weight):
+    input_grad = torch.matmul(grad, weight)
+    weight_grad = torch.matmul(grad.t(), input_data)
+    return input_grad.cpu(), weight_grad.cpu()

msprobe/pytorch/bench_functions/matmul_backward.py

@@ -1,48 +1,63 @@
-import torch
-
-
-def matmul_backward(grad, self, other, mask):
-    grad_self, grad_other = None, None
-    dim_self = self.dim()
-    dim_other = other.dim()
-
-    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
-    elif dim_self == 2 and dim_other == 1:
-        grad_self = grad.unsqueeze(1).mm(other.unsqueeze(0)) if mask[0] else grad_self
-        grad_other = self.transpose(-1, -2).mm(grad.unsqueeze(1)).squeeze_(1) if mask[1] else grad_other
-    elif dim_self == 1 and dim_other == 2:
-        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):
-        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]:
-            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:
-        view_size = 1 if dim_self == 1 else size_grad[-2]
-        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]:
-            # create a 2D-matrix from other
-            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)
-        if mask[1]:
-            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)
-    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
-
-    return grad_self.cpu(), grad_other.cpu()
+# 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):
+    grad_self, grad_other = None, None
+    dim_self = self.dim()
+    dim_other = other.dim()
+
+    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
+    elif dim_self == 2 and dim_other == 1:
+        grad_self = grad.unsqueeze(1).mm(other.unsqueeze(0)) if mask[0] else grad_self
+        grad_other = self.transpose(-1, -2).mm(grad.unsqueeze(1)).squeeze_(1) if mask[1] else grad_other
+    elif dim_self == 1 and dim_other == 2:
+        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):
+        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]:
+            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:
+        view_size = 1 if dim_self == 1 else size_grad[-2]
+        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]:
+            # create a 2D-matrix from other
+            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)
+        if mask[1]:
+            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)
+    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
+
+    return grad_self.cpu(), grad_other.cpu()