View source on GitHub |

## Class `JointDistributionCoroutineAutoBatched`

Joint distribution parameterized by a distribution-making generator.

Inherits From: `JointDistributionCoroutine`

This class provides alternate vectorization semantics for
`tfd.JointDistributionCoroutine`

, which in many cases eliminate the need to
explicitly account for batch shapes in the model specification.
Instead of simply summing the `log_prob`

s of component distributions
(which may have different shapes), it first reduces the component `log_prob`

s
to ensure that `jd.log_prob(jd.sample())`

always returns a scalar, unless
otherwise specified.

The essential changes are:

- An
`event`

of`JointDistributionCoroutineAutoBatched`

is the list of tensors produced by`.sample()`

; thus, the`event_shape`

is the list of the shapes of sampled tensors. These combine both the event and batch dimensions of the component distributions. By contrast, the event shape of a base`JointDistribution`

s does not include batch dimensions of component distributions. - The
`batch_shape`

is a global property of the entire model, rather than a per-component property as in base`JointDistribution`

s. The global batch shape must be a prefix of the batch shapes of each component; the length of this prefix is specified by an optional argument`batch_ndims`

. If`batch_ndims`

is not specified, the model has batch shape`[]`

.

#### Examples

A hierarchical model of Poisson log-rates, written using
`tfd.JointDistributionCoroutineAutoBatched`

:

```
tfd = tfp.distributions
Root = tfd.JointDistributionCoroutineAutoBatched.Root # Convenient alias.
def model():
global_log_rate = yield Root(tfd.Normal(loc=0., scale=1.))
local_log_rates = yield Root(tfd.Normal(loc=0., scale=tf.ones([20])))
observed_counts = yield Root(tfd.Poisson(
rate=tf.exp(global_log_rate + local_log_rates)))
joint = tfd.JointDistributionCoroutineAutoBatched(model)
print(joint.event_shape)
# ==> [[], [20], [20]]
print(joint.batch_shape)
# ==> []
xs = joint.sample()
print([x.shape for x in xs])
# ==> [[], [20], [20]]
lp = joint.log_prob(xs)
print(lp.shape)
# ==> []
```

Note that the component distributions of this model would, by themselves, return batches of log-densities (because they are constructed with batch shape); the joint model implicitly sums over these to compute the single joint log-density.

```
ds, xs = joint.sample_distributions()
print([d.event_shape for d in ds])
# ==> [[], [], []] != model.event_shape
print([d.batch_shape for d in ds])
# ==> [[], [20], [20]] != model.batch_shape
print([d.log_prob(x).shape for (d, x) in zip(ds, xs)])
# ==> [[], [20], [20]]
```

The behavior of `JointDistributionCoroutineAutoBatched`

is (assuming that
`batch_ndims`

is not specified) equivalent to
adding `tfp.distributions.Independent`

wrappers to reinterpret all batch
dimensions in a `JointDistributionCoroutine`

model. That is, the model above
would be equivalently written using `JointDistributionCoroutine`

as:

```
def model_jdc():
global_log_rate = yield Root(tfd.Normal(0., 1.))
local_log_rates = yield Root(tfd.Independent(
tfd.Normal(0., tf.ones([20])), reinterpreted_batch_ndims=1))
observed_counts = yield Root(tfd.Independent(
tfd.Poisson(tf.exp(global_log_rate + local_log_rates)),
reinterpreted_batch_ndims=1))
joint_jdc = tfd.JointDistributionCoroutine(model_jdc)
```

To define a *batch* of joint distributions (independent, but not identical,
joint distributions from the same family) using
`JointDistributionCoroutineAutoBatched`

, any batch dimensions must be a shared
prefix of the batch dimensions for all components. The `batch_ndims`

argument
determines the size of the prefix to consider. For example, consider a simple
joint model with two scalar normal random variables, where the second
variable's mean is given by the first variable. We can write a batch of five
such models as:

```
def model():
x = yield Root(tfd.Normal(0., scale=tf.ones([5])))
y = yield tfd.Normal(x, scale=[3., 2., 5., 1., 6.])
batch_joint = tfd.JointDistributionCoroutineAutoBatched(model, batch_ndims=1)
print(batch_joint.event_shape)
# ==> [[], []]
print(batch_joint.batch_shape)
# ==> [5]
print(batch_joint.log_prob(batch_joint.sample()).shape)
# ==> [5]
```

Note that if we had not passed `batch_ndims`

, this would be interpreted as a
single model over vector-valued random variables (whose components happen to
be independent):

