[numpy] Add np.random.pareto and np.random.power

python/mxnet/ndarray/numpy/random.py

@@ -24,7 +24,7 @@
 
 
 __all__ = ['randint', 'uniform', 'normal', "choice", "rand", "multinomial", "multivariate_normal",
-           "shuffle", 'gamma', 'beta', 'exponential', 'lognormal', 'weibull']
+           "shuffle", 'gamma', 'beta', 'exponential', 'lognormal', 'weibull', 'pareto', 'power']
 
 
 def randint(low, high=None, size=None, dtype=None, ctx=None, out=None):
@@ -462,7 +462,7 @@ def exponential(scale, size):
         return _npi.exponential(scale=scale, size=size)
 
 
-def weibull(a, size):
+def weibull(a, size=None):
     r"""Draw samples from a 1-parameter Weibull distribution with given
     parameter a, via inversion.
 
@@ -515,6 +515,92 @@ def weibull(a, size):
         return _npi.weibull(a=a, size=size)
 
 
+def pareto(a, size=None):
+    r"""Draw samples from a Pareto II or Lomax distribution with specified shape a.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+            Shape of the distribution. Must 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 ``a`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        Drawn samples from the Pareto distribution.
+
+    Examples
+    --------
+    >>> np.random.pareto(a=5)
+    array(0.12749612)
+    >>> mx.numpy.random.pareto(a=5, size=[2,3])
+    array([[0.06933999, 0.0344373 , 0.10654891],
+            [0.0311172 , 0.12911797, 0.03370714]])
+    >>> np.random.pareto(a=np.array([2,3])
+    array([0.26636696, 0.15685666])
+
+    The probability density for the Pareto distribution is f(x) = \frac{am^a}{x^{a+1}}
+    where a is the shape and m the scale. Here m is assumed 1. The Pareto distribution
+    is a power law distribution. Pareto created it to describe the wealth in the economy.
+    """
+    from ...numpy import ndarray as np_ndarray
+    tensor_type_name = np_ndarray
+    if size == ():
+        size = None
+    is_tensor = isinstance(a, tensor_type_name)
+    if is_tensor:
+        return _npi.pareto(a, a=None, size=size)
+    else:
+        return _npi.pareto(a=a, size=size)
+
+
+def power(a, size=None):
+    r"""Draw samples in [0, 1] from a power distribution with given parameter a.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Shape of the distribution. Must 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 ``a`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        Drawn samples from the power distribution.
+
+    Examples
+    --------
+    >>> np.random.power(a=5)
+    array(0.8602478)
+    >>> np.random.power(a=5, size=[2,3])
+    array([[0.988391  , 0.5153122 , 0.9383134 ],
+           [0.9078098 , 0.87819266, 0.730635]])
+    >>> np.random.power(a=np.array([2,3])
+    array([0.7499419 , 0.88894516])
+
+    The probability density function is f(x; a) = ax^{a-1}, 0 \le x \le 1, a>0.
+    The power distribution is just the inverse of the Pareto distribution and
+    a special case of the Beta distribution.
+    """
+    from ...numpy import ndarray as np_ndarray
+    tensor_type_name = np_ndarray
+    if size == ():
+        size = None
+    is_tensor = isinstance(a, tensor_type_name)
+    if is_tensor:
+        return _npi.powerd(a, a=None, size=size)
+    else:
+        return _npi.powerd(a=a, size=size)
+
+
 def gamma(shape, scale=1.0, size=None, dtype=None, ctx=None, out=None):
     """Draw samples from a Gamma distribution.
 

python/mxnet/numpy/random.py

@@ -22,7 +22,7 @@
 
 
 __all__ = ["randint", "uniform", "normal", "choice", "rand", "multinomial", "multivariate_normal",
-           "shuffle", "randn", "gamma", 'beta', "exponential", "lognormal", "weibull"]
+           "shuffle", "randn", "gamma", 'beta', "exponential", "lognormal", "weibull", "pareto", "power"]
 
 
 def randint(low, high=None, size=None, dtype=None, ctx=None, out=None):
