maxframe 1.3.0__cp38-cp38-win32.whl → 2.0.0b1__cp38-cp38-win32.whl

maxframe/tensor/datasource/core.py

@@ -12,8 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import List
+
 import numpy as np
 
+from ...core import EntityData
 from ...serialization.serializables import FieldTypes, StringField, TupleField
 from ..core import TensorOrder
 from ..operators import TensorOperator, TensorOperatorMixin
@@ -66,9 +69,10 @@ class TensorHasInput(TensorDataSource):
         if len(inputs) != 1:
             raise ValueError("Tensor can only have 1 input")
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self._input = self._inputs[0]
+    @classmethod
+    def _set_inputs(cls, op: "TensorHasInput", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input = op._inputs[0]
 
     def __call__(self, a, order=None):
         order = a.order if order is None else order
@@ -76,15 +80,16 @@ class TensorHasInput(TensorDataSource):
 
 
 class TensorLike(TensorHasInput):
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        if self.dtype is None:
-            self.dtype = self.input.dtype
-        if self.gpu is None:
-            self.gpu = self.input.op.gpu
+    @classmethod
+    def _set_inputs(cls, op: "TensorLike", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if op.dtype is None:
+            op.dtype = op.input.dtype
+        if op.gpu is None:
+            op.gpu = op.input.op.gpu
 
         # FIXME: remove when cupy supports other dtypes
-        if self.gpu and self.dtype not in (np.float32, np.float64):
+        if op.gpu and op.dtype not in (np.float32, np.float64):
             raise NotImplementedError(
                 "Sparse tensor on GPU only supports float32 and float64"
             )

maxframe/tensor/datasource/diag.py

@@ -0,0 +1,140 @@
+# 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
+
+from ... import opcodes
+from ...core import EntityData
+from ...lib.sparse import diag as sparse_diag
+from ...lib.sparse import get_sparse_module, issparse
+from ...lib.sparse.core import get_array_module
+from ...serialization.serializables import Int32Field
+from ..core import TENSOR_TYPE, TensorOrder
+from .array import tensor
+from .core import TensorHasInput
+
+
+def _get_diag_shape(v_shape, k):
+    size_0, size_1 = 0, 0
+    if k > 0:
+        size_1 += k
+    elif k < 0:
+        size_0 -= k
+    size = min(v_shape[0] - size_0, v_shape[1] - size_1)
+    return (size,)
+
+
+class TensorDiag(TensorHasInput):
+    _op_type_ = opcodes.TENSOR_DIAG
+
+    k = Int32Field("k", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorDiag", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if op.dtype is None:
+            op._dtype = op.inputs[0].dtype
+
+    def __call__(self, v, shape, chunk_size=None):
+        return self.new_tensor(
+            [v], shape, raw_chunk_size=chunk_size, order=TensorOrder.C_ORDER
+        )
+
+
+def diag(v, k=0, sparse=None, gpu=None, chunk_size=None):
+    """
+    Extract a diagonal or construct a diagonal tensor.
+
+    See the more detailed documentation for ``mt.diagonal`` if you use this
+    function to extract a diagonal and wish to write to the resulting tensor
+
+    Parameters
+    ----------
+    v : array_like
+        If `v` is a 2-D tensor, return its `k`-th diagonal.
+        If `v` is a 1-D tensor, return a 2-D tensor with `v` on the `k`-th
+        diagonal.
+    k : int, optional
+        Diagonal in question. The default is 0. Use `k>0` for diagonals
+        above the main diagonal, and `k<0` for diagonals below the main
+        diagonal.
+    sparse: bool, optional
+        Create sparse tensor if True, False as default
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+
+    Returns
+    -------
+    out : Tensor
+        The extracted diagonal or constructed diagonal tensor.
+
+    See Also
+    --------
+    diagonal : Return specified diagonals.
+    diagflat : Create a 2-D array with the flattened input as a diagonal.
+    trace : Sum along diagonals.
+    triu : Upper triangle of a tensor.
+    tril : Lower triangle of a tensor.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> x = mt.arange(9).reshape((3,3))
+    >>> x.execute()
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+
+    >>> mt.diag(x).execute()
+    array([0, 4, 8])
+    >>> mt.diag(x, k=1).execute()
+    array([1, 5])
+    >>> mt.diag(x, k=-1).execute()
+    array([3, 7])
+
+    >>> mt.diag(mt.diag(x)).execute()
+    array([[0, 0, 0],
+           [0, 4, 0],
+           [0, 0, 8]])
+
+    """
+    if not isinstance(v, TENSOR_TYPE):
+        tensor_v = tensor(v)
+        if tensor_v.issparse():
+            xps = get_sparse_module(tensor_v.data)
+            v = xps.csr_matrix(
+                (tensor_v.op.data, tensor_v.op.indices, tensor_v.op.indptr),
+                tensor_v.shape,
+            )
+            diag_v = sparse_diag(v, k=k)
+        else:
+            v = tensor(v).op.data
+            diag_v = get_array_module(v).diag(v, k=k)
+        sparse = sparse if sparse is not None else issparse(v)
+        return tensor(diag_v, gpu=gpu, sparse=sparse, chunk_size=chunk_size)
+
+    sparse = sparse if sparse is not None else v.issparse()
+
+    if v.ndim == 1:
+        shape = (v.size + abs(k),) * 2
+    elif v.ndim == 2:
+        shape = _get_diag_shape(v.shape, k)
+    else:
+        raise ValueError("Input must be 1- or 2-d.")
+
+    op = TensorDiag(k=k, dtype=v.dtype, gpu=gpu, sparse=sparse)
+    return op(v, shape)

maxframe/tensor/datasource/diagflat.py

@@ -0,0 +1,69 @@
+# 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 ..core import Tensor
+from .array import tensor as astensor
+from .diag import diag
+
+
+def diagflat(v, k=0, sparse=None, gpu=None, chunk_size=None):
+    """
+    Create a two-dimensional tensor with the flattened input as a diagonal.
+
+    Parameters
+    ----------
+    v : array_like
+        Input data, which is flattened and set as the `k`-th
+        diagonal of the output.
+    k : int, optional
+        Diagonal to set; 0, the default, corresponds to the "main" diagonal,
+        a positive (negative) `k` giving the number of the diagonal above
+        (below) the main.
+    sparse: bool, optional
+        Create sparse tensor if True, False as default
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+
+    Returns
+    -------
+    out : Tensor
+        The 2-D output tensor.
+
+    See Also
+    --------
+    diag : MATLAB work-alike for 1-D and 2-D tensors.
+    diagonal : Return specified diagonals.
+    trace : Sum along diagonals.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.diagflat([[1,2], [3,4]]).execute()
+    array([[1, 0, 0, 0],
+           [0, 2, 0, 0],
+           [0, 0, 3, 0],
+           [0, 0, 0, 4]])
+
+    >>> mt.diagflat([1,2], 1).execute()
+    array([[0, 1, 0],
+           [0, 0, 2],
+           [0, 0, 0]])
+
+    """
+    if not isinstance(v, Tensor):
+        v = astensor(v).op.data
+    return diag(v.flatten(), k=k, sparse=sparse, gpu=gpu, chunk_size=chunk_size)

maxframe/tensor/datasource/empty.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/tensor/datasource/eye.py

@@ -0,0 +1,95 @@
+# 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 ... import opcodes
+from ...serialization.serializables import Int32Field, StringField
+from ..utils import get_order
+from .core import TensorNoInput
+
+
+class TensorEye(TensorNoInput):
+    _op_type_ = opcodes.TENSOR_EYE
+
+    k = Int32Field("k", default=0)
+    order = StringField("order", default=None)
+
+    def __init__(self, dtype=None, **kw):
+        dtype = np.dtype(dtype or "f8")
+        super().__init__(dtype=dtype, **kw)
+
+
+def eye(N, M=None, k=0, dtype=None, sparse=False, gpu=None, chunk_size=None, order="C"):
+    """
+    Return a 2-D tensor with ones on the diagonal and zeros elsewhere.
+
+    Parameters
+    ----------
+    N : int
+      Number of rows in the output.
+    M : int, optional
+      Number of columns in the output. If None, defaults to `N`.
+    k : int, optional
+      Index of the diagonal: 0 (the default) refers to the main diagonal,
+      a positive value refers to an upper diagonal, and a negative value
+      to a lower diagonal.
+    dtype : data-type, optional
+      Data-type of the returned tensor.
+    sparse: bool, optional
+        Create sparse tensor if True, False as default
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    order : {'C', 'F'}, optional
+        Whether the output should be stored in row-major (C-style) or
+        column-major (Fortran-style) order in memory.
+
+    Returns
+    -------
+    I : Tensor of shape (N,M)
+      An tensor where all elements are equal to zero, except for the `k`-th
+      diagonal, whose values are equal to one.
+
+    See Also
+    --------
+    identity : (almost) equivalent function
+    diag : diagonal 2-D tensor from a 1-D tensor specified by the user.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.eye(2, dtype=int).execute()
+    array([[1, 0],
+           [0, 1]])
+    >>> mt.eye(3, k=1).execute()
+    array([[ 0.,  1.,  0.],
+           [ 0.,  0.,  1.],
+           [ 0.,  0.,  0.]])
+
+    """
+    if M is None:
+        M = N
+
+    shape = (N, M)
+    tensor_order = get_order(
+        order,
+        None,
+        available_options="CF",
+        err_msg="only 'C' or 'F' order is permitted",
+    )
+    op = TensorEye(k=k, dtype=dtype, gpu=gpu, sparse=sparse, order=order)
+    return op(shape, chunk_size=chunk_size, order=tensor_order)

maxframe/tensor/datasource/from_dataframe.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/tensor/datasource/from_dense.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,12 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections.abc import Iterable
-from functools import reduce
-from operator import and_
-
-import pandas as pd
-
 from ... import opcodes
 from ...serialization.serializables import AnyField, KeyField
 from .array import tensor
@@ -35,15 +27,6 @@ class DenseToSparse(TensorHasInput):
     def __init__(self, **kw):
         super().__init__(sparse=True, **kw)
 
-    @staticmethod
-    def _get_mask(data, missing):
-        if isinstance(missing, Iterable):
-            return reduce(and_, (DenseToSparse._get_mask(data, m) for m in missing))
-        elif pd.isna(missing):
-            return ~pd.isna(data)
-        else:
-            return data != missing
-
 
 def fromdense(a, missing=None):
     a = tensor(a)

maxframe/tensor/datasource/from_sparse.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/tensor/datasource/full.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/tensor/datasource/identity.py

@@ -0,0 +1,54 @@
+# 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 .eye import eye
+
+
+def identity(n, dtype=None, sparse=False, gpu=None, chunk_size=None):
+    """
+    Return the identity tensor.
+
+    The identity tensor is a square array with ones on
+    the main diagonal.
+
+    Parameters
+    ----------
+    n : int
+        Number of rows (and columns) in `n` x `n` output.
+    dtype : data-type, optional
+        Data-type of the output.  Defaults to ``float``.
+    sparse: bool, optional
+        Create sparse tensor if True, False as default
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    chunks : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+
+    Returns
+    -------
+    out : Tensor
+        `n` x `n` array with its main diagonal set to one,
+        and all other elements 0.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.identity(3).execute()
+    array([[ 1.,  0.,  0.],
+           [ 0.,  1.,  0.],
+           [ 0.,  0.,  1.]])
+
+    """
+    return eye(n, dtype=dtype, sparse=sparse, gpu=gpu, chunk_size=chunk_size)

maxframe/tensor/datasource/indices.py

@@ -0,0 +1,115 @@
+# 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 .arange import arange
+from .empty import empty
+from .meshgrid import meshgrid
+
+
+def indices(dimensions, dtype=int, chunk_size=None):
+    """
+    Return a tensor representing the indices of a grid.
+
+    Compute a tensor where the subtensors contain index values 0,1,...
+    varying only along the corresponding axis.
+
+    Parameters
+    ----------
+    dimensions : sequence of ints
+        The shape of the grid.
+    dtype : dtype, optional
+        Data type of the result.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+
+    Returns
+    -------
+    grid : Tensor
+        The tensor of grid indices,
+        ``grid.shape = (len(dimensions),) + tuple(dimensions)``.
+
+    See Also
+    --------
+    mgrid, meshgrid
+
+    Notes
+    -----
+    The output shape is obtained by prepending the number of dimensions
+    in front of the tuple of dimensions, i.e. if `dimensions` is a tuple
+    ``(r0, ..., rN-1)`` of length ``N``, the output shape is
+    ``(N,r0,...,rN-1)``.
+
+    The subtensors ``grid[k]`` contains the N-D array of indices along the
+    ``k-th`` axis. Explicitly::
+
+        grid[k,i0,i1,...,iN-1] = ik
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> grid = mt.indices((2, 3))
+    >>> grid.shape
+    (2, 2, 3)
+    >>> grid[0].execute()        # row indices
+    array([[0, 0, 0],
+           [1, 1, 1]])
+    >>> grid[1].execute()        # column indices
+    array([[0, 1, 2],
+           [0, 1, 2]])
+
+    The indices can be used as an index into a tensor.
+
+    >>> x = mt.arange(20).reshape(5, 4)
+    >>> row, col = mt.indices((2, 3))
+    >>> # x[row, col]
+
+    Note that it would be more straightforward in the above example to
+    extract the required elements directly with ``x[:2, :3]``.
+
+    """
+    from ..merge import stack
+
+    dimensions = tuple(dimensions)
+    dtype = np.dtype(dtype)
+    raw_chunk_size = chunk_size
+    if chunk_size is not None and isinstance(chunk_size, Iterable):
+        chunk_size = tuple(chunk_size)
+    else:
+        chunk_size = (chunk_size,) * len(dimensions)
+
+    xi = []
+    for ch, dim in zip(chunk_size, dimensions):
+        xi.append(arange(dim, dtype=dtype, chunk_size=ch))
+
+    grid = None
+    if np.prod(dimensions):
+        grid = meshgrid(*xi, indexing="ij")
+
+    if grid:
+        grid = stack(grid)
+    else:
+        if raw_chunk_size is None:
+            empty_chunk_size = None
+        else:
+            empty_chunk_size = (1,) + chunk_size
+        grid = empty(
+            (len(dimensions),) + dimensions, dtype=dtype, chunk_size=empty_chunk_size
+        )
+
+    return grid