docstr: Xnew is a tensor with the points of the data or minibatch, shape N x D
docstr_tok: ["Xnew","is","a","tensor","with","the","points","of","the","data","or","minibatch",",","shape","N","x","D"]
code: def _conditional_fused(self, Xnew, full_cov, full_output_cov):
      """
      Xnew is a tensor with the points of the data or minibatch, shape N x D
      """
      if full_output_cov:
          raise NotImplementedError
  
      f = self._q_dist.q_mu
      q_sqrt = self._q_dist.q_sqrt
  
      # num_data = tf.shape(Xnew)[0]  # M
      num_func = tf.shape(f)[1]  # K
  
      Kuu = cov.Kuu(
          self.X_data, self.kernel
      )  # this is now a LinearOperator
      Kuf = cov.Kuf(self.X_data, self.kernel, Xnew)  # still a Tensor
  
      KuuInv_Kuf = Kuu.solve(Kuf)
  
      # compute the covariance due to the conditioning
      if full_cov:
          fvar = self.kernel(Xnew) - tf.matmul(
              Kuf, KuuInv_Kuf, transpose_a=True
          )
          shape = (num_func, 1, 1)
      else:
          KufT_KuuInv_Kuf_diag = tf.reduce_sum(
              Kuf * KuuInv_Kuf, axis=-2
          )
          fvar = (
              self.kernel(Xnew, full_cov=False) - KufT_KuuInv_Kuf_diag
          )
          shape = (num_func, 1)
      fvar = tf.expand_dims(fvar, 0) * tf.ones(
          shape, dtype=gpflow.default_float()
      )  # K x N x N or K x N
  
      if self.whiten:
          raise NotImplementedError
  
      A = KuuInv_Kuf
  
      # construct the conditional mean
      fmean = tf.matmul(A, f, transpose_a=True)
  
      if q_sqrt is not None:
          if q_sqrt.shape.ndims == 2:
              # LTA = A * tf.expand_dims(q_sqrt, 2)  # K x M x N
              # won't work  # make ticket for this?
              raise NotImplementedError
          elif q_sqrt.shape.ndims == 3:
              # L = tf.matrix_band_part(tf.transpose(q_sqrt, (2, 0, 1)), -1, 0)  # K x M x M
  
              # K x M x N
              # A_tiled = tf.expand_dims(A.get(), 0) * tf.ones((num_func, 1, 1), dtype=float_type)
  
              # LTA = tf.matmul(L, A_tiled, transpose_a=True)  # K x M x N
              # TODO the following won't work for K > 1
              assert q_sqrt.shape[0] == 1
              # LTA = (A.T @ DenseMatrix(q_sqrt[:,:,0])).T.get()[None, :, :]
              ATL = tf.matmul(A, q_sqrt, transpose_a=True)
          else:
              raise ValueError(
                  "Bad dimension for q_sqrt: %s"
                  % str(q_sqrt.shape.ndims)
              )
          if full_cov:
              # fvar = fvar + tf.matmul(LTA, LTA, transpose_a=True)  # K x N x N
              fvar = fvar + tf.matmul(
                  ATL, ATL, transpose_b=True
              )  # K x N x N
          else:
              # fvar = fvar + tf.reduce_sum(tf.square(LTA), 1)  # K x N
              fvar = fvar + tf.reduce_sum(tf.square(ATL), 2)  # K x N
  
      if not full_cov:
          fvar = tf.transpose(fvar)  # N x K
  
      return fmean, fvar
  
imports: import numpy
  import tensorflow
  from check_shapes import Shape
  import gpflow
  from gpflow import covariances
  from gpflow import kullback_leiblers
  from gpflow.base import TensorLike
  from gpflow.ci_utils import reduce_in_tests
  from gpflow.inducing_variables import InducingVariables
  from gpflow.utilities import to_default_float
  import matplotlib.pyplot
  import gpflow.posteriors
label_desc: Use image node_id 1 for calling the VFFPosterior obj's underlying member method code with example usage: obj._conditional_fused(Xnew, full_cov, full_output_cov) and returns: fmean,  fvar