maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/reduction/argmin.py

@@ -0,0 +1,101 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# 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 numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import AnyField, TupleField
+from ..utils import validate_axis
+from .core import TensorArgReductionMixin, TensorReduction
+
+
+class TensorArgmin(TensorReduction, TensorArgReductionMixin):
+    _op_type_ = opcodes.ARGMIN
+    _func_name = "argmin"
+    _agg_func_name = "min"
+
+    offset = AnyField("offset", default=None)
+    total_shape = TupleField("total_shape", default=None)
+
+    def __init__(self, dtype=None, **kw):
+        if dtype is None:
+            dtype = np.dtype(int)
+        super().__init__(dtype=dtype, **kw)
+
+
+def argmin(a, axis=None, out=None):
+    """
+    Returns the indices of the minimum values along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    axis : int, optional
+        By default, the index is into the flattened tensor, otherwise
+        along the specified axis.
+    out : Tensor, optional
+        If provided, the result will be inserted into this tensor. It should
+        be of the appropriate shape and dtype.
+
+    Returns
+    -------
+    index_array : Tensor of ints
+        Tensor of indices into the tensor. It has the same shape as `a.shape`
+        with the dimension along `axis` removed.
+
+    See Also
+    --------
+    Tensor.argmin, argmax
+    amin : The minimum value along a given axis.
+    unravel_index : Convert a flat index into an index tuple.
+
+    Notes
+    -----
+    In case of multiple occurrences of the minimum values, the indices
+    corresponding to the first occurrence are returned.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.arange(6).reshape(2,3)
+    >>> a.execute()
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> mt.argmin(a).execute()
+    0
+    >>> mt.argmin(a, axis=0).execute()
+    array([0, 0, 0])
+    >>> mt.argmin(a, axis=1).execute()
+    array([0, 0])
+
+    Indices of the minimum elements of a N-dimensional tensor:
+
+    >>> ind = mt.unravel_index(mt.argmin(a, axis=None), a.shape)
+    >>> ind.execute()
+    (0, 0)
+    >>> a[ind]
+
+    >>> b = mt.arange(6)
+    >>> b[4] = 0
+    >>> b.execute()
+    array([0, 1, 2, 3, 0, 5])
+    >>> mt.argmin(b).execute()  # Only the first occurrence is returned.
+    0
+
+    """
+    axis = validate_axis(a.ndim, axis) if axis is not None else None
+    op = TensorArgmin(axis=axis, dtype=np.dtype(int))
+    return op(a, out=out)

maxframe/tensor/reduction/array_equal.py

@@ -0,0 +1,63 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# 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 array_equal(a1, a2):
+    """
+    True if two tensors have the same shape and elements, False otherwise.
+
+    Parameters
+    ----------
+    a1, a2 : array_like
+        Input arrays.
+
+    Returns
+    -------
+    b : bool
+        Returns True if the tensors are equal.
+
+    See Also
+    --------
+    allclose: Returns True if two tensors are element-wise equal within a
+              tolerance.
+    array_equiv: Returns True if input tensors are shape consistent and all
+                 elements equal.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.array_equal([1, 2], [1, 2]).execute()
+    True
+    >>> mt.array_equal(mt.array([1, 2]), mt.array([1, 2])).execute()
+    True
+    >>> mt.array_equal([1, 2], [1, 2, 3]).execute()
+    False
+    >>> mt.array_equal([1, 2], [1, 4]).execute()
+    False
+
+    """
+    from ..arithmetic import equal
+    from ..datasource import tensor as astensor
+    from ..datasource.scalar import scalar
+    from .all import all
+
+    try:
+        a1, a2 = astensor(a1), astensor(a2)
+    except Exception:
+        return scalar(False)
+
+    if a1.shape != a2.shape:
+        return scalar(False)
+    return all(astensor(equal(a1, a2, magic=True)))

maxframe/tensor/reduction/core.py