```
alternate_joint = tfd.JointDistributionCoroutineAutoBatched(model)
print(alternate_joint.event_shape)
# ==> [[5], [5]]
print(alternate_joint.batch_shape)
# ==> []
print(alternate_joint.log_prob(batch_joint.sample()).shape)
# ==> []
```

`__init__`

```
__init__(
*args,
**kwargs
)
```

Construct the `JointDistributionCoroutine`

distribution.

#### Args:

: A generator that yields a sequence of`model`

`tfd.Distribution`

-like instances.: Samples from this distribution will be structured like`sample_dtype`

`tf.nest.pack_sequence_as(sample`

.*dtype, list*)`sample_dtype`

is only used for`tf.nest.pack_sequence_as`

structuring of outputs, never casting (which is the responsibility of the component distributions). Default value:`None`

(i.e.,`tuple`

).: Python`validate_args`

`bool`

. Whether to validate input with asserts. If`validate_args`

is`False`

, and the inputs are invalid, correct behavior is not guaranteed. Default value:`False`

.: The name for ops managed by the distribution. Default value:`name`

`None`

(i.e.,`JointDistributionCoroutine`

).

## Child Classes

## Properties

`allow_nan_stats`

Python `bool`

describing behavior when a stat is undefined.

Stats return +/- infinity when it makes sense. E.g., the variance of a Cauchy distribution is infinity. However, sometimes the statistic is undefined, e.g., if a distribution's pdf does not achieve a maximum within the support of the distribution, the mode is undefined. If the mean is undefined, then by definition the variance is undefined. E.g. the mean for Student's T for df = 1 is undefined (no clear way to say it is either + or - infinity), so the variance = E[(X - mean)**2] is also undefined.

#### Returns:

: Python`allow_nan_stats`

`bool`

.

`batch_ndims`

`batch_shape`

`dtype`

The `DType`

of `Tensor`

s handled by this `Distribution`

.

`event_shape`

`model`

`name`

Name prepended to all ops created by this `Distribution`

.

`parameters`

Dictionary of parameters used to instantiate this `Distribution`

.

`reparameterization_type`

Describes how samples from the distribution are reparameterized.

Currently this is one of the static instances
`tfd.FULLY_REPARAMETERIZED`

or `tfd.NOT_REPARAMETERIZED`

.

#### Returns:

:`reparameterization_type`

`ReparameterizationType`

of each distribution in`model`

.

`trainable_variables`

`validate_args`

Python `bool`

indicating possibly expensive checks are enabled.

`variables`

## Methods

`__getitem__`

```
__getitem__(slices)
```

Slices the batch axes of this distribution, returning a new instance.

```
b = tfd.Bernoulli(logits=tf.zeros([3, 5, 7, 9]))
b.batch_shape # => [3, 5, 7, 9]
b2 = b[:, tf.newaxis, ..., -2:, 1::2]
b2.batch_shape # => [3, 1, 5, 2, 4]
x = tf.random.normal([5, 3, 2, 2])
cov = tf.matmul(x, x, transpose_b=True)
chol = tf.cholesky(cov)
loc = tf.random.normal([4, 1, 3, 1])
mvn = tfd.MultivariateNormalTriL(loc, chol)
mvn.batch_shape # => [4, 5, 3]
mvn.event_shape # => [2]
mvn2 = mvn[:, 3:, ..., ::-1, tf.newaxis]
mvn2.batch_shape # => [4, 2, 3, 1]
mvn2.event_shape # => [2]
```

#### Args:

: slices from the [] operator`slices`

#### Returns:

: A new`dist`

`tfd.Distribution`

instance with sliced parameters.

`__iter__`

```
__iter__()
```

`batch_shape_tensor`

```
batch_shape_tensor(
sample_shape=(),
name='batch_shape_tensor'
)
```

`cdf`

```
cdf(
value,
name='cdf',
**kwargs
)
```

Cumulative distribution function.

Given random variable `X`

, the cumulative distribution function `cdf`

is:

```
cdf(x) := P[X <= x]
```

#### Args:

:`value`

`float`

or`double`

`Tensor`

.: Python`name`

`str`

prepended to names of ops created by this function.: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

: a`cdf`

`Tensor`

of shape`sample_shape(x) + self.batch_shape`

with values of type`self.dtype`

.

`copy`

```
copy(**override_parameters_kwargs)
```

Creates a deep copy of the distribution.

#### Args:

: String/value dictionary of initialization arguments to override with new values.`**override_parameters_kwargs`

