maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/statistics/bincount.py

@@ -0,0 +1,133 @@
+# 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 typing import List, Optional
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import Int64Field, ReferenceField
+from ...typing_ import EntityType
+from ..datasource import tensor as astensor
+from ..operators import TensorMapReduceOperator, TensorOperatorMixin
+
+_DEFAULT_CHUNK_SIZE_LIMIT = 1e8
+
+
+class TensorBinCount(TensorMapReduceOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.BINCOUNT
+
+    weights = ReferenceField("weights", default=None)
+    minlength: Optional[int] = Int64Field("minlength", default=0)
+    chunk_size_limit: int = Int64Field("chunk_size_limit")
+
+    chunk_count: Optional[int] = Int64Field("chunk_count")
+    tileable_right_bound: Optional[int] = Int64Field("tileable_right_bound")
+
+    def __call__(self, x, weights=None):
+        inputs = [x]
+        self.weights = weights
+        dtype = np.dtype(np.int_)
+        if weights is not None:
+            inputs.append(weights)
+            dtype = weights.dtype
+        return self.new_tensor(inputs, dtype=dtype, shape=(np.nan,))
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorBinCount", inputs: List[EntityType]):
+        super()._set_inputs(op, inputs)
+        if len(inputs) > 1:
+            op.weights = inputs[1]
+
+
+def bincount(x, weights=None, minlength=0, chunk_size_limit=None):
+    """
+    Count number of occurrences of each value in array of non-negative ints.
+
+    The number of bins (of size 1) is one larger than the largest value in
+    `x`. If `minlength` is specified, there will be at least this number
+    of bins in the output array (though it will be longer if necessary,
+    depending on the contents of `x`).
+    Each bin gives the number of occurrences of its index value in `x`.
+    If `weights` is specified the input array is weighted by it, i.e. if a
+    value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead
+    of ``out[n] += 1``.
+
+    Parameters
+    ----------
+    x : tensor or array_like, 1 dimension, nonnegative ints
+        Input array.
+    weights : tensor or array_like, optional
+        Weights, array of the same shape as `x`.
+    minlength : int, optional
+        A minimum number of bins for the output array.
+
+    Returns
+    -------
+    out : tensor of ints
+        The result of binning the input array.
+        The length of `out` is equal to ``np.amax(x)+1``.
+
+    Raises
+    ------
+    ValueError
+        If the input is not 1-dimensional, or contains elements with negative
+        values, or if `minlength` is negative.
+    TypeError
+        If the type of the input is float or complex.
+
+    See Also
+    --------
+    histogram, digitize, unique
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> mt.bincount(mt.arange(5)).execute()
+    array([1, 1, 1, 1, 1])
+    >>> mt.bincount(mt.tensor([0, 1, 1, 3, 2, 1, 7])).execute()
+    array([1, 3, 1, 1, 0, 0, 0, 1])
+
+    The input array needs to be of integer dtype, otherwise a
+    TypeError is raised:
+
+    >>> mt.bincount(mt.arange(5, dtype=float)).execute()
+    Traceback (most recent call last):
+      ....execute()
+    TypeError: Cannot cast array data from dtype('float64') to dtype('int64')
+    according to the rule 'safe'
+
+    A possible use of ``bincount`` is to perform sums over
+    variable-size chunks of an array, using the ``weights`` keyword.
+
+    >>> w = mt.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
+    >>> x = mt.array([0, 1, 1, 2, 2, 2])
+    >>> mt.bincount(x, weights=w).execute()
+    array([ 0.3,  0.7,  1.1])
+    """
+    x = astensor(x)
+    weights = astensor(weights) if weights is not None else None
+
+    if not np.issubdtype(x.dtype, np.int_):
+        raise TypeError(f"Cannot cast array data from {x.dtype} to {np.dtype(np.int_)}")
+    if x.ndim != 1:
+        raise ValueError("'x' must be 1 dimension")
+    if minlength < 0:
+        raise ValueError("'minlength' must not be negative")
+
+    chunk_size_limit = (
+        chunk_size_limit if chunk_size_limit is not None else _DEFAULT_CHUNK_SIZE_LIMIT
+    )
+    op = TensorBinCount(minlength=minlength, chunk_size_limit=chunk_size_limit)
+    return op(x, weights=weights)

maxframe/tensor/statistics/corrcoef.py

@@ -0,0 +1,77 @@
+# 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 .cov import cov
+
+
+def corrcoef(x, y=None, rowvar=True):
+    r"""
+    Return Pearson product-moment correlation coefficients.
+
+    Please refer to the documentation for `cov` for more detail.  The
+    relationship between the correlation coefficient matrix, `R`, and the
+    covariance matrix, `C`, is
+
+    .. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} * C_{jj} } }
+
+    The values of `R` are between -1 and 1, inclusive.
+
+    Parameters
+    ----------
+    x : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `x` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same
+        shape as `x`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+
+    Returns
+    -------
+    R : Tensor
+        The correlation coefficient matrix of the variables.
+
+    See Also
+    --------
+    cov : Covariance matrix
+
+    Notes
+    -----
+    Due to floating point rounding the resulting tensor may not be Hermitian,
+    the diagonal elements may not be 1, and the elements may not satisfy the
+    inequality abs(a) <= 1. The real and imaginary parts are clipped to the
+    interval [-1,  1] in an attempt to improve on that situation but is not
+    much help in the complex case.
+
+    This function accepts but discards arguments `bias` and `ddof`.  This is
+    for backwards compatibility with previous versions of this function.  These
+    arguments had no effect on the return values of the function and can be
+    safely ignored in this and previous versions of numpy.
+
+    """
+    from ..arithmetic import sqrt
+    from ..datasource import diag
+
+    c = cov(x, y, rowvar)
+    if c.ndim == 0:
+        return c / c
+    d = diag(c)
+    d = d.reshape(d.shape[0], 1)
+    sqrt_d = sqrt(d)
+    return (c / sqrt_d) / sqrt_d.T

maxframe/tensor/statistics/cov.py

@@ -0,0 +1,222 @@
+# 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 warnings
+
+import numpy as np
+
+from ..core import Tensor
+from ..datasource import array
+from ..datasource import tensor as astensor
+from ..misc.squeeze import squeeze
+from ..misc.where import where
+from .average import average
+
+
+def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None):
+    """
+    Estimate a covariance matrix, given data and weights.
+
+    Covariance indicates the level to which two variables vary together.
+    If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
+    then the covariance matrix element :math:`C_{ij}` is the covariance of
+    :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
+    of :math:`x_i`.
+
+    See the notes for an outline of the algorithm.
+
+    Parameters
+    ----------
+    m : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `m` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same form
+        as that of `m`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : bool, optional
+        Default normalization (False) is by ``(N - 1)``, where ``N`` is the
+        number of observations given (unbiased estimate). If `bias` is True,
+        then normalization is by ``N``. These values can be overridden by using
+        the keyword ``ddof`` in numpy versions >= 1.5.
+    ddof : int, optional
+        If not ``None`` the default value implied by `bias` is overridden.
+        Note that ``ddof=1`` will return the unbiased estimate, even if both
+        `fweights` and `aweights` are specified, and ``ddof=0`` will return
+        the simple average. See the notes for the details. The default value
+        is ``None``.
+    fweights : array_like, int, optional
+        1-D tensor of integer freguency weights; the number of times each
+        observation vector should be repeated.
+    aweights : array_like, optional
+        1-D tensor of observation vector weights. These relative weights are
+        typically large for observations considered "important" and smaller for
+        observations considered less "important". If ``ddof=0`` the array of
+        weights can be used to assign probabilities to observation vectors.
+
+    Returns
+    -------
+    out : Tensor
+        The covariance matrix of the variables.
+
+    See Also
+    --------
+    corrcoef : Normalized covariance matrix
+
+    Notes
+    -----
+    Assume that the observations are in the columns of the observation
+    array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The
+    steps to compute the weighted covariance are as follows::
+
+        >>> w = f * a
+        >>> v1 = mt.sum(w)
+        >>> v2 = mt.sum(w * a)
+        >>> m -= mt.sum(m * w, axis=1, keepdims=True) / v1
+        >>> cov = mt.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
+
+    Note that when ``a == 1``, the normalization factor
+    ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)``
+    as it should.
+
+    Examples
+    --------
+    Consider two variables, :math:`x_0` and :math:`x_1`, which
+    correlate perfectly, but in opposite directions:
+
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([[0, 2], [1, 1], [2, 0]]).T
+    >>> x.execute()
+    array([[0, 1, 2],
+           [2, 1, 0]])
+
+    Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance
+    matrix shows this clearly:
+
+    >>> mt.cov(x).execute()
+    array([[ 1., -1.],
+           [-1.,  1.]])
+
+    Note that element :math:`C_{0,1}`, which shows the correlation between
+    :math:`x_0` and :math:`x_1`, is negative.
+
+    Further, note how `x` and `y` are combined:
+
+    >>> x = [-2.1, -1,  4.3]
+    >>> y = [3,  1.1,  0.12]
+    >>> X = mt.stack((x, y), axis=0)
+    >>> print(mt.cov(X).execute())
+    [[ 11.71        -4.286     ]
+     [ -4.286        2.14413333]]
+    >>> print(mt.cov(x, y).execute())
+    [[ 11.71        -4.286     ]
+     [ -4.286        2.14413333]]
+    >>> print(mt.cov(x).execute())
+    11.71
+
+    """
+    from ..linalg import dot
+    from ..merge import vstack
+
+    if ddof is not None and ddof != int(ddof):
+        raise ValueError("ddof must be integer")
+
+    m = astensor(m)
+    if m.ndim > 2:
+        raise ValueError("m has more than 2 dimensions")
+
+    if y is None:
+        dtype = np.result_type(m.dtype, np.float64)
+    else:
+        y = astensor(y)
+        if y.ndim > 2:
+            raise ValueError("y has more than 2 dimensions")
+        dtype = np.result_type(m.dtype, y.dtype, np.float64)
+
+    X = array(m, ndmin=2, dtype=dtype)
+    if not rowvar and X.shape[0] != 1:
+        X = X.T
+    if y is not None:
+        y = array(y, copy=False, ndmin=2, dtype=dtype)
+        if not rowvar and y.shape[0] != 1:
+            y = y.T
+        X = vstack((X, y))
+
+    if ddof is None:
+        if bias == 0:
+            ddof = 1
+        else:
+            ddof = 0
+
+    # Get the product of frequencies and weights
+    w = None
+    if fweights is not None:
+        fweights = astensor(fweights, dtype=float)
+        if fweights.ndim > 1:
+            raise RuntimeError("cannot handle multidimensional fweights")
+        if fweights.shape[0] != X.shape[1]:
+            raise RuntimeError("incompatible numbers of samples and fweights")
+        if any(fweights < 0):
+            raise ValueError("fweights cannot be negative")
+        w = fweights
+    if aweights is not None:
+        aweights = astensor(aweights, dtype=float)
+        if aweights.ndim > 1:
+            raise RuntimeError("cannot handle multidimensional aweights")
+        if aweights.shape[0] != X.shape[1]:
+            raise RuntimeError("incompatible numbers of samples and aweights")
+        if any(aweights < 0):
+            raise ValueError("aweights cannot be negative")
+        if w is None:
+            w = aweights
+        else:
+            w *= aweights
+
+    avg, w_sum = average(X, axis=1, weights=w, returned=True)
+    w_sum = w_sum[0]
+
+    # Determine the normalization
+    if w is None:
+        fact = X.shape[1] - ddof
+    elif ddof == 0:
+        fact = w_sum
+    elif aweights is None:
+        fact = w_sum - ddof
+    else:
+        fact = w_sum - ddof * sum(w * aweights) / w_sum
+
+    X -= avg[:, None]
+    if w is None:
+        X_T = X.T
+    else:
+        X_T = (X * w).T
+    c = dot(X, X_T.conj())
+    if isinstance(fact, Tensor):
+        fact = where(fact <= 0, 0.0, fact)
+        fact = fact.astype(float)
+    else:
+        if fact <= 0:
+            warnings.warn(
+                "Degrees of freedom <= 0 for slice", RuntimeWarning, stacklevel=2
+            )
+            fact = 0.0
+        fact = np.float64(fact)
+    c = c * (1.0 / fact)
+    return squeeze(c)

