View source on GitHub |

Half-Student's t distribution.

Inherits From: `Distribution`

```
tfp.experimental.substrates.jax.distributions.HalfStudentT(
df, loc, scale, validate_args=False, allow_nan_stats=True, name='HalfStudentT'
)
```

The half-Student's t distribution has three parameters: degree of freedom
`df`

, location `loc`

, and scale `scale`

. It represents the right half of the
two symmetric halves in a Student's t
distribution.

#### Mathematical Details

The probability density function (pdf) for the half-Student's t distribution is given by

```
pdf(x; df, loc, scale) = (1 + y**2 / df)**(-0.5 (df + 1)) / Z,
where
y = (x - loc) / scale
Z = 2 * scale * sqrt(df * pi) * gamma(0.5 * df) / gamma(0.5 * (df + 1))
```

where:

`df`

is a positive scalar in`R`

,`loc`

is a scalar in`R`

,`scale`

is a positive scalar in`R`

,`Z`

is the normalization constant, and`Gamma`

is the gamma function.

The support of the distribution is given by the interval `[loc, infinity)`

.

Samples of this distribution are reparameterized (pathwise differentiable). The derivatives are computed using the approach described in the paper

Michael Figurnov, Shakir Mohamed, Andriy Mnih. Implicit Reparameterization Gradients, 2018

#### Examples

```
import tensorflow_probability as tfp; tfp = tfp.experimental.substrates.jax
tfd = tfp.distributions
# Define a single scalar Student t distribution.
single_dist = tfd.HalfStudentT(df=3, loc=0, scale=1)
# Evaluate the pdf at 1, returning a scalar Tensor.
single_dist.prob(1.)
# Define a batch of two scalar valued half Student t's.
# The first has degrees of freedom 2, mean 1, and scale 11.
# The second 3, 2 and 22.
multi_dist = tfd.HalfStudentT(df=[2, 3], loc=[1, 2], scale=[11, 22])
# Evaluate the pdf of the first distribution at 1.5, and the second on 2.5,
# returning a length two tensor.
multi_dist.prob([1.5, 2.5])
# Get 3 samples, returning a 3 x 2 tensor.
multi_dist.sample(3)
```

Arguments are broadcast when possible.

```
# Define a batch of two half Student's t distributions.
# Both have df 2 and mean 1, but different scales.
dist = tfd.HalfStudentT(df=2, loc=1, scale=[11, 22.])
# Evaluate the pdf of both distributions on the same point, 3.0,
# returning a length 2 tensor.
dist.prob(3.0)
```

Compute the gradients of samples w.r.t. the parameters via implicit reparameterization through the gamma:

```
df = tf.constant(2.0)
loc = tf.constant(2.0)
scale = tf.constant(11.0)
dist = tfd.HalfStudentT(df=df, loc=loc, scale=scale)
with tf.GradientTape() as tape:
tape.watch((df, loc, scale))
loss = tf.reduce_mean(dist.sample(5))
# Unbiased stochastic gradients of the loss function
grads = tape.gradient(loss, (df, loc, scale))
```

#### Args:

: Floating-point`df`

`Tensor`

. The degrees of freedom of the distribution(s).`df`

must contain only positive values.: Floating-point`loc`

`Tensor`

; the location(s) of the distribution(s).: Floating-point`scale`

`Tensor`

; the scale(s) of the distribution(s). Must contain only positive values.: Python`validate_args`

`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. Default value:`False`

(i.e. do not validate args).: Python`allow_nan_stats`

`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. Default value:`True`

.: Python`name`

`str`

name prefixed to Ops created by this class. Default value: 'HalfStudentT'.

#### Attributes:

: Python`allow_nan_stats`

`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.

: Shape of a single sample from a single event index as a`batch_shape`

`TensorShape`

.May be partially defined or unknown.

The batch dimensions are indexes into independent, non-identical parameterizations of this distribution.

: Distribution parameter for the degrees of freedom.`df`

: The`dtype`

`DType`

of`Tensor`

s handled by this`Distribution`

.: Shape of a single sample from a single batch as a`event_shape`

`TensorShape`

.May be partially defined or unknown.

: Distribution parameter for the location.`loc`

: Name prepended to all ops created by this`name`

`Distribution`

.: Dictionary of parameters used to instantiate this`parameters`

`Distribution`

.: Describes how samples from the distribution are reparameterized.`reparameterization_type`

Currently this is one of the static instances

`tfd.FULLY_REPARAMETERIZED`

or`tfd.NOT_REPARAMETERIZED`

.: Distribution parameter for the scale.`scale`

`trainable_variables`

: Python`validate_args`

`bool`

indicating possibly expensive checks are enabled.`variables`

#### Raises:

: if`TypeError`

`loc`

and`scale`

have different`dtype`

.

## 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.stateless_normal([5, 3, 2, 2])
cov = tf.matmul(x, x, transpose_b=True)
chol = tf.cholesky(cov)
loc = tf.random.stateless_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(
name='batch_shape_tensor'
)
```

Shape of a single sample from a single event index as a 1-D `Tensor`

.

The batch dimensions are indexes into independent, non-identical parameterizations of this distribution.

#### Args:

: name to give to the op`name`

#### Returns:

:`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(
name='event_shape_tensor'
)
```

Shape of a single sample from a single batch as a 1-D int32 `Tensor`

.

#### Args:

: name to give to the op`name`

#### Returns:

:`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`

.

`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(
value, name='log_prob', **kwargs
)
```

Log probability density/mass function.

#### 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`log_prob`

`Tensor`

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

with values of type`self.dtype`

.

`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.

Additional documentation from `HalfStudentT`

:

The mean of a half-Student's t is defined if `df > 1`

, otherwise it is
`NaN`

. If `self.allow_nan_stats=False`

, then an exception will be raised
rather than returning `NaN`

.

`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(
value, name='prob', **kwargs
)
```

Probability density/mass function.

#### 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`prob`

`Tensor`

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

with values of type`self.dtype`

.

`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`

.

`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`

.

Additional documentation from `HalfStudentT`

:

The variance for half-Student's t is

```
defined, when df > 2
infinity, when 1 < df <= 2
NaN, when df <= 1
```

#### 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()`

.