maxframe 2.2.0__cp312-cp312-macosx_10_9_x86_64.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

@@ -0,0 +1,163 @@
+# 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 ..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"""
+    Compute the softmax function.
+    The softmax function transforms each element of a collection by
+    computing the exponential of each element divided by the sum of the
+    exponentials of all the elements. That is, if `x` is a one-dimensional
+    numpy array::
+
+        softmax(x) = np.exp(x)/sum(np.exp(x))
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axis : int or tuple of ints, optional
+        Axis to compute values along. Default is None and softmax will be
+        computed over the entire array `x`.
+
+    Returns
+    -------
+    s : ndarray
+        An array the same shape as `x`. The result will sum to 1 along the
+        specified axis.
+
+    Notes
+    -----
+    The formula for the softmax function :math:`\sigma(x)` for a vector
+    :math:`x = \{x_0, x_1, ..., x_{n-1}\}` is
+
+    .. math:: \sigma(x)_j = \frac{e^{x_j}}{\sum_k e^{x_k}}
+
+    The `softmax` function is the gradient of `logsumexp`.
+
+    The implementation uses shifting to avoid overflow. See [1]_ for more
+    details.
+
+    References
+    ----------
+
+    .. [1] P. Blanchard, D.J. Higham, N.J. Higham, "Accurately computing the
+       log-sum-exp and softmax functions", IMA Journal of Numerical Analysis,
+       Vol.41(4), :doi:`10.1093/imanum/draa038`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> from maxframe.tensor.special import softmax
+
+    >>> x = mt.array([[1, 0.5, 0.2, 3],
+    ...               [1,  -1,   7, 3],
+    ...               [2,  12,  13, 3]])
+    ...
+
+    Compute the softmax transformation over the entire array.
+
+    >>> m = softmax(x)
+    >>> m.to_numpy()
+    array([[  4.48309e-06,   2.71913e-06,   2.01438e-06,   3.31258e-05],
+           [  4.48309e-06,   6.06720e-07,   1.80861e-03,   3.31258e-05],
+           [  1.21863e-05,   2.68421e-01,   7.29644e-01,   3.31258e-05]])
+
+    >>> m.sum().to_numpy()
+    1.0
+
+    Compute the softmax transformation along the first axis (i.e., the
+    columns).
+
+    >>> m = softmax(x, axis=0)
+    >>> m.to_numpy()
+    array([[  2.11942e-01,   1.01300e-05,   2.75394e-06,   3.33333e-01],
+           [  2.11942e-01,   2.26030e-06,   2.47262e-03,   3.33333e-01],
+           [  5.76117e-01,   9.99988e-01,   9.97525e-01,   3.33333e-01]])
+    >>> m.sum(axis=0).to_numpy()
+    array([ 1.,  1.,  1.,  1.])
+
+    Compute the softmax transformation along the second axis (i.e., the rows).
+
+    >>> m = softmax(x, axis=1)
+    >>> m.to_numpy()
+    array([[  1.05877e-01,   6.42177e-02,   4.75736e-02,   7.82332e-01],
+           [  2.42746e-03,   3.28521e-04,   9.79307e-01,   1.79366e-02],
+           [  1.22094e-05,   2.68929e-01,   7.31025e-01,   3.31885e-05]])
+    >>> m.sum(axis=1).to_numpy()
+    array([ 1.,  1.,  1.])
+    """
+    from ... import tensor as mt
+
+    x = mt.tensor(x)
+    x_max = mt.amax(x, axis=axis, keepdims=True)
+    exp_x_shifted = mt.exp(x - x_max)
+    return exp_x_shifted / mt.sum(exp_x_shifted, axis=axis, keepdims=True)
+
+
+def softplus(x, **kwargs):
+    r"""
+    Compute the softplus function element-wise.
+
+    The softplus function is defined as: ``softplus(x) = log(1 + exp(x))``.
+    It is a smooth approximation of the rectifier function (ReLU).
+
+    Parameters
+    ----------
+    x : array_like
+        Input value.
+    **kwargs
+        For other keyword-only arguments, see the
+        `ufunc docs <https://numpy.org/doc/stable/reference/ufuncs.html>`_.
+
+    Returns
+    -------
+    softplus : ndarray
+        Logarithm of ``exp(0) + exp(x)``.
+
+    Examples
+    --------
+    >>> from maxframe.tensor import special
+
+    >>> special.softplus(0).to_numpy()
+    0.6931471805599453
+
+    >>> special.softplus([-1, 0, 1]).to_numpy()
+    array([0.31326169, 0.69314718, 1.31326169])
+    """
+    # use numpy implementation as softplus is introduced in scipy 1.15.
+    from ... import tensor as mt
+
+    return mt.logaddexp(0, x, **kwargs)

maxframe/tensor/special/statistical.py

@@ -0,0 +1,56 @@
+# 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 TensorSpecialUnaryOp, _register_special_op
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="always_false")
+class TensorExpit(TensorSpecialUnaryOp):
+    _func_name = "expit"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="always_false")
+class TensorLogit(TensorSpecialUnaryOp):
+    _func_name = "logit"
+
+
+@_register_special_op
+@arithmetic_operator(sparse_mode="always_false")
+class TensorLogExpit(TensorSpecialUnaryOp):
+    _func_name = "log_expit"
+
+
+@implement_scipy("scipy.special.expit")
+@infer_scipy_dtype("scipy.special.expit")
+def expit(x, **kwargs):
+    op = TensorExpit(**kwargs)
+    return op(x)
+
+
+@implement_scipy("scipy.special.logit")
+@infer_scipy_dtype("scipy.special.logit")
+def logit(x, **kwargs):
+    op = TensorLogit(**kwargs)
+    return op(x)
+
+
+@implement_scipy("scipy.special.log_expit")
+@infer_scipy_dtype("scipy.special.log_expit")
+def log_expit(x, **kwargs):
+    op = TensorLogExpit(**kwargs)
+    return op(x)

maxframe/tensor/statistics/__init__.py

@@ -0,0 +1,24 @@
+# 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 .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/average.py

@@ -0,0 +1,143 @@
+# 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 ..datasource import tensor as astensor
+from ..misc.broadcast_to import broadcast_to
+from ..misc.swapaxes import swapaxes
+
+
+def average(a, axis=None, weights=None, returned=False):
+    """
+    Compute the weighted average along the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor containing data to be averaged. If `a` is not a tensor, a
+        conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to average `a`.  The default,
+        axis=None, will average over 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, averaging is performed on all of the axes
+        specified in the tuple instead of a single axis or all the axes as
+        before.
+    weights : array_like, optional
+        A tensor of weights associated with the values in `a`. Each value in
+        `a` contributes to the average according to its associated weight.
+        The weights tensor can either be 1-D (in which case its length must be
+        the size of `a` along the given axis) or of the same shape as `a`.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.
+    returned : bool, optional
+        Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
+        is returned, otherwise only the average is returned.
+        If `weights=None`, `sum_of_weights` is equivalent to the number of
+        elements over which the average is taken.
+
+
+    Returns
+    -------
+    average, [sum_of_weights] : tensor_type or double
+        Return the average along the specified axis. When returned is `True`,
+        return a tuple with the average as the first element and the sum
+        of the weights as the second element. The return type is `Float`
+        if `a` is of integer type, otherwise it is of the same type as `a`.
+        `sum_of_weights` is of the same type as `average`.
+
+    Raises
+    ------
+    ZeroDivisionError
+        When all weights along axis are zero. See `numpy.ma.average` for a
+        version robust to this type of error.
+    TypeError
+        When the length of 1D `weights` is not the same as the shape of `a`
+        along axis.
+
+    See Also
+    --------
+    mean
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> data = list(range(1,5))
+    >>> data
+    [1, 2, 3, 4]
+    >>> mt.average(data).execute()
+    2.5
+    >>> mt.average(range(1,11), weights=range(10,0,-1)).execute()
+    4.0
+
+    >>> data = mt.arange(6).reshape((3,2))
+    >>> data.execute()
+    array([[0, 1],
+           [2, 3],
+           [4, 5]])
+    >>> mt.average(data, axis=1, weights=[1./4, 3./4]).execute()
+    array([ 0.75,  2.75,  4.75])
+    >>> mt.average(data, weights=[1./4, 3./4]).execute()
+    Traceback (most recent call last):
+    ...
+    TypeError: Axis must be specified when shapes of a and weights differ.
+
+    """
+    from ..arithmetic import multiply, truediv
+
+    a = astensor(a)
+
+    if weights is None:
+        avg = a.mean(axis)
+        scl = avg.dtype.type(a.size / avg.size)
+    else:
+        wgt = astensor(weights)
+
+        if issubclass(a.dtype.type, (np.integer, np.bool_)):
+            result_dtype = np.result_type(a.dtype, wgt.dtype, "f8")
+        else:
+            result_dtype = np.result_type(a.dtype, wgt.dtype)
+
+        # sanity checks
+        if a.shape != wgt.shape:
+            if axis is None:
+                raise TypeError(
+                    "Axis must be specified when shapes of a and weights differ."
+                )
+            if wgt.ndim != 1:
+                raise TypeError(
+                    "1D weights expected when shapes of a and weights differ."
+                )
+            if wgt.shape[0] != a.shape[axis]:
+                raise ValueError(
+                    "Length of weights not compatible with specified axis."
+                )
+
+            # setup wgt to broadcast along axis
+            wgt = broadcast_to(wgt, (a.ndim - 1) * (1,) + wgt.shape)
+            wgt = swapaxes(wgt, -1, axis)
+
+        scl = wgt.sum(axis=axis, dtype=result_dtype)
+        with np.errstate(divide="raise"):
+            avg = truediv(multiply(a, wgt, dtype=result_dtype).sum(axis), scl)
+
+    if returned:
+        if scl.shape != avg.shape:
+            scl = broadcast_to(scl, avg.shape)
+        return avg, scl
+    else:
+        return avg