tf.contrib.distributions.bijectors.MaskedAutoregressiveFlow

Аффинный биджектор MaskedAutoregressiveFlow для векторных событий.

Наследуется от: Bijector

tf.contrib.distributions.bijectors.MaskedAutoregressiveFlow(
    shift_and_log_scale_fn, is_constant_jacobian=False, validate_args=False,
    unroll_loop=False, name=None
)

Аффинный авторегрессивный поток [(Papamakarios et al., 2016)][3] предоставляет относительно простую структуру для пользовательских (глубоких) архитектур, чтобы обучить распределение над векторными событиями. Что касается терминологии,

"Авторегрессивные модели разлагают совместную плотность как произведение условных, и моделируют каждую условную по очереди. Нормализующие потоки преобразуют базовую плотность (например, стандартное гауссово распределение) в целевую плотность с помощью обратимого преобразования с вычислимым якобианом." [(Papamakarios et al., 2016)][3]

Другими словами, "авторегрессивное свойство" эквивалентно разложению, p(x) = prod{ p(x[i] | x[0:i]) : i=0, ..., d }. Предоставленный shift_and_log_scale_fn, masked_autoregressive_default_template, достигает этого свойства, обнуляя веса в своих masked_dense слоях.

В рамках tfp, "нормализующий поток" реализован как tfp.bijectors.Bijector. forward "авторегрессия" реализуется с использованием tf.while_loop и глубокой нейронной сети (DNN) с замаскированными весами таким образом, что авторегрессивное свойство автоматически выполняется в inverse.

А TransformedDistribution используя MaskedAutoregressiveFlow(...) использует (дорогостоящее) вычисление в прямом направлении для генерации выборок и (дешевое) вычисление в обратном направлении для вычисления логарифмических вероятностей. И наоборот, TransformedDistribution используя Invert(MaskedAutoregressiveFlow(...)) использует (дорогостоящее) вычисление в прямом направлении для вычисления логарифмических вероятностей и (дешевое) вычисление в обратном направлении для вычисления выборок. Смотрите "Пример использования" [ниже] для получения более подробной информации.

Учитывая shift_and_log_scale_fn, прямые и обратные преобразования представляют собой (последовательность) аффинных преобразований. "Валидный" shift_and_log_scale_fn должен вычислить каждый shift (также loc или "mu" в [Germain et al. (2015)][1]) и log(scale) (также "alpha" в [Germain et al. (2015)][1]) таким образом, чтобы каждый был совместим с аргументами для forward и inverse, т.е. таким образом, чтобы вычисления в forward, inverse [ниже] были возможны.

Для удобства masked_autoregressive_default_template предлагается как возможная shift_and_log_scale_fn функция. Она реализует архитектуру MADE [(Germain et al., 2015)][1]. MADE — это многослойная перцептронная сеть, которая вычисляет shift и log(scale) используя masked_dense слои в глубокой нейронной сети. Веса замаскированы, чтобы обеспечить авторегрессивное свойство. Возможно, эта архитектура не является оптимальной для вашей задачи. Для построения альтернативных сетей можно изменить аргументы для masked_autoregressive_default_template, использовать функцию masked_dense для разработки собственной или использовать другую архитектуру, например, с использованием tf.layers.

Предполагая, что shift_and_log_scale_fn имеет правильную форму и авторегрессивную семантику, прямое преобразование равно

def forward(x):
  y = zeros_like(x)
  event_size = x.shape[-1]
  for _ in range(event_size):
    shift, log_scale = shift_and_log_scale_fn(y)
    y = x * math_ops.exp(log_scale) + shift
  return y

и обратное преобразование равно

def inverse(y):
  shift, log_scale = shift_and_log_scale_fn(y)
  return (y - shift) / math_ops.exp(log_scale)

Обратите внимание, что inverse не требует цикла for. Это потому, что в прямом проходе каждое вычисление shift и log_scale основано на y вычисленном до этого момента (а не на x). В inverse y полностью известен, поэтому эквивалентен масштабированию, используемому в forward после event_size проходов, т.е. "последний" y используемый для вычисления shift, log_scale. (Грубо говоря, это также доказывает, что преобразование является взаимно однозначным.)

Примеры

import tensorflow_probability as tfp
tfd = tfp.distributions
tfb = tfp.bijectors

dims = 5

