tfp.distributions.OrderedLogistic

Ordered logistic distribution.

Inherits From: AutoCompositeTensorDistribution, Distribution, AutoCompositeTensor

tfp.distributions.OrderedLogistic(
    cutpoints,
    loc,
    dtype=tf.int32,
    validate_args=False,
    allow_nan_stats=True,
    name='OrderedLogistic'
)

The OrderedLogistic distribution is parameterized by a location and a set of cutpoints. It is defined over the integers {0, 1, ..., K} for K non-decreasing cutpoints.

One often useful way to interpret this distribution is by imagining a draw from a latent/unobserved logistic distribution with location loc and scale 1 and then only considering the index of the bin defined by the K cutpoints this draw falls between. An example implementation of this idea is as follows:

cutpoints = [0.0, 1.0]
loc = 0.5

def probs_from_latent(latent):
  augmented_cutpoints = tf.concat([[-np.inf], cutpoints, [np.inf]], axis=0)
  below = latent[..., tf.newaxis] < augmented_cutpoints[1:]
  above = latent[..., tf.newaxis] > augmented_cutpoints[:-1]
  return tf.cast(below & above, tf.float32)

latent_and_ordered_logistic = tfd.JointDistributionSequential([
  tfd.Logistic(loc=loc, scale=1.),
  lambda l: tfd.Categorical(probs=probs_from_latent(l), dtype=tf.float32)
])

tf.stack(latent_and_ordered_logistic.sample(5), axis=1)
# ==> array([[ 0.6434291,  1.       ],
             [ 3.0963311,  2.       ],
             [-1.2692463,  0.       ],
             [-3.3595495,  0.       ],
             [ 0.8468886,  1.       ]], dtype=float32)

which displays that latent draws < cutpoints[0] = 0. are category 0, latent draws between cutpoints[0] = 0. and cutpoints[1] = 1. are category 1, and finally latent draws > cutpoints[1] = 1. (the final cutpoint in this example) are the top category of 2.

This distribution can be useful for modelling outcomes which have inherent ordering but no real numerical values, for example modelling the outcome of a survey question where the responses are [bad, mediocre, good], which would be coded as [0, 1, 2] and the model would contain two cutpoints (K = 2).

Mathematical Details

The survival function (s) is:

s(x; c, eta) = P(X > x)
             = sigmoid(eta - concat([-inf, c, inf])[x+1])

where loc = eta is the location of a latent logistic distribution and cutpoints = c define points to split up this latent distribution. The concatenation of the cutpoints, concat([-inf, c, inf]), ensures that s(K) = P(X > K) = 0 and s(-1) = P(X > -1) = 1 which aids in the definition of the probability mass function (pmf):

pmf(x; c, eta) = P(X > x-1) - P(x > x)
               = s(x-1; c, eta) - s(x; c, eta)

Examples

Create a symmetric 4-class distribution:

import tensorflow_probability as tfp
tfd = tfp.distributions

dist = tfd.OrderedLogistic(cutpoints=[-2., 0., 2.], loc=0.)

dist.categorical_probs()
# ==> array([0.11920293, 0.38079706, 0.3807971 , 0.11920291], dtype=float32)

Create a batch of 3 4-class distributions via batching the location of the underlying latent logistic distribution. Additionally, compared to the above example, the cutpoints have moved closer together/to zero, thus the probability of a latent draw falling in the inner two categories has shrunk for the loc = 0 case:

dist = tfd.OrderedLogistic(cutpoints=[-1., 0., 1.], loc=[-1., 0., 1.])

dist.categorical_probs()
# ==> array([[0.5       , 0.23105855, 0.1497385 , 0.11920291],
             [0.2689414 , 0.23105861, 0.23105855, 0.26894143],
             [0.11920293, 0.14973842, 0.23105861, 0.5       ]], dtype=float32)

Some further functionallity:

dist = tfd.OrderedLogistic(cutpoints=[-1., 0., 2.], loc=0.)

dist.prob([0, 3])
# ==> array([0.2689414 , 0.11920291], dtype=float32)

dist.log_prob(1)
# ==> -1.4650838

dist.sample(3)
# ==> array([0, 1, 1], dtype=int32)

dist.entropy()
# ==> 1.312902

Args
`cutpoints`	A floating-point `Tensor` with shape `[B1, ..., Bb, K]` where `b >= 0` indicates the number of batch dimensions. Each entry is then a `K`-length vector of cutpoints. The vector of cutpoints should be non-decreasing, which is only checked if `validate_args=True`.
`loc`	A floating-point `Tensor` with shape `[B1, ..., Bb]` where `b >= 0` indicates the number of batch dimensions. The entries represent the mean(s) of the latent logistic distribution(s). Different batch shapes for `cutpoints` and `loc` are permitted, with the distribution `batch_shape` being `tf.shape(loc[..., tf.newaxis] - cutpoints)[:-1]` assuming the subtraction is a valid broadcasting operation.
`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. mode) 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.

Attributes
`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.
`batch_shape`	Shape of a single sample from a single event index as a `TensorShape`. May be partially defined or unknown. The batch dimensions are indexes into independent, non-identical parameterizations of this distribution.
`cutpoints`	Input argument `cutpoints`.
`dtype`	The `DType` of `Tensor`s handled by this `Distribution`.
`event_shape`	Shape of a single sample from a single batch as a `TensorShape`. May be partially defined or unknown.
`experimental_shard_axis_names`	The list or structure of lists of active shard axis names.
`loc`	Input argument `loc`.
`name`	Name prepended to all ops created by this `Distribution`.
`name_scope`	Returns a `tf.name_scope` instance for this class.
`non_trainable_variables`	Sequence of non-trainable variables owned by this module and its submodules. Note: this method uses reflection to find variables on the current instance and submodules. For performance reasons you may wish to cache the result of calling this method if you don't expect the return value to change.
`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`.
`submodules`	Sequence of all sub-modules. Submodules are modules which are properties of this module, or found as properties of modules which are properties of this module (and so on). `a = tf.Module()` `b = tf.Module()` `c = tf.Module()` `a.b = b` `b.c = c` `list(a.submodules) == [b, c]` `True` `list(b.submodules) == [c]` `True` `list(c.submodules) == []` `True`
`trainable_variables`	Sequence of trainable variables owned by this module and its submodules. Note: this method uses reflection to find variables on the current instance and submodules. For performance reasons you may wish to cache the result of calling this method if you don't expect the return value to change.
`validate_args`	Python `bool` indicating possibly expensive checks are enabled.
`variables`	Sequence of variables owned by this module and its submodules. Note: this method uses reflection to find variables on the current instance and submodules. For performance reasons you may wish to cache the result of calling this method if you don't expect the return value to change.

