maxframe 0.1.0b5__cp38-cp38-macosx_11_0_arm64.whl

maxframe/tensor/random/zipf.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 AnyField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin, handle_array
+
+
+class TensorZipf(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["a"]
+    _op_type_ = opcodes.RAND_ZIPF
+
+    _fields_ = "a", "size"
+    a = AnyField("a")
+    _func_name = "zipf"
+
+    def __call__(self, a, chunk_size=None):
+        return self.new_tensor([a], None, raw_chunk_size=chunk_size)
+
+
+def zipf(random_state, a, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a Zipf distribution.
+
+    Samples are drawn from a Zipf distribution with specified parameter
+    `a` > 1.
+
+    The Zipf distribution (also known as the zeta distribution) is a
+    continuous probability distribution that satisfies Zipf's law: the
+    frequency of an item is inversely proportional to its rank in a
+    frequency table.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Distribution parameter. Should be greater than 1.
+    size : int or tuple of ints, optional
+        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
+        ``m * n * k`` samples are drawn.  If size is ``None`` (default),
+        a single value is returned if ``a`` is a scalar. Otherwise,
+        ``mt.array(a).size`` samples are drawn.
+    chunk_size : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    gpu : bool, optional
+        Allocate the tensor on GPU if True, False as default
+    dtype : data-type, optional
+      Data-type of the returned tensor.
+
+    Returns
+    -------
+    out : Tensor or scalar
+        Drawn samples from the parameterized Zipf distribution.
+
+    See Also
+    --------
+    scipy.stats.zipf : probability density function, distribution, or
+        cumulative density function, etc.
+
+    Notes
+    -----
+    The probability density for the Zipf distribution is
+
+    .. math:: p(x) = \frac{x^{-a}}{\zeta(a)},
+
+    where :math:`\zeta` is the Riemann Zeta function.
+
+    It is named for the American linguist George Kingsley Zipf, who noted
+    that the frequency of any word in a sample of a language is inversely
+    proportional to its rank in the frequency table.
+
+    References
+    ----------
+    .. [1] Zipf, G. K., "Selected Studies of the Principle of Relative
+           Frequency in Language," Cambridge, MA: Harvard Univ. Press,
+           1932.
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> a = 2. # parameter
+    >>> s = mt.random.zipf(a, 1000)
+
+    Display the histogram of the samples, along with
+    the probability density function:
+
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy import special
+
+    Truncate s values at 50 so plot is interesting:
+
+    >>> count, bins, ignored = plt.hist(s[s<50].execute(), 50, normed=True)
+    >>> x = mt.arange(1., 50.)
+    >>> y = x**(-a) / special.zetac(a)
+    >>> plt.plot(x.execute(), (y/mt.max(y)).execute(), linewidth=2, color='r')
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().zipf(handle_array(a), size=(0,)).dtype
+
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorZipf(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(a, chunk_size=chunk_size)

maxframe/tensor/rechunk/__init__.py

@@ -0,0 +1,26 @@
+# Copyright 1999-2024 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 .rechunk import rechunk
+
+
+def _install():
+    from ..core import Tensor, TensorData
+
+    setattr(Tensor, "rechunk", rechunk)
+    setattr(TensorData, "rechunk", rechunk)
+
+
+_install()
+del _install

maxframe/tensor/rechunk/rechunk.py

@@ -0,0 +1,43 @@
+# Copyright 1999-2024 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 Tuple, Union
+
+from ... import opcodes
+from ...serialization.serializables import AnyField
+from ..core import Tensor
+from ..operators import TensorOperator, TensorOperatorMixin
+
+chunk_size_type = Union[int, Tuple[int], Tuple[Tuple[int], ...]]
+
+
+class TensorRechunk(TensorOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.RECHUNK
+
+    chunk_size = AnyField("chunk_size")
+
+    def __call__(self, tensor: Tensor):
+        return self.new_tensor([tensor], tensor.shape, order=tensor.order)
+
+
+def rechunk(
+    tensor: Tensor, chunk_size: chunk_size_type, reassign_worker=False
+) -> Tensor:
+    op = TensorRechunk(
+        chunk_size=chunk_size,
+        reassign_worker=reassign_worker,
+        dtype=tensor.dtype,
+        sparse=tensor.issparse(),
+    )
+    return op(tensor)

maxframe/tensor/reduction/__init__.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 .all import TensorAll, all
+from .allclose import allclose
+from .any import TensorAny, any
+from .argmax import TensorArgmax, argmax
+from .argmin import TensorArgmin, argmin
+from .array_equal import array_equal
+from .count_nonzero import TensorCountNonzero, count_nonzero
+from .cumprod import TensorCumprod, cumprod
+from .cumsum import TensorCumsum, cumsum
+from .max import TensorMax, max
+from .mean import TensorMean, mean
+from .min import TensorMin, min
+from .nanargmax import TensorNanArgmax, nanargmax
+from .nanargmin import TensorNanArgmin, nanargmin
+from .nancumprod import TensorNanCumprod, nancumprod
+from .nancumsum import TensorNanCumsum, nancumsum
+from .nanmax import TensorNanMax, nanmax
+from .nanmean import TensorNanMean, nanmean
+from .nanmin import TensorNanMin, nanmin
+from .nanprod import TensorNanProd, nanprod
+from .nanstd import nanstd
+from .nansum import TensorNanSum, nansum
+from .nanvar import TensorNanMoment, TensorNanVar, nanvar
+from .prod import TensorProd, prod
+from .std import std
+from .sum import TensorSum, sum
+from .var import TensorMoment, TensorVar, var
+
+
+def _install():
+    from ..core import Tensor, TensorData
+
+    for cls in (Tensor, TensorData):
+        setattr(cls, "sum", sum)
+        setattr(cls, "prod", prod)
+        setattr(cls, "max", max)
+        setattr(cls, "min", min)
+        setattr(cls, "all", all)
+        setattr(cls, "any", any)
+        setattr(cls, "mean", mean)
+        setattr(cls, "argmax", argmax)
+        setattr(cls, "argmin", argmin)
+        setattr(cls, "cumsum", cumsum)
+        setattr(cls, "cumprod", cumprod)
+        setattr(cls, "var", var)
+        setattr(cls, "std", std)
+
+
+_install()
+del _install

maxframe/tensor/reduction/all.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 ..datasource import tensor as astensor
+from .core import TensorReduction, TensorReductionMixin
+
+
+class TensorAll(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.ALL
+    _func_name = "all"
+
+
+def all(a, axis=None, out=None, keepdims=None):
+    """
+    Test whether all array elements along a given axis evaluate to True.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor or object that can be converted to a tensor.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a logical AND reduction is performed.
+        The default (`axis` = `None`) is to perform a logical AND over all
+        the dimensions of the input array. `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : Tensor, optional
+        Alternate output tensor in which to place the result.
+        It must have the same shape as the expected output and its
+        type is preserved (e.g., if ``dtype(out)`` is float, the result
+        will consist of 0.0's and 1.0's).  See `doc.ufuncs` (Section
+        "Output arguments") for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input tensor.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `all` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-classes `sum` method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    all : Tensor, bool
+        A new boolean or tensor is returned unless `out` is specified,
+        in which case a reference to `out` is returned.
+
+    See Also
+    --------
+    Tensor.all : equivalent method
+
+    any : Test whether any element along a given axis evaluates to True.
+
+    Notes
+    -----
+    Not a Number (NaN), positive infinity and negative infinity
+    evaluate to `True` because these are not equal to zero.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.all([[True,False],[True,True]]).execute()
+    False
+
+    >>> mt.all([[True,False],[True,True]], axis=0).execute()
+    array([ True, False])
+
+    >>> mt.all([-1, 4, 5]).execute()
+    True
+
+    >>> mt.all([1.0, mt.nan]).execute()
+    True
+
+    """
+    a = astensor(a)
+    if a.dtype == object:
+        dtype = a.dtype
+    else:
+        dtype = np.dtype(bool)
+    op = TensorAll(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/allclose.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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.
+
+
+def allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
+    """
+    Returns True if two tensors are element-wise equal within a tolerance.
+
+    The tolerance values are positive, typically very small numbers.  The
+    relative difference (`rtol` * abs(`b`)) and the absolute difference
+    `atol` are added together to compare against the absolute difference
+    between `a` and `b`.
+
+    If either array contains one or more NaNs, False is returned.
+    Infs are treated as equal if they are in the same place and of the same
+    sign in both tensors.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input tensors to compare.
+    rtol : float
+        The relative tolerance parameter (see Notes).
+    atol : float
+        The absolute tolerance parameter (see Notes).
+    equal_nan : bool
+        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
+        considered equal to NaN's in `b` in the output tensor.
+
+    Returns
+    -------
+    allclose : bool
+        Returns True if the two tensors are equal within the given
+        tolerance; False otherwise.
+
+    See Also
+    --------
+    isclose, all, any, equal
+
+    Notes
+    -----
+    If the following equation is element-wise True, then allclose returns
+    True.
+
+     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
+
+    The above equation is not symmetric in `a` and `b`, so that
+    ``allclose(a, b)`` might be different from ``allclose(b, a)`` in
+    some rare cases.
+
+    The comparison of `a` and `b` uses standard broadcasting, which
+    means that `a` and `b` need not have the same shape in order for
+    ``allclose(a, b)`` to evaluate to True.  The same is true for
+    `equal` but not `array_equal`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.allclose([1e10,1e-7], [1.00001e10,1e-8]).execute()
+    False
+    >>> mt.allclose([1e10,1e-8], [1.00001e10,1e-9]).execute()
+    True
+    >>> mt.allclose([1e10,1e-8], [1.0001e10,1e-9]).execute()
+    False
+    >>> mt.allclose([1.0, mt.nan], [1.0, mt.nan]).execute()
+    False
+    >>> mt.allclose([1.0, mt.nan], [1.0, mt.nan], equal_nan=True).execute()
+    True
+
+    """
+    from ..arithmetic.isclose import isclose
+    from .all import all
+
+    return all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan))

maxframe/tensor/reduction/any.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 ..datasource import tensor as astensor
+from .core import TensorReduction, TensorReductionMixin
+
+
+class TensorAny(TensorReduction, TensorReductionMixin):
+    _op_type_ = opcodes.ANY
+    _func_name = "any"
+
+
+def any(a, axis=None, out=None, keepdims=None):
+    """
+    Test whether any tensor element along a given axis evaluates to True.
+
+    Returns single boolean unless `axis` is not ``None``
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor or object that can be converted to an array.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a logical OR reduction is performed.
+        The default (`axis` = `None`) is to perform a logical OR over all
+        the dimensions of the input array. `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : Tensor, optional
+        Alternate output tensor in which to place the result.  It must have
+        the same shape as the expected output and its type is preserved
+        (e.g., if it is of type float, then it will remain so, returning
+        1.0 for True and 0.0 for False, regardless of the type of `a`).
+        See `doc.ufuncs` (Section "Output arguments") for details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input tensor.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `any` method of sub-classes of
+        `Tensor`, however any non-default value will be.  If the
+        sub-classes `sum` method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    any : bool or Tensor
+        A new boolean or `Tensor` is returned unless `out` is specified,
+        in which case a reference to `out` is returned.
+
+    See Also
+    --------
+    Tensor.any : equivalent method
+
+    all : Test whether all elements along a given axis evaluate to True.
+
+    Notes
+    -----
+    Not a Number (NaN), positive infinity and negative infinity evaluate
+    to `True` because these are not equal to zero.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.any([[True, False], [True, True]]).execute()
+    True
+
+    >>> mt.any([[True, False], [False, False]], axis=0).execute()
+    array([ True, False])
+
+    >>> mt.any([-1, 0, 5]).execute()
+    True
+
+    >>> mt.any(mt.nan).execute()
+    True
+
+    """
+    a = astensor(a)
+    if a.dtype == object:
+        dtype = a.dtype
+    else:
+        dtype = np.dtype(bool)
+    op = TensorAny(axis=axis, dtype=dtype, keepdims=keepdims)
+    return op(a, out=out)

maxframe/tensor/reduction/argmax.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 1999-2024 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 AnyField, TupleField
+from ..utils import validate_axis
+from .core import TensorArgReductionMixin, TensorReduction
+
+
+class TensorArgmax(TensorReduction, TensorArgReductionMixin):
+    _op_type_ = opcodes.ARGMAX
+    _func_name = "argmax"
+    _agg_func_name = "max"
+
+    offset = AnyField("offset", default=None)
+    total_shape = TupleField("total_shape", default=None)
+
+    def __init__(self, dtype=None, **kw):
+        if dtype is None:
+            dtype = np.dtype(int)
+        super().__init__(dtype=dtype, **kw)
+
+
+def argmax(a, axis=None, out=None):
+    """
+    Returns the indices of the maximum values along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input tensor.
+    axis : int, optional
+        By default, the index is into the flattened tensor, otherwise
+        along the specified axis.
+    out : Tensor, optional
+        If provided, the result will be inserted into this tensor. It should
+        be of the appropriate shape and dtype.
+
+    Returns
+    -------
+    index_array : Tensor of ints
+        Tensor of indices into the tensor. It has the same shape as `a.shape`
+        with the dimension along `axis` removed.
+
+    See Also
+    --------
+    Tensor.argmax, argmin
+    amax : The maximum value along a given axis.
+    unravel_index : Convert a flat index into an index tuple.
+
+    Notes
+    -----
+    In case of multiple occurrences of the maximum values, the indices
+    corresponding to the first occurrence are returned.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> a = mt.arange(6).reshape(2,3)
+    >>> a.execute()
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> mt.argmax(a).execute()
+    5
+    >>> mt.argmax(a, axis=0).execute()
+    array([1, 1, 1])
+    >>> mt.argmax(a, axis=1).execute()
+    array([2, 2])
+
+    Indexes of the maximal elements of a N-dimensional tensor:
+
+    >>> ind = mt.unravel_index(mt.argmax(a, axis=None), a.shape)
+    >>> ind.execute()
+    (1, 2)
+    >>> a[ind].execute()  # TODO(jisheng): accomplish when fancy index on tensor is supported
+
+    >>> b = mt.arange(6)
+    >>> b[1] = 5
+    >>> b.execute()
+    array([0, 5, 2, 3, 4, 5])
+    >>> mt.argmax(b).execute()  # Only the first occurrence is returned.
+    1
+
+    """
+    axis = validate_axis(a.ndim, axis) if axis is not None else None
+    op = TensorArgmax(axis=axis, dtype=np.dtype(int))
+    return op(a, out=out)