# A common choice for a normalizing flow is to use a Gaussian for the base
# distribution. (However, any continuous distribution would work.) E.g.,
maf = tfd.TransformedDistribution(
    distribution=tfd.Normal(loc=0., scale=1.),
    bijector=tfb.MaskedAutoregressiveFlow(
        shift_and_log_scale_fn=tfb.masked_autoregressive_default_template(
            hidden_layers=[512, 512])),
    event_shape=[dims])

x = maf.sample()  # Expensive; uses `tf.while_loop`, no Bijector caching.
maf.log_prob(x)   # Almost free; uses Bijector caching.
maf.log_prob(0.)  # Cheap; no `tf.while_loop` despite no Bijector caching.

# [Papamakarios et al. (2016)][3] also describe an Inverse Autoregressive
# Flow [(Kingma et al., 2016)][2]:
iaf = tfd.TransformedDistribution(
    distribution=tfd.Normal(loc=0., scale=1.),
    bijector=tfb.Invert(tfb.MaskedAutoregressiveFlow(
        shift_and_log_scale_fn=tfb.masked_autoregressive_default_template(
            hidden_layers=[512, 512]))),
    event_shape=[dims])

x = iaf.sample()  # Cheap; no `tf.while_loop` despite no Bijector caching.
iaf.log_prob(x)   # Almost free; uses Bijector caching.
iaf.log_prob(0.)  # Expensive; uses `tf.while_loop`, no Bijector caching.

# In many (if not most) cases the default `shift_and_log_scale_fn` will be a
# poor choice. Here's an example of using a "shift only" version and with a
# different number/depth of hidden layers.
shift_only = True
maf_no_scale_hidden2 = tfd.TransformedDistribution(
    distribution=tfd.Normal(loc=0., scale=1.),
    bijector=tfb.MaskedAutoregressiveFlow(
        tfb.masked_autoregressive_default_template(
            hidden_layers=[32],
            shift_only=shift_only),
        is_constant_jacobian=shift_only),
    event_shape=[dims])

Ссылки

[1]: Mathieu Germain, Karol Gregor, Iain Murray и Hugo Larochelle. MADE: Замаскированный автокодировщик для оценки распределения. В Международной конференции по машинному обучению, 2015. https://arxiv.org/abs/1502.03509

[2]: Diederik P. Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever и Max Welling. Улучшение вариационного вывода с помощью обратного авторегрессивного потока. В Нейронных системах обработки информации, 2016. https://arxiv.org/abs/1606.04934

[3]: George Papamakarios, Theo Pavlakou и Iain Murray. Замаскированный авторегрессивный поток для оценки плотности. В Нейронных системах обработки информации, 2017. https://arxiv.org/abs/1705.07057

Методы

forward

Просмотреть исходный код

forward(
    x, name='forward'
)

Возвращает вычисление прямого Bijector , т.е. X = g(Y).

forward_event_shape

Просмотреть исходный код

forward_event_shape(
    input_shape
)

Форма одного образца из одной партии в виде TensorShape.

То же, что и forward_event_shape_tensor. Может быть частично определена.

forward_event_shape_tensor

Просмотреть исходный код

forward_event_shape_tensor(
    input_shape, name='forward_event_shape_tensor'
)

Форма одного образца из одной партии как 1D int32 Tensor.

forward_log_det_jacobian

Просмотреть исходный код

forward_log_det_jacobian(
    x, event_ndims, name='forward_log_det_jacobian'
)

Возвращает как forward_log_det_jacobian.

inverse

Просмотреть исходный код

inverse(
    y, name='inverse'
)

Возвращает обратное вычисление Bijector, т. е. X = g^{-1}(Y).

inverse_event_shape

Просмотреть исходный код

inverse_event_shape(
    output_shape
)

Форма одного образца из одной партии как TensorShape.

То же, что и inverse_event_shape_tensor. Может быть определена лишь частично.

inverse_event_shape_tensor

Просмотреть исходный код

inverse_event_shape_tensor(
    output_shape, name='inverse_event_shape_tensor'
)

Форма одного образца из одной партии как int32 1D Tensor.

inverse_log_det_jacobian

Просмотреть исходный код

inverse_log_det_jacobian(
    y, event_ndims, name='inverse_log_det_jacobian'
)

Возвращает (log o det o Jacobian o inverse)(y).

Математически возвращает: log(det(dX/dY))(Y). (Вспомните, что: X=g^{-1}(Y).)

Обратите внимание, что forward_log_det_jacobian является отрицанием этой функции, вычисленной в g^{-1}(y).