uniform.py 9.7 KB
Newer Older
1
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
2
#
3 4 5
# 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
6
#
7
#     http://www.apache.org/licenses/LICENSE-2.0
8
#
9 10 11 12 13 14 15
# 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
16 17

import paddle
18
from paddle import _C_ops, _legacy_C_ops
19
from paddle.distribution import distribution
20 21
from paddle.fluid.data_feeder import check_type, convert_dtype
from paddle.fluid.framework import (
22
    _in_legacy_dygraph,
23 24 25 26 27 28 29
    _non_static_mode,
    in_dygraph_mode,
)
from paddle.fluid.layers import (
    nn,
    tensor,
)
30 31

import paddle
32
from paddle.tensor import random
33 34 35


class Uniform(distribution.Distribution):
36 37 38 39 40 41 42 43
    r"""Uniform distribution with `low` and `high` parameters.

    Mathematical Details

    The probability density function (pdf) is

    .. math::

44
        pdf(x; a, b) = \frac{1}{Z}, \ a <=x <b
45 46 47 48 49 50 51 52 53 54 55 56

    .. math::

        Z = b - a

    In the above equation:

    * :math:`low = a`,
    * :math:`high = b`,
    * :math:`Z`: is the normalizing constant.

    The parameters `low` and `high` must be shaped in a way that supports
57
    :ref:`user_guide_broadcasting` (e.g., `high - low` is a valid operation).
58 59

    Args:
60 61 62 63 64
        low(int|float|list|tuple|numpy.ndarray|Tensor): The lower boundary of
            uniform distribution.The data type is float32 and float64.
        high(int|float|list|tuple|numpy.ndarray|Tensor): The higher boundary
            of uniform distribution.The data type is float32 and float64.
        name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
65 66 67 68

    Examples:
        .. code-block:: python

69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
            import paddle
            from paddle.distribution import Uniform

            # Without broadcasting, a single uniform distribution [3, 4]:
            u1 = Uniform(low=3.0, high=4.0)
            # 2 distributions [1, 3], [2, 4]
            u2 = Uniform(low=[1.0, 2.0], high=[3.0, 4.0])
            # 4 distributions
            u3 = Uniform(low=[[1.0, 2.0], [3.0, 4.0]],
                        high=[[1.5, 2.5], [3.5, 4.5]])

            # With broadcasting:
            u4 = Uniform(low=3.0, high=[5.0, 6.0, 7.0])

            # Complete example
            value_tensor = paddle.to_tensor([0.8], dtype="float32")

            uniform = Uniform([0.], [2.])

            sample = uniform.sample([2])
            # a random tensor created by uniform distribution with shape: [2, 1]
            entropy = uniform.entropy()
            # [0.6931472] with shape: [1]
            lp = uniform.log_prob(value_tensor)
            # [-0.6931472] with shape: [1]
            p = uniform.probs(value_tensor)
            # [0.5] with shape: [1]
96 97 98
    """

    def __init__(self, low, high, name=None):
J
Jiabin Yang 已提交
99
        if not _non_static_mode():
100 101 102 103 104 105 106 107 108 109 110 111
            check_type(
                low,
                'low',
                (int, float, np.ndarray, tensor.Variable, list, tuple),
                'Uniform',
            )
            check_type(
                high,
                'high',
                (int, float, np.ndarray, tensor.Variable, list, tuple),
                'Uniform',
            )
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130

        self.all_arg_is_float = False
        self.batch_size_unknown = False
        self.name = name if name is not None else 'Uniform'
        self.dtype = 'float32'

        if isinstance(low, int):
            low = float(low)
        if isinstance(high, int):
            high = float(high)

        if self._validate_args(low, high):
            self.batch_size_unknown = True
            self.low = low
            self.high = high
            self.dtype = convert_dtype(low.dtype)
        else:
            if isinstance(low, float) and isinstance(high, float):
                self.all_arg_is_float = True
131 132 133 134
            if isinstance(low, np.ndarray) and str(low.dtype) in [
                'float32',
                'float64',
            ]:
135
                self.dtype = low.dtype
136 137 138 139
            elif isinstance(high, np.ndarray) and str(high.dtype) in [
                'float32',
                'float64',
            ]:
140 141 142 143 144 145 146
                self.dtype = high.dtype
            # pylint: disable=unbalanced-tuple-unpacking
            self.low, self.high = self._to_tensor(low, high)
            if self.dtype != convert_dtype(self.low.dtype):
                self.low = tensor.cast(self.low, dtype=self.dtype)
                self.high = tensor.cast(self.high, dtype=self.dtype)

147
        super().__init__(self.low.shape)
148

149 150 151 152
    def sample(self, shape, seed=0):
        """Generate samples of the specified shape.

        Args:
153 154
            shape (list): 1D `int32`. Shape of the generated samples.
            seed (int): Python integer number.
155 156

        Returns:
157
            Tensor, A tensor with prepended dimensions shape. The data type is float32.
158 159

        """
J
Jiabin Yang 已提交
160
        if not _non_static_mode():