#### Returns:

: A new instance of`distribution`

`type(self)`

initialized from the union of self.parameters and override_parameters_kwargs, i.e.,`dict(self.parameters, **override_parameters_kwargs)`

.

`covariance`

```
covariance(
name='covariance',
**kwargs
)
```

Covariance.

Covariance is (possibly) defined only for non-scalar-event distributions.

For example, for a length-`k`

, vector-valued distribution, it is calculated
as,

```
Cov[i, j] = Covariance(X_i, X_j) = E[(X_i - E[X_i]) (X_j - E[X_j])]
```

where `Cov`

is a (batch of) `k x k`

matrix, `0 <= (i, j) < k`

, and `E`

denotes expectation.

Alternatively, for non-vector, multivariate distributions (e.g.,
matrix-valued, Wishart), `Covariance`

shall return a (batch of) matrices
under some vectorization of the events, i.e.,

```
Cov[i, j] = Covariance(Vec(X)_i, Vec(X)_j) = [as above]
```

where `Cov`

is a (batch of) `k' x k'`

matrices,
`0 <= (i, j) < k' = reduce_prod(event_shape)`

, and `Vec`

is some function
mapping indices of this distribution's event dimensions to indices of a
length-`k'`

vector.

#### Args:

: Python`name`

`str`

prepended to names of ops created by this function.: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

: Floating-point`covariance`

`Tensor`

with shape`[B1, ..., Bn, k', k']`

where the first`n`

dimensions are batch coordinates and`k' = reduce_prod(self.event_shape)`

.

`cross_entropy`

```
cross_entropy(
other,
name='cross_entropy'
)
```

Computes the (Shannon) cross entropy.

Denote this distribution (`self`

) by `P`

and the `other`

distribution by
`Q`

. Assuming `P, Q`

are absolutely continuous with respect to
one another and permit densities `p(x) dr(x)`

and `q(x) dr(x)`

, (Shannon)
cross entropy is defined as:

```
H[P, Q] = E_p[-log q(X)] = -int_F p(x) log q(x) dr(x)
```

where `F`

denotes the support of the random variable `X ~ P`

.

#### Args:

:`other`

`tfp.distributions.Distribution`

instance.: Python`name`

`str`

prepended to names of ops created by this function.

#### Returns:

:`cross_entropy`

`self.dtype`

`Tensor`

with shape`[B1, ..., Bn]`

representing`n`

different calculations of (Shannon) cross entropy.

`entropy`

```
entropy(
name='entropy',
**kwargs
)
```

Shannon entropy in nats.

`event_shape_tensor`

```
event_shape_tensor(
sample_shape=(),
name='event_shape_tensor'
)
```

`is_scalar_batch`

```
is_scalar_batch(name='is_scalar_batch')
```

Indicates that `batch_shape == []`

.

#### Args:

: Python`name`

`str`

prepended to names of ops created by this function.

#### Returns:

:`is_scalar_batch`

`bool`

scalar`Tensor`

.

`is_scalar_event`

```
is_scalar_event(name='is_scalar_event')
```

Indicates that `event_shape == []`

.

#### Args:

: Python`name`

`str`

prepended to names of ops created by this function.

#### Returns:

:`is_scalar_event`

`bool`

scalar`Tensor`

for each distribution in`model`

.

`kl_divergence`

```
kl_divergence(
other,
name='kl_divergence'
)
```

Computes the Kullback--Leibler divergence.

Denote this distribution (`self`

) by `p`

and the `other`

distribution by
`q`

. Assuming `p, q`

are absolutely continuous with respect to reference
measure `r`

, the KL divergence is defined as:

```
KL[p, q] = E_p[log(p(X)/q(X))]
= -int_F p(x) log q(x) dr(x) + int_F p(x) log p(x) dr(x)
= H[p, q] - H[p]
```

where `F`

denotes the support of the random variable `X ~ p`

, `H[., .]`

denotes (Shannon) cross entropy, and `H[.]`

denotes (Shannon) entropy.

#### Args:

:`other`

`tfp.distributions.Distribution`

instance.: Python`name`

`str`

prepended to names of ops created by this function.

#### Returns:

:`kl_divergence`

`self.dtype`

`Tensor`

with shape`[B1, ..., Bn]`

representing`n`

different calculations of the Kullback-Leibler divergence.

`log_cdf`

```
log_cdf(
value,
name='log_cdf',
**kwargs
)
```

Log cumulative distribution function.

Given random variable `X`

