maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/reduction/tests/test_reduction.py

@@ -0,0 +1,189 @@
+# 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
+import pytest
+
+from ....utils import collect_leaf_operators
+from ...datasource import ones, tensor
+from .. import *  # noqa: F401
+from ..core import TensorReduction
+
+
+def test_base_reduction():
+    sum = lambda x, *args, **kwargs: x.sum(*args, **kwargs)
+    prod = lambda x, *args, **kwargs: x.prod(*args, **kwargs)
+    max = lambda x, *args, **kwargs: x.max(*args, **kwargs)
+    min = lambda x, *args, **kwargs: x.min(*args, **kwargs)
+    all = lambda x, *args, **kwargs: x.all(*args, **kwargs)
+    any = lambda x, *args, **kwargs: x.any(*args, **kwargs)
+
+    for f in [sum, prod, max, min, all, any]:
+        res = f(ones((8, 8), chunk_size=8))
+        assert res.shape == ()
+
+        res = f(ones((10, 8), chunk_size=3))
+        assert res.dtype is not None
+        assert res.shape == ()
+
+        res = f(ones((10, 8), chunk_size=3), axis=0)
+        assert res.shape == (8,)
+
+        res = f(ones((10, 8), chunk_size=3), axis=1)
+        assert res.shape == (10,)
+
+        with pytest.raises(np.AxisError):
+            f(ones((10, 8), chunk_size=3), axis=2)
+
+        res = f(ones((10, 8), chunk_size=3), axis=-1)
+        assert res.shape == (10,)
+
+        with pytest.raises(np.AxisError):
+            f(ones((10, 8), chunk_size=3), axis=-3)
+
+        res = f(ones((10, 8), chunk_size=3), keepdims=True)
+        assert res.shape == (1, 1)
+
+        res = f(ones((10, 8), chunk_size=3), axis=0, keepdims=True)
+        assert res.shape == (1, 8)
+
+        res = f(ones((10, 8), chunk_size=3), axis=1, keepdims=True)
+        assert res.shape == (10, 1)
+
+        res = f(ones((10, 8, 10), chunk_size=3), axis=1)
+        assert res.shape == (10, 10)
+
+        res = f(ones((10, 8, 10), chunk_size=3), axis=1, keepdims=True)
+        assert res.shape == (10, 1, 10)
+
+        res = f(ones((10, 8, 10), chunk_size=3), axis=(0, 2))
+        assert res.shape == (8,)
+
+        res = f(ones((10, 8, 10), chunk_size=3), axis=(0, 2), keepdims=True)
+        assert res.shape == (1, 8, 1)
+
+
+def test_mean_reduction():
+    mean = lambda x, *args, **kwargs: x.mean(*args, **kwargs)
+
+    res = mean(ones((10, 8), chunk_size=3))
+    assert res.shape == ()
+    assert res.dtype is not None
+
+    res = mean(ones((8, 8), chunk_size=8))
+    assert res.shape == ()
+
+    res = mean(ones((10, 8), chunk_size=3), axis=0)
+    assert res.shape == (8,)
+
+    res = mean(ones((10, 8), chunk_size=3), axis=1)
+    assert res.shape == (10,)
+
+    with pytest.raises(np.AxisError):
+        mean(ones((10, 8), chunk_size=3), axis=2)
+
+    res = mean(ones((10, 8), chunk_size=3), axis=-1)
+    assert res.shape == (10,)
+
+    with pytest.raises(np.AxisError):
+        mean(ones((10, 8), chunk_size=3), axis=-3)
+
+    res = mean(ones((10, 8), chunk_size=3), keepdims=True)
+    assert res.shape == (1, 1)
+
+    res = mean(ones((10, 8), chunk_size=3), axis=0, keepdims=True)
+    assert res.shape == (1, 8)
+
+    res = mean(ones((10, 8), chunk_size=3), axis=1, keepdims=True)
+    assert res.shape == (10, 1)
+
+
+def test_arg_reduction():
+    argmax = lambda x, *args, **kwargs: x.argmax(*args, **kwargs)
+    argmin = lambda x, *args, **kwargs: x.argmin(*args, **kwargs)
+
+    res1 = argmax(ones((10, 8, 10), chunk_size=3))
+    res2 = argmin(ones((10, 8, 10), chunk_size=3))
+    assert res1.shape == ()
+    assert res1.dtype is not None
+    assert res2.shape == ()
+
+    res1 = argmax(ones((10, 8), chunk_size=3), axis=1)
+    res2 = argmin(ones((10, 8), chunk_size=3), axis=1)
+    assert res1.shape == (10,)
+    assert res2.shape == (10,)
+
+    pytest.raises(
+        TypeError, lambda: argmax(ones((10, 8, 10), chunk_size=3), axis=(0, 1))
+    )
+    pytest.raises(
+        TypeError, lambda: argmin(ones((10, 8, 10), chunk_size=3), axis=(0, 1))
+    )
+    pytest.raises(np.AxisError, lambda: argmin(ones((10, 8, 10), chunk_size=3), axis=3))
+    pytest.raises(
+        np.AxisError, lambda: argmin(ones((10, 8, 10), chunk_size=3), axis=-4)
+    )
+
+
+def test_cum_reduction():
+    cumsum = lambda x, *args, **kwargs: x.cumsum(*args, **kwargs)
+    cumprod = lambda x, *args, **kwargs: x.cumprod(*args, **kwargs)
+
+    res1 = cumsum(ones((10, 8), chunk_size=3), axis=0)
+    res2 = cumprod(ones((10, 8), chunk_size=3), axis=0)
+    assert res1.shape == (10, 8)
+    assert res1.dtype is not None
+    assert res2.shape == (10, 8)
+    assert res2.dtype is not None
+
+    res1 = cumsum(ones((10, 8, 8), chunk_size=3), axis=1)
+    res2 = cumprod(ones((10, 8, 8), chunk_size=3), axis=1)
+    assert res1.shape == (10, 8, 8)
+    assert res2.shape == (10, 8, 8)
+
+    res1 = cumsum(ones((10, 8, 8), chunk_size=3), axis=-2)
+    res2 = cumprod(ones((10, 8, 8), chunk_size=3), axis=-2)
+    assert res1.shape == (10, 8, 8)
+    assert res2.shape == (10, 8, 8)
+
+    with pytest.raises(np.AxisError):
+        cumsum(ones((10, 8), chunk_size=3), axis=2)
+    with pytest.raises(np.AxisError):
+        cumsum(ones((10, 8), chunk_size=3), axis=-3)
+
+
+def test_all_reduction():
+    o = tensor([False])
+
+    with pytest.raises(ValueError):
+        all([-1, 4, 5], out=o)
+
+
+def test_var_reduction():
+    var = lambda x, *args, **kwargs: x.var(*args, **kwargs)
+
+    res1 = var(ones((10, 8), chunk_size=3), ddof=2)
+    assert res1.shape == ()
+    assert res1.op.ddof == 2
+
+    res1 = var(ones((10, 8, 8), chunk_size=3), axis=1)
+    assert res1.shape == (10, 8)
+
+
+def test_reduction_op_func_name():
+    # make sure all the binary op has defined the func name.
+
+    results = collect_leaf_operators(TensorReduction)
+    for op_type in results:
+        assert hasattr(op_type, "_func_name")

