maxframe 0.1.0b5__cp310-cp310-macosx_11_0_arm64.whl

maxframe/tensor/reduction/nansum.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 .core import TensorReduction, TensorReductionMixin
+
+
+class TensorNanSum(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.NANSUM
+    _func_name = "nansum"
+
+
+def nansum(a, axis=None, dtype=None, out=None, keepdims=None):
+    """
+    Return the sum of array elements over a given axis treating Not a
+    Numbers (NaNs) as zero.
+
+    Zero is returned for slices that are all-NaN or
+    empty.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose sum is desired. If `a` is not an
+        tensor, a conversion is attempted.
+    axis : int, optional
+        Axis along which the sum is computed. The default is to compute the
+        sum of the flattened array.
+    dtype : data-type, optional
+        The type of the returned tensor and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+    out : Tensor, optional
+        Alternate output tensor in which to place the result.  The default
+        is ``None``. If provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.  See
+        `doc.ufuncs` for details. The casting of NaN to integer can yield
+        unexpected results.
+    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 original `a`.
+
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `Tensor`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+    Returns
+    -------
+    nansum : Tensor.
+        A new tensor holding the result is returned unless `out` is
+        specified, in which it 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 array.
+
+    See Also
+    --------
+    mt.sum : Sum across tensor propagating NaNs.
+    isnan : Show which elements are NaN.
+    isfinite: Show which elements are not NaN or +/-inf.
+
+    Notes
+    -----
+    If both positive and negative infinity are present, the sum will be Not
+    A Number (NaN).
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.nansum(1).execute()
+    1
+    >>> mt.nansum([1]).execute()
+    1
+    >>> mt.nansum([1, mt.nan]).execute()
+    1.0
+    >>> a = mt.array([[1, 1], [1, mt.nan]])
+    >>> mt.nansum(a).execute()
+    3.0
+    >>> mt.nansum(a, axis=0).execute()
+    array([ 2.,  1.])
+    >>> mt.nansum([1, mt.nan, mt.inf]).execute()
+    inf
+    >>> mt.nansum([1, mt.nan, mt.NINF]).execute()
+    -inf
+    >>> mt.nansum([1, mt.nan, mt.inf, -mt.inf]).execute() # both +/- infinity present
+    nan
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.nansum(np.empty((1,), dtype=a.dtype)).dtype
+    op = TensorNanSum(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/nanvar.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 Int32Field
+from ..datasource import tensor as astensor
+from .core import TensorReduction, TensorReductionMixin
+
+
+class TensorNanMoment(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.NANMOMENT
+
+    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 TensorNanVar(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.NANVAR
+
+    ddof = Int32Field("ddof", default=0)
+
+    def __new__(cls, *args, **kwargs):
+        if kwargs.get("stage") is not None:
+            return TensorNanMoment(*args, **kwargs)
+        return super().__new__(cls)
+
+    def __init__(self, dtype=None, **kw):
+        super().__init__(dtype=dtype, **kw)
+
+    def _get_op_kw(self):
+        kw = dict()
+        kw["ddof"] = self.ddof
+        return kw
+
+
+def nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=None):
+    """
+    Compute the variance along the specified axis, while ignoring NaNs.
+
+    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.
+
+    For all-NaN slices or slices with zero degrees of freedom, NaN is
+    returned and a `RuntimeWarning` is raised.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing numbers whose variance is desired.  If `a` is not a
+        tensor, a conversion is attempted.
+    axis : int, optional
+        Axis along which the variance is computed.  The default is to compute
+        the variance of the flattened array.
+    dtype : data-type, optional
+        Type to use in computing the variance.  For tensors 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 tensor 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 non-NaN
+        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 original `a`.
+
+
+    Returns
+    -------
+    variance : Tensor, see dtype parameter above
+        If `out` is None, return a new tensor containing the variance,
+        otherwise return a reference to the output tensor. If ddof is >= the
+        number of non-NaN elements in a slice or the slice contains only
+        NaNs, then the result for that slice is NaN.
+
+    See Also
+    --------
+    std : Standard deviation
+    mean : Average
+    var : Variance while not ignoring NaNs
+    nanstd, nanmean
+
+    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.
+
+    For this function to work on sub-classes of Tensor, they must define
+    `sum` with the kwarg `keepdims`
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.array([[1, mt.nan], [3, 4]])
+    >>> mt.nanvar(a).execute()
+    1.5555555555555554
+    >>> mt.nanvar(a, axis=0).execute()
+    array([ 1.,  0.])
+    >>> mt.nanvar(a, axis=1).execute()
+    array([ 0.,  0.25])
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.nanvar(np.ones((1,), dtype=a.dtype)).dtype
+    op = TensorNanVar(axis=axis, dtype=dtype, keepdims=keepdims, ddof=ddof)
+    return op(a, out=out)

maxframe/tensor/reduction/prod.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 .core import TensorReduction, TensorReductionMixin
+
+
+class TensorProd(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.PROD
+    _func_name = "prod"
+
+
+def prod(a, axis=None, dtype=None, out=None, keepdims=None):
+    """
+    Return the product of tensor elements over a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a product is performed.  The default,
+        axis=None, will calculate the product of all the elements in the
+        input tensor. If axis is negative it counts from the last to the
+        first axis.
+
+        If axis is a tuple of ints, a product is performed on all of the
+        axes specified in the tuple instead of a single axis or all the
+        axes as before.
+    dtype : dtype, optional
+        The type of the returned tensor, as well as of the accumulator in
+        which the elements are multiplied.  The dtype of `a` is used by
+        default unless `a` has an integer dtype of less precision than the
+        default platform integer.  In that case, if `a` is signed then the
+        platform integer is used while if `a` is unsigned then an unsigned
+        integer of the same precision as the platform integer is used.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary.
+    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 array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `prod` 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
+    -------
+    product_along_axis : Tensor, see `dtype` parameter above.
+        An tensor shaped as `a` but with the specified axis removed.
+        Returns a reference to `out` if specified.
+
+    See Also
+    --------
+    Tensor.prod : equivalent method
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.  That means that, on a 32-bit platform:
+
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([536870910, 536870910, 536870910, 536870910])
+    >>> mt.prod(x).execute()  # random
+    16
+
+    The product of an empty array is the neutral element 1:
+
+    >>> mt.prod([]).execute()
+    1.0
+
+    Examples
+    --------
+    By default, calculate the product of all elements:
+
+    >>> mt.prod([1.,2.]).execute()
+    2.0
+
+    Even when the input array is two-dimensional:
+
+    >>> mt.prod([[1.,2.],[3.,4.]]).execute()
+    24.0
+
+    But we can also specify the axis over which to multiply:
+
+    >>> mt.prod([[1.,2.],[3.,4.]], axis=1).execute()
+    array([  2.,  12.])
+
+    If the type of `x` is unsigned, then the output type is
+    the unsigned platform integer:
+
+    >>> x = mt.array([1, 2, 3], dtype=mt.uint8)
+    >>> mt.prod(x).dtype == mt.uint
+    True
+
+    If `x` is of a signed integer type, then the output type
+    is the default platform integer:
+
+    >>> x = mt.array([1, 2, 3], dtype=mt.int8)
+    >>> mt.prod(x).dtype == int
+    True
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        dtype = np.empty((1,), dtype=a.dtype).prod().dtype
+    op = TensorProd(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/std.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 ..arithmetic.sqrt import sqrt
+from .var import var
+
+
+def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=None):
+    """
+    Compute the standard deviation along the specified axis.
+
+    Returns the standard deviation, a measure of the spread of a distribution,
+    of the tensor elements. The standard deviation is computed for the
+    flattened tensor by default, otherwise over the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Calculate the standard deviation of these values.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the standard deviation is computed. The
+        default is to compute the standard deviation of the flattened tensor.
+
+        If this is a tuple of ints, a standard deviation is performed over
+        multiple axes, instead of a single axis or all the axes as before.
+    dtype : dtype, optional
+        Type to use in computing the standard deviation. For tensors of
+        integer type the default is float64, for tensors of float types it is
+        the same as the array type.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must have
+        the same shape as the expected output but the type (of the calculated
+        values) will be cast if necessary.
+    ddof : int, optional
+        Means Delta Degrees of Freedom.  The divisor used in calculations
+        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 `std` 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
+    -------
+    standard_deviation : Tensor, see dtype parameter above.
+        If `out` is None, return a new tensor containing the standard deviation,
+        otherwise return a reference to the output array.
+
+    See Also
+    --------
+    var, mean, nanmean, nanstd, nanvar
+
+    Notes
+    -----
+    The standard deviation is the square root of the average of the squared
+    deviations from the mean, i.e., ``std = sqrt(mean(abs(x - x.mean())**2))``.
+
+    The average squared deviation 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 the infinite population. ``ddof=0`` provides a maximum likelihood
+    estimate of the variance for normally distributed variables. The
+    standard deviation computed in this function is the square root of
+    the estimated variance, so even with ``ddof=1``, it will not be an
+    unbiased estimate of the standard deviation per se.
+
+    Note that, for complex numbers, `std` takes the absolute
+    value before squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the *std* 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.std(a).execute()
+    1.1180339887498949
+    >>> mt.std(a, axis=0).execute()
+    array([ 1.,  1.])
+    >>> mt.std(a, axis=1).execute()
+    array([ 0.5,  0.5])
+
+    In single precision, std() can be inaccurate:
+
+    >>> a = mt.zeros((2, 512*512), dtype=mt.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> mt.std(a).execute()
+    0.45000005
+
+    Computing the standard deviation in float64 is more accurate:
+
+    >>> mt.std(a, dtype=mt.float64).execute()
+    0.44999999925494177
+
+    """
+    ret = sqrt(
+        var(
+            a,
+            axis=axis,
+            dtype=dtype,
+            out=out,
+            ddof=ddof,
+            keepdims=keepdims,
+        )
+    )
+    if dtype is not None and ret.dtype != dtype:
+        ret = ret.astype(dtype)
+    return ret

maxframe/tensor/reduction/sum.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 .core import TensorReduction, TensorReductionMixin
+
+
+class TensorSum(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.SUM
+    _func_name = "sum"
+
+
+def sum(a, axis=None, dtype=None, out=None, keepdims=None):
+    """
+    Sum of tensor elements over a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Elements to sum.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a sum is performed.  The default,
+        axis=None, will sum all of the elements of the input tensor.  If
+        axis is negative it counts from the last to the first axis.
+
+        If axis is a tuple of ints, a sum is performed on all of the axes
+        specified in the tuple instead of a single axis or all the axes as
+        before.
+    dtype : dtype, optional
+        The type of the returned tensor and of the accumulator in which the
+        elements are summed.  The dtype of `a` is used by default unless `a`
+        has an integer dtype of less precision than the default platform
+        integer.  In that case, if `a` is signed then the platform integer
+        is used while if `a` is unsigned then an unsigned integer of the
+        same precision as the platform integer is used.
+    out : Tensor, optional
+        Alternative output tensor in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary.
+    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 `sum` 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
+    -------
+    sum_along_axis : Tensor
+        An array with the same shape as `a`, with the specified
+        axis removed.   If `a` is a 0-d tensor, or if `axis` is None, a scalar
+        is returned.  If an output array is specified, a reference to
+        `out` is returned.
+
+    See Also
+    --------
+    Tensor.sum : Equivalent method.
+
+    cumsum : Cumulative sum of tensor elements.
+
+    trapz : Integration of tensor values using the composite trapezoidal rule.
+
+    mean, average
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    The sum of an empty array is the neutral element 0:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mt.sum([]).execute()
+    0.0
+
+    Examples
+    --------
+    >>> mt.sum([0.5, 1.5]).execute()
+    2.0
+    >>> mt.sum([0.5, 0.7, 0.2, 1.5], dtype=mt.int32).execute()
+    1
+    >>> mt.sum([[0, 1], [0, 5]]).execute()
+    6
+    >>> mt.sum([[0, 1], [0, 5]], axis=0).execute()
+    array([0, 6])
+    >>> mt.sum([[0, 1], [0, 5]], axis=1).execute()
+    array([1, 5])
+
+    If the accumulator is too small, overflow occurs:
+
+    >>> mt.ones(128, dtype=mt.int8).sum(dtype=mt.int8).execute()
+    -128
+
+    """
+    a = astensor(a)
+    if dtype is None:
+        if a.dtype == object:
+            dtype = a.dtype
+        else:
+            dtype = np.empty((1,), dtype=a.dtype).sum().dtype
+    else:
+        dtype = np.dtype(dtype)
+    op = TensorSum(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/tests/__init__.py

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