, the cumulative distribution function `cdf`

is:

```
log_cdf(x) := Log[ P[X <= x] ]
```

Often, a numerical approximation can be used for `log_cdf(x)`

that yields
a more accurate answer than simply taking the logarithm of the `cdf`

when
`x << -1`

.

#### Args:

:`value`

`float`

or`double`

`Tensor`

.: Python`name`

`str`

prepended to names of ops created by this function.: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

: a`logcdf`

`Tensor`

of shape`sample_shape(x) + self.batch_shape`

with values of type`self.dtype`

.

`log_prob`

```
log_prob(
*args,
**kwargs
)
```

Log probability density/mass function.

```
The measure methods of `JointDistribution` (`log_prob`, `prob`, etc.)
can be called either by passing a single structure of tensors or by using
named args for each part of the joint distribution state. For example,
```

`jd = tfd.JointDistributionSequential([ tfd.Normal(0., 1.), lambda z: tfd.Normal(z, 1.) ], validate_args=True) jd.dtype # ==> [tf.float32, tf.float32] z, x = sample = jd.sample() # The following calling styles are all permissable and produce the exactly # the same output. assert (jd.log_prob(sample) == jd.log_prob(value=sample) == jd.log_prob(z, x) == jd.log_prob(z=z, x=x) == jd.log_prob(z, x=x)) # These calling possibilities also imply that one can also use `*` # expansion, if `sample` is a sequence: jd.log_prob(*sample) # and similarly, if `sample` is a map, one can use `**` expansion: jd.log_prob(**sample)`

```
`JointDistribution` component distributions names are resolved via
`jd._flat_resolve_names()`, which is implemented by each `JointDistribution`
subclass (see subclass documentation for details). Generally, for components
where a name was provided---
either explicitly as the `name` argument to a distribution or as a key in a
dict-valued JointDistribution, or implicitly, e.g., by the argument name of
a `JointDistributionSequential` distribution-making function---the provided
name will be used. Otherwise the component will receive a dummy name; these
may change without warning and should not be relied upon.
Note: not all `JointDistribution` subclasses support all calling styles;
for example, `JointDistributionNamed` does not support positional arguments
(aka "unnamed arguments") unless the provided model specifies an ordering of
variables (i.e., is an `collections.OrderedDict` or `collections.namedtuple`
rather than a plain `dict`).
Note: care is taken to resolve any potential ambiguity---this is generally
possible by inspecting the structure of the provided argument and "aligning"
it to the joint distribution output structure (defined by `jd.dtype`). For
example,
```

`trivial_jd = tfd.JointDistributionSequential([tfd.Exponential(1.)]) trivial_jd.dtype # => [tf.float32] trivial_jd.log_prob([4.]) # ==> Tensor with shape `[]`. lp = trivial_jd.log_prob(4.) # ==> Tensor with shape `[]`.`

```
Notice that in the first call, `[4.]` is interpreted as a list of one
scalar while in the second call the input is a scalar. Hence both inputs
result in identical scalar outputs. If we wanted to pass an explicit
vector to the `Exponential` component---creating a vector-shaped batch
of `log_prob`s---we could instead write
`trivial_jd.log_prob(np.array([4]))`.
Args:
*args: Positional arguments: a `value` structure or component values
(see above).
**kwargs: Keyword arguments: a `value` structure or component values
(see above). May also include `name`, specifying a Python string name
for ops generated by this method.
```

#### Returns:

: a`log_prob`

`Tensor`

of shape`sample_shape(x) + self.batch_shape`

with values of type`self.dtype`

.

`log_prob_parts`

```
log_prob_parts(
value,
name='log_prob_parts'
)
```

Log probability density/mass function.

#### Args:

:`value`

`list`

of`Tensor`

s in`distribution_fn`

order for which we compute the`log_prob_parts`

and to parameterize other ("downstream") distributions.: name prepended to ops created by this function. Default value:`name`

`"log_prob_parts"`

.

#### Returns:

: a`log_prob_parts`

`tuple`

of`Tensor`

s representing the`log_prob`

for each`distribution_fn`

evaluated at each corresponding`value`

.

`log_survival_function`

```
log_survival_function(
value,
name='log_survival_function',
**kwargs
)
```

Log survival function.

Given random variable `X`

, the survival function is defined:

```
log_survival_function(x) = Log[ P[X > x] ]
= Log[ 1 - P[X <= x] ]
= Log[ 1 - cdf(x) ]
```

