# LostTech.TensorFlow : API Documentation

Type VectorSinhArcsinhDiag

Namespace tensorflow.contrib.distributions

Parent TransformedDistribution

Interfaces IVectorSinhArcsinhDiag

The (diagonal) SinhArcsinh transformation of a distribution on `R^k`.

This distribution models a random vector `Y = (Y1,...,Yk)`, 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 iid random vector `Z = (Z1,...,Zk)`, we define the VectorSinhArcsinhDiag transformation of `Z`, `Y`, parameterized by `(loc, scale, skewness, tailweight)`, via the relation (with `@` denoting matrix multiplication):

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

### Public static methods

#### VectorSinhArcsinhDiagNewDyn(object loc, object scale_diag, object scale_identity_multiplier, object skewness, object tailweight, object distribution, ImplicitContainer<T> validate_args, ImplicitContainer<T> allow_nan_stats, ImplicitContainer<T> name)

Construct VectorSinhArcsinhDiag distribution on `R^k`. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed after 2018-10-01. Instructions for updating: The TensorFlow Distributions library has moved to TensorFlow Probability (https://github.com/tensorflow/probability). You should update all references to use `tfp.distributions` instead of `tf.contrib.distributions`.

The arguments `scale_diag` and `scale_identity_multiplier` combine to define the diagonal `scale` referred to in this class docstring:

```none scale = diag(scale_diag + scale_identity_multiplier * ones(k)) ```

The `batch_shape` is the broadcast shape between `loc` and `scale` arguments.

The `event_shape` is given by last dimension of the matrix implied by `scale`. The last dimension of `loc` (if provided) must broadcast with this

##### Parameters
`object` loc
Floating-point `Tensor`. If this is set to `None`, `loc` is implicitly `0`. When specified, may have shape `[B1,..., Bb, k]` where `b >= 0` and `k` is the event size.
`object` scale_diag
Non-zero, floating-point `Tensor` representing a diagonal matrix added to `scale`. May have shape `[B1,..., Bb, k]`, `b >= 0`, and characterizes `b`-batches of `k x k` diagonal matrices added to `scale`. When both `scale_identity_multiplier` and `scale_diag` are `None` then `scale` is the `Identity`.
`object` scale_identity_multiplier
Non-zero, floating-point `Tensor` representing a scale-identity-matrix added to `scale`. May have shape `[B1,..., Bb]`, `b >= 0`, and characterizes `b`-batches of scale `k x k` identity matrices added to `scale`. When both `scale_identity_multiplier` and `scale_diag` are `None` then `scale` is the `Identity`.
`object` skewness
Skewness parameter. floating-point `Tensor` with shape broadcastable with `event_shape`.
`object` tailweight
Tailweight parameter. floating-point `Tensor` with shape broadcastable with `event_shape`.
`object` distribution
`tf.Distribution`-like instance. Distribution from which `k` iid samples are used as input to transformation `F`. Default is `tfp.distributions.Normal(loc=0., scale=1.)`. Must be a scalar-batch, scalar-event distribution. Typically `distribution.reparameterization_type = FULLY_REPARAMETERIZED` or it is a function of non-trainable parameters. WARNING: If you backprop through a VectorSinhArcsinhDiag sample and `distribution` is not `FULLY_REPARAMETERIZED` yet is a function of trainable variables, then the gradient will be incorrect!
`ImplicitContainer<T>` 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.
`ImplicitContainer<T>` 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.
`ImplicitContainer<T>` name
Python `str` name prefixed to Ops created by this class.

### Public properties

#### objectloc get;

The `loc` in `Y := loc + scale @ F(Z) * (2 / F(2)).

#### objectloc_dyn get;

The `loc` in `Y := loc + scale @ F(Z) * (2 / F(2)).

#### objectscale get;

The `LinearOperator` `scale` in `Y := loc + scale @ F(Z) * (2 / F(2)).

#### objectscale_dyn get;

The `LinearOperator` `scale` in `Y := loc + scale @ F(Z) * (2 / F(2)).

#### objectskewness get;

Controls the skewness. `Skewness > 0` means right skew.

#### objectskewness_dyn get;

Controls the skewness. `Skewness > 0` means right skew.

#### objecttailweight get;

Controls the tail decay. `tailweight > 1` means faster than Normal.

#### objecttailweight_dyn get;

Controls the tail decay. `tailweight > 1` means faster than Normal.