@@ -0,0 +1,166 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# 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 builtins
+import operator
+from collections.abc import Iterable
+from functools import reduce
+
+from ...serialization.serializables import AnyField, BoolField, Int32Field, KeyField
+from ..array_utils import get_array_module
+from ..core import Tensor, TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import check_out_param, validate_axis
+
+
+def numel(x, **kwargs):
+    xp = get_array_module(x)
+    return xp.sum(xp.ones_like(x), **kwargs)
+
+
+def nannumel(x, **kwargs):
+    x_size = reduce(operator.mul, x.shape)
+    xp = get_array_module(x)
+    return x_size - xp.sum(xp.isnan(x), **kwargs)
+
+
+class TensorReductionMixin(TensorOperatorMixin):
+    __slots__ = ()
+
+    @classmethod
+    def _is_cum(cls):
+        return False
+
+    @classmethod
+    def _calc_order(cls, a, out):
+        return out.order if out is not None else a.order
+
+    @classmethod
+    def _is_sparse(cls, input_sparse, shape):
+        return False
+
+    def _call(self, a, out):
+        a = astensor(a)
+        if out is not None and not isinstance(out, Tensor):
+            raise TypeError(f"out should be Tensor object, got {type(out)} instead")
+
+        axis = getattr(self, "axis", None)
+        keepdims = getattr(self, "keepdims", None)
+        order = self._calc_order(a, out)
+
+        if self._is_cum():
+            if axis is None:
+                a, axis = a.ravel(), 0
+                setattr(self, "axis", axis)
+            shape = a.shape
+        else:
+            axis = list(range(len(a.shape))) if axis is None else axis
+            if not isinstance(axis, Iterable):
+                axis = (validate_axis(a.ndim, axis),)
+            axis = set(axis)
+
+            shape = tuple(
+                s if i not in axis else 1
+                for i, s in enumerate(a.shape)
+                if keepdims or i not in axis
+            )
+
+        self.sparse = self._is_sparse(a.issparse(), shape)
+        t = self.new_tensor([a], shape, order=order)
+
+        if out is None:
+            return t
+
+        check_out_param(out, t, "same_kind")
+        out_shape, out_dtype = out.shape, out.dtype
+        # if `out` is specified, use out's dtype and shape
+        if out_shape != t.shape:
+            if out.ndim > t.ndim:
+                raise ValueError("output has too many dimensions")
+            raise ValueError(f"output shape should be {t.shape}, got {out_shape}")
+
+        setattr(self, "dtype", out_dtype)
+
+        out.data = t.data
+        return out
+
+    def _new_tileables(self, inputs, kws=None, **kw):
+        tensors = super()._new_tileables(inputs, kws=kws, **kw)
+        setattr(self, "_input", getattr(self, "_inputs")[0])
+        return tensors
+
+    def __call__(self, a, out=None):
+        return self._call(a, out=out)
+
+    @classmethod
+    def get_axis(cls, axis):
+        return tuple(axis) if axis is not None else axis
+
+    @classmethod
+    def get_arg_axis(cls, axis, ndim):
+        return None if len(axis) == ndim or ndim == 1 else axis[0]
+
+
+class TensorArgReductionMixin(TensorReductionMixin):
+    __slots__ = ()
+
+    @staticmethod
+    def _get_arg_axis(axis, ndim):
+        if axis is None:
+            axis = tuple(range(ndim))
+            ravel = True
+        elif isinstance(axis, int):
+            axis = validate_axis(ndim, axis)
+            axis = (axis,)
+            ravel = ndim == 1
+        else:
+            raise TypeError(f"axis must be either `None` or int, got '{axis}'")
+        return axis, ravel
+
+    @staticmethod
+    def _get_offset(tensor, axis, chunk, ravel):
+        nsplits = tensor.nsplits
+        offset = tuple(
+            builtins.sum(split[:idx]) for split, idx in zip(nsplits, chunk.index)
+        )
+        if not ravel:
+            offset = offset[axis[0]]
+        return offset
+
+    @classmethod
+    def _calc_order(cls, a, out):
+        return out.order if out is not None else TensorOrder.C_ORDER
+
+
+class TensorCumReductionMixin(TensorReductionMixin):
+    __slots__ = ()
+
+    @classmethod
+    def _is_cum(cls):
+        return True
+
+
+class TensorReduction(TensorHasInput):
+    _input = KeyField("input")
+    out = KeyField("out", default=None)
+    axis = AnyField(
+        "axis", default=None
+    )  # can be None or int or tuple of ints, just infer the data
+    keepdims = BoolField("keepdims", default=None)
+
+
+class TensorCumReduction(TensorHasInput):
+    _input = KeyField("input")
+    axis = Int32Field("axis", default=None)

