tfp.distributions.PoissonLogNormalQuadratureCompound

tfp.distributions.PoissonLogNormalQuadratureCompound(
    loc,
    scale,
    quadrature_size=8,
    quadrature_fn=tfp.distributions.quadrature_scheme_lognormal_quantiles,
    validate_args=False,
    allow_nan_stats=True,
    name='PoissonLogNormalQuadratureCompound'
)

p(k|loc, scale)
= int_{R_+} dl LogNormal(l | loc, scale) Poisson(k | l)
approx= sum{ prob[d] Poisson(k | lambda(grid[d])) : d=0, ..., deg-1 }

pdf(k | loc, scale, deg)
  = sum{ prob[d] Poisson(k | lambda=exp(grid[d]))
        : d=0, ..., deg-1 }

tfd = tfp.distributions

# Create two batches of PoissonLogNormalQuadratureCompounds, one with
# prior `loc = 0.` and another with `loc = 1.` In both cases `scale = 1.`
pln = tfd.PoissonLogNormalQuadratureCompound(
    loc=[0., -0.5],
    scale=1.,
    quadrature_size=10,
    validate_args=True)

<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2"><h2 class="add-link">Args</h2></th></tr>

<tr>
<td>
`loc`<a id="loc"></a>
</td>
<td>
`float`-like (batch of) scalar `Tensor`; the location parameter of
the LogNormal prior.
</td>
</tr><tr>
<td>
`scale`<a id="scale"></a>
</td>
<td>
`float`-like (batch of) scalar `Tensor`; the scale parameter of
the LogNormal prior.
</td>
</tr><tr>
<td>
`quadrature_size`<a id="quadrature_size"></a>
</td>
<td>
Python `int` scalar representing the number of quadrature
points.
</td>
</tr><tr>
<td>
`quadrature_fn`<a id="quadrature_fn"></a>
</td>
<td>
Python callable taking `loc`, `scale`,
`quadrature_size`, `validate_args` and returning `tuple(grid, probs)`
representing the LogNormal grid and corresponding normalized weight.
Default value: `quadrature_scheme_lognormal_quantiles`.
</td>
</tr><tr>
<td>
`validate_args`<a id="validate_args"></a>
</td>
<td>
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.
</td>
</tr><tr>
<td>
`allow_nan_stats`<a id="allow_nan_stats"></a>
</td>
<td>
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.
</td>
</tr><tr>
<td>
`name`<a id="name"></a>
</td>
<td>
Python `str` name prefixed to Ops created by this class.
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2"><h2 class="add-link">Raises</h2></th></tr>

<tr>
<td>
`TypeError`<a id="TypeError"></a>
</td>
<td>
if `quadrature_grid` and `quadrature_probs` have different base
`dtype`.
</td>
</tr>
</table>





<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2"><h2 class="add-link">Attributes</h2></th></tr>

<tr>
<td>
`allow_nan_stats`<a id="allow_nan_stats"></a>
</td>
<td>
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.
</td>
</tr><tr>
<td>
`batch_shape`<a id="batch_shape"></a>
</td>
<td>
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.
</td>
</tr><tr>
<td>
`dtype`<a id="dtype"></a>
</td>
<td>
The `DType` of `Tensor`s handled by this `Distribution`.
</td>
</tr><tr>
<td>
`event_shape`<a id="event_shape"></a>
</td>
<td>
Shape of a single sample from a single batch as a `TensorShape`.

May be partially defined or unknown.
</td>
</tr><tr>
<td>
`experimental_shard_axis_names`<a id="experimental_shard_axis_names"></a>
</td>
<td>
The list or structure of lists of active shard axis names.
</td>
</tr><tr>
<td>
`loc`<a id="loc"></a>
</td>
<td>
Location parameter of the LogNormal prior.
</td>
</tr><tr>
<td>
`name`<a id="name"></a>
</td>
<td>
Name prepended to all ops created by this `Distribution`.
</td>
</tr><tr>
<td>
`name_scope`<a id="name_scope"></a>
</td>
<td>
Returns a `tf.name_scope` instance for this class.
</td>
</tr><tr>
<td>
`non_trainable_variables`<a id="non_trainable_variables"></a>
</td>
<td>
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.
</td>
</tr><tr>
<td>
`parameters`<a id="parameters"></a>
</td>
<td>
Dictionary of parameters used to instantiate this `Distribution`.
</td>
</tr><tr>
<td>
`quadrature_size`<a id="quadrature_size"></a>
</td>
<td>

</td>
</tr><tr>
<td>
`reparameterization_type`<a id="reparameterization_type"></a>
</td>
<td>
Describes how samples from the distribution are reparameterized.

