def __init__(self, loc=0., scale=1., validate_args=False, name="gumbel"): """Instantiates the `Gumbel` bijector. Args: loc: Float-like `Tensor` that is the same dtype and is broadcastable with `scale`. This is `loc` in `Y = g(X) = exp(-exp(-(X - loc) / scale))`. scale: Positive Float-like `Tensor` that is the same dtype and is broadcastable with `loc`. This is `scale` in `Y = g(X) = exp(-exp(-(X - loc) / scale))`. validate_args: Python `bool` indicating whether arguments should be checked for correctness. name: Python `str` name given to ops managed by this object. """ with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([loc, scale], dtype_hint=tf.float32) self._loc = tensor_util.convert_immutable_to_tensor(loc, dtype=dtype, name="loc") self._scale = tensor_util.convert_immutable_to_tensor(scale, dtype=dtype, name="scale") super(Gumbel, self).__init__(validate_args=validate_args, forward_min_event_ndims=0, name=name)
def test_tf_variable(self): x = tf.Variable(1., trainable=True) y = tensor_util.convert_immutable_to_tensor(x) self.assertIs(x, y) x = tf.Variable(1., trainable=False) y = tensor_util.convert_immutable_to_tensor(x) self.assertIs(x, y)
def __init__(self, skewness=None, tailweight=None, validate_args=False, name="sinh_arcsinh"): """Instantiates the `SinhArcsinh` bijector. Args: skewness: Skewness parameter. Float-type `Tensor`. Default is `0` of type `float32`. tailweight: Tailweight parameter. Positive `Tensor` of same `dtype` as `skewness` and broadcastable `shape`. Default is `1` of type `float32`. validate_args: Python `bool` indicating whether arguments should be checked for correctness. name: Python `str` name given to ops managed by this object. """ with tf.name_scope(name) as name: tailweight = 1. if tailweight is None else tailweight skewness = 0. if skewness is None else skewness dtype = dtype_util.common_dtype([tailweight, skewness], dtype_hint=tf.float32) self._skewness = tensor_util.convert_immutable_to_tensor( skewness, dtype=dtype, name="skewness") self._tailweight = tensor_util.convert_immutable_to_tensor( tailweight, dtype=dtype, name="tailweight") super(SinhArcsinh, self).__init__(forward_min_event_ndims=0, validate_args=validate_args, name=name)
def __init__(self, concentration1=1., concentration0=1., validate_args=False, name="kumaraswamy"): """Instantiates the `Kumaraswamy` bijector. Args: concentration1: Python `float` scalar indicating the transform power, i.e., `Y = g(X) = (1 - (1 - X)**(1 / b))**(1 / a)` where `a` is `concentration1`. concentration0: Python `float` scalar indicating the transform power, i.e., `Y = g(X) = (1 - (1 - X)**(1 / b))**(1 / a)` where `b` is `concentration0`. validate_args: Python `bool` indicating whether arguments should be checked for correctness. name: Python `str` name given to ops managed by this object. """ with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([concentration0, concentration1], dtype_hint=tf.float32) self._concentration0 = tensor_util.convert_immutable_to_tensor( concentration0, dtype=dtype, name="concentration0") self._concentration1 = tensor_util.convert_immutable_to_tensor( concentration1, dtype=dtype, name="concentration1") super(Kumaraswamy, self).__init__(forward_min_event_ndims=0, validate_args=validate_args, name=name)
def __init__(self, loc, scale, concentration, validate_args=False, allow_nan_stats=True, name=None): """Construct a Generalized Pareto distribution. Args: loc: The location / shift of the distribution. GeneralizedPareto is a location-scale distribution. This parameter lower bounds the distribution's support. Must broadcast with `scale`, `concentration`. Floating point `Tensor`. scale: The scale of the distribution. GeneralizedPareto is a location-scale distribution, so doubling the `scale` doubles a sample and halves the density. Strictly positive floating point `Tensor`. Must broadcast with `loc`, `concentration`. concentration: The shape parameter of the distribution. The larger the magnitude, the more the distribution concentrates near `loc` (for `concentration >= 0`) or near `loc - (scale/concentration)` (for `concentration < 0`). Floating point `Tensor`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. Raises: TypeError: if `loc`, `scale`, or `concentration` have different dtypes. """ parameters = dict(locals()) with tf.name_scope(name or 'GeneralizedPareto') as name: dtype = dtype_util.common_dtype([loc, scale, concentration], dtype_hint=tf.float32) self._loc = tensor_util.convert_immutable_to_tensor(loc, dtype=dtype, name='loc') self._scale = tensor_util.convert_immutable_to_tensor(scale, dtype=dtype, name='scale') self._concentration = tensor_util.convert_immutable_to_tensor( concentration, dtype=dtype, name='concentration') super(GeneralizedPareto, self).__init__(dtype=dtype, validate_args=validate_args, allow_nan_stats=allow_nan_stats, reparameterization_type=reparameterization. FULLY_REPARAMETERIZED, parameters=parameters, name=name)
def __init__(self, total_count, logits=None, probs=None, validate_args=False, allow_nan_stats=True, name='Multinomial'): """Initialize a batch of Multinomial distributions. Args: total_count: Non-negative floating point tensor with shape broadcastable to `[N1,..., Nm]` with `m >= 0`. Defines this as a batch of `N1 x ... x Nm` different Multinomial distributions. Its components should be equal to integer values. logits: Floating point tensor representing unnormalized log-probabilities of a positive event with shape broadcastable to `[N1,..., Nm, K]` `m >= 0`, and the same dtype as `total_count`. Defines this as a batch of `N1 x ... x Nm` different `K` class Multinomial distributions. Only one of `logits` or `probs` should be passed in. probs: Positive floating point tensor with shape broadcastable to `[N1,..., Nm, K]` `m >= 0` and same dtype as `total_count`. Defines this as a batch of `N1 x ... x Nm` different `K` class Multinomial distributions. `probs`'s components in the last portion of its shape should sum to `1`. Only one of `logits` or `probs` should be passed in. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. """ parameters = dict(locals()) if (probs is None) == (logits is None): raise ValueError('Must pass probs or logits, but not both.') with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([total_count, logits, probs], dtype_hint=tf.float32) self._total_count = tensor_util.convert_immutable_to_tensor( total_count, name='total_count', dtype=dtype) self._probs = tensor_util.convert_immutable_to_tensor(probs, dtype=dtype, name='probs') self._logits = tensor_util.convert_immutable_to_tensor( logits, dtype=dtype, name='logits') super(Multinomial, self).__init__( dtype=dtype, reparameterization_type=reparameterization.NOT_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def __init__(self, df, loc, scale, validate_args=False, allow_nan_stats=True, name='StudentT'): """Construct Student's t distributions. The distributions have degree of freedom `df`, mean `loc`, and scale `scale`. The parameters `df`, `loc`, and `scale` must be shaped in a way that supports broadcasting (e.g. `df + loc + scale` is a valid operation). Args: df: Floating-point `Tensor`. The degrees of freedom of the distribution(s). `df` must contain only positive values. loc: Floating-point `Tensor`. The mean(s) of the distribution(s). scale: Floating-point `Tensor`. The scaling factor(s) for the distribution(s). Note that `scale` is not technically the standard deviation of this distribution but has semantics more similar to standard deviation than variance. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value '`NaN`' to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. Raises: TypeError: if loc and scale are different dtypes. """ parameters = dict(locals()) with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([df, loc, scale], tf.float32) self._df = tensor_util.convert_immutable_to_tensor( df, name='df', dtype=dtype) self._loc = tensor_util.convert_immutable_to_tensor( loc, name='loc', dtype=dtype) self._scale = tensor_util.convert_immutable_to_tensor( scale, name='scale', dtype=dtype) dtype_util.assert_same_float_dtype((self._df, self._loc, self._scale)) super(StudentT, self).__init__( dtype=dtype, reparameterization_type=reparameterization.FULLY_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def test_tf_module(self): x = FakeModule(1.) y = tensor_util.convert_immutable_to_tensor(x) self.assertIsInstance(y, tf.Tensor) self.assertEqual(1., self.evaluate(y)) x = FakeModule(tf.Variable(2., trainable=True)) y = tensor_util.convert_immutable_to_tensor(x) self.assertIs(x, y) x = FakeModule(tf.Variable(2., trainable=False)) y = tensor_util.convert_immutable_to_tensor(x) self.assertIs(x, y)
def __init__(self, scale, validate_args=False, allow_nan_stats=True, name='HalfNormal'): """Construct HalfNormals with scale `scale`. Args: scale: Floating point tensor; the scales of the distribution(s). Must contain only positive values. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value '`NaN`' to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. """ parameters = dict(locals()) with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([scale], dtype_hint=tf.float32) self._scale = tensor_util.convert_immutable_to_tensor(scale, name='scale', dtype=dtype) super(HalfNormal, self).__init__(dtype=dtype, reparameterization_type=reparameterization. FULLY_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def __init__(self, loc, scale, validate_args=False, allow_nan_stats=True, name='Laplace'): """Construct Laplace distribution with parameters `loc` and `scale`. The parameters `loc` and `scale` must be shaped in a way that supports broadcasting (e.g., `loc / scale` is a valid operation). Args: loc: Floating point tensor which characterizes the location (center) of the distribution. scale: Positive floating point tensor which characterizes the spread of the distribution. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value '`NaN`' to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. Raises: TypeError: if `loc` and `scale` are of different dtype. """ parameters = dict(locals()) with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([loc, scale], tf.float32) self._loc = tensor_util.convert_immutable_to_tensor(loc, name='loc', dtype=dtype) self._scale = tensor_util.convert_immutable_to_tensor(scale, name='scale', dtype=dtype) dtype_util.assert_same_float_dtype([self._loc, self._scale]) super(Laplace, self).__init__(dtype=dtype, reparameterization_type=reparameterization. FULLY_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def __init__(self, concentration, rate, validate_args=False, allow_nan_stats=True, name="Gamma"): """Construct Gamma with `concentration` and `rate` parameters. The parameters `concentration` and `rate` must be shaped in a way that supports broadcasting (e.g. `concentration + rate` is a valid operation). Args: concentration: Floating point tensor, the concentration params of the distribution(s). Must contain only positive values. rate: Floating point tensor, the inverse scale params of the distribution(s). Must contain only positive values. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. Raises: TypeError: if `concentration` and `rate` are different dtypes. """ parameters = dict(locals()) with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([concentration, rate], dtype_hint=tf.float32) self._concentration = tensor_util.convert_immutable_to_tensor( concentration, dtype=dtype, name="concentration") self._rate = tensor_util.convert_immutable_to_tensor(rate, dtype=dtype, name="rate") super(Gamma, self).__init__(dtype=dtype, validate_args=validate_args, allow_nan_stats=allow_nan_stats, reparameterization_type=reparameterization. FULLY_REPARAMETERIZED, parameters=parameters, name=name)
def __init__(self, logits=None, probs=None, dtype=tf.int32, validate_args=False, allow_nan_stats=True, name='Bernoulli'): """Construct Bernoulli distributions. Args: logits: An N-D `Tensor` representing the log-odds of a `1` event. Each entry in the `Tensor` parametrizes an independent Bernoulli distribution where the probability of an event is sigmoid(logits). Only one of `logits` or `probs` should be passed in. probs: An N-D `Tensor` representing the probability of a `1` event. Each entry in the `Tensor` parameterizes an independent Bernoulli distribution. Only one of `logits` or `probs` should be passed in. dtype: The type of the event samples. Default: `int32`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. Raises: ValueError: If p and logits are passed, or if neither are passed. """ parameters = dict(locals()) if (probs is None) == (logits is None): raise ValueError('Must pass probs or logits, but not both.') with tf.name_scope(name) as name: self._probs = tensor_util.convert_immutable_to_tensor( probs, dtype_hint=tf.float32, name='probs') self._logits = tensor_util.convert_immutable_to_tensor( logits, dtype_hint=tf.float32, name='logits') super(Bernoulli, self).__init__( dtype=dtype, reparameterization_type=reparameterization.NOT_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def __init__(self, logits=None, probs=None, dtype=tf.int32, validate_args=False, allow_nan_stats=True, name='Categorical'): """Initialize Categorical distributions using class log-probabilities. Args: logits: An N-D `Tensor`, `N >= 1`, representing the unnormalized log probabilities of a set of Categorical distributions. The first `N - 1` dimensions index into a batch of independent distributions and the last dimension represents a vector of logits for each class. Only one of `logits` or `probs` should be passed in. probs: An N-D `Tensor`, `N >= 1`, representing the probabilities of a set of Categorical distributions. The first `N - 1` dimensions index into a batch of independent distributions and the last dimension represents a vector of probabilities for each class. Only one of `logits` or `probs` should be passed in. dtype: The type of the event samples (default: int32). validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. """ parameters = dict(locals()) if (probs is None) == (logits is None): raise ValueError('Must pass probs or logits, but not both.') with tf.name_scope(name) as name: self._probs = tensor_util.convert_immutable_to_tensor( probs, dtype_hint=tf.float32, name='probs') self._logits = tensor_util.convert_immutable_to_tensor( logits, dtype_hint=tf.float32, name='logits') super(Categorical, self).__init__( dtype=dtype, reparameterization_type=reparameterization.NOT_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def __init__(self, loc, scale, validate_args=False, allow_nan_stats=True, name="Normal"): """Construct Normal distributions with mean and stddev `loc` and `scale`. The parameters `loc` and `scale` must be shaped in a way that supports broadcasting (e.g. `loc + scale` is a valid operation). Args: loc: Floating point tensor; the means of the distribution(s). scale: Floating point tensor; the stddevs of the distribution(s). Must contain only positive values. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. Raises: TypeError: if `loc` and `scale` have different `dtype`. """ parameters = dict(locals()) with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([loc, scale], preferred_dtype=tf.float32) self._loc = tensor_util.convert_immutable_to_tensor(loc, dtype=dtype, name="loc") self._scale = tensor_util.convert_immutable_to_tensor(scale, dtype=dtype, name="scale") super(Normal, self).__init__(dtype=dtype, reparameterization_type=reparameterization. FULLY_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def __init__(self, scale=2, validate_args=False, name=None): with tf.name_scope(name or 'forward_only') as name: self._scale = tensor_util.convert_immutable_to_tensor( scale, dtype_hint=tf.float32) super(ForwardOnlyBijector, self).__init__(validate_args=validate_args, forward_min_event_ndims=0, name=name)
def __init__(self, shift=None, scale=None, validate_args=False, name="affine_scalar"): """Instantiates the `AffineScalar` bijector. This `Bijector` is initialized with `shift` `Tensor` and `scale` arguments, giving the forward operation: ```none Y = g(X) = scale * X + shift ``` if `scale` is not specified, then the bijector has the semantics of `scale = 1.`. Similarly, if `shift` is not specified, then the bijector has the semantics of `shift = 0.`. Args: shift: Floating-point `Tensor`. If this is set to `None`, no shift is applied. scale: Floating-point `Tensor`. If this is set to `None`, no scale is applied. validate_args: Python `bool` indicating whether arguments should be checked for correctness. name: Python `str` name given to ops managed by this object. """ with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([shift, scale], dtype_hint=tf.float32) self._shift = tensor_util.convert_immutable_to_tensor(shift, dtype=dtype, name="shift") self._scale = tensor_util.convert_immutable_to_tensor(scale, dtype=dtype, name="scale") super(AffineScalar, self).__init__(forward_min_event_ndims=0, is_constant_jacobian=True, validate_args=validate_args, dtype=dtype, name=name)
def __init__(self, concentration1, concentration0, validate_args=False, allow_nan_stats=True, name="Beta"): """Initialize a batch of Beta distributions. Args: concentration1: Positive floating-point `Tensor` indicating mean number of successes; aka "alpha". Implies `self.dtype` and `self.batch_shape`, i.e., `concentration1.shape = [N1, N2, ..., Nm] = self.batch_shape`. concentration0: Positive floating-point `Tensor` indicating mean number of failures; aka "beta". Otherwise has same semantics as `concentration1`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. """ parameters = dict(locals()) with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([concentration1, concentration0], dtype_hint=tf.float32) self._concentration1 = tensor_util.convert_immutable_to_tensor( concentration1, dtype=dtype, name="concentration1") self._concentration0 = tensor_util.convert_immutable_to_tensor( concentration0, dtype=dtype, name="concentration0") super(Beta, self).__init__( dtype=dtype, validate_args=validate_args, allow_nan_stats=allow_nan_stats, reparameterization_type=reparameterization.FULLY_REPARAMETERIZED, parameters=parameters, name=name)
def __init__(self, shift=None, scale=None, adjoint=False, validate_args=False, name='affine_linear_operator'): """Instantiates the `AffineLinearOperator` bijector. Args: shift: Floating-point `Tensor`. scale: Subclass of `LinearOperator`. Represents the (batch) positive definite matrix `M` in `R^{k x k}`. adjoint: Python `bool` indicating whether to use the `scale` matrix as specified or its adjoint. Default value: `False`. validate_args: Python `bool` indicating whether arguments should be checked for correctness. name: Python `str` name given to ops managed by this object. Raises: TypeError: if `scale` is not a `LinearOperator`. TypeError: if `shift.dtype` does not match `scale.dtype`. ValueError: if not `scale.is_non_singular`. """ with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([shift, scale], preferred_dtype=tf.float32) self._shift = tensor_util.convert_immutable_to_tensor(shift, dtype=dtype, name='shift') if scale is not None: if not isinstance(scale, tf.linalg.LinearOperator): raise TypeError( 'scale is not an instance of tf.LinearOperator') if validate_args and not scale.is_non_singular: raise ValueError('Scale matrix must be non-singular.') self._scale = scale self._adjoint = adjoint super(AffineLinearOperator, self).__init__(forward_min_event_ndims=1, is_constant_jacobian=True, dtype=dtype, validate_args=validate_args, name=name)
def __init__(self, axis=-1, validate_args=False, name='cumsum'): """Instantiates the `Cumsum` bijector. Args: axis: Negative Python `int` indicating the axis along which to compute the cumulative sum. Note that positive (and zero) values are not supported. validate_args: Python `bool` indicating whether arguments should be checked for correctness. name: Python `str` name given to ops managed by this object. Raises: TypeError: if `axis` is not an `int`. ValueError: if `axis` is not negative. """ with tf.name_scope(name) as name: self._axis = tensor_util.convert_immutable_to_tensor( axis, dtype_hint=tf.int32, name='axis') super(Cumsum, self).__init__( is_constant_jacobian=True, # Positive because we verify `axis < 0`. forward_min_event_ndims=-axis, validate_args=validate_args, name=name)
def __init__(self, rate, validate_args=False, allow_nan_stats=True, name="Exponential"): """Construct Exponential distribution with parameter `rate`. Args: rate: Floating point tensor, equivalent to `1 / mean`. Must contain only positive values. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. name: Python `str` name prefixed to Ops created by this class. """ parameters = dict(locals()) # Even though all statistics of are defined for valid inputs, this is not # true in the parent class "Gamma." Therefore, passing # allow_nan_stats=True # through to the parent class results in unnecessary asserts. with tf.name_scope(name) as name: self._rate = tensor_util.convert_immutable_to_tensor( rate, name="rate", dtype=dtype_util.common_dtype([rate], dtype_hint=tf.float32)) super(Exponential, self).__init__(concentration=1., rate=self._rate, allow_nan_stats=allow_nan_stats, validate_args=validate_args, name=name) self._parameters = parameters
def __init__(self, loc, atol=None, rtol=None, is_vector=False, validate_args=False, allow_nan_stats=True, parameters=None, name="_BaseDeterministic"): """Initialize a batch of `_BaseDeterministic` distributions. The `atol` and `rtol` parameters allow for some slack in `pmf`, `cdf` computations, e.g. due to floating-point error. ``` pmf(x; loc) = 1, if Abs(x - loc) <= atol + rtol * Abs(loc), = 0, otherwise. ``` Args: loc: Numeric `Tensor`. The point (or batch of points) on which this distribution is supported. atol: Non-negative `Tensor` of same `dtype` as `loc` and broadcastable shape. The absolute tolerance for comparing closeness to `loc`. Default is `0`. rtol: Non-negative `Tensor` of same `dtype` as `loc` and broadcastable shape. The relative tolerance for comparing closeness to `loc`. Default is `0`. is_vector: Python `bool`. If `True`, this is for `VectorDeterministic`, else `Deterministic`. validate_args: Python `bool`, default `False`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. allow_nan_stats: Python `bool`, default `True`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. parameters: Dict of locals to facilitate copy construction. name: Python `str` name prefixed to Ops created by this class. Raises: ValueError: If `loc` is a scalar. """ with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([loc, atol, rtol], dtype_hint=tf.float32) self._loc = tensor_util.convert_immutable_to_tensor( loc, dtype_hint=dtype, name="loc") self._atol = tensor_util.convert_immutable_to_tensor( 0 if atol is None else atol, dtype=dtype, name="atol") self._rtol = tensor_util.convert_immutable_to_tensor( 0 if rtol is None else rtol, dtype=dtype, name="rtol") self._is_vector = is_vector super(_BaseDeterministic, self).__init__( dtype=self._loc.dtype, reparameterization_type=reparameterization.NOT_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def __init__(self, rate=None, log_rate=None, interpolate_nondiscrete=True, validate_args=False, allow_nan_stats=True, name='Poisson'): """Initialize a batch of Poisson distributions. Args: rate: Floating point tensor, the rate parameter. `rate` must be positive. Must specify exactly one of `rate` and `log_rate`. log_rate: Floating point tensor, the log of the rate parameter. Must specify exactly one of `rate` and `log_rate`. interpolate_nondiscrete: Python `bool`. When `False`, `log_prob` returns `-inf` (and `prob` returns `0`) for non-integer inputs. When `True`, `log_prob` evaluates the continuous function `k * log_rate - lgamma(k+1) - rate`, which matches the Poisson pmf at integer arguments `k` (note that this function is not itself a normalized probability log-density). Default value: `True`. validate_args: Python `bool`. When `True` distribution parameters are checked for validity despite possibly degrading runtime performance. When `False` invalid inputs may silently render incorrect outputs. Default value: `False`. allow_nan_stats: Python `bool`. When `True`, statistics (e.g., mean, mode, variance) use the value "`NaN`" to indicate the result is undefined. When `False`, an exception is raised if one or more of the statistic's batch members are undefined. Default value: `True`. name: Python `str` name prefixed to Ops created by this class. Raises: ValueError: if none or both of `rate`, `log_rate` are specified. TypeError: if `rate` is not a float-type. TypeError: if `log_rate` is not a float-type. """ parameters = dict(locals()) if (rate is None) == (log_rate is None): raise ValueError( 'Must specify exactly one of `rate` and `log_rate`.') with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([rate, log_rate], dtype_hint=tf.float32) if not dtype_util.is_floating(dtype): raise TypeError( '[log_]rate.dtype ({}) is a not a float-type.'.format( dtype_util.name(dtype))) self._rate = tensor_util.convert_immutable_to_tensor(rate, name='rate', dtype=dtype) self._log_rate = tensor_util.convert_immutable_to_tensor( log_rate, name='log_rate', dtype=dtype) self._interpolate_nondiscrete = interpolate_nondiscrete super(Poisson, self).__init__( dtype=dtype, reparameterization_type=reparameterization.NOT_REPARAMETERIZED, validate_args=validate_args, allow_nan_stats=allow_nan_stats, parameters=parameters, name=name)
def __init__(self, shift=None, scale=None, log_scale=None, validate_args=False, name='affine_scalar'): """Instantiates the `AffineScalar` bijector. This `Bijector` is initialized with `shift` `Tensor` and `scale` arguments, giving the forward operation: ```none Y = g(X) = scale * X + shift ``` Alternatively, you can specify `log_scale` instead of `scale` for slighly better numerics with tiny scales. Note that when using `log_scale` it is currently impossible to specify a negative scale. If `scale` or `log_scale` are not specified, then the bijector has the semantics of `scale = 1.`. Similarly, if `shift` is not specified, then the bijector has the semantics of `shift = 0.`. Args: shift: Floating-point `Tensor`. If this is set to `None`, no shift is applied. scale: Floating-point `Tensor`. If this is set to `None`, no scale is applied. This should not be set if `log_scale` is set. log_scale: Floating-point `Tensor`. Logarithm of the scale. If this is set to `None`, no scale is applied. This should not be set if `scale` is set. validate_args: Python `bool` indicating whether arguments should be checked for correctness. name: Python `str` name given to ops managed by this object. Raises: ValueError: If both `scale` and `log_scale` are specified. """ with tf.name_scope(name) as name: dtype = dtype_util.common_dtype([shift, scale, log_scale], dtype_hint=tf.float32) if scale is not None and log_scale is not None: raise ValueError( 'At most one of `scale` and `log_scale` should be ' 'specified') self._shift = tensor_util.convert_immutable_to_tensor(shift, dtype=dtype, name='shift') self._scale = tensor_util.convert_immutable_to_tensor(scale, dtype=dtype, name='scale') self._log_scale = tensor_util.convert_immutable_to_tensor( log_scale, dtype=dtype, name='log_scale') super(AffineScalar, self).__init__(forward_min_event_ndims=0, is_constant_jacobian=True, validate_args=validate_args, dtype=dtype, name=name)
def test_tf_tensor(self): x = tf.constant(1.) y = tensor_util.convert_immutable_to_tensor(x) self.assertIs(x, y)
def test_np_object(self): x = np.array(0.) y = tensor_util.convert_immutable_to_tensor(x) self.assertIsInstance(y, tf.Tensor) self.assertEqual(x, self.evaluate(y))