maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/tensor/random/core.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
+from contextlib import contextmanager
+from typing import List
+
+import numpy as np
+
+from ...core import EntityData
+from ...serialization.serializables import FieldTypes, Int32Field, TupleField
+from ...utils import on_deserialize_shape, on_serialize_shape
+from ..core import TENSOR_TYPE
+from ..datasource import tensor as astensor
+from ..misc import broadcast_to
+from ..operators import TensorMapReduceOperator, TensorOperator, TensorOperatorMixin
+from ..utils import broadcast_shape
+
+
+class RandomState:
+    def __init__(self, seed=None):
+        self._random_state = np.random.RandomState(seed=seed)
+
+    def seed(self, seed=None):
+        """
+        Seed the generator.
+
+        This method is called when `RandomState` is initialized. It can be
+        called again to re-seed the generator. For details, see `RandomState`.
+
+        Parameters
+        ----------
+        seed : int or 1-d array_like, optional
+            Seed for `RandomState`.
+            Must be convertible to 32 bit unsigned integers.
+
+        See Also
+        --------
+        RandomState
+        """
+        self._random_state.seed(seed=seed)
+
+    def to_numpy(self):
+        return self._random_state
+
+    @classmethod
+    def from_numpy(cls, np_random_state):
+        state = RandomState()
+        state._random_state = np_random_state
+        return state
+
+    @classmethod
+    def _handle_size(cls, size):
+        if size is None:
+            return size
+        try:
+            return tuple(int(s) for s in size)
+        except TypeError:
+            return (size,)
+
+
+_random_state = RandomState()
+
+
+def handle_array(arg):
+    if not isinstance(arg, TENSOR_TYPE):
+        if not isinstance(arg, Iterable):
+            return arg
+
+        arg = np.asarray(arg)
+        return arg[(0,) * max(1, arg.ndim)]
+    elif hasattr(arg, "op") and hasattr(arg.op, "data"):
+        return arg.op.data[(0,) * max(1, arg.ndim)]
+
+    return np.empty((0,), dtype=arg.dtype)
+
+
+class TensorRandomOperatorMixin(TensorOperatorMixin):
+    __slots__ = ()
+
+    def _calc_shape(self, shapes):
+        shapes = list(shapes)
+        if getattr(self, "size", None) is not None:
+            shapes.append(getattr(self, "size"))
+        return broadcast_shape(*shapes)
+
+    @classmethod
+    def _handle_arg(cls, arg, chunk_size):
+        if isinstance(arg, (list, np.ndarray)):
+            arg = astensor(arg, chunk_size=chunk_size)
+
+        return arg
+
+    @contextmanager
+    def _get_inputs_shape_by_given_fields(
+        self, inputs, shape, raw_chunk_size=None, tensor=True
+    ):
+        fields = getattr(self, "_input_fields_", [])
+        to_one_chunk_fields = set(getattr(self, "_into_one_chunk_fields_", list()))
+
+        field_to_obj = dict()
+        to_broadcast_shapes = []
+        if fields:
+            if getattr(self, fields[0], None) is None:
+                # create from beginning
+                for field, val in zip(fields, inputs):
+                    if field not in to_one_chunk_fields:
+                        if isinstance(val, list):
+                            val = np.asarray(val)
+                        if tensor:
+                            val = self._handle_arg(val, raw_chunk_size)
+                    if isinstance(val, TENSOR_TYPE):
+                        field_to_obj[field] = val
+                        if field not in to_one_chunk_fields:
+                            to_broadcast_shapes.append(val.shape)
+                    setattr(self, field, val)
+            else:
+                inputs_iter = iter(inputs)
+                for field in fields:
+                    if isinstance(getattr(self, field), TENSOR_TYPE):
+                        field_to_obj[field] = next(inputs_iter)
+
+        if tensor:
+            if shape is None:
+                shape = self._calc_shape(to_broadcast_shapes)
+
+            for field, inp in field_to_obj.items():
+                if field not in to_one_chunk_fields:
+                    field_to_obj[field] = broadcast_to(inp, shape)
+
+        yield [field_to_obj[f] for f in fields if f in field_to_obj], shape
+
+        inputs_iter = iter(getattr(self, "_inputs"))
+        for field in fields:
+            if field in field_to_obj:
+                setattr(self, field, next(inputs_iter))
+
+    @classmethod
+    def _get_shape(cls, kws, kw):
+        if kw.get("shape") is not None:
+            return kw.get("shape")
+        elif kws is not None and len(kws) > 0:
+            return kws[0].get("shape")
+
+    def _new_tileables(self, inputs, kws=None, **kw):
+        raw_chunk_size = kw.get("chunk_size", None)
+        shape = self._get_shape(kws, kw)
+        with self._get_inputs_shape_by_given_fields(
+            inputs, shape, raw_chunk_size, True
+        ) as (inputs, shape):
+            kw["shape"] = shape
+            return super()._new_tileables(inputs, kws=kws, **kw)
+
+
+def _on_serialize_random_state(rs):
+    return rs.get_state() if rs is not None else None
+
+
+def _on_deserialize_random_state(tup):
+    if tup is None:
+        return None
+
+    rs = np.random.RandomState()
+    rs.set_state(tup)
+    return rs
+
+
+def RandomStateField(name, **kwargs):
+    kwargs.update(
+        dict(
+            on_serialize=_on_serialize_random_state,
+            on_deserialize=_on_deserialize_random_state,
+        )
+    )
+    return TupleField(name, **kwargs)
+
+
+class TensorSeedOperatorMixin:
+    @property
+    def seed(self):
+        return getattr(self, "seed", None)
+
+    @property
+    def args(self):
+        if hasattr(self, "_fields_"):
+            return self._fields_
+        else:
+            return [
+                field
+                for field in self._FIELDS
+                if field not in TensorRandomOperator._FIELDS
+            ]
+
+    @classmethod
+    def _set_inputs(cls, op: "TensorRandomOperator", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        fields = getattr(cls, "_input_fields_", [])
+        for field, inp in zip(fields, inputs):
+            setattr(op, field, inp)
+
+
+class TensorRandomOperator(TensorSeedOperatorMixin, TensorOperator):
+    seed = Int32Field("seed", default=None)
+
+    def __init__(self, dtype=None, **kw):
+        dtype = np.dtype(dtype) if dtype is not None else dtype
+        if "state" in kw:
+            kw["_state"] = kw.pop("state")
+        super().__init__(dtype=dtype, **kw)
+
+
+class TensorRandomMapReduceOperator(TensorSeedOperatorMixin, TensorMapReduceOperator):
+    seed = Int32Field("seed", default=None)
+
+    def __init__(self, dtype=None, **kw):
+        dtype = np.dtype(dtype) if dtype is not None else dtype
+        if "state" in kw:
+            kw["_state"] = kw.pop("state")
+        super().__init__(dtype=dtype, **kw)
+
+
+class TensorDistribution(TensorRandomOperator):
+    size = TupleField("size", FieldTypes.int64)
+
+
+class TensorSimpleRandomData(TensorRandomOperator):
+    size = TupleField(
+        "size",
+        FieldTypes.int64,
+        default=None,
+        on_serialize=on_serialize_shape,
+        on_deserialize=on_deserialize_shape,
+    )
+
+    def __init__(self, size=None, **kw):
+        if type(size) is int:
+            size = (size,)
+        super().__init__(size=size, **kw)

maxframe/tensor/random/dirichlet.py

@@ -0,0 +1,121 @@
+# 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 TupleField
+from ..utils import gen_random_seeds
+from .core import TensorDistribution, TensorRandomOperatorMixin
+
+
+class TensorDirichlet(TensorDistribution, TensorRandomOperatorMixin):
+    _op_type_ = opcodes.RAND_DIRICHLET
+
+    _fields_ = "alpha", "size"
+    alpha = TupleField("alpha", default=None)
+    _func_name = "dirichlet"
+
+    def _calc_shape(self, shapes):
+        shape = super()._calc_shape(shapes)
+        return shape + (len(self.alpha),)
+
+    def __call__(self, chunk_size=None):
+        return self.new_tensor(None, None, raw_chunk_size=chunk_size)
+
+
+def dirichlet(random_state, alpha, size=None, chunk_size=None, gpu=None, dtype=None):
+    r"""
+    Draw samples from the Dirichlet distribution.
+
+    Draw `size` samples of dimension k from a Dirichlet distribution. A
+    Dirichlet-distributed random variable can be seen as a multivariate
+    generalization of a Beta distribution. Dirichlet pdf is the conjugate
+    prior of a multinomial in Bayesian inference.
+
+    Parameters
+    ----------
+    alpha : array
+        Parameter of the distribution (k dimension for sample of
+        dimension k).
+    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.
+    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
+    -------
+    samples : Tensor
+        The drawn samples, of shape (size, alpha.ndim).
+
+    Raises
+    -------
+    ValueError
+        If any value in alpha is less than or equal to zero
+
+    Notes
+    -----
+    .. math:: X \approx \prod_{i=1}^{k}{x^{\alpha_i-1}_i}
+
+    Uses the following property for computation: for each dimension,
+    draw a random sample y_i from a standard gamma generator of shape
+    `alpha_i`, then
+    :math:`X = \frac{1}{\sum_{i=1}^k{y_i}} (y_1, \ldots, y_n)` is
+    Dirichlet distributed.
+
+    References
+    ----------
+    .. [1] David McKay, "Information Theory, Inference and Learning
+           Algorithms," chapter 23,
+           http://www.inference.phy.cam.ac.uk/mackay/
+    .. [2] Wikipedia, "Dirichlet distribution",
+           http://en.wikipedia.org/wiki/Dirichlet_distribution
+
+    Examples
+    --------
+    Taking an example cited in Wikipedia, this distribution can be used if
+    one wanted to cut strings (each of initial length 1.0) into K pieces
+    with different lengths, where each piece had, on average, a designated
+    average length, but allowing some variation in the relative sizes of
+    the pieces.
+
+    >>> import maxframe.tensor as mt
+
+    >>> s = mt.random.dirichlet((10, 5, 3), 20).transpose()
+
+    >>> import matplotlib.pyplot as plt
+
+    >>> plt.barh(range(20), s[0].execute())
+    >>> plt.barh(range(20), s[1].execute(), left=s[0].execute(), color='g')
+    >>> plt.barh(range(20), s[2].execute(), left=(s[0]+s[1]).execute(), color='r')
+    >>> plt.title("Lengths of Strings")
+    """
+    if isinstance(alpha, Iterable):
+        alpha = tuple(alpha)
+    else:
+        raise TypeError("`alpha` should be an array")
+    if dtype is None:
+        dtype = np.random.RandomState().dirichlet(alpha, size=(0,)).dtype
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorDirichlet(seed=seed, alpha=alpha, size=size, gpu=gpu, dtype=dtype)
+    return op(chunk_size=chunk_size)

maxframe/tensor/random/exponential.py

@@ -0,0 +1,92 @@
+# 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 TensorExponential(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["scale"]
+    _op_type_ = opcodes.RAND_EXPONENTIAL
+
+    _fields_ = "scale", "size"
+    scale = AnyField("scale")
+    _func_name = "exponential"
+
+    def __call__(self, scale, chunk_size=None):
+        return self.new_tensor([scale], self.size, raw_chunk_size=chunk_size)
+
+
+def exponential(
+    random_state, scale=1.0, size=None, chunk_size=None, gpu=None, dtype=None
+):
+    r"""
+    Draw samples from an exponential distribution.
+
+    Its probability density function is
+
+    .. math:: f(x; \frac{1}{\beta}) = \frac{1}{\beta} \exp(-\frac{x}{\beta}),
+
+    for ``x > 0`` and 0 elsewhere. :math:`\beta` is the scale parameter,
+    which is the inverse of the rate parameter :math:`\lambda = 1/\beta`.
+    The rate parameter is an alternative, widely used parameterization
+    of the exponential distribution [3]_.
+
+    The exponential distribution is a continuous analogue of the
+    geometric distribution.  It describes many common situations, such as
+    the size of raindrops measured over many rainstorms [1]_, or the time
+    between page requests to Wikipedia [2]_.
+
+    Parameters
+    ----------
+    scale : float or array_like of floats
+        The scale parameter, :math:`\beta = 1/\lambda`.
+    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 ``scale`` is a scalar.  Otherwise,
+        ``np.array(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 exponential distribution.
+
+    References
+    ----------
+    .. [1] Peyton Z. Peebles Jr., "Probability, Random Variables and
+           Random Signal Principles", 4th ed, 2001, p. 57.
+    .. [2] Wikipedia, "Poisson process",
+           http://en.wikipedia.org/wiki/Poisson_process
+    .. [3] Wikipedia, "Exponential distribution",
+           http://en.wikipedia.org/wiki/Exponential_distribution
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState().exponential(handle_array(scale), size=(0,)).dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorExponential(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(scale, chunk_size=chunk_size)

maxframe/tensor/random/f.py

@@ -0,0 +1,133 @@
+# 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 TensorFDist(TensorDistribution, TensorRandomOperatorMixin):
+    _input_fields_ = ["dfnum", "dfden"]
+    _op_type_ = opcodes.RAND_F
+
+    _fields_ = "dfnum", "dfden", "size"
+    dfnum = AnyField("dfnum")
+    dfden = AnyField("dfden")
+    _func_name = "f"
+
+    def __call__(self, dfnum, dfden, chunk_size=None):
+        return self.new_tensor([dfnum, dfden], None, raw_chunk_size=chunk_size)
+
+
+def f(random_state, dfnum, dfden, size=None, chunk_size=None, gpu=None, dtype=None):
+    """
+    Draw samples from an F distribution.
+
+    Samples are drawn from an F distribution with specified parameters,
+    `dfnum` (degrees of freedom in numerator) and `dfden` (degrees of
+    freedom in denominator), where both parameters should be greater than
+    zero.
+
+    The random variate of the F distribution (also known as the
+    Fisher distribution) is a continuous probability distribution
+    that arises in ANOVA tests, and is the ratio of two chi-square
+    variates.
+
+    Parameters
+    ----------
+    dfnum : float or array_like of floats
+        Degrees of freedom in numerator, should be > 0.
+    dfden : float or array_like of float
+        Degrees of freedom in denominator, 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 ``dfnum`` and ``dfden`` are both scalars.
+        Otherwise, ``np.broadcast(dfnum, dfden).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 Fisher distribution.
+
+    See Also
+    --------
+    scipy.stats.f : probability density function, distribution or
+        cumulative density function, etc.
+
+    Notes
+    -----
+    The F statistic is used to compare in-group variances to between-group
+    variances. Calculating the distribution depends on the sampling, and
+    so it is a function of the respective degrees of freedom in the
+    problem.  The variable `dfnum` is the number of samples minus one, the
+    between-groups degrees of freedom, while `dfden` is the within-groups
+    degrees of freedom, the sum of the number of samples in each group
+    minus the number of groups.
+
+    References
+    ----------
+    .. [1] Glantz, Stanton A. "Primer of Biostatistics.", McGraw-Hill,
+           Fifth Edition, 2002.
+    .. [2] Wikipedia, "F-distribution",
+           http://en.wikipedia.org/wiki/F-distribution
+
+    Examples
+    --------
+    An example from Glantz[1], pp 47-40:
+
+    Two groups, children of diabetics (25 people) and children from people
+    without diabetes (25 controls). Fasting blood glucose was measured,
+    case group had a mean value of 86.1, controls had a mean value of
+    82.2. Standard deviations were 2.09 and 2.49 respectively. Are these
+    data consistent with the null hypothesis that the parents diabetic
+    status does not affect their children's blood glucose levels?
+    Calculating the F statistic from the data gives a value of 36.01.
+
+    Draw samples from the distribution:
+
+    >>> import maxframe.tensor as mt
+
+    >>> dfnum = 1. # between group degrees of freedom
+    >>> dfden = 48. # within groups degrees of freedom
+    >>> s = mt.random.f(dfnum, dfden, 1000).execute()
+
+    The lower bound for the top 1% of the samples is :
+
+    >>> sorted(s)[-10]
+    7.61988120985
+
+    So there is about a 1% chance that the F statistic will exceed 7.62,
+    the measured value is 36, so the null hypothesis is rejected at the 1%
+    level.
+    """
+    if dtype is None:
+        dtype = (
+            np.random.RandomState()
+            .f(handle_array(dfnum), handle_array(dfden), size=(0,))
+            .dtype
+        )
+    size = random_state._handle_size(size)
+    seed = gen_random_seeds(1, random_state.to_numpy())[0]
+    op = TensorFDist(seed=seed, size=size, gpu=gpu, dtype=dtype)
+    return op(dfnum, dfden, chunk_size=chunk_size)