@@ -529,6 +529,76 @@ def weibull(a, size=None):
     return _mx_nd_np.random.weibull(a, size)
 
 
+def pareto(a, size=None):
+    r"""Draw samples from a Pareto II or Lomax distribution with specified shape a.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+            Shape of the distribution. Must 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 ``a`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        Drawn samples from the Pareto distribution.
+
+    Examples
+    --------
+    >>> np.random.pareto(a=5)
+    array(0.12749612)
+    >>> mx.numpy.random.pareto(a=5, size=[2,3])
+    array([[0.06933999, 0.0344373 , 0.10654891],
+            [0.0311172 , 0.12911797, 0.03370714]])
+    >>> np.random.pareto(a=np.array([2,3])
+    array([0.26636696, 0.15685666])
+
+    The probability density for the Pareto distribution is f(x) = \frac{am^a}{x^{a+1}}
+    where a is the shape and m the scale. Here m is assumed 1. The Pareto distribution
+    is a power law distribution. Pareto created it to describe the wealth in the economy.
+    """
+    return _mx_nd_np.random.pareto(a, size)
+
+
+def power(a, size=None):
+    r"""Draw samples in [0, 1] from a power distribution with given parameter a.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Shape of the distribution. Must 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 ``a`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        Drawn samples from the power distribution.
+
+    Examples
+    --------
+    >>> np.random.power(a=5)
+    array(0.8602478)
+    >>> np.random.power(a=5, size=[2,3])
+    array([[0.988391  , 0.5153122 , 0.9383134 ],
+           [0.9078098 , 0.87819266, 0.730635]])
+    >>> np.random.power(a=np.array([2,3])
+    array([0.7499419 , 0.88894516])
+
+    The probability density function is f(x; a) = ax^{a-1}, 0 \le x \le 1, a>0.
+    The power distribution is just the inverse of the Pareto distribution and
+    a special case of the Beta distribution.
+    """
+    return _mx_nd_np.random.power(a, size)
+
+
 def shuffle(x):
     """
     Modify a sequence in-place by shuffling its contents.

python/mxnet/symbol/numpy/random.py

@@ -23,7 +23,7 @@
 
 
 __all__ = ['randint', 'uniform', 'normal', 'multivariate_normal',
-           'rand', 'shuffle', 'gamma', 'beta', 'exponential', 'lognormal', 'weibull']
+           'rand', 'shuffle', 'gamma', 'beta', 'exponential', 'lognormal', 'weibull', 'pareto', 'power']
 
 
 def randint(low, high=None, size=None, dtype=None, ctx=None, out=None):
@@ -469,7 +469,7 @@ def exponential(scale=1.0, size=None):
         return _npi.exponential(scale=scale, size=size)
 
 
-def weibull(a, size):
+def weibull(a, size=None):
     r"""Draw samples from a 1-parameter Weibull distribution with given parameter a
     via inversion.
 
@@ -524,6 +524,92 @@ def weibull(a, size):
         return _npi.weibull(a=a, size=size)
 
 
