maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/random/normal.py

@@ -0,0 +1,141 @@
+# 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 AnyField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin, handle_array
+
+
+class TensorNormal(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["loc", "scale"]
+    _op_type_ = opcodes.RAND_NORMAL
+
+    _fields_ = "loc", "scale", "size"
+    loc = AnyField("loc")
+    scale = AnyField("scale")
+    _func_name = "normal"
+
+    def __call__(self, loc, scale, chunk_size=None):
+        return self.new_tensor([loc, scale], None, raw_chunk_size=chunk_size)
+
+
+def normal(
+    random_state, loc=0.0, scale=1.0, size=None, chunk_size=None, gpu=None, dtype=None
+):
+    r"""
+    Draw random samples from a normal (Gaussian) distribution.
+
+    The probability density function of the normal distribution, first
+    derived by De Moivre and 200 years later by both Gauss and Laplace
+    independently [2]_, is often called the bell curve because of
+    its characteristic shape (see the example below).
+
+    The normal distributions occurs often in nature.  For example, it
+    describes the commonly occurring distribution of samples influenced
+    by a large number of tiny, random disturbances, each with its own
+    unique distribution [2]_.
+
+    Parameters
+    ----------
+    loc : float or array_like of floats
+        Mean ("centre") of the distribution.
+    scale : float or array_like of floats
+        Standard deviation (spread or "width") of the distribution.
+    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 ``loc`` and ``scale`` are both scalars.
+        Otherwise, ``mt.broadcast(loc, scale).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 normal distribution.
+
+    See Also
+    --------
+    scipy.stats.norm : probability density function, distribution or
+        cumulative density function, etc.
+
+    Notes
+    -----
+    The probability density for the Gaussian distribution is
+
+    .. math:: p(x) = \frac{1}{\sqrt{ 2 \pi \sigma^2 }}
+                     e^{ - \frac{ (x - \mu)^2 } {2 \sigma^2} },
+
+    where :math:`\mu` is the mean and :math:`\sigma` the standard
+    deviation. The square of the standard deviation, :math:`\sigma^2`,
+    is called the variance.
+
+    The function has its peak at the mean, and its "spread" increases with
+    the standard deviation (the function reaches 0.607 times its maximum at
+    :math:`x + \sigma` and :math:`x - \sigma` [2]_).  This implies that
+    `numpy.random.normal` is more likely to return samples lying close to
+    the mean, rather than those far away.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Normal distribution",
+           http://en.wikipedia.org/wiki/Normal_distribution
+    .. [2] P. R. Peebles Jr., "Central Limit Theorem" in "Probability,
+           Random Variables and Random Signal Principles", 4th ed., 2001,
+           pp. 51, 51, 125.
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mu, sigma = 0, 0.1 # mean and standard deviation
+    >>> s = mt.random.normal(mu, sigma, 1000)
+
+    Verify the mean and the variance:
+
+    >>> (abs(mu - mt.mean(s)) < 0.01).execute()
+    True
+
+    >>> (abs(sigma - mt.std(s, ddof=1)) < 0.01).execute()
+    True
+
+    Display the histogram of the samples, along with
+    the probability density function:
+
+    >>> import matplotlib.pyplot as plt
+    >>> count, bins, ignored = plt.hist(s.execute(), 30, normed=True)
+    >>> plt.plot(bins, (1/(sigma * mt.sqrt(2 * mt.pi)) *
+    ...                mt.exp( - (bins - mu)**2 / (2 * sigma**2) )).execute(),
+    ...          linewidth=2, color='r')
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .normal(handle_array(loc), handle_array(scale), size=(0,))
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorNormal(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(loc, scale, chunk_size=chunk_size)

maxframe/tensor/random/pareto.py

@@ -0,0 +1,138 @@
+# 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 AnyField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin, handle_array
+
+
+class TensorPareto(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["a"]
+    _op_type_ = opcodes.RAND_PARETO
+
+    _fields_ = "a", "size"
+    a = AnyField("a")
+    _func_name = "pareto"
+
+    def __call__(self, a, chunk_size=None):
+        return self.new_tensor([a], None, raw_chunk_size=chunk_size)
+
+
+def pareto(random_state, a, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a Pareto II or Lomax distribution with
+    specified shape.
+
+    The Lomax or Pareto II distribution is a shifted Pareto
+    distribution. The classical Pareto distribution can be
+    obtained from the Lomax distribution by adding 1 and
+    multiplying by the scale parameter ``m`` (see Notes).  The
+    smallest value of the Lomax distribution is zero while for the
+    classical Pareto distribution it is ``mu``, where the standard
+    Pareto distribution has location ``mu = 1``.  Lomax can also
+    be considered as a simplified version of the Generalized
+    Pareto distribution (available in SciPy), with the scale set
+    to one and the location set to zero.
+
+    The Pareto distribution must be greater than zero, and is
+    unbounded above.  It is also known as the "80-20 rule".  In
+    this distribution, 80 percent of the weights are in the lowest
+    20 percent of the range, while the other 20 percent fill the
+    remaining 80 percent of the range.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Shape of the distribution. Should be greater than zero.
+    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 Pareto distribution.
+
+    See Also
+    --------
+    scipy.stats.lomax : probability density function, distribution or
+        cumulative density function, etc.
+    scipy.stats.genpareto : probability density function, distribution or
+        cumulative density function, etc.
+
+    Notes
+    -----
+    The probability density for the Pareto distribution is
+
+    .. math:: p(x) = \frac{am^a}{x^{a+1}}
+
+    where :math:`a` is the shape and :math:`m` the scale.
+
+    The Pareto distribution, named after the Italian economist
+    Vilfredo Pareto, is a power law probability distribution
+    useful in many real world problems.  Outside the field of
+    economics it is generally referred to as the Bradford
+    distribution. Pareto developed the distribution to describe
+    the distribution of wealth in an economy.  It has also found
+    use in insurance, web page access statistics, oil field sizes,
+    and many other problems, including the download frequency for
+    projects in Sourceforge [1]_.  It is one of the so-called
+    "fat-tailed" distributions.
+
+
+    References
+    ----------
+    .. [1] Francis Hunt and Paul Johnson, On the Pareto Distribution of
+           Sourceforge projects.
+    .. [2] Pareto, V. (1896). Course of Political Economy. Lausanne.
+    .. [3] Reiss, R.D., Thomas, M.(2001), Statistical Analysis of Extreme
+           Values, Birkhauser Verlag, Basel, pp 23-30.
+    .. [4] Wikipedia, "Pareto distribution",
+           http://en.wikipedia.org/wiki/Pareto_distribution
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> a, m = 3., 2.  # shape and mode
+    >>> s = (mt.random.pareto(a, 1000) + 1) * m
+
+    Display the histogram of the samples, along with the probability
+    density function:
+
+    >>> import matplotlib.pyplot as plt
+    >>> count, bins, _ = plt.hist(s.execute(), 100, normed=True)
+    >>> fit = a*m**a / bins**(a+1)
+    >>> plt.plot(bins, max(count)*fit/max(fit), linewidth=2, color='r')
+    >>> plt.show()
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().pareto(handle_array(a), size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorPareto(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(a, chunk_size=chunk_size)

maxframe/tensor/random/permutation.py

@@ -0,0 +1,107 @@
+# 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 numbers import Integral
+from typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import Int32Field, KeyField
+from ..datasource import tensor as astensor
+from ..operators import TensorOperatorMixin
+from ..utils import gen_random_seeds, validate_axis
+from .core import TensorRandomMapReduceOperator
+
+
+def _permutation_on_axis(ar, axis, rs, xp):
+    try:
+        return rs.permutation(ar, axis=axis)
+    except TypeError:
+        # numpy starts to support axis from 1.18
+        if axis == 0:
+            return rs.permutation(ar)
+        indices = xp.arange(ar.shape[axis])
+        rs.shuffle(indices)
+        slc = (slice(None),) * axis + (indices,)
+        return ar[slc]
+
+
+class TensorPermutation(TensorRandomMapReduceOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.PERMUTATION
+
+    input = KeyField("input")
+    axis = Int32Field("axis")
+
+    reduce_size = Int32Field("reduce_size")
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorPermutation", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.input = op._inputs[0]
+
+    def __call__(self, x):
+        return self.new_tensor([x], x.shape, order=x.order)
+
+
+def permutation(random_state, x, axis=0, chunk_size=None):
+    r"""
+    Randomly permute a sequence, or return a permuted range.
+
+    Parameters
+    ----------
+    x : int or array_like
+        If `x` is an integer, randomly permute ``mt.arange(x)``.
+        If `x` is an array, make a copy and shuffle the elements
+        randomly.
+    axis : int, optional
+        The axis which `x` is shuffled along. Default is 0.
+    chunk_size : : int or tuple of int or tuple of ints, optional
+        Desired chunk size on each dimension
+    Returns
+    -------
+    out : Tensor
+        Permuted sequence or tensor range.
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> rng = mt.random.RandomState()
+    >>> rng.permutation(10).execute()
+    array([1, 2, 3, 7, 9, 8, 0, 6, 4, 5]) # random
+    >>> rng.permutation([1, 4, 9, 12, 15]).execute()
+    array([ 9,  4, 12,  1, 15]) # random
+    >>> arr = mt.arange(9).reshape((3, 3))
+    >>> rng.permutation(arr).execute()
+    array([[3, 4, 5], # random
+           [6, 7, 8],
+           [0, 1, 2]])
+    >>> rng.permutation("abc")
+    Traceback (most recent call last):
+        ...
+    numpy.AxisError: x must be an integer or at least 1-dimensional
+    """
+    if isinstance(x, (Integral, np.integer)):
+        from ..datasource import arange
+
+        x = arange(x, chunk_size=chunk_size)
+    else:
+        x = astensor(x, chunk_size=chunk_size)
+        if x.ndim < 1:
+            raise np.AxisError("x must be an integer or at least 1-dimensional")
+
+    axis = validate_axis(x.ndim, axis)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorPermutation(seed=seed, axis=axis, dtype=x.dtype, gpu=x.op.gpu)
+    return op(x)

maxframe/tensor/random/poisson.py

@@ -0,0 +1,109 @@
+# 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 AnyField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin, handle_array
+
+
+class TensorPoisson(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["lam"]
+    _op_type_ = opcodes.RAND_POSSION
+
+    _fields_ = "lam", "size"
+    lam = AnyField("lam")
+    _func_name = "poisson"
+
+    def __call__(self, lam, chunk_size=None):
+        return self.new_tensor([lam], None, raw_chunk_size=chunk_size)
+
+
+def poisson(random_state, lam=1.0, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a Poisson distribution.
+
+    The Poisson distribution is the limit of the binomial distribution
+    for large N.
+
+    Parameters
+    ----------
+    lam : float or array_like of floats
+        Expectation of interval, should be >= 0. A sequence of expectation
+        intervals must be broadcastable over the requested size.
+    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 ``lam`` is a scalar. Otherwise,
+        ``mt.array(lam).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 Poisson distribution.
+
+    Notes
+    -----
+    The Poisson distribution
+
+    .. math:: f(k; \lambda)=\frac{\lambda^k e^{-\lambda}}{k!}
+
+    For events with an expected separation :math:`\lambda` the Poisson
+    distribution :math:`f(k; \lambda)` describes the probability of
+    :math:`k` events occurring within the observed
+    interval :math:`\lambda`.
+
+    Because the output is limited to the range of the C long type, a
+    ValueError is raised when `lam` is within 10 sigma of the maximum
+    representable value.
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. "Poisson Distribution."
+           From MathWorld--A Wolfram Web Resource.
+           http://mathworld.wolfram.com/PoissonDistribution.html
+    .. [2] Wikipedia, "Poisson distribution",
+           http://en.wikipedia.org/wiki/Poisson_distribution
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+    >>> s = mt.random.poisson(5, 10000)
+
+    Display histogram of the sample:
+
+    >>> import matplotlib.pyplot as plt
+    >>> count, bins, ignored = plt.hist(s.execute(), 14, normed=True)
+    >>> plt.show()
+
+    Draw each 100 values for lambda 100 and 500:
+
+    >>> s = mt.random.poisson(lam=(100., 500.), size=(100, 2))
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().poisson(handle_array(lam), size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorPoisson(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(lam, chunk_size=chunk_size)

maxframe/tensor/random/power.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.
+
+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 TensorRandomPower(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["a"]
+    _op_type_ = opcodes.RAND_POWER
+
+    _fields_ = "a", "size"
+    a = AnyField("a")
+    _func_name = "power"
+
+    def __call__(self, a, chunk_size=None):
+        return self.new_tensor([a], None, raw_chunk_size=chunk_size)
+
+
+def power(random_state, a, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draws samples in [0, 1] from a power distribution with positive
+    exponent a - 1.
+
+    Also known as the power function distribution.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Parameter of the distribution. Should be greater than zero.
+    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 power distribution.
+
+    Raises
+    ------
+    ValueError
+        If a < 1.
+
+    Notes
+    -----
+    The probability density function is
+
+    .. math:: P(x; a) = ax^{a-1}, 0 \le x \le 1, a>0.
+
+    The power function distribution is just the inverse of the Pareto
+    distribution. It may also be seen as a special case of the Beta
+    distribution.
+
+    It is used, for example, in modeling the over-reporting of insurance
+    claims.
+
+    References
+    ----------
+    .. [1] Christian Kleiber, Samuel Kotz, "Statistical size distributions
+           in economics and actuarial sciences", Wiley, 2003.
+    .. [2] Heckert, N. A. and Filliben, James J. "NIST Handbook 148:
+           Dataplot Reference Manual, Volume 2: Let Subcommands and Library
+           Functions", National Institute of Standards and Technology
+           Handbook Series, June 2003.
+           http://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/powpdf.pdf
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> a = 5. # shape
+    >>> samples = 1000
+    >>> s = mt.random.power(a, samples)
+
+    Display the histogram of the samples, along with
+    the probability density function:
+
+    >>> import matplotlib.pyplot as plt
+    >>> count, bins, ignored = plt.hist(s.execute(), bins=30)
+    >>> x = mt.linspace(0, 1, 100)
+    >>> y = a*x**(a-1.)
+    >>> normed_y = samples*mt.diff(bins)[0]*y
+    >>> plt.plot(x.execute(), normed_y.execute())
+    >>> plt.show()
+
+    Compare the power function distribution to the inverse of the Pareto.
+
+    >>> from scipy import stats
+    >>> rvs = mt.random.power(5, 1000000)
+    >>> rvsp = mt.random.pareto(5, 1000000)
+    >>> xx = mt.linspace(0,1,100)
+    >>> powpdf = stats.powerlaw.pdf(xx.execute(),5)
+
+    >>> plt.figure()
+    >>> plt.hist(rvs.execute(), bins=50, normed=True)
+    >>> plt.plot(xx.execute(),powpdf,'r-')
+    >>> plt.title('np.random.power(5)')
+
+    >>> plt.figure()
+    >>> plt.hist((1./(1.+rvsp)).execute(), bins=50, normed=True)
+    >>> plt.plot(xx.execute(),powpdf,'r-')
+    >>> plt.title('inverse of 1 + np.random.pareto(5)')
+
+    >>> plt.figure()
+    >>> plt.hist((1./(1.+rvsp)).execute(), bins=50, normed=True)
+    >>> plt.plot(xx.execute(),powpdf,'r-')
+    >>> plt.title('inverse of stats.pareto(5)')
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().power(handle_array(a), size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRandomPower(size=size, seed=seed, gpu=gpu, dtype=dtype)
+    return op(a, chunk_size=chunk_size)