maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/linalg/norm.py

@@ -0,0 +1,249 @@
+# 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 collections.abc import Iterable
+
+import numpy as np
+
+from ... import opcodes
+from ...serialization.serializables import AnyField, BoolField, FieldTypes, TupleField
+from ..arithmetic import sqrt
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+from ..utils import validate_axis
+from .svd import svd
+
+
+class TensorNorm(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.NORM
+
+    ord = AnyField("ord", default=None)
+    axis = TupleField("axis", FieldTypes.int32, default=0)
+    keepdims = BoolField("keepdims", default=None)
+
+    def __call__(self, x):
+        r = x.astype(self.dtype)
+        shape = self._norm(r, self.ord, self.axis, self.keepdims).shape
+        return self.new_tensor([x], shape)
+
+    @staticmethod
+    def _norm(r, ord, axis, keepdims):
+        if ord is None:
+            return sqrt((abs(r) ** 2).sum(axis=axis, keepdims=keepdims))
+        elif ord == "nuc":
+            if len(axis) == 1:
+                raise ValueError("Invalid norm order for vectors.")
+            return svd(r)[1][np.newaxis].sum(keepdims=keepdims)
+        elif ord == np.inf:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            r = abs(r)
+            if len(axis) == 1:
+                return r.max(axis=axis, keepdims=keepdims)
+            else:
+                return r.sum(axis=axis[1], keepdims=keepdims).max(keepdims=keepdims)
+        elif ord == -np.inf:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            r = abs(r)
+            if len(axis) == 1:
+                return r.min(axis=axis, keepdims=keepdims)
+            else:
+                return r.sum(axis=axis[1], keepdims=keepdims).min(keepdims=keepdims)
+        elif ord == 0:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            if len(axis) == 2:
+                raise ValueError("Invalid norm order for matrices.")
+            return (r != 0).astype(r.dtype).sum(axis=axis, keepdims=keepdims)
+        elif ord == 1:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            r = abs(r)
+            if len(axis) == 1:
+                return r.sum(axis=axis, keepdims=keepdims)
+            else:
+                return r.sum(axis=axis[0], keepdims=keepdims).max(keepdims=keepdims)
+        elif ord == -1 and len(axis) == 2:
+            if r.ndim > 2:
+                raise ValueError("Improper number of dimensions to norm.")
+            return abs(r).sum(axis=axis[0], keepdims=keepdims).min(keepdims=keepdims)
+        elif ord == 2 and len(axis) == 2:
+            return svd(r)[1][np.newaxis].max(keepdims=keepdims)
+        elif ord == -2 and len(axis) == 2:
+            return svd(r)[1][np.newaxis].min(keepdims=keepdims)
+        else:
+            if len(axis) == 2:
+                raise ValueError("Invalid norm order for matrices.")
+
+            return (abs(r) ** ord).sum(axis=axis, keepdims=keepdims) ** (1.0 / ord)
+
+
+def norm(x, ord=None, axis=None, keepdims=False):
+    r"""
+    Matrix or vector norm.
+
+    This function is able to return one of eight different matrix norms,
+    or one of an infinite number of vector norms (described below), depending
+    on the value of the ``ord`` parameter.
+
+    Parameters
+    ----------
+    x : array_like
+        Input tensor.  If `axis` is None, `x` must be 1-D or 2-D.
+    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
+        Order of the norm (see table under ``Notes``). inf means maxframe tensor's
+        `inf` object.
+    axis : {int, 2-tuple of ints, None}, optional
+        If `axis` is an integer, it specifies the axis of `x` along which to
+        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
+        axes that hold 2-D matrices, and the matrix norms of these matrices
+        are computed.  If `axis` is None then either a vector norm (when `x`
+        is 1-D) or a matrix norm (when `x` is 2-D) is returned.
+    keepdims : bool, optional
+        If this is set to True, the axes which are normed over are left in the
+        result as dimensions with size one.  With this option the result will
+        broadcast correctly against the original `x`.
+
+    Returns
+    -------
+    n : float or Tensor
+        Norm of the matrix or vector(s).
+
+    Notes
+    -----
+    For values of ``ord <= 0``, the result is, strictly speaking, not a
+    mathematical 'norm', but it may still be useful for various numerical
+    purposes.
+
+    The following norms can be calculated:
+
+    =====  ============================  ==========================
+    ord    norm for matrices             norm for vectors
+    =====  ============================  ==========================
+    None   Frobenius norm                2-norm
+    'fro'  Frobenius norm                --
+    'nuc'  nuclear norm                  --
+    inf    max(sum(abs(x), axis=1))      max(abs(x))
+    -inf   min(sum(abs(x), axis=1))      min(abs(x))
+    0      --                            sum(x != 0)
+    1      max(sum(abs(x), axis=0))      as below
+    -1     min(sum(abs(x), axis=0))      as below
+    2      2-norm (largest sing. value)  as below
+    -2     smallest singular value       as below
+    other  --                            sum(abs(x)**ord)**(1./ord)
+    =====  ============================  ==========================
+
+    The Frobenius norm is given by [1]_:
+
+        :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
+
+    The nuclear norm is the sum of the singular values.
+
+    References
+    ----------
+    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
+           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
+
+    Examples
+    --------
+    >>> from maxframe.tensor import linalg as LA
+    >>> import maxframe.tensor as mt
+    >>> a = mt.arange(9) - 4
+    >>> a.execute()
+    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
+    >>> b = a.reshape((3, 3))
+    >>> b.execute()
+    array([[-4, -3, -2],
+           [-1,  0,  1],
+           [ 2,  3,  4]])
+
+    >>> LA.norm(a).execute()
+    7.745966692414834
+    >>> LA.norm(b).execute()
+    7.745966692414834
+    >>> LA.norm(b, 'fro').execute()
+    7.745966692414834
+    >>> LA.norm(a, mt.inf).execute()
+    4.0
+    >>> LA.norm(b, mt.inf).execute()
+    9.0
+    >>> LA.norm(a, -mt.inf).execute()
+    0.0
+    >>> LA.norm(b, -mt.inf).execute()
+    2.0
+
+    >>> LA.norm(a, 1).execute()
+    20.0
+    >>> LA.norm(b, 1).execute()
+    7.0
+    >>> LA.norm(a, -1).execute()
+    0.0
+    >>> LA.norm(b, -1).execute()
+    6.0
+    >>> LA.norm(a, 2).execute()
+    7.745966692414834
+    >>> LA.norm(b, 2).execute()
+    7.3484692283495345
+
+    >>> LA.norm(a, -2).execute()
+    0.0
+    >>> LA.norm(b, -2).execute()
+    4.351066026358965e-18
+    >>> LA.norm(a, 3).execute()
+    5.8480354764257312
+    >>> LA.norm(a, -3).execute()
+    0.0
+
+    Using the `axis` argument to compute vector norms:
+
+    >>> c = mt.array([[ 1, 2, 3],
+    ...               [-1, 1, 4]])
+    >>> LA.norm(c, axis=0).execute()
+    array([ 1.41421356,  2.23606798,  5.        ])
+    >>> LA.norm(c, axis=1).execute()
+    array([ 3.74165739,  4.24264069])
+    >>> LA.norm(c, ord=1, axis=1).execute()
+    array([ 6.,  6.])
+
+    Using the `axis` argument to compute matrix norms:
+
+    >>> m = mt.arange(8).reshape(2,2,2)
+    >>> LA.norm(m, axis=(1,2)).execute()
+    array([  3.74165739,  11.22497216])
+    >>> LA.norm(m[0, :, :]).execute(), LA.norm(m[1, :, :]).execute()
+    (3.7416573867739413, 11.224972160321824)
+
+    """
+    x = astensor(x)
+    ndim = x.ndim
+
+    if ord == "fro":
+        ord = None
+    if axis is not None:
+        if isinstance(axis, Iterable):
+            axis = tuple(validate_axis(ndim, a) for a in axis)
+        else:
+            axis = (validate_axis(ndim, axis),)
+    else:
+        axis = tuple(range(x.ndim))
+
+    op = TensorNorm(
+        ord=ord,
+        axis=axis,
+        keepdims=keepdims,
+        dtype=np.result_type(x.dtype, np.float_),
+        sparse=x.issparse(),
+    )
+    return op(x)

maxframe/tensor/linalg/qr.py

@@ -0,0 +1,124 @@
+# 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 numpy.linalg import LinAlgError
+
+from ... import opcodes
+from ...core import ExecutableTuple
+from ...serialization.serializables import StringField
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorHasInput, TensorOperatorMixin
+
+
+class TensorQR(TensorHasInput, TensorOperatorMixin):
+    _op_type_ = opcodes.QR
+
+    method = StringField("method")
+
+    @property
+    def output_limit(self):
+        return 2
+
+    def __call__(self, a):
+        a = astensor(a)
+
+        if a.ndim != 2:
+            raise LinAlgError(
+                f"{a.ndim}-dimensional tensor given. Tensor must be two-dimensional"
+            )
+
+        tiny_q, tiny_r = np.linalg.qr(np.ones((1, 1), dtype=a.dtype))
+
+        x, y = a.shape
+        q_shape, r_shape = (a.shape, (y, y)) if x > y else ((x, x), a.shape)
+        q, r = self.new_tensors(
+            [a],
+            kws=[
+                {
+                    "side": "q",
+                    "dtype": tiny_q.dtype,
+                    "shape": q_shape,
+                    "order": TensorOrder.C_ORDER,
+                },
+                {
+                    "side": "r",
+                    "dtype": tiny_r.dtype,
+                    "shape": r_shape,
+                    "order": TensorOrder.C_ORDER,
+                },
+            ],
+        )
+        return ExecutableTuple([q, r])
+
+
+def qr(a, method="tsqr"):
+    """
+    Compute the qr factorization of a matrix.
+
+    Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is
+    upper-triangular.
+
+    Parameters
+    ----------
+    a : array_like, shape (M, N)
+        Matrix to be factored.
+    method: {'tsqr', 'sfqr'}, optional
+        method to calculate qr factorization, tsqr as default
+
+        TSQR is presented in:
+
+            A. Benson, D. Gleich, and J. Demmel.
+            Direct QR factorizations for tall-and-skinny matrices in
+            MapReduce architectures.
+            IEEE International Conference on Big Data, 2013.
+            http://arxiv.org/abs/1301.1071
+
+        FSQR is a QR decomposition for fat and short matrix:
+            A = [A1, A2, A3, ...], A1 may be decomposed as A1 = Q1 * R1,
+            for A = Q * R, Q = Q1, R = [R1, R2, R3, ...] where A2 = Q1 * R2, A3 = Q1 * R3, ...
+
+    Returns
+    -------
+    q : Tensor of float or complex, optional
+        A matrix with orthonormal columns. When mode = 'complete' the
+        result is an orthogonal/unitary matrix depending on whether or not
+        a is real/complex. The determinant may be either +/- 1 in that
+        case.
+    r : Tensor of float or complex, optional
+        The upper-triangular matrix.
+
+    Raises
+    ------
+    LinAlgError
+        If factoring fails.
+
+    Notes
+    -----
+    For more information on the qr factorization, see for example:
+    http://en.wikipedia.org/wiki/QR_factorization
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.random.randn(9, 6)
+    >>> q, r = mt.linalg.qr(a)
+    >>> mt.allclose(a, mt.dot(q, r)).execute()  # a does equal qr
+    True
+
+    """
+    op = TensorQR(method=method)
+    return op(a)

maxframe/tensor/linalg/solve.py

@@ -0,0 +1,72 @@
+# 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 ..datasource import tensor as astensor
+from .cholesky import cholesky
+from .lu import lu
+from .solve_triangular import solve_triangular
+
+
+def solve(a, b, sym_pos=False, sparse=None):
+    """
+    Solve the equation ``a x = b`` for ``x``.
+
+    Parameters
+    ----------
+    a : (M, M) array_like
+        A square matrix.
+    b : (M,) or (M, N) array_like
+        Right-hand side matrix in ``a x = b``.
+    sym_pos : bool
+        Assume `a` is symmetric and positive definite. If ``True``, use Cholesky
+        decomposition.
+    sparse: bool, optional
+        Return sparse value or not.
+
+    Returns
+    -------
+    x : (M,) or (M, N) ndarray
+    Solution to the system ``a x = b``.  Shape of the return matches the
+    shape of `b`.
+
+    Raises
+    ------
+    LinAlgError
+    If `a` is singular.
+
+    Examples
+    --------
+    Given `a` and `b`, solve for `x`:
+
+    >>> import maxframe.tensor as mt
+    >>> a = mt.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
+    >>> b = mt.array([2, 4, -1])
+    >>> x = mt.linalg.solve(a, b)
+    >>> x.execute()
+    array([ 2., -2.,  9.])
+
+    >>> mt.dot(a, x).execute()  # Check the result
+    array([ 2., 4., -1.])
+    """
+    a = astensor(a)
+    b = astensor(b)
+    if sym_pos:
+        l_ = cholesky(a, lower=True)
+        u = l_.T
+    else:
+        p, l_, u = lu(a)
+        b = p.T.dot(b)
+    sparse = sparse if sparse is not None else a.issparse()
+    uy = solve_triangular(l_, b, lower=True, sparse=sparse)
+    return solve_triangular(u, uy, sparse=sparse)

maxframe/tensor/linalg/solve_triangular.py

@@ -0,0 +1,103 @@
+# 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 numpy.linalg import LinAlgError
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import BoolField, KeyField
+from ..core import TensorOrder
+from ..datasource import tensor as astensor
+from ..operators import TensorOperator, TensorOperatorMixin
+
+
+class TensorSolveTriangular(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.SOLVE_TRIANGULAR
+
+    a = KeyField("a")
+    b = KeyField("b")
+    lower = BoolField("lower", default=None)
+    strict = BoolField("strict", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorSolveTriangular", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.a, op.b = op._inputs
+
+    def __call__(self, a, b):
+        shape = (a.shape[1],) if len(b.shape) == 1 else (a.shape[1], b.shape[1])
+        return self.new_tensor([a, b], shape, order=TensorOrder.F_ORDER)
+
+
+def solve_triangular(a, b, lower=False, sparse=None):
+    """
+    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
+
+    Parameters
+    ----------
+    a : (M, M) array_like
+        A triangular matrix
+    b : (M,) or (M, N) array_like
+        Right-hand side matrix in `a x = b`
+    lower : bool, optional
+        Use only data contained in the lower triangle of `a`.
+        Default is to use upper triangle.
+    sparse: bool, optional
+        Return sparse value or not.
+
+    Returns
+    -------
+    x : (M,) or (M, N) ndarray
+        Solution to the system `a x = b`.  Shape of return matches `b`.
+
+    Examples
+    --------
+    Solve the lower triangular system a x = b, where::
+             [3  0  0  0]       [4]
+        a =  [2  1  0  0]   b = [2]
+             [1  0  1  0]       [4]
+             [1  1  1  1]       [2]
+
+    >>> import maxframe.tensor as mt
+    >>> a = mt.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
+    >>> b = mt.array([4, 2, 4, 2])
+    >>> x = mt.linalg.solve_triangular(a, b, lower=True)
+    >>> x.execute()
+    array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
+
+    >>> a.dot(x).execute()  # Check the result
+    array([ 4.,  2.,  4.,  2.])
+    """
+    import scipy.linalg
+
+    a = astensor(a)
+    b = astensor(b)
+
+    if a.ndim != 2:
+        raise LinAlgError("a must be 2 dimensional")
+    if b.ndim <= 2:
+        if a.shape[1] != b.shape[0]:
+            raise LinAlgError("a.shape[1] and b.shape[0] must be equal")
+    else:
+        raise LinAlgError("b must be 1 or 2 dimensional")
+
+    tiny_x = scipy.linalg.solve_triangular(
+        np.array([[2, 0], [2, 1]], dtype=a.dtype), np.array([[2], [3]], dtype=b.dtype)
+    )
+    sparse = sparse if sparse is not None else a.issparse()
+    op = TensorSolveTriangular(lower=lower, dtype=tiny_x.dtype, sparse=sparse)
+    return op(a, b)