maxframe/tensor/reduction/var.py

@@ -0,0 +1,176 @@
+# 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.
+
+from math import factorial
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import Int32Field
+from ..datasource import tensor as astensor
+from .core import TensorReduction, TensorReductionMixin
+
+
+def reduce_var_square(var_square, avg_diff, count, op, axis, sum_func):
+    moment = op.moment
+    dtype = op.dtype
+    kw = dict(axis=axis, dtype=dtype, keepdims=bool(op.keepdims))
+
+    reduced_var_square = var_square[..., moment - 2].sum(**kw) + sum_func(
+        count * avg_diff**moment, **kw
+    )
+    for i in range(1, moment - 1):
+        coeff = factorial(moment) / float(factorial(i) * factorial(moment - i))
+        reduced_var_square += coeff * sum_func(
+            var_square[..., moment - i - 2] * avg_diff**moment, **kw
+        )
+    return reduced_var_square
+
+
+class TensorMoment(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.MOMENT
+    _func_name = "var"
+
+    moment = Int32Field("moment", default=2)
+    ddof = Int32Field("ddof", default=None)
+
+    def __init__(self, moment=None, **kw):
+        if moment is not None:
+            kw["moment"] = moment
+        super().__init__(**kw)
+
+
+class TensorVar(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.VAR
+    _func_name = "var"
+
+    ddof = Int32Field("ddof", default=0)
+
+    def __new__(cls, *args, **kwargs):
+        if kwargs.get("stage") is not None:
+            return TensorMoment(*args, **kwargs)
+        return super().__new__(cls)
+
+    def _get_op_kw(self):
+        kw = dict()
+        kw["ddof"] = self.ddof
+        return kw
+
+
+def var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=None):
+    """
+    Compute the variance along the specified axis.
+
+    Returns the variance of the tensor elements, a measure of the spread of a
+    distribution.  The variance is computed for the flattened tensor by
+    default, otherwise over the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose variance is desired.  If `a` is not a
+        tensor, a conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the variance is computed.  The default is to
+        compute the variance of the flattened array.
+
+        If this is a tuple of ints, a variance is performed over multiple axes,
+        instead of a single axis or all the axes as before.
+    dtype : data-type, optional
+        Type to use in computing the variance.  For arrays of integer type
+        the default is `float32`; for tensors of float types it is the same as
+        the tensor type.
+    out : Tensor, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output, but the type is cast if
+        necessary.
+    ddof : int, optional
+        "Delta Degrees of Freedom": the divisor used in the calculation is
+        ``N - ddof``, where ``N`` represents the number of elements. By
+        default `ddof` is zero.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input tensor.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `var` method of sub-classes of
+        `Tensor`, however any non-default value will be.  If the
+        sub-classes `sum` method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    variance : Tensor, see dtype parameter above
+        If ``out=None``, returns a new tensor containing the variance;
+        otherwise, a reference to the output tensor is returned.
+
+    See Also
+    --------
+    std , mean, nanmean, nanstd, nanvar
+
+    Notes
+    -----
+    The variance is the average of the squared deviations from the mean,
+    i.e.,  ``var = mean(abs(x - x.mean())**2)``.
+
+    The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.
+    If, however, `ddof` is specified, the divisor ``N - ddof`` is used
+    instead.  In standard statistical practice, ``ddof=1`` provides an
+    unbiased estimator of the variance of a hypothetical infinite population.
+    ``ddof=0`` provides a maximum likelihood estimate of the variance for
+    normally distributed variables.
+
+    Note that for complex numbers, the absolute value is taken before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the variance is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32` (see example
+    below).  Specifying a higher-accuracy accumulator using the ``dtype``
+    keyword can alleviate this issue.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1, 2], [3, 4]])
+    >>> mt.var(a).execute()
+    1.25
+    >>> mt.var(a, axis=0).execute()
+    array([ 1.,  1.])
+    >>> mt.var(a, axis=1).execute()
+    array([ 0.25,  0.25])
+
+    In single precision, var() can be inaccurate:
+
+    >>> a = mt.zeros((2, 512*512), dtype=mt.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> mt.var(a).execute()
+    0.20250003
+
+    Computing the variance in float64 is more accurate:
+
+    >>> mt.var(a, dtype=mt.float64).execute()
+    0.20249999932944759
+    >>> ((1-0.55)**2 + (0.1-0.55)**2)/2
+    0.2025
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.var(np.ones((1,), dtype=a.dtype)).dtype
+    op = TensorVar(axis=axis, dtype=dtype, keepdims=keepdims, ddof=ddof)
+    return op(a, out=out)

maxframe/tensor/reshape/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+
+from .reshape import reshape

maxframe/tensor/reshape/reshape.py

@@ -0,0 +1,192 @@
+# 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 logging
+from typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import FieldTypes, KeyField, StringField, TupleField
+from ..datasource import tensor as astensor
+from ..operators import TensorMapReduceOperator, TensorOperatorMixin
+from ..utils import get_order
+
+logger = logging.getLogger(__name__)
+
+
+class TensorReshape(TensorMapReduceOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.RESHAPE
+
+    _input = KeyField("input")
+    newshape = TupleField("newshape", FieldTypes.int64, default=None)
+    order = StringField("order", default=None)
+
+    axis_offsets = TupleField("axis_offsets", FieldTypes.uint64, default=None)
+    oldshape = TupleField("oldshape", FieldTypes.uint64, default=None)
+    new_chunk_size = TupleField("new_chunk_size", FieldTypes.uint64, default=None)
+
+    @property
+    def input(self):
+        return self._input
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorReshape", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input = op._inputs[0]
+
+    def on_output_modify(self, new_output):
+        return reshape(new_output, self._input.shape)
+
+    def on_input_modify(self, new_input):
+        op = self.copy().reset_key()
+        return op(new_input)
+
+    def __call__(self, a, order, out_shape):
+        return self.new_tensor([a], out_shape, order=order)
+
+
+def calc_shape(size, newshape):
+    if isinstance(newshape, int):
+        newshape = (newshape,)
+    else:
+        newshape = tuple(int(s) for s in newshape)
+
+    known_shape = [s for s in newshape if s >= 0]
+    missing_dim = len(newshape) - len(known_shape)
+    if missing_dim > 1:
+        raise ValueError("can only specify one unknown dimension")
+    if missing_dim == 1:
+        known_size = np.prod(known_shape)
+        newshape = tuple(
+            int(size / known_size) if s < 0 and known_size > 0 else s for s in newshape
+        )
+
+    return newshape
+
+
+def reshape(a, newshape, order="C"):
+    """
+    Gives a new shape to a tensor without changing its data.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor to be reshaped.
+    newshape : int or tuple of ints
+        The new shape should be compatible with the original shape. If
+        an integer, then the result will be a 1-D tensor of that length.
+        One shape dimension can be -1. In this case, the value is
+        inferred from the length of the tensor and remaining dimensions.
+    order : {'C', 'F', 'A'}, optional
+        Read the elements of `a` using this index order, and place the
+        elements into the reshaped array using this index order.  'C'
+        means to read / write the elements using C-like index order,
+        with the last axis index changing fastest, back to the first
+        axis index changing slowest. 'F' means to read / write the
+        elements using Fortran-like index order, with the first index
+        changing fastest, and the last index changing slowest. Note that
+        the 'C' and 'F' options take no account of the memory layout of
+        the underlying array, and only refer to the order of indexing.
+        'A' means to read / write the elements in Fortran-like index
+        order if `a` is Fortran *contiguous* in memory, C-like order
+        otherwise.
+
+    Returns
+    -------
+    reshaped_array : Tensor
+        This will be a new view object if possible; otherwise, it will
+        be a copy.
+
+    See Also
+    --------
+    Tensor.reshape : Equivalent method.
+
+    Notes
+    -----
+    It is not always possible to change the shape of a tensor without
+    copying the data. If you want an error to be raised when the data is copied,
+    you should assign the new shape to the shape attribute of the array::
+
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.arange(6).reshape((3, 2))
+    >>> a.execute()
+    array([[0, 1],
+           [2, 3],
+           [4, 5]])
+
+    You can think of reshaping as first raveling the tensor (using the given
+    index order), then inserting the elements from the raveled tensor into the
+    new tensor using the same kind of index ordering as was used for the
+    raveling.
+
+    >>> mt.reshape(a, (2, 3)).execute()
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> mt.reshape(mt.ravel(a), (2, 3)).execute()
+    array([[0, 1, 2],
+           [3, 4, 5]])
+
+    Examples
+    --------
+    >>> a = mt.array([[1,2,3], [4,5,6]])
+    >>> mt.reshape(a, 6).execute()
+    array([1, 2, 3, 4, 5, 6])
+
+    >>> mt.reshape(a, (3,-1)).execute()       # the unspecified value is inferred to be 2
+    array([[1, 2],
+           [3, 4],
+           [5, 6]])
+    """
+    a = astensor(a)
+
+    if np.isnan(sum(a.shape)):
+        # some shape is nan
+        new_shape = [newshape] if isinstance(newshape, int) else list(newshape)
+        # if -1 exists in newshape, just treat it as unknown shape
+        new_shape = [s if s != -1 else np.nan for s in new_shape]
+        out_shape = tuple(new_shape)
+    else:
+        out_shape = newshape = calc_shape(a.size, newshape)
+        if a.size != np.prod(newshape):
+            raise ValueError(
+                f"cannot reshape array of size {a.size} into shape {newshape}"
+            )
+
+    tensor_order = get_order(order, a.order, available_options="CFA")
+
+    if a.shape == newshape and (
+        a.ndim <= 1 or (a.ndim > 1 and tensor_order == a.order)
+    ):
+        # does not need to reshape
+        return a
+    return _reshape(
+        a, newshape, order=order, tensor_order=tensor_order, out_shape=out_shape
+    )
+
+
+def _reshape(a, newshape, order="C", tensor_order=None, out_shape=None):
+    if tensor_order is None:
+        tensor_order = get_order(order, a.order, available_options="CFA")
+    op = TensorReshape(
+        newshape=newshape,
+        order=order,
+        dtype=a.dtype,
+        create_view=tensor_order == a.order,
+    )
+    if out_shape is None:
+        out_shape = newshape
+    return op(a, tensor_order, out_shape)

maxframe/tensor/reshape/tests/__init__.py

@@ -0,0 +1,13 @@
+# 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.

maxframe/tensor/reshape/tests/test_reshape.py

@@ -0,0 +1,35 @@
+# 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
+import pytest
+
+from ...datasource import ones
+
+
+def test_reshape():
+    a = ones((10, 600), chunk_size=5)
+    a.shape = [10, 30, 20]
+
+    # test reshape unknown shape
+    c = a[a > 0]
+    d = c.reshape(10, 600)
+    assert d.shape == (10, 600)
+    d = c.reshape(-1, 10)
+    assert len(d.shape) == 2
+    assert np.isnan(d.shape[0])
+    assert d.shape[1]
+
+    with pytest.raises(TypeError):
+        a.reshape((10, 30, 20), other_argument=True)

maxframe/tensor/sort/__init__.py

@@ -0,0 +1,18 @@
+# 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.
+
+from .argpartition import argpartition
+from .argsort import argsort
+from .partition import partition
+from .sort import sort