maxframe/tensor/statistics/digitize.py

@@ -0,0 +1,126 @@
+# 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 typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...lib.sparse.core import get_array_module
+from ...serialization.serializables import AnyField, BoolField, KeyField
+from ...typing_ import EntityType
+from ..core import Tensor, TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+
+
+class TensorDigitize(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.DIGITIZE
+
+    input = KeyField("input")
+    bins = AnyField("bins")
+    right = BoolField("right")
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorDigitize", inputs: List[EntityType]):
+        super()._set_inputs(op, inputs)
+        if len(inputs) > 1:
+            op.bins = op._inputs[1]
+
+    def __call__(self, x, bins):
+        x = astensor(x)
+        inputs = [x]
+        if not isinstance(bins, Tensor):
+            bins = get_array_module(bins).asarray(bins)
+            self.bins = bins
+        else:
+            inputs.append(bins)
+        self.dtype = np.digitize(
+            [0], np.empty(1, dtype=bins.dtype), right=self.right
+        ).dtype
+
+        return self.new_tensor(inputs, x.shape, order=TensorOrder.C_ORDER)
+
+
+def digitize(x, bins, right=False):
+    """
+    Return the indices of the bins to which each value in input tensor belongs.
+
+    Each index ``i`` returned is such that ``bins[i-1] <= x < bins[i]`` if
+    `bins` is monotonically increasing, or ``bins[i-1] > x >= bins[i]`` if
+    `bins` is monotonically decreasing. If values in `x` are beyond the
+    bounds of `bins`, 0 or ``len(bins)`` is returned as appropriate. If right
+    is True, then the right bin is closed so that the index ``i`` is such
+    that ``bins[i-1] < x <= bins[i]`` or ``bins[i-1] >= x > bins[i]`` if `bins`
+    is monotonically increasing or decreasing, respectively.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor to be binned.
+    bins : array_like
+        Array of bins. It has to be 1-dimensional and monotonic.
+    right : bool, optional
+        Indicating whether the intervals include the right or the left bin
+        edge. Default behavior is (right==False) indicating that the interval
+        does not include the right edge. The left bin end is open in this
+        case, i.e., bins[i-1] <= x < bins[i] is the default behavior for
+        monotonically increasing bins.
+
+    Returns
+    -------
+    out : Tensor of ints
+        Output tensor of indices, of same shape as `x`.
+
+    Raises
+    ------
+    ValueError
+        If `bins` is not monotonic.
+    TypeError
+        If the type of the input is complex.
+
+    See Also
+    --------
+    bincount, histogram, unique, searchsorted
+
+    Notes
+    -----
+    If values in `x` are such that they fall outside the bin range,
+    attempting to index `bins` with the indices that `digitize` returns
+    will result in an IndexError.
+
+    `mt.digitize` is  implemented in terms of `mt.searchsorted`. This means
+    that a binary search is used to bin the values, which scales much better
+    for larger number of bins than the previous linear search. It also removes
+    the requirement for the input array to be 1-dimensional.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.array([0.2, 6.4, 3.0, 1.6])
+    >>> bins = mt.array([0.0, 1.0, 2.5, 4.0, 10.0])
+    >>> inds = mt.digitize(x, bins)
+    >>> inds.execute()
+    array([1, 4, 3, 2])
+
+    >>> x = mt.array([1.2, 10.0, 12.4, 15.5, 20.])
+    >>> bins = mt.array([0, 5, 10, 15, 20])
+    >>> mt.digitize(x,bins,right=True).execute()
+    array([1, 2, 3, 4, 4])
+    >>> mt.digitize(x,bins,right=False).execute()
+    array([1, 3, 3, 4, 5])
+    """
+    op = TensorDigitize(right=right)
+    return op(x, bins)