fix d class models on OrangePi (#2214)

Author: lvyufeng

mindtorch/_apis/npu.py

@@ -182,7 +182,7 @@ def cast(input, dtype):
     """
     return legacy.cast(input, dtype)
 
-def sub(input, other, alpha):
+def sub(input, other, alpha=1.0):
     """
     Subtracts the other tensor from the input tensor.
 
@@ -271,8 +271,10 @@ def matmul(input, other):
         Tensor: The result of the matrix multiplication.
     """
     if ON_ORANGE_PI:
+        dtype = input.dtype
         input = cast(input, mindspore.float16)
         other = cast(other, mindspore.float16)
+        return cast(pyboost.matmul_ext_op(input, other), dtype)
     if use_pyboost():
         return pyboost.matmul_ext_op(input, other)
     return legacy.mat_mul(input, other)
@@ -1144,9 +1146,9 @@ def neg(input):
     return legacy.neg(input)
 
 def log1p(input):
-    if use_pyboost():
+    if use_pyboost() and not ON_ORANGE_PI:
         return pyboost.log1p_op(input)
-    return legacy.log1p(input)
+    return log(add(input, 1))
 
 def pow_scalar_tensor(input, scalar):
     if use_pyboost():
@@ -1506,19 +1508,24 @@ def var(input, dim=None, correction=1, keepdim=False):
     return legacy.var(input, dim, correction, keepdim)
 
 def linspace(start, end, steps, dtype=None):
-    if use_pyboost():
+    if use_pyboost() and not ON_ORANGE_PI:
         return pyboost.lin_space_ext_op(start, end, steps, dtype)
-    return legacy.lin_space(start, end, steps)
+    start = float(start)
+    end = float(end)
+    return legacy.lin_space(mindspore.Tensor(start), mindspore.Tensor(end), steps)
 
 def masked_select(input, mask):
     if use_pyboost():
         return pyboost.masked_select_op(input, mask)
     return legacy.masked_select(input, mask)
 
 def glu(input, dim=-1):
-    if use_pyboost():
+    if use_pyboost() and not ON_ORANGE_PI:
         return pyboost.glu_impl(input, dim)
-    return legacy.glu(input, dim)
+    a, b = chunk(input, 2, dim)
+    gate = sigmoid(b)
+    return mul(a, gate)
+
 
 def scatter_value(input, dim, index, src, reduce='none'):
     if use_pyboost():
@@ -1668,11 +1675,13 @@ def pixel_shuffle(input, upscale_factor):
     return legacy.pixel_shuffle(input, upscale_factor)
 
 def view_as_complex(input):
+    if ON_ORANGE_PI:
+        input = clone(input)
     real_part, imag_part = chunk(input, 2, -1)
     return legacy.complex(squeeze(real_part, -1), squeeze(imag_part, -1))
 
 def rms_norm(input, weight, eps=1e-5):
-    if use_pyboost():
+    if use_pyboost() and not ON_ORANGE_PI:
         return pyboost.rms_norm_impl(input, weight, eps)[0]
     input_dtype = input.dtype
     input = cast(input, mindspore.float32)
@@ -1904,4 +1913,11 @@ def tensor_scatter_update(input, indices, updates):
     return legacy.tensor_scatter_update(input, indices, updates)
 
 def lerp(input, end, weight):
-    return legacy.lerp(input, end, weight)
+    return legacy.lerp(input, end, weight)
+
+def logaddexp(input, other):
+    m = maximum(input, other)
+    abs_val = abs(sub(input, other))
+    exp_val = exp(neg(abs_val))
+    y = add(m, log1p(exp_val))
+    return y

mindtorch/ops/creation.py

@@ -103,7 +103,7 @@ def ones_like(input, *, dtype=None, layout=None, device=None, requires_grad=Fals
 # arange
 def arange(start=0, end=None, step=1, *, out=None, dtype=None, layout=None, device=None, requires_grad=False):
     if end is None:
-        start, end = 0, start
+        start, end = 0, int(start)
     if dtype is None:
         dtype = mindtorch.py2dtype[type(start)]
     if device is None:

mindtorch/ops/other.py

@@ -79,6 +79,7 @@ def bucketize(input, boundaries, *, out_int32=False, right=False, out=None):
 def cdist(x1, x2, p=2.0, compute_mode="use_mm_for_euclid_dist_if_necessary"):
     return execute('cdist', x1, x2, p)
 
+
 # clone
 def clone(input, *, memory_format=mindtorch.preserve_format):
     return execute('clone', input)

mindtorch/ops/pointwise.py

@@ -391,9 +391,12 @@ def mul(input, other):
         other = other.to(device)
         input = input.to(device)
     if not isinstance(other, numbers.Number) and other.dtype != input.dtype:
-        dtype = min([input.dtype, other.dtype])
-        other = other.to(dtype)
-        input = input.to(dtype)
+        if other.dtype == mindtorch.bool:
+            other = other.to(input.dtype)
+        else:
+            dtype = min([input.dtype, other.dtype])
+            other = other.to(dtype)
+            input = input.to(dtype)
     #  and isinstance(input, torch.Tensor):
     #     return execute("muls", input, other)
     return execute("mul", input, other)