mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.11__cp38-cp38-manylinux1_x86_64.whl

mindspore/scipy/optimize/linear_sum_assignment.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,59 +15,64 @@
 """Linear Sum Assignment"""
 import sys
 from ..ops import LinearSumAssignment
-from ...common import dtype as mstype
-from ..utils import _mstype_check, _dtype_check
 from ... import Tensor
 
 
-def _linear_sum_assignment(cost_matrix, maximize, dimension_limit=Tensor(sys.maxsize)):
-    """
+def linear_sum_assignment(cost_matrix, maximize, dimension_limit=Tensor(sys.maxsize)):
+    r"""
     Solve the linear sum assignment problem.
 
+    The assignment problem is represented as follows:
+
+    .. math::
+        min\sum_{i}^{} \sum_{j}^{} C_{i,j} X_{i,j}
+
+    where :math:`C` is cost matrix, :math:`X_{i,j} = 1` means column :math:`j` is assigned to row :math:`i` .
+
     Args:
-        cost_matrix: 2-D Input Tensor.
-            The cost matrix of the bipartite graph.
-        maximize: 0-D Input bool Tensor.
-            Calculates a maximum weight matching if true.
-        dimension_limit: 0-D Input Tensor.
-            A scalar used to limit the actual size of the 1st dimension. Optimized for
-            padding scenes. Default means no dimension limit.
+        cost_matrix (Tensor): 2-D cost matrix. Tensor of shape :math:`(M, N)` .
+        maximize (bool): Calculate a maximum weight matching if true, otherwise calculate a minimum weight matching.
+        dimension_limit (Tensor, optional): A scalar used to limit the actual size of the 2nd dimension of
+            ``cost_matrix``. Default is ``Tensor(sys.maxsize)``, which means no limitation. The type is 0-D int64
+            Tensor.
 
     Returns:
-        1-D Output Tensors with 'row_indx' and 'col_idx'. An array of row indices and
-        one of corresponding column indices giving the optimal assignment. If specified
-        dimension_limit, padding value at the end would be -1.
+        A tuple of tensors containing 'row_idx' and 'col_idx'.
+
+        - **row_idx** (Tensor) - Row indices of the problem. If `dimension_limit` is given, -1 would be padded at the
+          end. The shape is  :math:`(N, )` , where :math:`N` is the minimum value of `cost_matrix` dimension.
+        - **col_idx** (Tensor) - Column indices of the problem. If `dimension_limit` is given, -1 would be padded at
+          the end. The shape is  :math:`(N, )` , where :math:`N` is the minimum value of `cost_matrix` dimension.
+
+    Raises:
+        TypeError: If the data type of `cost_matrix` is not the type in [float16, float32, float64,
+                   int8, int16, int32, int64, uint8, uint16, uint32, uint64, bool]
+        TypeError: If the type of `maximize` is not bool.
+        TypeError: If the data type of `dimension_limit` is not int64.
+        ValueError: If the rank of `cost_matrix` is not 2.
+
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``CPU``
 
-     Examples:
+    Examples:
         >>> import mindspore as ms
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore.scipy.optimize.linear_sum_assignment import _linear_sum_assignment as lsap
-        >>> cost_matrix = Tensor(np.array([[2, 3, 3], [3, 2, 3], [3, 3, 2]])).astype("float64")
+        >>> import mindspore.scipy.optimize.linear_sum_assignment as lsap
+        >>> cost_matrix = Tensor(np.array([[2, 3, 3], [3, 2, 3], [3, 3, 2]])).astype(ms.float64)
         >>> dimension_limit = Tensor(2)
-        >>> maximize = Tensor(False)
+        >>> maximize = False
         >>> a, b = lsap(cost_matrix, maximize, dimension_limit)
         >>> print(a)
-        [[0 1 -1]]
+        [0 1 -1]
         >>> print(b)
-        [[0 1 -1]]
+        [0 1 -1]
         >>> a, b = lsap(cost_matrix, maximize)
         >>> print(a)
