mindspore 2.7.0rc1__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/ops/operations/_custom_ops_utils.py

@@ -228,20 +228,18 @@ class ExtensionBuilder:
             source_file.write(content)
 
     def _run_ninja_build(self, module_name):
-        """Run ninja build."""
+        """Run ninja build and log output to .build_log.txt"""
         cmd = ['ninja', '-v']
         env = os.environ.copy()
+        log_file = os.path.join(self.build_dir, '.build_log.txt')
 
         try:
-            subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=self.build_dir, check=True, env=env)
-            # If the build succeeds, do nothing with the output (silent)
+            with open(log_file, 'w', encoding='utf-8') as f:
+                # If the build succeeds, do nothing with the output (silent)
+                subprocess.run(cmd, stdout=f, stderr=f, cwd=self.build_dir, check=True, env=env)
         except subprocess.CalledProcessError as e:
-            # Capture the error details
-            stderr_output = e.stderr.decode() if e.stderr else ""
-            stdout_output = e.stdout.decode() if e.stdout else ""
-            full_output = stderr_output + stdout_output
-
-            # Format the error message
+            with open(log_file, 'r', encoding='utf-8') as rf:
+                full_output = rf.read()
             msg = f"Error building extension '{module_name}': {full_output}"
 
             # In multi-card situation, only one process build the library.

mindspore/ops/operations/_inner_ops.py

@@ -25,10 +25,10 @@ from mindspore.ops.operations._scalar_ops import bit_or, bit_and
 from mindspore.ops import signature as sig
 from mindspore.ops.operations.math_ops import _infer_shape_reduce
 from mindspore.ops.primitive import PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register, Primitive, \
-    _run_op, _check_contains_variable
+    _check_contains_variable
 from mindspore._c_expression import TensorPy as Tensor_
 from mindspore._c_expression import typing, HookType
-from mindspore._c_expression import pyboost_generator
+from mindspore._c_expression import pyboost_generator, pyboost_cell_backward_hook
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
@@ -1413,6 +1413,7 @@ class PsROIPooling(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self, pooled_height, pooled_width, num_rois, spatial_scale, out_dim, group_size):
+
         """Initialize PsROIPooling"""
         validator.check_value_type("pooled_height", pooled_height, [int], self.name)
         validator.check_value_type("pooled_width", pooled_width, [int], self.name)
@@ -1565,10 +1566,11 @@ class CellBackwardHook(PrimitiveWithInfer):
         self.add_prim_attr("cell_id", cell_id)
         self.grad_output = None
 
-    def __call__(self, *args):
-        # If args is empty, just return.
-        if not args:
-            return args
+    def __call__(self, args):
+        is_tuple = True
+        if not isinstance(args, tuple):
+            args = (args,)
+            is_tuple = False
 
         # Collect the indices and values of arguments that are instances of Tensor
         tensors_idx = []
@@ -1578,20 +1580,18 @@ class CellBackwardHook(PrimitiveWithInfer):
                 tensors_idx.append(i)
                 tensors.append(arg)
 
-        # If there are no Tensor arguments, return the single argument or the original tuple
+        # If there are no Tensor arguments, return original args
         if not tensors:
-            return args[0] if len(args) == 1 else args
+            return args if is_tuple else args[0]
 
-        new_tensors = _run_op(self, self.name, tensors)
-        if not isinstance(new_tensors, tuple):
-            new_tensors = (new_tensors,)
+        new_tensors = pyboost_cell_backward_hook(self, (tensors,))
 
         # Replace the original Tensor arguments with the processed ones
         arg_list = list(args)
         for idx, val in zip(tensors_idx, new_tensors):
             arg_list[idx] = val
 
-        return arg_list[0] if len(arg_list) == 1 else tuple(arg_list)
+        return tuple(arg_list) if is_tuple else arg_list[0]
 
     def infer_shape(self, *inputs_shape):
         if len(inputs_shape) == 1:
@@ -1727,44 +1727,6 @@ class Format(PrimitiveWithInfer):
         return {'dtype': mstype.string, 'shape': [], 'value': value}
 
 
-class FlattenConcat(Primitive):
-    """
-    Flatten input tensors and concatenate them into several chunk tensors grouped by data types.
-
-    Args:
-        fusion_size (int): Maximum memory chunk size in bytes, 0 for unlimited. Default: 0.
-
-    Inputs:
-        - **tensors** (tuple[Tensor], list[Tensor]) - The input Tensors to be flattened and concatenated.
-
-    Outputs:
-        tuple[Tensor], result chunk tensors.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> from mindspore.ops.operations import _inner_ops as inner
-        >>> t1 = Tensor(np.array([1]).astype(np.float32))
-        >>> t2 = Tensor(np.array([2]).astype(np.float32))
-        >>> t3 = Tensor(np.array([3]).astype(np.float64))
-        >>> t4 = Tensor(np.array([4]).astype(np.float32))
-        >>> t5 = Tensor(np.array([5]).astype(np.float64))
-        >>> chunks = inner.FlattenConcat()([t1, t2, t2, t3, t4, t5])
-        >>> print(chunks[0].asnumpy())
-        >>> print(chunks[1].asnumpy())
-        [1. 2. 4.]
-        [3. 5.]
-    """
-
-    @prim_attr_register
-    def __init__(self, fusion_size=0):
-        """Initialize FlattenConcat"""
-        validator.check_non_negative_int(fusion_size, 'fusion_size', self.name)
-        self.fusion_size = fusion_size
-        self.add_prim_attr('fusion_size', fusion_size)
-
-
 class KMeansCentroids(PrimitiveWithInfer):
     """
     Calculate the segment_sum, segment_count, kmean_total_sum that are clustering results