Args
`value`	`float` or `double` `Tensor`.
`name`	Python `str` prepended to names of ops created by this function.
`**kwargs`	Named arguments forwarded to subclass implementation.

Args
`other`	`tfp.distributions.Distribution` instance.
`name`	Python `str` prepended to names of ops created by this function.

Args
`*args`	Passed to implementation `_default_event_space_bijector`.
`**kwargs`	Passed to implementation `_default_event_space_bijector`.

Args
`value`	a `Tensor` valid sample from this distribution family.
`sample_ndims`	Positive `int` Tensor number of leftmost dimensions of `value` that index i.i.d. samples. Default value: `1`.
`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. Default value: `False`.
`**init_kwargs`	Additional keyword arguments passed through to `cls.__init__`. These take precedence in case of collision with the fitted parameters; for example, `tfd.Normal.experimental_fit([1., 1.], scale=20.)` returns a Normal distribution with `scale=20.` rather than the maximum likelihood parameter `scale=0.`.

Args
`value`	`float` or `double` `Tensor`.
`backward_compat`	`bool` specifying whether to fall back to returning `FullSpace` as the tangent space, and representing R^n with the standard basis.
`**kwargs`	Named arguments forwarded to subclass implementation.

Returns
`log_prob`	a `Tensor` representing the log probability density, of shape `sample_shape(x) + self.batch_shape` with values of type `self.dtype`.
`tangent_space`	a `TangentSpace` object (by default `FullSpace`) representing the tangent space to the manifold at `value`.

Args
`sample_shape`	integer `Tensor` desired shape of samples to draw. Default value: `()`.
`seed`	PRNG seed; see `tfp.random.sanitize_seed` for details. Default value: `None`.
`name`	name to give to the op. Default value: `'sample_and_log_prob'`.
`**kwargs`	Named arguments forwarded to subclass implementation.

Returns
`samples`	a `Tensor`, or structure of `Tensor`s, with prepended dimensions `sample_shape`.
`log_prob`	a `Tensor` of shape `sample_shape(x) + self.batch_shape` with values of type `self.dtype`.

Args
`sample_shape`	`Tensor` or python list/tuple. Desired shape of a call to `sample()`.
`name`	name to prepend ops with.

Args
`dtype`	Optional float `dtype` to assume for continuous-valued parameters. Some constraining bijectors require advance knowledge of the dtype because certain constants (e.g., `tfb.Softplus.low`) must be instantiated with the same dtype as the values to be transformed.
`num_classes`	Optional `int` `Tensor` number of classes to assume when inferring the shape of parameters for categorical-like distributions. Otherwise ignored.

Args
`sample_shape`	0D or 1D `int32` `Tensor`. Shape of the generated samples.
`seed`	PRNG seed; see `tfp.random.sanitize_seed` for details.
`name`	name to give to the op.
`**kwargs`	Named arguments forwarded to subclass implementation.

tfp.distributions.OrderedLogistic

Mathematical Details

Examples

Args

Attributes

Methods

batch_shape_tensor

categorical_log_probs

categorical_probs

cdf

copy

covariance

cross_entropy

entropy

event_shape_tensor

experimental_default_event_space_bijector

experimental_fit

experimental_local_measure

experimental_sample_and_log_prob

is_scalar_batch

is_scalar_event

kl_divergence

log_cdf

log_prob

log_survival_function

mean

mode

param_shapes

param_static_shapes

parameter_properties

prob

quantile

sample

stddev

survival_function

unnormalized_log_prob

variance

with_name_scope

__getitem__

__iter__

`batch_shape_tensor`

`categorical_log_probs`

`categorical_probs`

`cdf`

`copy`

`covariance`

`cross_entropy`

`entropy`

`event_shape_tensor`

`experimental_default_event_space_bijector`

`experimental_fit`

`experimental_local_measure`

`experimental_sample_and_log_prob`

`is_scalar_batch`

`is_scalar_event`

`kl_divergence`

`log_cdf`

`log_prob`

`log_survival_function`

`mean`

`mode`

`param_shapes`

`param_static_shapes`

`parameter_properties`

`prob`

`quantile`

`sample`

`stddev`

`survival_function`

`unnormalized_log_prob`

`variance`

`with_name_scope`

`getitem`

`iter`