code: def invertible_1x1_conv(name, x, reverse=False):
      """1X1 convolution on x.
  
      The 1X1 convolution is parametrized as P*L*(U + sign(s)*exp(log(s))) where
      1. P is a permutation matrix.
      2. L is a lower triangular matrix with diagonal entries unity.
      3. U is a upper triangular matrix where the diagonal entries zero.
      4. s is a vector.
  
      sign(s) and P are fixed and the remaining are optimized. P, L, U and s are
      initialized by the PLU decomposition of a random rotation matrix.
  
      Args:
        name: scope
        x: Input Tensor.
        reverse: whether the pass is from z -> x or x -> z.
  
      Returns:
        x_conv: x after a 1X1 convolution is applied on x.
        objective: sum(log(s))
      """
      _, height, width, channels = common_layers.shape_list(x)
      w_shape = [channels, channels]
  
      # Random rotation-matrix Q
      random_matrix = np.random.rand(channels, channels)
      np_w = scipy.linalg.qr(random_matrix)[0].astype("float32")
  
      # Initialize P,L,U and s from the LU decomposition of a random rotation matrix
      np_p, np_l, np_u = scipy.linalg.lu(np_w)
      np_s = np.diag(np_u)
      np_sign_s = np.sign(np_s)
      np_log_s = np.log(np.abs(np_s))
      np_u = np.triu(np_u, k=1)
  
      with tf.variable_scope(name, reuse=tf.AUTO_REUSE):
          p = tf.get_variable("P", initializer=np_p, trainable=False)
          l = tf.get_variable("L", initializer=np_l)
          sign_s = tf.get_variable(
              "sign_S", initializer=np_sign_s, trainable=False
          )
          log_s = tf.get_variable("log_S", initializer=np_log_s)
          u = tf.get_variable("U", initializer=np_u)
  
          # W = P * L * (U + sign_s * exp(log_s))
          l_mask = np.tril(
              np.ones([channels, channels], dtype=np.float32), -1
          )
          l = l * l_mask + tf.eye(channels, channels)
          u = u * np.transpose(l_mask) + tf.diag(sign_s * tf.exp(log_s))
          w = tf.matmul(p, tf.matmul(l, u))
  
          # If height or width cannot be statically determined then they end up as
          # tf.int32 tensors, which cannot be directly multiplied with a floating
          # point tensor without a cast.
          objective = tf.reduce_sum(log_s) * tf.cast(
              height * width, log_s.dtype
          )
          if not reverse:
              w = tf.reshape(w, [1, 1] + w_shape)
              x = tf.nn.conv2d(
                  x, w, [1, 1, 1, 1], "SAME", data_format="NHWC"
              )
          else:
              w_inv = tf.reshape(tf.linalg.inv(w), [1, 1] + w_shape)
              x = tf.nn.conv2d(
                  x, w_inv, [1, 1, 1, 1], "SAME", data_format="NHWC"
              )
              objective *= -1
      return x, objective
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import functools
  import numpy
  import scipy
  from tensor2tensor.layers import common_layers
  from tensor2tensor.layers import common_video
  from tensor2tensor.utils import contrib
  import tensorflow.compat.v1
  from tensorflow.compat.v1 import estimator
  import tensorflow_probability
label_desc: Use image node_id 16 for calling a global function with example usage: invertible_1x1_conv(name, x, reverse) and returns: x,  objective