Posit AI Weblog: Moving into the circulate: Bijectors in TensorFlow Likelihood

As of at this time, deep studying’s best successes have taken place within the realm of supervised studying, requiring tons and plenty of annotated coaching information. Nonetheless, information doesn’t (usually) include annotations or labels. Additionally, unsupervised studying is enticing due to the analogy to human cognition.

On this weblog to date, we’ve got seen two main architectures for unsupervised studying: variational autoencoders and generative adversarial networks. Lesser recognized, however interesting for conceptual in addition to for efficiency causes are normalizing flows (Jimenez Rezende and Mohamed 2015). On this and the subsequent put up, we’ll introduce flows, specializing in easy methods to implement them utilizing TensorFlow Likelihood (TFP).

In distinction to earlier posts involving TFP that accessed its performance utilizing low-level $-syntax, we now make use of tfprobability, an R wrapper within the model of keras, tensorflow and tfdatasets. A word relating to this package deal: It’s nonetheless beneath heavy growth and the API might change. As of this writing, wrappers don’t but exist for all TFP modules, however all TFP performance is on the market utilizing $-syntax if want be.

Density estimation and sampling

Again to unsupervised studying, and particularly considering of variational autoencoders, what are the primary issues they offer us? One factor that’s seldom lacking from papers on generative strategies are footage of super-real-looking faces (or mattress rooms, or animals …). So evidently sampling (or: technology) is a vital half. If we will pattern from a mannequin and procure real-seeming entities, this implies the mannequin has discovered one thing about how issues are distributed on this planet: it has discovered a distribution.
Within the case of variational autoencoders, there may be extra: The entities are purported to be decided by a set of distinct, disentangled (hopefully!) latent elements. However this isn’t the idea within the case of normalizing flows, so we aren’t going to elaborate on this right here.

As a recap, how will we pattern from a VAE? We draw from (z), the latent variable, and run the decoder community on it. The outcome ought to – we hope – appear like it comes from the empirical information distribution. It shouldn’t, nevertheless, look precisely like all of the objects used to coach the VAE, or else we’ve got not discovered something helpful.

The second factor we might get from a VAE is an evaluation of the plausibility of particular person information, for use, for instance, in anomaly detection. Right here “plausibility” is obscure on objective: With VAE, we don’t have a method to compute an precise density beneath the posterior.

What if we would like, or want, each: technology of samples in addition to density estimation? That is the place normalizing flows are available in.

Normalizing flows

A circulate is a sequence of differentiable, invertible mappings from information to a “good” distribution, one thing we will simply pattern from and use to calculate a density. Let’s take as instance the canonical approach to generate samples from some distribution, the exponential, say.

We begin by asking our random quantity generator for some quantity between 0 and 1:

This quantity we deal with as coming from a cumulative likelihood distribution (CDF) – from an exponential CDF, to be exact. Now that we’ve got a price from the CDF, all we have to do is map that “again” to a price. That mapping CDF -> worth we’re searching for is simply the inverse of the CDF of an exponential distribution, the CDF being

[F(x) = 1 – e^{-lambda x}]

The inverse then is

[
F^{-1}(u) = -frac{1}{lambda} ln (1 – u)
]

which implies we might get our exponential pattern doing

lambda  0.5 # decide some lambda
x  -1/lambda * log(1-u)

We see the CDF is definitely a circulate (or a constructing block thereof, if we image most flows as comprising a number of transformations), since

• It maps information to a uniform distribution between 0 and 1, permitting to evaluate information probability.
• Conversely, it maps a likelihood to an precise worth, thus permitting to generate samples.

From this instance, we see why a circulate needs to be invertible, however we don’t but see why it needs to be differentiable. This can turn out to be clear shortly, however first let’s check out how flows can be found in tfprobability.

Bijectors

TFP comes with a treasure trove of transformations, referred to as bijectors, starting from easy computations like exponentiation to extra complicated ones just like the discrete cosine rework.

To get began, let’s use tfprobability to generate samples from the conventional distribution.
There’s a bijector tfb_normal_cdf() that takes enter information to the interval ([0,1]). Its inverse rework then yields a random variable with the usual regular distribution:

Conversely, we will use this bijector to find out the (log) likelihood of a pattern from the conventional distribution. We’ll test in opposition to a simple use of tfd_normal within the distributions module:

x  2.01
d_n  tfd_normal(loc = 0, scale = 1) 