Typically, different numerical approximations can be used for the log
survival function, which are more accurate than `1 - cdf(x)`

when `x >> 1`

.

#### Args:

:`value`

`float`

or`double`

`Tensor`

.: Python`name`

`str`

prepended to names of ops created by this function.: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

`Tensor`

of shape `sample_shape(x) + self.batch_shape`

with values of type
`self.dtype`

.

`mean`

```
mean(
name='mean',
**kwargs
)
```

Mean.

`mode`

```
mode(
name='mode',
**kwargs
)
```

Mode.

`param_shapes`

```
@classmethod
param_shapes(
cls,
sample_shape,
name='DistributionParamShapes'
)
```

Shapes of parameters given the desired shape of a call to `sample()`

.

This is a class method that describes what key/value arguments are required
to instantiate the given `Distribution`

so that a particular shape is
returned for that instance's call to `sample()`

.

Subclasses should override class method `_param_shapes`

.

#### Args:

:`sample_shape`

`Tensor`

or python list/tuple. Desired shape of a call to`sample()`

.: name to prepend ops with.`name`

#### Returns:

`dict`

of parameter name to `Tensor`

shapes.

`param_static_shapes`

```
@classmethod
param_static_shapes(
cls,
sample_shape
)
```

param_shapes with static (i.e. `TensorShape`

) shapes.

This is a class method that describes what key/value arguments are required
to instantiate the given `Distribution`

so that a particular shape is
returned for that instance's call to `sample()`

. Assumes that the sample's
shape is known statically.

Subclasses should override class method `_param_shapes`

to return
constant-valued tensors when constant values are fed.

#### Args:

:`sample_shape`

`TensorShape`

or python list/tuple. Desired shape of a call to`sample()`

.

#### Returns:

`dict`

of parameter name to `TensorShape`

.

#### Raises:

: if`ValueError`

`sample_shape`

is a`TensorShape`

and is not fully defined.

`prob`

```
prob(
*args,
**kwargs
)
```

Probability density/mass function.

```
The measure methods of `JointDistribution` (`log_prob`, `prob`, etc.)
can be called either by passing a single structure of tensors or by using
named args for each part of the joint distribution state. For example,
```

`jd = tfd.JointDistributionSequential([ tfd.Normal(0., 1.), lambda z: tfd.Normal(z, 1.) ], validate_args=True) jd.dtype # ==> [tf.float32, tf.float32] z, x = sample = jd.sample() # The following calling styles are all permissable and produce the exactly # the same output. assert (jd.prob(sample) == jd.prob(value=sample) == jd.prob(z, x) == jd.prob(z=z, x=x) == jd.prob(z, x=x)) # These calling possibilities also imply that one can also use `*` # expansion, if `sample` is a sequence: jd.prob(*sample) # and similarly, if `sample` is a map, one can use `**` expansion: jd.prob(**sample)`

```
`JointDistribution` component distributions names are resolved via
`jd._flat_resolve_names()`, which is implemented by each `JointDistribution`
subclass (see subclass documentation for details). Generally, for components
where a name was provided---
either explicitly as the `name` argument to a distribution or as a key in a
dict-valued JointDistribution, or implicitly, e.g., by the argument name of
a `JointDistributionSequential` distribution-making function---the provided
name will be used. Otherwise the component will receive a dummy name; these
may change without warning and should not be relied upon.
Note: not all `JointDistribution` subclasses support all calling styles;
for example, `JointDistributionNamed` does not support positional arguments
(aka "unnamed arguments") unless the provided model specifies an ordering of
variables (i.e., is an `collections.OrderedDict` or `collections.namedtuple`
rather than a plain `dict`).
Note: care is taken to resolve any potential ambiguity---this is generally
possible by inspecting the structure of the provided argument and "aligning"
it to the joint distribution output structure (defined by `jd.dtype`). For
example,
```

`trivial_jd = tfd.JointDistributionSequential([tfd.Exponential(1.)]) trivial_jd.dtype # => [tf.float32] trivial_jd.prob([4.]) # ==> Tensor with shape `[]`. prob = trivial_jd.prob(4.) # ==> Tensor with shape `[]`.`

```
Notice that in the first call, `[4.]` is interpreted as a list of one
scalar while in the second call the input is a scalar. Hence both inputs
result in identical scalar outputs. If we wanted to pass an explicit
vector to the `Exponential` component---creating a vector-shaped batch
of `prob`s---we could instead write
`trivial_jd.prob(np.array([4]))`.
Args:
*args: Positional arguments: a `value` structure or component values
(see above).
**kwargs: Keyword arguments: a `value` structure or component values
(see above). May also include `name`, specifying a Python string name
for ops generated by this method.
```

