Type SinhArcsinh
Namespace tensorflow.contrib.distributions
Parent TransformedDistribution
Interfaces ISinhArcsinh
The SinhArcsinh transformation of a distribution on `(-inf, inf)`. This distribution models a random variable, making use of
a `SinhArcsinh` transformation (which has adjustable tailweight and skew),
a rescaling, and a shift. The `SinhArcsinh` transformation of the Normal is described in great depth in
[Sinh-arcsinh distributions](https://www.jstor.org/stable/27798865).
Here we use a slightly different parameterization, in terms of `tailweight`
and `skewness`. Additionally we allow for distributions other than Normal,
and control over `scale` as well as a "shift" parameter `loc`. #### Mathematical Details Given random variable `Z`, we define the SinhArcsinh
transformation of `Z`, `Y`, parameterized by
`(loc, scale, skewness, tailweight)`, via the relation: ```
Y := loc + scale * F(Z) * (2 / F_0(2))
F(Z) := Sinh( (Arcsinh(Z) + skewness) * tailweight )
F_0(Z) := Sinh( Arcsinh(Z) * tailweight )
``` This distribution is similar to the location-scale transformation
`L(Z) := loc + scale * Z` in the following ways: * If `skewness = 0` and `tailweight = 1` (the defaults), `F(Z) = Z`, and then
`Y = L(Z)` exactly.
* `loc` is used in both to shift the result by a constant factor.
* The multiplication of `scale` by `2 / F_0(2)` ensures that if `skewness = 0`
`P[Y - loc <= 2 * scale] = P[L(Z) - loc <= 2 * scale]`.
Thus it can be said that the weights in the tails of `Y` and `L(Z)` beyond
`loc + 2 * scale` are the same. This distribution is different than `loc + scale * Z` due to the
reshaping done by `F`: * Positive (negative) `skewness` leads to positive (negative) skew.
* positive skew means, the mode of `F(Z)` is "tilted" to the right.
* positive skew means positive values of `F(Z)` become more likely, and
negative values become less likely.
* Larger (smaller) `tailweight` leads to fatter (thinner) tails.
* Fatter tails mean larger values of `|F(Z)|` become more likely.
* `tailweight < 1` leads to a distribution that is "flat" around `Y = loc`,
and a very steep drop-off in the tails.
* `tailweight > 1` leads to a distribution more peaked at the mode with
heavier tails. To see the argument about the tails, note that for `|Z| >> 1` and
`|Z| >> (|skewness| * tailweight)**tailweight`, we have
`Y approx 0.5 Z**tailweight e**(sign(Z) skewness * tailweight)`. To see the argument regarding multiplying `scale` by `2 / F_0(2)`, ```
P[(Y - loc) / scale <= 2] = P[F(Z) * (2 / F_0(2)) <= 2]
= P[F(Z) <= F_0(2)]
= P[Z <= 2] (if F = F_0).
```
Properties
- allow_nan_stats
- allow_nan_stats_dyn
- batch_shape
- batch_shape_dyn
- bijector
- bijector_dyn
- distribution
- distribution_dyn
- dtype
- dtype_dyn
- event_shape
- event_shape_dyn
- loc
- loc_dyn
- name
- name_dyn
- parameters
- parameters_dyn
- PythonObject
- reparameterization_type
- reparameterization_type_dyn
- scale
- scale_dyn
- skewness
- skewness_dyn
- tailweight
- tailweight_dyn
- validate_args
- validate_args_dyn
Public properties
object allow_nan_stats get;
object allow_nan_stats_dyn get;
TensorShape batch_shape get;
object batch_shape_dyn get;
object bijector get;
object bijector_dyn get;
object distribution get;
object distribution_dyn get;
object dtype get;
object dtype_dyn get;
TensorShape event_shape get;
object event_shape_dyn get;
object loc get;
The `loc` in `Y := loc + scale @ F(Z) * (2 / F(2)).
object loc_dyn get;
The `loc` in `Y := loc + scale @ F(Z) * (2 / F(2)).
string name get;
object name_dyn get;
IDictionary<object, object> parameters get;
object parameters_dyn get;
object PythonObject get;
object reparameterization_type get;
object reparameterization_type_dyn get;
object scale get;
The `LinearOperator` `scale` in `Y := loc + scale @ F(Z) * (2 / F(2)).
object scale_dyn get;
The `LinearOperator` `scale` in `Y := loc + scale @ F(Z) * (2 / F(2)).
object skewness get;
Controls the skewness. `Skewness > 0` means right skew.
object skewness_dyn get;
Controls the skewness. `Skewness > 0` means right skew.
object tailweight get;
Controls the tail decay. `tailweight > 1` means faster than Normal.
object tailweight_dyn get;
Controls the tail decay. `tailweight > 1` means faster than Normal.