maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/tensor/random/choice.py

@@ -0,0 +1,186 @@
+#!/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 numbers import Integral
+
+import numpy as np
+
+from ... import opcodes
+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")
+
+    def _set_inputs(self, inputs):
+        super()._set_inputs(inputs)
+        if isinstance(self.a, TENSOR_TYPE):
+            self.a = self._inputs[0]
+        if isinstance(self.p, TENSOR_TYPE):
+            self.p = self._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)

maxframe/tensor/random/core.py

@@ -0,0 +1,234 @@
+# 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 collections.abc import Iterable
+from contextlib import contextmanager
+
+import numpy as np
+
+from ...serialization.serializables import FieldTypes, Int32Field, TupleField
+from ..base import broadcast_to
+from ..core import TENSOR_TYPE
+from ..datasource import tensor as astensor
+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(object):
+    @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
+            ]
+
+
+class TensorRandomOperator(TensorSeedOperatorMixin, TensorOperator):
+    seed = Int32Field("seed")
+
+    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")
+
+    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)
+
+    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,123 @@
+#!/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 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,94 @@
+#!/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 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)