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

msprobe/pytorch/bench_functions/fast_gelu.py

@@ -1,55 +1,55 @@
-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()
+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,6 @@
-import torch
-
-
-def npu_layer_norm_eval(data, normalized_shape):
-    result = torch.nn.functional.layer_norm(data, normalized_shape)
-    return result.cpu()
+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,12 @@
-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()
+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,48 @@
-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()
+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()