code: # Copyright 2016 James Hensman, alexggmatthews
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  # http://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.
  
  # ------------------------------------------
  # Modification notice:
  # This file was modified by Vincent ADAM
  # ------------------------------------------
  
  import tensorflow as tf
  from settings import float_type
  from quadrature import hermgauss
  import numpy as np
  
  
  def eye(N):
      """
      An identitiy matrix
      """
      return tf.diag(tf.ones(tf.stack([N, ]), dtype=float_type))
  
  
  def variational_expectations( Fmu, Fvar, phi, num_gauss_hermite_points=20):
      """
      Compute the expected value of a function phi, given a Gaussian
      distribution for the input values.
      if
          q(f) = N(Fmu, Fvar)
      then this method computes
         \int phi(f) q(f) df.
      Here, we implement a default Gauss-Hermite quadrature routine
      """
      gh_x, gh_w = hermgauss(num_gauss_hermite_points)
      gh_x = gh_x.reshape(1, -1)
      gh_w = gh_w.reshape(-1, 1) / np.sqrt(np.pi)
      shape = tf.shape(Fmu)
      Fmu, Fvar = [tf.reshape(e, (-1, 1)) for e in (Fmu, Fvar)]
      X = gh_x * tf.sqrt(2.0 * Fvar) + Fmu
      logp = phi(X)
      return tf.reshape(tf.matmul(logp, gh_w), shape)
  
  
  
  import tensorflow as tf
  
  def block_diagonal(matrices, dtype=tf.float32):
      """Constructs block-diagonal matrices from a list of batched 2D tensors.
      Args:
        matrices: A list of Tensors with shape [..., N_i, M_i] (i.e. a list of
          matrices with the same batch dimension).
        dtype: Data type to use. The Tensors in `matrices` must match this dtype.
      Returns:
        A matrix with the input matrices stacked along its main diagonal, having
        shape [..., \sum_i N_i, \sum_i M_i].
    
      """
      matrices = [tf.convert_to_tensor(matrix, dtype=dtype) for matrix in matrices]
      blocked_rows = tf.Dimension(0)
      blocked_cols = tf.Dimension(0)
      batch_shape = tf.TensorShape(None)
      for matrix in matrices:
          full_matrix_shape = matrix.get_shape().with_rank_at_least(2)
          batch_shape = batch_shape.merge_with(full_matrix_shape[:-2])
          blocked_rows += full_matrix_shape[-2]
          blocked_cols += full_matrix_shape[-1]
      ret_columns_list = []
      for matrix in matrices:
          matrix_shape = tf.shape(matrix)
          ret_columns_list.append(matrix_shape[-1])
      ret_columns = tf.add_n(ret_columns_list)
      row_blocks = []
      current_column = 0
      for matrix in matrices:
          matrix_shape = tf.shape(matrix)
          row_before_length = current_column
          current_column += matrix_shape[-1]
          row_after_length = ret_columns - current_column
          row_blocks.append(tf.pad(
              tensor=matrix,
              paddings=tf.concat(
                  [tf.zeros([tf.rank(matrix) - 1, 2], dtype=tf.int32),
                   [(row_before_length, row_after_length)]],
                  axis=0)))
      blocked = tf.concat(row_blocks, -2)
      blocked.set_shape(batch_shape.concatenate((blocked_rows, blocked_cols)))
      return blocked
apis: tensorflow.stack tensorflow.add_n tensorflow.shape tensorflow.reshape tensorflow.sqrt tensorflow.Dimension tensorflow.matmul tensorflow.TensorShape tensorflow.convert_to_tensor tensorflow.concat numpy.sqrt tensorflow.rank