d_n %>% tfd_log_prob(x) %>% as.numeric() # -2.938989

To acquire that very same log likelihood from the bijector, we add two parts:

• Firstly, we run the pattern by way of the ahead transformation and compute log likelihood beneath the uniform distribution.
• Secondly, as we’re utilizing the uniform distribution to find out likelihood of a standard pattern, we have to monitor how likelihood adjustments beneath this transformation. That is executed by calling tfb_forward_log_det_jacobian (to be additional elaborated on under).

b  tfb_normal_cdf()
d_u  tfd_uniform()

l  d_u %>% tfd_log_prob(b %>% tfb_forward(x))
j  b %>% tfb_forward_log_det_jacobian(x, event_ndims = 0)

(l + j) %>% as.numeric() # -2.938989

Why does this work? Let’s get some background.

Likelihood mass is conserved

Flows are primarily based on the precept that beneath transformation, likelihood mass is conserved. Say we’ve got a circulate from (x) to (z):
[z = f(x)]

Suppose we pattern from (z) after which, compute the inverse rework to acquire (x). We all know the likelihood of (z). What’s the likelihood that (x), the remodeled pattern, lies between (x_0) and (x_0 + dx)?

This likelihood is (p(x) dx), the density occasions the size of the interval. This has to equal the likelihood that (z) lies between (f(x)) and (f(x + dx)). That new interval has size (f'(x) dx), so:

[p(x) dx = p(z) f'(x) dx]

Or equivalently

[p(x) = p(z) * dz/dx]

Thus, the pattern likelihood (p(x)) is set by the bottom likelihood (p(z)) of the remodeled distribution, multiplied by how a lot the circulate stretches house.

The identical goes in larger dimensions: Once more, the circulate is concerning the change in likelihood quantity between the (z) and (y) areas:

[p(x) = p(z) frac{vol(dz)}{vol(dx)}]

In larger dimensions, the Jacobian replaces the by-product. Then, the change in quantity is captured by absolutely the worth of its determinant:

[p(mathbf{x}) = p(f(mathbf{x})) bigg|detfrac{partial f({mathbf{x})}}{partial{mathbf{x}}}bigg|]

In follow, we work with log chances, so

[log p(mathbf{x}) = log p(f(mathbf{x})) + log bigg|detfrac{partial f({mathbf{x})}}{partial{mathbf{x}}}bigg| ]

Let’s see this with one other bijector instance, tfb_affine_scalar. Under, we assemble a mini-flow that maps a couple of arbitrary chosen (x) values to double their worth (scale = 2):

x  c(0, 0.5, 1)
b  tfb_affine_scalar(shift = 0, scale = 2)

To match densities beneath the circulate, we select the conventional distribution, and take a look at the log densities:

d_n  tfd_normal(loc = 0, scale = 1)
d_n %>% tfd_log_prob(x) %>% as.numeric() # -0.9189385 -1.0439385 -1.4189385

Now apply the circulate and compute the brand new log densities as a sum of the log densities of the corresponding (x) values and the log determinant of the Jacobian:

z  b %>% tfb_forward(x)

(d_n  %>% tfd_log_prob(b %>% tfb_inverse(z))) +
  (b %>% tfb_inverse_log_det_jacobian(z, event_ndims = 0)) %>%
  as.numeric() # -1.6120857 -1.7370857 -2.1120858

We see that because the values get stretched in house (we multiply by 2), the person log densities go down.
We are able to confirm the cumulative likelihood stays the identical utilizing tfd_transformed_distribution():

d_t  tfd_transformed_distribution(distribution = d_n, bijector = b)
d_n %>% tfd_cdf(x) %>% as.numeric()  # 0.5000000 0.6914625 0.8413447

d_t %>% tfd_cdf(y) %>% as.numeric()  # 0.5000000 0.6914625 0.8413447

Thus far, the flows we noticed had been static – how does this match into the framework of neural networks?

Coaching a circulate

On condition that flows are bidirectional, there are two methods to consider them. Above, we’ve got principally burdened the inverse mapping: We would like a easy distribution we will pattern from, and which we will use to compute a density. In that line, flows are typically referred to as “mappings from information to noise” – noise principally being an isotropic Gaussian. Nonetheless in follow, we don’t have that “noise” but, we simply have information.
So in follow, we’ve got to study a circulate that does such a mapping. We do that by utilizing bijectors with trainable parameters.
We’ll see a quite simple instance right here, and depart “actual world flows” to the subsequent put up.

The instance relies on half 1 of Eric Jang’s introduction to normalizing flows. The principle distinction (aside from simplification to indicate the fundamental sample) is that we’re utilizing keen execution.

We begin from a two-dimensional, isotropic Gaussian, and we need to mannequin information that’s additionally regular, however with a imply of 1 and a variance of two (in each dimensions).

library(tensorflow)
library(tfprobability)

tfe_enable_eager_execution(device_policy = "silent")

library(tfdatasets)

# the place we begin from
base_dist  tfd_multivariate_normal_diag(loc = c(0, 0))

# the place we need to go
target_dist  tfd_multivariate_normal_diag(loc = c(1, 1), scale_identity_multiplier = 2)

# create coaching information from the goal distribution
target_samples  target_dist %>% tfd_sample(1000) %>% tf$solid(tf$float32)

batch_size  100
dataset  tensor_slices_dataset(target_samples) %>%
  dataset_shuffle(buffer_size = dim(target_samples)[1]) %>%
  dataset_batch(batch_size)

Now we’ll construct a tiny neural community, consisting of an affine transformation and a nonlinearity.
For the previous, we will make use of tfb_affine, the multi-dimensional relative of tfb_affine_scalar.
As to nonlinearities, at present TFP comes with tfb_sigmoid and tfb_tanh, however we will construct our personal parameterized ReLU utilizing tfb_inline:

# alpha is a learnable parameter
bijector_leaky_relu  operate(alpha) {
  
  tfb_inline(
    # ahead rework leaves constructive values untouched and scales adverse ones by alpha
    forward_fn = operate(x)
      tf$the place(tf$greater_equal(x, 0), x, alpha * x),
    # inverse rework leaves constructive values untouched and scales adverse ones by 1/alpha
    inverse_fn = operate(y)
      tf$the place(tf$greater_equal(y, 0), y, 1/alpha * y),
    # quantity change is 0 when constructive and 1/alpha when adverse
    inverse_log_det_jacobian_fn = operate(y) {
      I  tf$ones_like(y)
      J_inv  tf$the place(tf$greater_equal(y, 0), I, 1/alpha * I)
      log_abs_det_J_inv  tf$log(tf$abs(J_inv))
      tf$reduce_sum(log_abs_det_J_inv, axis = 1L)
    },
    forward_min_event_ndims = 1
  )
}

Outline the learnable variables for the affine and the PReLU layers:

d  2 # dimensionality
r  2 # rank of replace

# shift of affine bijector
shift  tf$get_variable("shift", d)
# scale of affine bijector
L  tf$get_variable('L', c(d * (d + 1) / 2))
# rank-r replace
V  tf$get_variable("V", c(d, r))

# scaling issue of parameterized relu
alpha  tf$abs(tf$get_variable('alpha', listing())) + 0.01

With keen execution, the variables have for use contained in the loss operate, so that’s the place we outline the bijectors. Our little circulate now could be a tfb_chain of bijectors, and we wrap it in a TransformedDistribution (tfd_transformed_distribution) that hyperlinks supply and goal distributions.

loss  operate() {
  
 affine  tfb_affine(
        scale_tril = tfb_fill_triangular() %>% tfb_forward(L),
        scale_perturb_factor = V,
        shift = shift
      )
 lrelu  bijector_leaky_relu(alpha = alpha)  
 
 circulate  listing(lrelu, affine) %>% tfb_chain()
 
 dist  tfd_transformed_distribution(distribution = base_dist,
                          bijector = circulate)
  
 l  -tf$reduce_mean(dist$log_prob(batch))
 # preserve monitor of progress
 print(spherical(as.numeric(l), 2))
 l
}

Now we will really run the coaching!

optimizer  tf$prepare$AdamOptimizer(1e-4)

n_epochs  100
for (i in 1:n_epochs) {
  iter  make_iterator_one_shot(dataset)
  until_out_of_range({
    batch  iterator_get_next(iter)
    optimizer$reduce(loss)
  })
}

Outcomes will differ relying on random initialization, however you need to see a gentle (if sluggish) progress. Utilizing bijectors, we’ve got really skilled and outlined a little bit neural community.

Outlook

Undoubtedly, this circulate is simply too easy to mannequin complicated information, but it surely’s instructive to have seen the fundamental ideas earlier than delving into extra complicated flows. Within the subsequent put up, we’ll take a look at autoregressive flows, once more utilizing TFP and tfprobability.