+def pareto(a, size=None):
+    r"""Draw samples from a Pareto II or Lomax distribution with specified shape a.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+            Shape of the distribution. Must 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 ``a`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+
+    Returns
+    -------
+    out : _Symbol
+        Drawn samples from the Pareto distribution.
+
+    Examples
+    --------
+    >>> np.random.pareto(a=5)
+    array(0.12749612)
+    >>> mx.numpy.random.pareto(a=5, size=[2,3])
+    array([[0.06933999, 0.0344373 , 0.10654891],
+            [0.0311172 , 0.12911797, 0.03370714]])
+    >>> np.random.pareto(a=np.array([2,3])
+    array([0.26636696, 0.15685666])
+
+    The probability density for the Pareto distribution is f(x) = \frac{am^a}{x^{a+1}}
+    where a is the shape and m the scale. Here m is assumed 1. The Pareto distribution
+    is a power law distribution. Pareto created it to describe the wealth in the economy.
+    """
+    from ..numpy import _Symbol as np_symbol
+    tensor_type_name = np_symbol
+    if size == ():
+        size = None
+    is_tensor = isinstance(a, tensor_type_name)
+    if is_tensor:
+        return _npi.pareto(a, a=None, size=size)
+    else:
+        return _npi.pareto(a=a, size=size)
+
+
+def power(a, size=None):
+    r"""Draw samples in [0, 1] from a power distribution with given parameter a.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Shape of the distribution. Must 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 ``a`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+
+    Returns
+    -------
+    out : _Symbol
+        Drawn samples from the power distribution.
+
+    Examples
+    --------
+    >>> np.random.power(a=5)
+    array(0.8602478)
+    >>> np.random.power(a=5, size=[2,3])
+    array([[0.988391  , 0.5153122 , 0.9383134 ],
+           [0.9078098 , 0.87819266, 0.730635]])
+    >>> np.random.power(a=np.array([2,3])
+    array([0.7499419 , 0.88894516])
+
+    The probability density function is f(x; a) = ax^{a-1}, 0 \le x \le 1, a>0.
+    The power distribution is just the inverse of the Pareto distribution and
+    a special case of the Beta distribution.
+    """
+    from ..numpy import _Symbol as np_symbol
+    tensor_type_name = np_symbol
+    if size == ():
+        size = None
+    is_tensor = isinstance(a, tensor_type_name)
+    if is_tensor:
+        return _npi.powerd(a, a=None, size=size)
+    else:
+        return _npi.powerd(a=a, size=size)
+
+
 def multivariate_normal(mean, cov, size=None, check_valid=None, tol=None):
     """
     multivariate_normal(mean, cov, size=None, check_valid=None, tol=None)

src/operator/numpy/random/np_pareto_op.cc

@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+
+/*!
+ * Copyright (c) 2019 by Contributors
+ * \file np_pareto_op.cc
+ * \brief Operator for numpy sampling from Pareto distributions
+ */
+
+#include "./np_pareto_op.h"
+#include "./dist_common.h"
+
+namespace mxnet {
+namespace op {
+
+DMLC_REGISTER_PARAMETER(NumpyParetoParam);
+
+NNVM_REGISTER_OP(_npi_pareto)
+.set_num_inputs(
+  [](const nnvm::NodeAttrs& attrs) {
+    const NumpyParetoParam& param = nnvm::get<NumpyParetoParam>(attrs.parsed);
+    int num_inputs = 1;
+    if (param.a.has_value()) {
+      num_inputs -= 1;
+    }
+    return num_inputs;
+  })
+.set_num_outputs(1)
+.set_attr<nnvm::FListInputNames>("FListInputNames",
+  [](const NodeAttrs& attrs) {
+    const NumpyParetoParam& param = nnvm::get<NumpyParetoParam>(attrs.parsed);
+    int num_inputs = 1;
+    if (param.a.has_value()) {
+      num_inputs -= 1;
+    }
+    return (num_inputs == 0) ? std::vector<std::string>() : std::vector<std::string>{"input1"};
+  })
+.set_attr_parser(ParamParser<NumpyParetoParam>)
+.set_attr<mxnet::FInferShape>("FInferShape", UnaryDistOpShape<NumpyParetoParam>)
+.set_attr<nnvm::FInferType>("FInferType",
+  [](const nnvm::NodeAttrs &attrs, std::vector<int> *in_attrs,  std::vector<int> *out_attrs) {
+    (*out_attrs)[0] = mshadow::kFloat32;
+    return true;
+  })
+.set_attr<FResourceRequest>("FResourceRequest",
+  [](const nnvm::NodeAttrs& attrs) {
+      return std::vector<ResourceRequest>{
+        ResourceRequest::kRandom, ResourceRequest::kTempSpace};
+  })
+.set_attr<FCompute>("FCompute<cpu>", NumpyParetoForward<cpu>)
+.set_attr<nnvm::FGradient>("FGradient", MakeZeroGradNodes)
+.add_argument("input1", "NDArray-or-Symbol", "Source input")
+.add_arguments(NumpyParetoParam::__FIELDS__());
+
+}  // namespace op
+}  // namespace mxnet