maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/random/beta.py

@@ -0,0 +1,87 @@
+# 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 TensorRandBeta(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["a", "b"]
+    _op_type_ = opcodes.RAND_BETA
+
+    _fields_ = "a", "b", "size"
+    a = AnyField("a")
+    b = AnyField("b")
+    _func_name = "beta"
+
+    def __call__(self, a, b, chunk_size=None):
+        return self.new_tensor([a, b], None, raw_chunk_size=chunk_size)
+
+
+def beta(random_state, a, b, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a Beta distribution.
+
+    The Beta distribution is a special case of the Dirichlet distribution,
+    and is related to the Gamma distribution.  It has the probability
+    distribution function
+
+    .. math:: f(x; a,b) = \frac{1}{B(\alpha, \beta)} x^{\alpha - 1}
+                                                     (1 - x)^{\beta - 1},
+
+    where the normalisation, B, is the beta function,
+
+    .. math:: B(\alpha, \beta) = \int_0^1 t^{\alpha - 1}
+                                 (1 - t)^{\beta - 1} dt.
+
+    It is often seen in Bayesian inference and order statistics.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Alpha, non-negative.
+    b : float or array_like of floats
+        Beta, non-negative.
+    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`` and ``b`` are both scalars.
+        Otherwise, ``mt.broadcast(a, b).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 beta distribution.
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .beta(handle_array(a), handle_array(b), size=(0,))
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorRandBeta(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(a, b, chunk_size=chunk_size)

maxframe/tensor/random/binomial.py

@@ -0,0 +1,135 @@
+# 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 TensorBinomial(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["n", "p"]
+    _op_type_ = opcodes.RAND_BINOMIAL
+
+    _fields_ = "n", "p", "size"
+    n = AnyField("n")
+    p = AnyField("p")
+    _func_name = "binomial"
+
+    def __call__(self, n, p, chunk_size=None):
+        return self.new_tensor([n, p], None, raw_chunk_size=chunk_size)
+
+
+def binomial(random_state, n, p, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a binomial distribution.
+
+    Samples are drawn from a binomial distribution with specified
+    parameters, n trials and p probability of success where
+    n an integer >= 0 and p is in the interval [0,1]. (n may be
+    input as a float, but it is truncated to an integer in use)
+
+    Parameters
+    ----------
+    n : int or array_like of ints
+        Parameter of the distribution, >= 0. Floats are also accepted,
+        but they will be truncated to integers.
+    p : float or array_like of floats
+        Parameter of the distribution, >= 0 and <=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 ``n`` and ``p`` are both scalars.
+        Otherwise, ``mt.broadcast(n, p).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 binomial distribution, where
+        each sample is equal to the number of successes over the n trials.
+
+    See Also
+    --------
+    scipy.stats.binom : probability density function, distribution or
+        cumulative density function, etc.
+
+    Notes
+    -----
+    The probability density for the binomial distribution is
+
+    .. math:: P(N) = \binom{n}{N}p^N(1-p)^{n-N},
+
+    where :math:`n` is the number of trials, :math:`p` is the probability
+    of success, and :math:`N` is the number of successes.
+
+    When estimating the standard error of a proportion in a population by
+    using a random sample, the normal distribution works well unless the
+    product p*n <=5, where p = population proportion estimate, and n =
+    number of samples, in which case the binomial distribution is used
+    instead. For example, a sample of 15 people shows 4 who are left
+    handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,
+    so the binomial distribution should be used in this case.
+
+    References
+    ----------
+    .. [1] Dalgaard, Peter, "Introductory Statistics with R",
+           Springer-Verlag, 2002.
+    .. [2] Glantz, Stanton A. "Primer of Biostatistics.", McGraw-Hill,
+           Fifth Edition, 2002.
+    .. [3] Lentner, Marvin, "Elementary Applied Statistics", Bogden
+           and Quigley, 1972.
+    .. [4] Weisstein, Eric W. "Binomial Distribution." From MathWorld--A
+           Wolfram Web Resource.
+           http://mathworld.wolfram.com/BinomialDistribution.html
+    .. [5] Wikipedia, "Binomial distribution",
+           http://en.wikipedia.org/wiki/Binomial_distribution
+
+    Examples
+    --------
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> n, p = 10, .5  # number of trials, probability of each trial
+    >>> s = mt.random.binomial(n, p, 1000).execute()
+    # result of flipping a coin 10 times, tested 1000 times.
+
+    A real world example. A company drills 9 wild-cat oil exploration
+    wells, each with an estimated probability of success of 0.1. All nine
+    wells fail. What is the probability of that happening?
+
+    Let's do 20,000 trials of the model, and count the number that
+    generate zero positive results.
+
+    >>> (mt.sum(mt.random.binomial(9, 0.1, 20000) == 0)/20000.).execute()
+    # answer = 0.38885, or 38%.
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .binomial(handle_array(n), handle_array(p), size=(0,))
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorBinomial(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(n, p, chunk_size=chunk_size)

maxframe/tensor/random/bytes.py

@@ -0,0 +1,37 @@
+# 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.
+
+
+def bytes(random_state, length):
+    """
+    Return random bytes.
+
+    Parameters
+    ----------
+    length : int
+        Number of random bytes.
+
+    Returns
+    -------
+    out : str
+        String of length `length`.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.bytes(10)
+    ' eh\x85\x022SZ\xbf\xa4' #random
+    """
+    return random_state._random_state.bytes(length)

maxframe/tensor/random/chisquare.py

@@ -0,0 +1,108 @@
+# 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 TensorChisquareDist(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["df"]
+    _op_type_ = opcodes.RAND_CHISQUARE
+
+    _fields_ = "df", "size"
+    df = AnyField("df")
+    _func_name = "chisquare"
+
+    def __call__(self, df, chunk_size=None):
+        return self.new_tensor([df], self.size, raw_chunk_size=chunk_size)
+
+
+def chisquare(random_state, df, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from a chi-square distribution.
+
+    When `df` independent random variables, each with standard normal
+    distributions (mean 0, variance 1), are squared and summed, the
+    resulting distribution is chi-square (see Notes).  This distribution
+    is often used in hypothesis testing.
+
+    Parameters
+    ----------
+    df : float or array_like of floats
+         Number of degrees of freedom, should be > 0.
+    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 ``df`` is a scalar.  Otherwise,
+        ``mt.array(df).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 chi-square distribution.
+
+    Raises
+    ------
+    ValueError
+        When `df` <= 0 or when an inappropriate `size` (e.g. ``size=-1``)
+        is given.
+
+    Notes
+    -----
+    The variable obtained by summing the squares of `df` independent,
+    standard normally distributed random variables:
+
+    .. math:: Q = \sum_{i=0}^{\mathtt{df}} X^2_i
+
+    is chi-square distributed, denoted
+
+    .. math:: Q \sim \chi^2_k.
+
+    The probability density function of the chi-squared distribution is
+
+    .. math:: p(x) = \frac{(1/2)^{k/2}}{\Gamma(k/2)}
+                     x^{k/2 - 1} e^{-x/2},
+
+    where :math:`\Gamma` is the gamma function,
+
+    .. math:: \Gamma(x) = \int_0^{-\infty} t^{x - 1} e^{-t} dt.
+
+    References
+    ----------
+    .. [1] NIST "Engineering Statistics Handbook"
+           http://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.chisquare(2,4).execute()
+    array([ 1.89920014,  9.00867716,  3.13710533,  5.62318272])
+    """
+    if dtype is None:
+        dtype = np.random.RandomState().chisquare(handle_array(df), size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorChisquareDist(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(df, chunk_size=chunk_size)

maxframe/tensor/random/choice.py

@@ -0,0 +1,187 @@
+# 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 (
+    AnyField,
+    BoolField,
+    FieldTypes,
+    KeyField,
+    TupleField,
+)
+from ..core import TENSOR_TYPE, TensorOrder
+from ..datasource import array
+from ..operators import TensorOperatorMixin
+from ..utils import gen_random_seeds
+from .core import TensorRandomOperator
+
+
+class TensorChoice(TensorRandomOperator, TensorOperatorMixin):
+    _op_type_ = opcodes.RAND_CHOICE
+
+    a = AnyField("a")
+    size = TupleField("size", FieldTypes.int64)
+    replace = BoolField("replace")
+    p = KeyField("p")
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorChoice", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if isinstance(op.a, TENSOR_TYPE):
+            op.a = op._inputs[0]
+        if isinstance(op.p, TENSOR_TYPE):
+            op.p = op._inputs[-1]
+
+    def __call__(self, a, p, chunk_size=None):
+        inputs = []
+        if isinstance(a, TENSOR_TYPE):
+            inputs.append(a)
+        if isinstance(p, TENSOR_TYPE):
+            inputs.append(p)
+        return self.new_tensor(
+            inputs,
+            shape=self.size,
+            raw_chunk_size=chunk_size,
+            order=TensorOrder.C_ORDER,
+        )
+
+
+def choice(random_state, a, size=None, replace=True, p=None, chunk_size=None, gpu=None):
+    """
+    Generates a random sample from a given 1-D array
+
+    Parameters
+    -----------
+    a : 1-D array-like or int
+        If a tensor, a random sample is generated from its elements.
+        If an int, the random sample is generated as if a were mt.arange(a)
+    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.  Default is None, in which case a
+        single value is returned.
+    replace : boolean, optional
+        Whether the sample is with or without replacement
+    p : 1-D array-like, optional
+        The probabilities associated with each entry in a.
+        If not given the sample assumes a uniform distribution over all
+        entries in a.
+    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
+
+    Returns
+    --------
+    samples : single item or tensor
+        The generated random samples
+
+    Raises
+    -------
+    ValueError
+        If a is an int and less than zero, if a or p are not 1-dimensional,
+        if a is an array-like of size 0, if p is not a vector of
+        probabilities, if a and p have different lengths, or if
+        replace=False and the sample size is greater than the population
+        size
+
+    See Also
+    ---------
+    randint, shuffle, permutation
+
+    Examples
+    ---------
+    Generate a uniform random sample from mt.arange(5) of size 3:
+
+    >>> import maxframe.tensor as mt
+
+    >>> mt.random.choice(5, 3).execute()
+    array([0, 3, 4])
+    >>> #This is equivalent to mt.random.randint(0,5,3)
+
+    Generate a non-uniform random sample from np.arange(5) of size 3:
+
+    >>> mt.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0]).execute()
+    array([3, 3, 0])
+
+    Generate a uniform random sample from mt.arange(5) of size 3 without
+    replacement:
+
+    >>> mt.random.choice(5, 3, replace=False).execute()
+    array([3,1,0])
+    >>> #This is equivalent to np.random.permutation(np.arange(5))[:3]
+
+    Generate a non-uniform random sample from mt.arange(5) of size
+    3 without replacement:
+
+    >>> mt.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0]).execute()
+    array([2, 3, 0])
+
+    Any of the above can be repeated with an arbitrary array-like
+    instead of just integers. For instance:
+
+    >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']
+    >>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])
+    array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'],
+          dtype='|S11')
+    """
+
+    if isinstance(a, Integral):
+        if a <= 0:
+            raise ValueError("a must be greater than 0")
+        a_size = a
+        dtype = np.random.choice(
+            1, size=(), p=np.array([1]) if p is not None else p
+        ).dtype
+    else:
+        a = array(a)
+        if a.ndim != 1:
+            raise ValueError("a must be one dimensional")
+        a_size = a.size
+        dtype = a.dtype
+
+    if p is not None:
+        if not isinstance(p, TENSOR_TYPE):
+            p = np.asarray(p)
+            if not np.isclose(p.sum(), 1, rtol=1e-7, atol=0):
+                raise ValueError("probabilities do not sum to 1")
+            p = array(p, chunk_size=p.size)
+        if p.ndim != 1:
+            raise ValueError("p must be one dimensional")
+
+    if size is None:
+        size = ()
+        length = 1
+    else:
+        try:
+            tuple(size)
+            length = np.prod(size)
+        except TypeError:
+            length = size
+    if replace is False and length > a_size:
+        raise ValueError(
+            "Cannot take a larger sample than population when 'replace=False'"
+        )
+
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorChoice(
+        a=a, p=p, seed=seed, replace=replace, size=size, dtype=dtype, gpu=gpu
+    )
+    return op(a, p, chunk_size=chunk_size)