maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/tensor/special/info_theory.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.
+
+from ..arithmetic.utils import arithmetic_operator
+from ..utils import implement_scipy, infer_scipy_dtype
+from .core import TensorSpecialBinOp, TensorSpecialUnaryOp, _register_special_op
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="unary")
+class TensorEntr(TensorSpecialUnaryOp):
+    _func_name = "entr"
+
+
+@implement_scipy("scipy.special.entr")
+@infer_scipy_dtype("scipy.special.entr")
+def entr(x, out=None, where=None, **kwargs):
+    r"""
+    Elementwise function for computing entropy.
+
+    .. math:: \text{entr}(x) = \begin{cases} - x \log(x) & x > 0  \\ 0 & x = 0 \\ -\infty & \text{otherwise} \end{cases}
+
+    Parameters
+    ----------
+    x : Tensor
+        Input tensor.
+
+    Returns
+    -------
+    res : Tensor
+        The value of the elementwise entropy function at the given points `x`.
+
+    See Also
+    --------
+    kl_div, rel_entr
+
+    Notes
+    -----
+    This function is concave.
+    """
+    op = TensorEntr(**kwargs)
+    return op(x, out=out, where=where)
+
+
+@_register_special_op
+class TensorRelEntr(TensorSpecialBinOp):
+    _func_name = "rel_entr"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse():
+            return True
+        return False
+
+
+@implement_scipy("scipy.special.rel_entr")
+@infer_scipy_dtype("scipy.special.rel_entr")
+def rel_entr(x, y, out=None, where=None, **kwargs):
+    r"""
+    Elementwise function for computing relative entropy.
+
+    .. math::
+
+        \mathrm{rel\_entr}(x, y) =
+            \begin{cases}
+                x \log(x / y) & x > 0, y > 0 \\
+                0 & x = 0, y \ge 0 \\
+                \infty & \text{otherwise}
+            \end{cases}
+
+    Parameters
+    ----------
+    x, y : array_like
+        Input arrays
+    out : ndarray, optional
+        Optional output array for the function results
+
+    Returns
+    -------
+    scalar or ndarray
+        Relative entropy of the inputs
+
+    See Also
+    --------
+    entr, kl_div
+
+    Notes
+    -----
+    This function is jointly convex in x and y.
+
+    The origin of this function is in convex programming; see
+    [1]_. Given two discrete probability distributions :math:`p_1,
+    \ldots, p_n` and :math:`q_1, \ldots, q_n`, to get the relative
+    entropy of statistics compute the sum
+
+    .. math::
+
+        \sum_{i = 1}^n \mathrm{rel\_entr}(p_i, q_i).
+
+    See [2]_ for details.
+
+    References
+    ----------
+    .. [1] Grant, Boyd, and Ye, "CVX: Matlab Software for Disciplined Convex
+        Programming", http://cvxr.com/cvx/
+    .. [2] Kullback-Leibler divergence,
+        https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence
+    """
+    op = TensorRelEntr(**kwargs)
+    return op(x, y, out=out, where=where)
+
+
+@_register_special_op
+class TensorKlDiv(TensorSpecialBinOp):
+    _func_name = "kl_div"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse():
+            return True
+        return False
+
+
+@implement_scipy("scipy.special.kl_div")
+@infer_scipy_dtype("scipy.special.kl_div")
+def kl_div(x, y, out=None, where=None, **kwargs):
+    r"""
+    Elementwise function for computing relative entropy.
+
+    .. math::
+
+        \mathrm{rel\_entr}(x, y) =
+            \begin{cases}
+                x \log(x / y) & x > 0, y > 0 \\
+                0 & x = 0, y \ge 0 \\
+                \infty & \text{otherwise}
+            \end{cases}
+
+    Parameters
+    ----------
+    x, y : array_like
+        Input arrays
+    out : ndarray, optional
+        Optional output array for the function results
+
+    Returns
+    -------
+    scalar or ndarray
+        Relative entropy of the inputs
+
+    See Also
+    --------
+    entr, kl_div
+
+    Notes
+    -----
+    This function is jointly convex in x and y.
+
+    The origin of this function is in convex programming; see
+    [1]_. Given two discrete probability distributions :math:`p_1,
+    \ldots, p_n` and :math:`q_1, \ldots, q_n`, to get the relative
+    entropy of statistics compute the sum
+
+    .. math::
+
+        \sum_{i = 1}^n \mathrm{rel\_entr}(p_i, q_i).
+
+    See [2]_ for details.
+
+    References
+    ----------
+    .. [1] Grant, Boyd, and Ye, "CVX: Matlab Software for Disciplined Convex
+        Programming", http://cvxr.com/cvx/
+    .. [2] Kullback-Leibler divergence,
+        https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence
+    """
+    op = TensorKlDiv(**kwargs)
+    return op(x, y, out=out, where=where)

maxframe/tensor/special/misc.py

@@ -12,6 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from ..utils import implement_scipy, infer_scipy_dtype
+from .core import TensorSpecialBinOp, _register_special_op
+
+
+@_register_special_op
+class TensorXLogY(TensorSpecialBinOp):
+    _func_name = "xlogy"
+
+    @classmethod
+    def _is_sparse(cls, x1, x2):
+        if hasattr(x1, "issparse") and x1.issparse():
+            return True
+        return False
+
+
+@implement_scipy("scipy.special.xlogy")
+@infer_scipy_dtype("scipy.special.xlogy")
+def xlogy(x1, x2, out=None, where=None, **kwargs):
+    op = TensorXLogY(**kwargs)
+    return op(x1, x2, out=out, where=where)
+
 
 def softmax(x, axis=None):
     r"""

maxframe/tensor/statistics/__init__.py

@@ -14,5 +14,11 @@
 
 from .average import average
 from .bincount import bincount
+from .corrcoef import corrcoef
+from .cov import cov
+from .digitize import digitize
+from .histogram import histogram, histogram_bin_edges
+from .median import median
 from .percentile import percentile
+from .ptp import ptp
 from .quantile import quantile

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)