-        [[0 1 2]]
+        [0 1 2]
         >>> print(b)
-        [[0 1 2]]
+        [0 1 2]
     """
-    func_name = 'linear_sum_assignment'
-    _mstype_check(func_name, cost_matrix, mstype.TensorType, 'cost_matrix')
-    _mstype_check(func_name, dimension_limit,
-                  mstype.TensorType, 'dimension_limit')
-    _mstype_check(func_name, maximize, mstype.TensorType, 'maximize')
-    _dtype_check(func_name, cost_matrix, [mstype.float32, mstype.float64])
-    _dtype_check(func_name, dimension_limit, [mstype.int64])
-    _dtype_check(func_name, maximize, [mstype.bool_])
-
     solve = LinearSumAssignment()
     return solve(cost_matrix, dimension_limit, maximize)

mindspore/scipy/optimize/minimize.py

@@ -99,10 +99,14 @@ def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bo
             if it is a callable, it should be a function that returns the gradient vector:
             :math:`jac(x, *args) -> array\_like, shape (n,)`
             where x is an array with shape :math:`(n,)` and args is a tuple with the fixed parameters.
+        hess (Callable, optional): Method for calculating the Hessian Matrix. Not implemented yet.
+        hessp (Callable, optional): Hessian of objective function times an arbitrary vector `p`. Not implemented yet.
+        bounds (Sequence, optional): Sequence of `(min, max)` pairs for each element in `x`. Not implemented yet.
+        constraints (Callable, optional): representing the inequality constrains, each function in constrains indicates
+            the function < 0 as an inequality constrain.
         tol (float, optional): tolerance for termination. For detailed control, use solver-specific
             options. Default: ``None`` .
-        constraints(Callable, optional): representing the inequality constrains, each function in constrains indicates
-            the function < 0 as an inequality constrain.
+        callback (Callable, optional): A callable called after each iteration. Not implemented yet.
         options (Mapping[str, Any], optional): a dictionary of solver options. All methods accept the following
             generic options. Default: ``None`` .
 
@@ -111,7 +115,7 @@ def minimize(func, x0, args=(), method=None, jac=None, hess=None, hessp=None, bo
             - maxiter (int): Maximum number of iterations to perform. Depending on the
               method each iteration may use several function evaluations.
 
-        The follow options are exclusive to Lagrange method:
+            The follow options are exclusive to Lagrange method:
 
             - save_tol (list): list of saving tolerance, with the same length with 'constrains'.
             - obj_weight (float): weight for objective function, usually between 1.0 - 100000.0.

mindspore/train/_utils.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2021 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -66,7 +66,11 @@ def _exec_datagraph(exec_dataset, dataset_size, phase='dataset', create_data_inf
     # transform data format
     dataset_types, dataset_shapes = _get_types_and_shapes(exec_dataset)
     send_epoch_end = bool(dataset_size == -1)
-    exec_dataset = exec_dataset.device_que(send_epoch_end=send_epoch_end, create_data_info_queue=create_data_info_queue)
+    queue_name = _cell_graph_executor.get_queue_name(phase)
+    if queue_name is None:
+        queue_name = str("")
+    exec_dataset = exec_dataset.device_que(send_epoch_end=send_epoch_end,
+                                           create_data_info_queue=create_data_info_queue, queue_name=queue_name)
     _cell_graph_executor.init_dataset(exec_dataset.queue_name,
                                       dataset_size,
                                       batch_size,
@@ -105,7 +109,7 @@ def _construct_tensor_list(types, shapes, batch_expand_num=1):
                 new_shape += (item * batch_expand_num,)
             else:
                 new_shape += (item,)
-        tensor = Tensor(np.zeros(new_shape, dtype_to_nptype(type_)))
+        tensor = Tensor(np.zeros(new_shape, dtype_to_nptype(type_)), dtype=type_)
         tensor.virtual_flag = True
         tensor_list.append(tensor)
     return tensor_list