Add numpy random weibull operator (#17505)

python/mxnet/ndarray/numpy/random.py

@@ -24,7 +24,7 @@
 
 
 __all__ = ['randint', 'uniform', 'normal', "choice", "rand", "multinomial", "multivariate_normal",
-           "shuffle", 'gamma', 'beta', 'exponential', 'lognormal']
+           "shuffle", 'gamma', 'beta', 'exponential', 'lognormal', 'weibull']
 
 
 def randint(low, high=None, size=None, dtype=None, ctx=None, out=None):
@@ -462,6 +462,59 @@ def exponential(scale, size):
         return _npi.exponential(scale=scale, size=size)
 
 
+def weibull(a, size):
+    r"""Draw samples from a 1-parameter Weibull distribution with given
+    parameter a, via inversion.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Shape of the distribution. Must be 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`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+    Returns
+    -------
+    out : ndarray or scalar
+        Drawn samples from the 1-parameter Weibull distribution.
+    Examples
+    --------
+    >>> np.random.weibull(a=5)
+    array(0.9553641)
+
+    >>> np.random.weibull(a=5, size=[2,3])
+    array([[1.0466299 , 1.1320982 , 0.98415005],
+          [1.1430776 , 0.9532727 , 1.1344457 ]])
+
+    >>> np.random.weibull(a=np.array([2,3])
+    array([0.98843634, 1.0125613 ])
+
+    The Weibull distribution is one of a class of Generalized Extreme
+    Value (GEV) distributions. This class includes the Gumbel and Frechet
+    distributions.
+
+    The probability density for the Weibull distribution is
+    f(x) = \frac{a}{\lambda}(\frac{x}{\lambda})^{a-1}e^{-(x/\lambda)^a},
+    where a is the shape and \lambda the scale. The generated 1-parameter
+    Weibull sample has the scale parameter \lambda = 1.
+
+    The Weibull distribution is commonly used in reliability engineering to
+    model time to failure, in modeling particle sizes, in information retrieval
+    to model dwell time on pages, in quantitative finance to model risk etc.
+    """
+    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.weibull(a, a=None, size=size)
+    else:
+        return _npi.weibull(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"]
+           "shuffle", "randn", "gamma", 'beta', "exponential", "lognormal", "weibull"]
 
 
 def randint(low, high=None, size=None, dtype=None, ctx=None, out=None):
@@ -484,6 +484,51 @@ def exponential(scale=1.0, size=None):
     return _mx_nd_np.random.exponential(scale, size)
 
 
+def weibull(a, size=None):
+    r"""Draw samples from a 1-parameter Weibull distribution with given parameter a
+    via inversion.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Shape of the distribution. Must be 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`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+    Returns
+    -------
+    out : ndarray or scalar
+        Drawn samples from the 1-parameter Weibull distribution.
+    Examples
+    --------
+    >>> np.random.weibull(a=5)
+    array(0.9553641)
+
+    >>> np.random.weibull(a=5, size=[2,3])
+    array([[1.0466299 , 1.1320982 , 0.98415005],
+          [1.1430776 , 0.9532727 , 1.1344457 ]])
+
+    >>> np.random.weibull(a=np.array([2,3])
+    array([0.98843634, 1.0125613 ])
+
+    The Weibull distribution is one of a class of Generalized Extreme
+    Value (GEV) distributions. This class includes the Gumbel and Frechet
+    distributions.
+
+    The probability density for the Weibull distribution is
+    f(x) = \frac{a}{\lambda}(\frac{x}{\lambda})^{a-1}e^{-(x/\lambda)^a},
+    where a is the shape and \lambda the scale. The generated 1-parameter Weibull
+    sample has the scale parameter \lambda = 1.
+
+    The Weibull distribution is commonly used in reliability engineering to
+    model time to failure, in modeling particle sizes, in information retrieval
+    to model dwell time on pages, in quantitative finance to model risk etc.
+    """
+    return _mx_nd_np.random.weibull(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']
+           'rand', 'shuffle', 'gamma', 'beta', 'exponential', 'lognormal', 'weibull']
 
 
 def randint(low, high=None, size=None, dtype=None, ctx=None, out=None):
@@ -469,6 +469,61 @@ def exponential(scale=1.0, size=None):
         return _npi.exponential(scale=scale, size=size)
 
 
+def weibull(a, size):
+    r"""Draw samples from a 1-parameter Weibull distribution with given parameter a
+    via inversion.
+
+    Parameters
+    ----------
+    a : float or array_like of floats
+        Shape of the distribution. Must be 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`` is a scalar. Otherwise,
+        ``np.array(a).size`` samples are drawn.
+
+    Returns
+    -------
+    out : _Symbol
+        Drawn samples from the 1-parameter Weibull distribution.
+
+    Examples
+    --------
+    >>> np.random.weibull(a=5)
+    array(0.9553641)
+
+    >>> np.random.weibull(a=5, size=[2,3])
+    array([[1.0466299 , 1.1320982 , 0.98415005],
+          [1.1430776 , 0.9532727 , 1.1344457 ]])
+
+    >>> np.random.weibull(a=np.array([2,3])
+    array([0.98843634, 1.0125613 ])
+
+    The Weibull distribution is one of a class of Generalized Extreme
+    Value (GEV) distributions. This class includes the Gumbel and Frechet
+    distributions.
+
+    The probability density for the Weibull distribution is
+    f(x) = \frac{a}{\lambda}(\frac{x}{\lambda})^{a-1}e^{-(x/\lambda)^a},
+    where a is the shape and \lambda the scale. The generated 1-parameter Weibull
+    sample has the scale parameter \lambda = 1.
+
+    The Weibull distribution is commonly used in reliability engineering to
+    model time to failure, in modeling particle sizes, in information retrieval
+    to model dwell time on pages, in quantitative finance to model risk etc.
+    """
+    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.weibull(a, a=None, size=size)
+    else:
+        return _npi.weibull(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_weibull_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_weibull_op.cc
+ * \brief Operator for numpy sampling from Weibull distributions
+ */
+
+#include "./np_weibull_op.h"
+#include "./dist_common.h"
+
+namespace mxnet {
+namespace op {
+
+DMLC_REGISTER_PARAMETER(NumpyWeibullParam);
+
+NNVM_REGISTER_OP(_npi_weibull)
+.set_num_inputs(
+  [](const nnvm::NodeAttrs& attrs) {
+    const NumpyWeibullParam& param = nnvm::get<NumpyWeibullParam>(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 NumpyWeibullParam& param = nnvm::get<NumpyWeibullParam>(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<NumpyWeibullParam>)
+.set_attr<mxnet::FInferShape>("FInferShape", UnaryDistOpShape<NumpyWeibullParam>)
+.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>", NumpyWeibullForward<cpu>)
+.set_attr<nnvm::FGradient>("FGradient", MakeZeroGradNodes)
+.add_argument("input1", "NDArray-or-Symbol", "Source input")
+.add_arguments(NumpyWeibullParam::__FIELDS__());
+
+}  // namespace op
+}  // namespace mxnet

src/operator/numpy/random/np_weibull_op.cu

@@ -0,0 +1,35 @@
+/*
+ * 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_weibull_op.cu
+ * \brief Operator for numpy sampling from weibull distributions
+ */
+
+#include "./np_weibull_op.h"
+
+namespace mxnet {
+namespace op {
+
+NNVM_REGISTER_OP(_npi_weibull)
+.set_attr<FCompute>("FCompute<gpu>", NumpyWeibullForward<gpu>);
+
+}  // namespace op
+}  // namespace mxnet