Currently this is one of the static instances
`tfd.FULLY_REPARAMETERIZED` or `tfd.NOT_REPARAMETERIZED`.
</td>
</tr><tr>
<td>
`scale`<a id="scale"></a>
</td>
<td>
Scale parameter of the LogNormal prior.
</td>
</tr><tr>
<td>
`submodules`<a id="submodules"></a>
</td>
<td>
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).

<pre class="devsite-click-to-copy prettyprint lang-py">
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">a = tf.Module()</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">b = tf.Module()</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">c = tf.Module()</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">a.b = b</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">b.c = c</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(a.submodules) == [b, c]</code>
<code class="no-select nocode">True</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(b.submodules) == [c]</code>
<code class="no-select nocode">True</code>
<code class="devsite-terminal" data-terminal-prefix="&gt;&gt;&gt;">list(c.submodules) == []</code>
<code class="no-select nocode">True</code>
</pre>

</td>
</tr><tr>
<td>
`trainable_variables`<a id="trainable_variables"></a>
</td>
<td>
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.
</td>
</tr><tr>
<td>
`validate_args`<a id="validate_args"></a>
</td>
<td>
Python `bool` indicating possibly expensive checks are enabled.
</td>
</tr><tr>
<td>
`variables`<a id="variables"></a>
</td>
<td>
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.
</td>
</tr>
</table>



## Methods

<h3 id="batch_shape_tensor"><code>batch_shape_tensor</code></h3>

<a target="_blank" class="external" href="https://github.com/tensorflow/probability/blob/v0.23.0/tensorflow_probability/python/distributions/distribution.py#L992-L1030">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>batch_shape_tensor(
    name=&#x27;batch_shape_tensor&#x27;
)
</code></pre>

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.

<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Args</th></tr>

<tr>
<td>
`name`
</td>
<td>
name to give to the op
</td>
</tr>
</table>



<!-- Tabular view -->
 <table class="responsive fixed orange">
<colgroup><col width="214px"><col></colgroup>
<tr><th colspan="2">Returns</th></tr>

<tr>
<td>
`batch_shape`
</td>
<td>
`Tensor`.
</td>
</tr>
</table>



<h3 id="cdf"><code>cdf</code></h3>

<a target="_blank" class="external" href="https://github.com/tensorflow/probability/blob/v0.23.0/tensorflow_probability/python/distributions/distribution.py#L1411-L1429">View source</a>

<pre class="devsite-click-to-copy prettyprint lang-py tfo-signature-link">
<code>cdf(
    value, name=&#x27;cdf&#x27;, **kwargs
)
</code></pre>

Cumulative distribution function.

Given random variable `X`, the cumulative distribution function `cdf` is:

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

copy(
    **override_parameters_kwargs
)

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

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

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

cross_entropy(
    other, name='cross_entropy'
)

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

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

event_shape_tensor(
    name='event_shape_tensor'
)

experimental_default_event_space_bijector(
    *args, **kwargs
)

@classmethod
experimental_fit(
    value, sample_ndims=1, validate_args=False, **init_kwargs
)

experimental_local_measure(
    value, backward_compat=False, **kwargs
)

experimental_sample_and_log_prob(
    sample_shape=(), seed=None, name='sample_and_log_prob', **kwargs
)

def _sample_and_log_prob(self, sample_shape, seed, **kwargs):
  x = self.sample(sample_shape=sample_shape, seed=seed, **kwargs)
  return x, self.log_prob(x, **kwargs)

is_scalar_batch(
    name='is_scalar_batch'
)

is_scalar_event(
    name='is_scalar_event'
)

kl_divergence(
    other, name='kl_divergence'
)

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]

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

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

log_prob(
    value, name='log_prob', **kwargs
)

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

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

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

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

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

@classmethod
param_static_shapes(
    sample_shape
)

@classmethod
parameter_properties(
    dtype=tf.float32, num_classes=None
)

poisson_and_mixture_distributions()

prob(
    value, name='prob', **kwargs
)

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

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

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

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

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

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

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

unnormalized_log_prob(
    value, name='unnormalized_log_prob', **kwargs
)

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

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

@classmethod
with_name_scope(
    method
)

class MyModule(tf.Module):
  @tf.Module.with_name_scope
  def __call__(self, x):
    if not hasattr(self, 'w'):
      self.w = tf.Variable(tf.random.normal([x.shape[1], 3]))
    return tf.matmul(x, self.w)

mod = MyModule()
mod(tf.ones([1, 2]))
<tf.Tensor: shape=(1, 3), dtype=float32, numpy=..., dtype=float32)>
mod.w
<tf.Variable 'my_module/Variable:0' shape=(2, 3) dtype=float32,
numpy=..., dtype=float32)>

__getitem__(
    slices
)

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.linalg.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]

__iter__()