#### Returns:

: a`prob`

`Tensor`

of shape`sample_shape(x) + self.batch_shape`

with values of type`self.dtype`

.

`prob_parts`

```
prob_parts(
value,
name='prob_parts'
)
```

Log probability density/mass function.

#### Args:

:`value`

`list`

of`Tensor`

s in`distribution_fn`

order for which we compute the`prob_parts`

and to parameterize other ("downstream") distributions.: name prepended to ops created by this function. Default value:`name`

`"prob_parts"`

.

#### Returns:

: a`prob_parts`

`tuple`

of`Tensor`

s representing the`prob`

for each`distribution_fn`

evaluated at each corresponding`value`

.

`quantile`

```
quantile(
value,
name='quantile',
**kwargs
)
```

Quantile function. Aka 'inverse cdf' or 'percent point function'.

Given random variable `X`

and `p in [0, 1]`

, the `quantile`

is:

```
quantile(p) := x such that P[X <= x] == p
```

#### Args:

:`value`

`float`

or`double`

`Tensor`

.: Python`name`

`str`

prepended to names of ops created by this function.: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

: a`quantile`

`Tensor`

of shape`sample_shape(x) + self.batch_shape`

with values of type`self.dtype`

.

`sample`

```
sample(
sample_shape=(),
seed=None,
name='sample',
**kwargs
)
```

Generate samples of the specified shape.

Note that a call to `sample()`

without arguments will generate a single
sample.

#### Args:

: 0D or 1D`sample_shape`

`int32`

`Tensor`

. Shape of the generated samples.: Python integer or`seed`

`tfp.util.SeedStream`

instance, for seeding PRNG.: name to give to the op.`name`

: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

: a`samples`

`Tensor`

with prepended dimensions`sample_shape`

.

`sample_distributions`

```
sample_distributions(
sample_shape=(),
seed=None,
value=None,
name='sample_distributions'
)
```

Generate samples and the (random) distributions.

Note that a call to `sample()`

without arguments will generate a single
sample.

#### Args:

: 0D or 1D`sample_shape`

`int32`

`Tensor`

. Shape of the generated samples.: Python integer seed for generating random numbers.`seed`

:`value`

`list`

of`Tensor`

s in`distribution_fn`

order to use to parameterize other ("downstream") distribution makers. Default value:`None`

(i.e., draw a sample from each distribution).: name prepended to ops created by this function. Default value:`name`

`"sample_distributions"`

.

#### Returns:

: a`distributions`

`tuple`

of`Distribution`

instances for each of`distribution_fn`

.: a`samples`

`tuple`

of`Tensor`

s with prepended dimensions`sample_shape`

for each of`distribution_fn`

.

`stddev`

```
stddev(
name='stddev',
**kwargs
)
```

Standard deviation.

Standard deviation is defined as,

```
stddev = E[(X - E[X])**2]**0.5
```

where `X`

is the random variable associated with this distribution, `E`

denotes expectation, and `stddev.shape = batch_shape + event_shape`

.

#### Args:

: Python`name`

`str`

prepended to names of ops created by this function.: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

: Floating-point`stddev`

`Tensor`

with shape identical to`batch_shape + event_shape`

, i.e., the same shape as`self.mean()`

.

`survival_function`

```
survival_function(
value,
name='survival_function',
**kwargs
)
```

Survival function.

Given random variable `X`

, the survival function is defined:

```
survival_function(x) = P[X > x]
= 1 - P[X <= x]
= 1 - cdf(x).
```

#### Args:

:`value`

`float`

or`double`

`Tensor`

.: Python`name`

`str`

prepended to names of ops created by this function.: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

`Tensor`

of shape `sample_shape(x) + self.batch_shape`

with values of type
`self.dtype`

.

`variance`

```
variance(
name='variance',
**kwargs
)
```

Variance.

Variance is defined as,

```
Var = E[(X - E[X])**2]
```

where `X`

is the random variable associated with this distribution, `E`

denotes expectation, and `Var.shape = batch_shape + event_shape`

.

#### Args:

: Python`name`

`str`

prepended to names of ops created by this function.: Named arguments forwarded to subclass implementation.`**kwargs`

#### Returns:

: Floating-point`variance`

`Tensor`

with shape identical to`batch_shape + event_shape`

, i.e., the same shape as`self.mean()`

.