Factorial_Mixture.ipynb

Kernel: Python 3

Copyright 2018 The TensorFlow Probability Authors.

Licensed under the Apache License, Version 2.0 (the "License");

#@title Licensed under the Apache License, Version 2.0 (the "License"); { display-mode: "form" }
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Mezcla factorial

Ver en TensorFlow.org

Ejecutar en Google Colab

Ver fuente en GitHub

Descargar el bloc de notas

En este bloc de notas, mostramos cómo usar TensorFlow Probability (TFP) para tomar muestras de una distribución factorial de mezcla de gaussianas definida como: $$p(x_1, ..., x_n) = \prod_i p_i(x_i)$$ donde: $$\begin{align*} p_i &\equiv \frac{1}{K}\sum_{k=1}^K \pi_{ik}\,\text{Normal}\left(\text{loc}=\mu_{ik},\, \text{scale}=\sigma_{ik}\right)\\1&=\sum_{k=1}^K\pi_{ik}, \forall i.\hphantom{MMMMMMMMMMM}\end{align*}$$

Cada variable $x_i$ se modela como una mezcla de gaussianas y la distribución conjunta sobre todas las $n$ variables es un producto de estas densidades.

A partir de un conjunto de datos $x^{(1)}, ..., x^{(T)}$, modelamos cada punto de datos $x^{(j)}$ como una mezcla factorial de gaussianos: $$p(x^{(j)}) = \prod_i p_i (x_i^{(j)})$$

Las mezclas factoriales son una forma sencilla de crear distribuciones con una pequeña cantidad de parámetros y una gran cantidad de modos.

import tensorflow as tf
import numpy as np
import tensorflow_probability as tfp
import matplotlib.pyplot as plt
import seaborn as sns
tfd = tfp.distributions

# Use try/except so we can easily re-execute the whole notebook.
try:
  tf.enable_eager_execution()
except:
  pass

Construya la mezcla factorial de gaussianas con TFP

num_vars = 2        # Number of variables (`n` in formula).
var_dim = 1         # Dimensionality of each variable `x[i]`.
num_components = 3  # Number of components for each mixture (`K` in formula).
sigma = 5e-2        # Fixed standard deviation of each component.

# Choose some random (component) modes.
component_mean = tfd.Uniform().sample([num_vars, num_components, var_dim])

factorial_mog = tfd.Independent(
   tfd.MixtureSameFamily(
       # Assume uniform weight on each component.
       mixture_distribution=tfd.Categorical(
           logits=tf.zeros([num_vars, num_components])),
       components_distribution=tfd.MultivariateNormalDiag(
           loc=component_mean, scale_diag=[sigma])),
   reinterpreted_batch_ndims=1)

Observe nuestro uso de tfd.Independent. Esta "metadistribución" aplica una reduce_sum en el cálculo log_prob sobre las dimensiones de lote reinterpreted_batch_ndims situadas más a la derecha. En nuestro caso, esto suma la dimensión de las variables y deja solo la dimensión del lote cuando calculamos log_prob. Tenga en cuenta que esto no afecta el muestreo.

Trace la densidad

Calcule la densidad en una cuadrícula de puntos y muestre las ubicaciones de los modos con estrellas rojas. Cada modo de la mezcla factorial corresponde a un par de modos de la mezcla subyacente de variables individuales de gaussianas. Podemos ver 9 modos en el gráfico siguiente, pero solo necesitábamos 6 parámetros (3 para especificar las ubicaciones de los modos en $x_1$ y 3 para especificar las ubicaciones de los modos en $x_2$). Por el contrario, una mezcla de distribución gaussiana en el espacio bidimensional $(x_1, x_2)$ requeriría 2 * 9 = 18 parámetros para especificar los 9 modos.

plt.figure(figsize=(6,5))

# Compute density.
nx = 250 # Number of bins per dimension.
x = np.linspace(-3 * sigma, 1 + 3 * sigma, nx).astype('float32')
vals = tf.reshape(tf.stack(np.meshgrid(x, x), axis=2), (-1, num_vars, var_dim))
probs = factorial_mog.prob(vals).numpy().reshape(nx, nx)

# Display as image.
from matplotlib.colors import ListedColormap
cmap = ListedColormap(sns.color_palette("Blues", 256))
p = plt.pcolor(x, x, probs, cmap=cmap)
ax = plt.axis('tight');

# Plot locations of means.
means_np = component_mean.numpy().squeeze()
for mu_x in means_np[0]:
  for mu_y in means_np[1]:
    plt.scatter(mu_x, mu_y, s=150, marker='*', c='r', edgecolor='none');
plt.axis(ax);

plt.xlabel('$x_1$')
plt.ylabel('$x_2$')
plt.title('Density of factorial mixture of Gaussians');

Trace muestras y estimaciones de densidad marginal

samples = factorial_mog.sample(1000).numpy()

g = sns.jointplot(
    x=samples[:, 0, 0],
    y=samples[:, 1, 0],
    kind="scatter",
    marginal_kws=dict(bins=50))
g.set_axis_labels("$x_1$", "$x_2$");