161 162 163 164 165 166 167 168
            check_type(shape, 'shape', (list), 'sample')
            check_type(seed, 'seed', (int), 'sample')

        name = self.name + '_sample'
        batch_shape = list((self.low + self.high).shape)
        if self.batch_size_unknown:
            output_shape = shape + batch_shape
            zero_tmp = tensor.fill_constant_batch_size_like(
169 170
                self.low + self.high, batch_shape + shape, self.dtype, 0.0
            )
171
            uniform_random_tmp = random.uniform_random_batch_size_like(
172 173 174
                zero_tmp,
                zero_tmp.shape,
                dtype=self.dtype,
175 176 177 178
                min=0.0,
                max=1.0,
                seed=seed,
            )
179 180
            zero_tmp_reshape = paddle.reshape(zero_tmp, output_shape)
            uniform_random_tmp_reshape = paddle.reshape(
181 182 183 184 185
                uniform_random_tmp, output_shape
            )
            output = uniform_random_tmp_reshape * (
                zero_tmp_reshape + self.high - self.low
            )
186
            output = paddle.add(output, self.low, name=name)
187 188 189 190
            return output
        else:
            output_shape = shape + batch_shape
            output = nn.uniform_random(
191 192 193 194 195
                output_shape, dtype=self.dtype, min=0.0, max=1.0, seed=seed
            ) * (
                tensor.zeros(output_shape, dtype=self.dtype)
                + (self.high - self.low)
            )
196
            output = paddle.add(output, self.low, name=name)
197
            if self.all_arg_is_float:
198
                return paddle.reshape(output, shape, name=name)
199 200 201 202 203 204 205
            else:
                return output

    def log_prob(self, value):
        """Log probability density/mass function.

        Args:
206
            value (Tensor): The input tensor.
207 208

        Returns:
209
            Tensor, log probability.The data type is same with value.
210 211 212

        """
        value = self._check_values_dtype_in_probs(self.low, value)
J
Jiabin Yang 已提交
213
        if _non_static_mode():
214 215 216 217
            # ensure value in [low, high]
            lb_bool = self.low < value
            ub_bool = value < self.high

218 219 220
            if in_dygraph_mode():
                lb = _C_ops.cast(lb_bool, value.dtype)
                ub = _C_ops.cast(ub_bool, value.dtype)
221
                return paddle.log(lb * ub) - paddle.log(self.high - self.low)
222 223

            if _in_legacy_dygraph():
224 225 226 227 228 229
                lb = _legacy_C_ops.cast(
                    lb_bool, 'in_dtype', lb_bool.dtype, 'out_dtype', value.dtype
                )
                ub = _legacy_C_ops.cast(
                    ub_bool, 'in_dtype', ub_bool.dtype, 'out_dtype', value.dtype
                )
230
                return paddle.log(lb * ub) - paddle.log(self.high - self.low)
231 232 233 234 235 236

        name = self.name + '_log_prob'
        lb_bool = self.low < value
        ub_bool = value < self.high
        lb = tensor.cast(lb_bool, dtype=value.dtype)
        ub = tensor.cast(ub_bool, dtype=value.dtype)
237
        return paddle.subtract(
238
            paddle.log(lb * ub), paddle.log(self.high - self.low), name=name
239
        )
240 241 242 243 244

    def probs(self, value):
        """Probability density/mass function.

        Args:
245
            value (Tensor): The input tensor.
246 247

        Returns:
248
            Tensor, probability. The data type is same with value.
249 250 251

        """
        value = self._check_values_dtype_in_probs(self.low, value)
J
Jiabin Yang 已提交
252
        if _non_static_mode():
253 254 255
            lb_bool = self.low < value
            ub_bool = value < self.high

256 257 258 259 260 261
            if in_dygraph_mode():
                lb = _C_ops.cast(lb_bool, value.dtype)
                ub = _C_ops.cast(ub_bool, value.dtype)
                return (lb * ub) / (self.high - self.low)

            if _in_legacy_dygraph():
262 263 264 265 266 267
                lb = _legacy_C_ops.cast(
                    lb_bool, 'in_dtype', lb_bool.dtype, 'out_dtype', value.dtype
                )
                ub = _legacy_C_ops.cast(
                    ub_bool, 'in_dtype', ub_bool.dtype, 'out_dtype', value.dtype
                )
268
                return (lb * ub) / (self.high - self.low)
269 270 271 272 273 274

        name = self.name + '_probs'
        lb_bool = self.low < value
        ub_bool = value < self.high
        lb = tensor.cast(lb_bool, dtype=value.dtype)
        ub = tensor.cast(ub_bool, dtype=value.dtype)
275
        return paddle.divide((lb * ub), (self.high - self.low), name=name)
276 277 278 279 280 281 282 283 284 285 286

    def entropy(self):
        r"""Shannon entropy in nats.

        The entropy is

        .. math::

            entropy(low, high) = \\log (high - low)

        Returns:
287
            Tensor, Shannon entropy of uniform distribution.The data type is float32.
288 289 290

        """
        name = self.name + '_entropy'
291
        return paddle.log(self.high - self.low, name=name)