maxframe/tensor/reduction/count_nonzero.py

@@ -0,0 +1,80 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# 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 numpy as np
+
+from ... import opcodes
+from .core import TensorReduction, TensorReductionMixin
+
+
+class TensorCountNonzero(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.COUNT_NONZERO
+    _func_name = "count_nonzero"
+
+    def __init__(self, dtype=None, **kw):
+        if dtype is None:
+            dtype = np.dtype(np.intp)
+        super().__init__(dtype=dtype, **kw)
+
+
+def count_nonzero(a, axis=None):
+    """
+    Counts the number of non-zero values in the tensor ``a``.
+
+    The word "non-zero" is in reference to the Python 2.x
+    built-in method ``__nonzero__()`` (renamed ``__bool__()``
+    in Python 3.x) of Python objects that tests an object's
+    "truthfulness". For example, any number is considered
+    truthful if it is nonzero, whereas any string is considered
+    truthful if it is not the empty string. Thus, this function
+    (recursively) counts how many elements in ``a`` (and in
+    sub-tensors thereof) have their ``__nonzero__()`` or ``__bool__()``
+    method evaluated to ``True``.
+
+    Parameters
+    ----------
+    a : array_like
+        The tensor for which to count non-zeros.
+    axis : int or tuple, optional
+        Axis or tuple of axes along which to count non-zeros.
+        Default is None, meaning that non-zeros will be counted
+        along a flattened version of ``a``.
+
+    Returns
+    -------
+    count : int or tensor of int
+        Number of non-zero values in the array along a given axis.
+        Otherwise, the total number of non-zero values in the tensor
+        is returned.
+
+    See Also
+    --------
+    nonzero : Return the coordinates of all the non-zero values.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.count_nonzero(mt.eye(4)).execute()
+    4
+    >>> mt.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]]).execute()
+    5
+    >>> mt.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]], axis=0).execute()
+    array([1, 1, 1, 1, 1])
+    >>> mt.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]], axis=1).execute()
+    array([2, 3])
+
+    """
+    op = TensorCountNonzero(axis=axis, dtype=np.dtype(int), keepdims=None)
+    return op(a)

maxframe/tensor/reduction/cumprod.py

@@ -0,0 +1,95 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# 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 numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from ..utils import validate_axis
+from .core import TensorCumReduction, TensorCumReductionMixin
+
+
+class TensorCumprod(TensorCumReduction, TensorCumReductionMixin):
+    _op_type_ = opcodes.CUMPROD
+    _func_name = "cumprod"
+
+
+def cumprod(a, axis=None, dtype=None, out=None):
+    """
+    Return the cumulative product of elements along a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    axis : int, optional
+        Axis along which the cumulative product is computed.  By default
+        the input is flattened.
+    dtype : dtype, optional
+        Type of the returned tensor, as well as of the accumulator in which
+        the elements are multiplied.  If *dtype* is not specified, it
+        defaults to the dtype of `a`, unless `a` has an integer dtype with
+        a precision less than that of the default platform integer.  In
+        that case, the default platform integer is used instead.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type of the resulting values will be cast if necessary.
+
+    Returns
+    -------
+    cumprod : Tensor
+        A new tensor holding the result is returned unless `out` is
+        specified, in which case a reference to out is returned.
+
+    See Also
+    --------
+    numpy.doc.ufuncs : Section "Output arguments"
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([1,2,3])
+    >>> mt.cumprod(a).execute() # intermediate results 1, 1*2
+    ...                         # total product 1*2*3 = 6
+    array([1, 2, 6])
+    >>> a = mt.array([[1, 2, 3], [4, 5, 6]])
+    >>> mt.cumprod(a, dtype=float).execute() # specify type of output
+    array([   1.,    2.,    6.,   24.,  120.,  720.])
+
+    The cumulative product for each column (i.e., over the rows) of `a`:
+
+    >>> mt.cumprod(a, axis=0).execute()
+    array([[ 1,  2,  3],
+           [ 4, 10, 18]])
+
+    The cumulative product for each row (i.e. over the columns) of `a`:
+
+    >>> mt.cumprod(a,axis=1).execute()
+    array([[  1,   2,   6],
+           [  4,  20, 120]])
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.empty((1,), dtype=a.dtype).cumprod().dtype
+    axis = validate_axis(a.ndim, axis) if axis is not None else None
+    op = TensorCumprod(axis=axis, dtype=dtype)
+    return op(a, out=out)

maxframe/tensor/reduction/cumsum.py

@@ -0,0 +1,99 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# 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 numpy as np
+
+from ... import opcodes
+from ..datasource import tensor as astensor
+from ..utils import validate_axis
+from .core import TensorCumReduction, TensorCumReductionMixin
+
+
+class TensorCumsum(TensorCumReduction, TensorCumReductionMixin):
+    _op_type_ = opcodes.CUMSUM
+    _func_name = "cumsum"
+
+
+def cumsum(a, axis=None, dtype=None, out=None):
+    """
+    Return the cumulative sum of the elements along a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    axis : int, optional
+        Axis along which the cumulative sum is computed. The default
+        (None) is to compute the cumsum over the flattened tensor.
+    dtype : dtype, optional
+        Type of the returned tensor and of the accumulator in which the
+        elements are summed.  If `dtype` is not specified, it defaults
+        to the dtype of `a`, unless `a` has an integer dtype with a
+        precision less than that of the default platform integer.  In
+        that case, the default platform integer is used.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary. See `doc.ufuncs`
+        (Section "Output arguments") for more details.
+
+    Returns
+    -------
+    cumsum_along_axis : Tensor.
+        A new tensor holding the result is returned unless `out` is
+        specified, in which case a reference to `out` is returned. The
+        result has the same size as `a`, and the same shape as `a` if
+        `axis` is not None or `a` is a 1-d tensor.
+
+
+    See Also
+    --------
+    sum : Sum tensor elements.
+
+    trapz : Integration of tensor values using the composite trapezoidal rule.
+
+    diff :  Calculate the n-th discrete difference along given axis.
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1,2,3], [4,5,6]])
+    >>> a.execute()
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> mt.cumsum(a).execute()
+    array([ 1,  3,  6, 10, 15, 21])
+    >>> mt.cumsum(a, dtype=float).execute()     # specifies type of output value(s)
+    array([  1.,   3.,   6.,  10.,  15.,  21.])
+
+    >>> mt.cumsum(a,axis=0).execute()      # sum over rows for each of the 3 columns
+    array([[1, 2, 3],
+           [5, 7, 9]])
+    >>> mt.cumsum(a,axis=1).execute()      # sum over columns for each of the 2 rows
+    array([[ 1,  3,  6],
+           [ 4,  9, 15]])
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.empty((1,), dtype=a.dtype).cumsum().dtype
+    axis = validate_axis(a.ndim, axis) if axis is not None else None
+    op = TensorCumsum(axis=axis, dtype=dtype)
+    return op(a, out=out)