class_docstr: StudentTProcessRegressionModel.
  
  This is an analogue of the GaussianProcessRegressionModel, except
  we use a Student-T process here (i.e. this represents the posterior predictive
  of a Student-T process, where we assume that the kernel hyperparameters and
  degrees of freedom are constants, and hence do optimizations in the
  constructor).
  
  Specifically, we assume a Student-T Process prior, `f ~ StP(df, m, k)` along
  with a noise model whose mathematical implementation is similar to a Gaussian
  Process albeit whose interpretation is very different.
  
  In particular, this noise model takes the following form:
  
  ```none
    e ~ MVT(df + n, 0, 1 + v / df * (1 + f^T k(t, t)^-1 f^T))
  ```
  which can be interpreted as Multivariate T noise whose covariance depends on
  the data fit term.
  
  Using the conventions in the `GaussianProcessRegressionModel` class, we have
  the posterior predictive distribution as:
  
  ```none
    (f(t) | t, x, f(x)) ~ MVT(df + n, loc, cov)
  
    where
  
    n is the number of observation points
    b = (y - loc)^T @ inv(k(x, x) + v * I) @ (y - loc)
    v = observation noise variance
    loc = k(t, x) @ inv(k(x, x) + v * I) @ (y - loc)
    cov = (df + b - 2) / (df + n - 2) * (
      k(t, t) - k(t, x) @ inv(k(x, x) + v * I) @ k(x, t))
  ```
  
  Note that the posterior predictive mean is the same as a Gaussian Process,
  but the covariance is multiplied by a term that takes in to account
  observations.
  
  This distribution does precomputaiton in the constructor by assuming
  `observation_index_points`, `observations`, `kernel` and
  `observation_noise_variance` are fixed, and that `mean_fn` is the zero
  function. We do these precomputations in a non-tape safe way.
  
  #### References
  [1]: Amar Shah, Andrew Gordon Wilson, Zoubin Ghahramani.
       Student-t Processes as Alternatives to Gaussian Processes
       https://arxiv.org/abs/1402.4306
  
  [2]: Qingtao Tang, Yisen Wang, Shu-Tao Xia
       Student-T Process Regression with Dependent Student-t Noise
       https://www.ijcai.org/proceedings/2017/393
class_docstr_tok: ["StudentTProcessRegressionModel",".","This","is","an","analogue","of","the","GaussianProcessRegressionModel",",","except","we","use","a","Student-T","process","here","(","i.e",".","this","represents","the","posterior","predictive","of","a","Student-T","process",",","where","we","assume","that","the","kernel","hyperparameters","and","degrees","of","freedom","are","constants",",","and","hence","do","optimizations","in","the","constructor",")",".","Specifically",",","we","assume","a","Student-T","Process","prior",",","`","f","~","StP","(","df",",","m",",","k",")","`","along","with","a","noise","model","whose","mathematical","implementation","is","similar","to","a","Gaussian","Process","albeit","whose","interpretation","is","very","different",".","In","particular",",","this","noise","model","takes","the","following","form",":","``","`","none","e","~","MVT","(","df","+","n",",","0",",","1","+","v","\/","df","*","(","1","+","f^T","k","(","t",",","t",")","^-1","f^T",")",")","``","`","which","can","be","interpreted","as","Multivariate","T","noise","whose","covariance","depends","on","the","data","fit","term",".","Using","the","conventions","in","the","`","GaussianProcessRegressionModel","`","class",",","we","have","the","posterior","predictive","distribution","as",":","``","`","none","(","f","(","t",")","|","t",",","x",",","f","(","x",")",")","~","MVT","(","df","+","n",",","loc",",","cov",")","where","n","is","the","number","of","observation","points","b","=","(","y","-","loc",")","^T","@","inv","(","k","(","x",",","x",")","+","v","*","I",")","@","(","y","-","loc",")","v","=","observation","noise","variance","loc","=","k","(","t",",","x",")","@","inv","(","k","(","x",",","x",")","+","v","*","I",")","@","(","y","-","loc",")","cov","=","(","df","+","b","-","2",")","\/","(","df","+","n","-","2",")","*","(","k","(","t",",","t",")","-","k","(","t",",","x",")","@","inv","(","k","(","x",",","x",")","+","v","*","I",")","@","k","(","x",",","t",")",")","``","`","Note","that","the","posterior","predictive","mean","is","the","same","as","a","Gaussian","Process",",","but","the","covariance","is","multiplied","by","a","term","that","takes","in","to","account","observations",".","This","distribution","does","precomputaiton","in","the","constructor","by","assuming","`","observation_index_points","`",",","`","observations","`",",","`","kernel","`","and","`","observation_noise_variance","`","are","fixed",",","and","that","`","mean_fn","`","is","the","zero","function",".","We","do","these","precomputations","in","a","non-tape","safe","way",".","#","#","#","#","References","[","1","]",":","Amar","Shah",",","Andrew","Gordon","Wilson",",","Zoubin","Ghahramani",".","Student-t","Processes","as","Alternatives","to","Gaussian","Processes","https",":","\/\/arxiv.org\/abs\/1402.4306","[","2","]",":","Qingtao","Tang",",","Yisen","Wang",",","Shu-Tao","Xia","Student-T","Process","Regression","with","Dependent","Student-t","Noise","https",":","\/\/www.ijcai.org\/proceedings\/2017\/393"]
docstr: Construct a StudentTProcessRegressionModel instance.
  
  Args:
    df: Positive Floating-point `Tensor` representing the degrees of freedom.
      Must be greather than 2.
    kernel: `PositiveSemidefiniteKernel`-like instance representing the
      StP's covariance function.
    index_points: (Nested) `Tensor` representing finite collection, or batch
      of collections, of points in the index set over which the STP is
      defined. Shape (of each nested component) has the form `[b1, ..., bB,
      e, f1, ..., fF]` where `F` is the number of feature dimensions and
      must equal `kernel.feature_ndims` (or its corresponding nested
      component) and `e` is the number (size) of index points in each
      batch. Ultimately this distribution corresponds to an `e`-dimensional
      multivariate Student T. The batch shape must be broadcastable with
      `kernel.batch_shape` and any batch dims yielded by `mean_fn`.
    observation_index_points: (Nested) `Tensor` representing finite
      collection, or batch of collections, of points in the index set for
      which some data has been observed. Shape (of each nested component)
      has the form `[b1, ..., bB, e, f1, ..., fF]` where `F` is the number
      of feature dimensions and must equal `kernel.feature_ndims` (or its
      corresponding nested component), and `e` is the number (size) of
      index points in each batch. `[b1, ..., bB, e]` must be broadcastable
      with the shape of `observations`, and `[b1, ..., bB]` must be
      broadcastable with the shapes of all other batched parameters
      (`kernel.batch_shape`, `index_points`, etc). The default value is
      `None`, which corresponds to the empty set of observations, and
      simply results in the prior predictive model (a STP with noise of
      variance `predictive_noise_variance`).
    observations: `float` `Tensor` representing collection, or batch of
      collections, of observations corresponding to
      `observation_index_points`. Shape has the form `[b1, ..., bB, e]`, which
      must be brodcastable with the batch and example shapes of
      `observation_index_points`. The batch shape `[b1, ..., bB]` must be
      broadcastable with the shapes of all other batched parameters
      (`kernel.batch_shape`, `index_points`, etc.).
    observation_noise_variance: `float` `Tensor` representing the variance
      of the noise in the Normal likelihood distribution of the model. May be
      batched, in which case the batch shape must be broadcastable with the
      shapes of all other batched parameters (`kernel.batch_shape`,
      `index_points`, etc.).
      Default value: `0.`
    predictive_noise_variance: `float` `Tensor` representing the variance in
      the posterior predictive model. If `None`, we simply re-use
      `observation_noise_variance` for the posterior predictive noise. If set
      explicitly, however, we use this value. This allows us, for example, to
      omit predictive noise variance (by setting this to zero) to obtain
      noiseless posterior predictions of function values, conditioned on noisy
      observations.
    mean_fn: Python `callable` that acts on `index_points` to produce a
      collection, or batch of collections, of mean values at `index_points`.
      Takes a (nested) `Tensor` of shape `[b1, ..., bB, e, f1, ..., fF]` and
      returns a `Tensor` whose shape is broadcastable with `[b1, ..., bB, e]`.
      Default value: `None` implies the constant zero function.
    cholesky_fn: Callable which takes a single (batch) matrix argument and
      returns a Cholesky-like lower triangular factor.  Default value: `None`,
      in which case `make_cholesky_with_jitter_fn`.
    marginal_fn: A Python callable that takes a location, covariance matrix,
      optional `validate_args`, `allow_nan_stats` and `name` arguments, and
      returns a multivariate Student-T subclass of `tfd.Distribution`.
      Default value: `None`, in which case a Cholesky-factorizing function
      is created using `make_cholesky_with_jitter_fn`.
    always_yield_multivariate_student_t: Deprecated and ignored.
    validate_args: Python `bool`, default `False`. When `True` distribution
      parameters are checked for validity despite possibly degrading runtime
      performance. When `False` invalid inputs may silently render incorrect
      outputs.
      Default value: `False`.
    allow_nan_stats: Python `bool`, default `True`. When `True`,
      statistics (e.g., mean, mode, variance) use the value `NaN` to
      indicate the result is undefined. When `False`, an exception is raised
      if one or more of the statistic's batch members are undefined.
      Default value: `False`.
    name: Python `str` name prefixed to Ops created by this class.
      Default value: 'StudentTProcessRegressionModel'.
    _conditional_kernel: Internal parameter -- do not use.
    _conditional_mean_fn: Internal parameter -- do not use.
docstr_tok: ["Construct","a","StudentTProcessRegressionModel","instance",".","Args",":","df",":","Positive","Floating-point","`","Tensor","`","representing","the","degrees","of","freedom",".","Must","be","greather","than","2.","kernel",":","`","PositiveSemidefiniteKernel","`","-like","instance","representing","the","StP","'s","covariance","function",".","index_points",":","(","Nested",")","`","Tensor","`","representing","finite","collection",",","or","batch","of","collections",",","of","points","in","the","index","set","over","which","the","STP","is","defined",".","Shape","(","of","each","nested","component",")","has","the","form","`","[","b1",",","...",",","bB",",","e",",","f1",",","...",",","fF","]","`","where","`","F","`","is","the","number","of","feature","dimensions","and","must","equal","`","kernel.feature_ndims","`","(","or","its","corresponding","nested","component",")","and","`","e","`","is","the","number","(","size",")","of","index","points","in","each","batch",".","Ultimately","this","distribution","corresponds","to","an","`","e","`","-dimensional","multivariate","Student","T.","The","batch","shape","must","be","broadcastable","with","`","kernel.batch_shape","`","and","any","batch","dims","yielded","by","`","mean_fn","`",".","observation_index_points",":","(","Nested",")","`","Tensor","`","representing","finite","collection",",","or","batch","of","collections",",","of","points","in","the","index","set","for","which","some","data","has","been","observed",".","Shape","(","of","each","nested","component",")","has","the","form","`","[","b1",",","...",",","bB",",","e",",","f1",",","...",",","fF","]","`","where","`","F","`","is","the","number","of","feature","dimensions","and","must","equal","`","kernel.feature_ndims","`","(","or","its","corresponding","nested","component",")",",","and","`","e","`","is","the","number","(","size",")","of","index","points","in","each","batch",".","`","[","b1",",","...",",","bB",",","e","]","`","must","be","broadcastable","with","the","shape","of","`","observations","`",",","and","`","[","b1",",","...",",","bB","]","`","must","be","broadcastable","with","the","shapes","of","all","other","batched","parameters","(","`","kernel.batch_shape","`",",","`","index_points","`",",","etc",")",".","The","default","value","is","`","None","`",",","which","corresponds","to","the","empty","set","of","observations",",","and","simply","results","in","the","prior","predictive","model","(","a","STP","with","noise","of","variance","`","predictive_noise_variance","`",")",".","observations",":","`","float","`","`","Tensor","`","representing","collection",",","or","batch","of","collections",",","of","observations","corresponding","to","`","observation_index_points","`",".","Shape","has","the","form","`","[","b1",",","...",",","bB",",","e","]","`",",","which","must","be","brodcastable","with","the","batch","and","example","shapes","of","`","observation_index_points","`",".","The","batch","shape","`","[","b1",",","...",",","bB","]","`","must","be","broadcastable","with","the","shapes","of","all","other","batched","parameters","(","`","kernel.batch_shape","`",",","`","index_points","`",",","etc.",")",".","observation_noise_variance",":","`","float","`","`","Tensor","`","representing","the","variance","of","the","noise","in","the","Normal","likelihood","distribution","of","the","model",".","May","be","batched",",","in","which","case","the","batch","shape","must","be","broadcastable","with","the","shapes","of","all","other","batched","parameters","(","`","kernel.batch_shape","`",",","`","index_points","`",",","etc.",")",".","Default","value",":","`","0.","`","predictive_noise_variance",":","`","float","`","`","Tensor","`","representing","the","variance","in","the","posterior","predictive","model",".","If","`","None","`",",","we","simply","re-use","`","observation_noise_variance","`","for","the","posterior","predictive","noise",".","If","set","explicitly",",","however",",","we","use","this","value",".","This","allows","us",",","for","example",",","to","omit","predictive","noise","variance","(","by","setting","this","to","zero",")","to","obtain","noiseless","posterior","predictions","of","function","values",",","conditioned","on","noisy","observations",".","mean_fn",":","Python","`","callable","`","that","acts","on","`","index_points","`","to","produce","a","collection",",","or","batch","of","collections",",","of","mean","values","at","`","index_points","`",".","Takes","a","(","nested",")","`","Tensor","`","of","shape","`","[","b1",",","...",",","bB",",","e",",","f1",",","...",",","fF","]","`","and","returns","a","`","Tensor","`","whose","shape","is","broadcastable","with","`","[","b1",",","...",",","bB",",","e","]","`",".","Default","value",":","`","None","`","implies","the","constant","zero","function",".","cholesky_fn",":","Callable","which","takes","a","single","(","batch",")","matrix","argument","and","returns","a","Cholesky-like","lower","triangular","factor",".","Default","value",":","`","None","`",",","in","which","case","`","make_cholesky_with_jitter_fn","`",".","marginal_fn",":","A","Python","callable","that","takes","a","location",",","covariance","matrix",",","optional","`","validate_args","`",",","`","allow_nan_stats","`","and","`","name","`","arguments",",","and","returns","a","multivariate","Student-T","subclass","of","`","tfd.Distribution","`",".","Default","value",":","`","None","`",",","in","which","case","a","Cholesky-factorizing","function","is","created","using","`","make_cholesky_with_jitter_fn","`",".","always_yield_multivariate_student_t",":","Deprecated","and","ignored",".","validate_args",":","Python","`","bool","`",",","default","`","False","`",".","When","`","True","`","distribution","parameters","are","checked","for","validity","despite","possibly","degrading","runtime","performance",".","When","`","False","`","invalid","inputs","may","silently","render","incorrect","outputs",".","Default","value",":","`","False","`",".","allow_nan_stats",":","Python","`","bool","`",",","default","`","True","`",".","When","`","True","`",",","statistics","(","e.g.",",","mean",",","mode",",","variance",")","use","the","value","`","NaN","`","to","indicate","the","result","is","undefined",".","When","`","False","`",",","an","exception","is","raised","if","one","or","more","of","the","statistic","'s","batch","members","are","undefined",".","Default","value",":","`","False","`",".","name",":","Python","`","str","`","name","prefixed","to","Ops","created","by","this","class",".","Default","value",":","'StudentTProcessRegressionModel","'",".","_conditional_kernel",":","Internal","parameter","--","do","not","use",".","_conditional_mean_fn",":","Internal","parameter","--","do","not","use","."]
code: def __init__(
      self,
      df,
      kernel,
      index_points=None,
      observation_index_points=None,
      observations=None,
      observation_noise_variance=0.0,
      predictive_noise_variance=None,
      mean_fn=None,
      cholesky_fn=None,
      marginal_fn=None,
      always_yield_multivariate_student_t=None,
      validate_args=False,
      allow_nan_stats=False,
      name="StudentTProcessRegressionModel",
      _conditional_kernel=None,
      _conditional_mean_fn=None,
  ):
      """Construct a StudentTProcessRegressionModel instance.
  
      Args:
        df: Positive Floating-point `Tensor` representing the degrees of freedom.
          Must be greather than 2.
        kernel: `PositiveSemidefiniteKernel`-like instance representing the
          StP's covariance function.
        index_points: (Nested) `Tensor` representing finite collection, or batch
          of collections, of points in the index set over which the STP is
          defined. Shape (of each nested component) has the form `[b1, ..., bB,
          e, f1, ..., fF]` where `F` is the number of feature dimensions and
          must equal `kernel.feature_ndims` (or its corresponding nested
          component) and `e` is the number (size) of index points in each
          batch. Ultimately this distribution corresponds to an `e`-dimensional
          multivariate Student T. The batch shape must be broadcastable with
          `kernel.batch_shape` and any batch dims yielded by `mean_fn`.
        observation_index_points: (Nested) `Tensor` representing finite
          collection, or batch of collections, of points in the index set for
          which some data has been observed. Shape (of each nested component)
          has the form `[b1, ..., bB, e, f1, ..., fF]` where `F` is the number
          of feature dimensions and must equal `kernel.feature_ndims` (or its
          corresponding nested component), and `e` is the number (size) of
          index points in each batch. `[b1, ..., bB, e]` must be broadcastable
          with the shape of `observations`, and `[b1, ..., bB]` must be
          broadcastable with the shapes of all other batched parameters
          (`kernel.batch_shape`, `index_points`, etc). The default value is
          `None`, which corresponds to the empty set of observations, and
          simply results in the prior predictive model (a STP with noise of
          variance `predictive_noise_variance`).
        observations: `float` `Tensor` representing collection, or batch of
          collections, of observations corresponding to
          `observation_index_points`. Shape has the form `[b1, ..., bB, e]`, which
          must be brodcastable with the batch and example shapes of
          `observation_index_points`. The batch shape `[b1, ..., bB]` must be
          broadcastable with the shapes of all other batched parameters
          (`kernel.batch_shape`, `index_points`, etc.).
        observation_noise_variance: `float` `Tensor` representing the variance
          of the noise in the Normal likelihood distribution of the model. May be
          batched, in which case the batch shape must be broadcastable with the
          shapes of all other batched parameters (`kernel.batch_shape`,
          `index_points`, etc.).
          Default value: `0.`
        predictive_noise_variance: `float` `Tensor` representing the variance in
          the posterior predictive model. If `None`, we simply re-use
          `observation_noise_variance` for the posterior predictive noise. If set
          explicitly, however, we use this value. This allows us, for example, to
          omit predictive noise variance (by setting this to zero) to obtain
          noiseless posterior predictions of function values, conditioned on noisy
          observations.
        mean_fn: Python `callable` that acts on `index_points` to produce a
          collection, or batch of collections, of mean values at `index_points`.
          Takes a (nested) `Tensor` of shape `[b1, ..., bB, e, f1, ..., fF]` and
          returns a `Tensor` whose shape is broadcastable with `[b1, ..., bB, e]`.
          Default value: `None` implies the constant zero function.
        cholesky_fn: Callable which takes a single (batch) matrix argument and
          returns a Cholesky-like lower triangular factor.  Default value: `None`,
          in which case `make_cholesky_with_jitter_fn`.
        marginal_fn: A Python callable that takes a location, covariance matrix,
          optional `validate_args`, `allow_nan_stats` and `name` arguments, and
          returns a multivariate Student-T subclass of `tfd.Distribution`.
          Default value: `None`, in which case a Cholesky-factorizing function
          is created using `make_cholesky_with_jitter_fn`.
        always_yield_multivariate_student_t: Deprecated and ignored.
        validate_args: Python `bool`, default `False`. When `True` distribution
          parameters are checked for validity despite possibly degrading runtime
          performance. When `False` invalid inputs may silently render incorrect
          outputs.
          Default value: `False`.
        allow_nan_stats: Python `bool`, default `True`. When `True`,
          statistics (e.g., mean, mode, variance) use the value `NaN` to
          indicate the result is undefined. When `False`, an exception is raised
          if one or more of the statistic's batch members are undefined.
          Default value: `False`.
        name: Python `str` name prefixed to Ops created by this class.
          Default value: 'StudentTProcessRegressionModel'.
        _conditional_kernel: Internal parameter -- do not use.
        _conditional_mean_fn: Internal parameter -- do not use.
      """
      parameters = dict(locals())
      with tf.name_scope(name) as name:
          if tf.nest.is_nested(kernel.feature_ndims):
              input_dtype = dtype_util.common_dtype(
                  [kernel, index_points, observation_index_points],
                  dtype_hint=nest_util.broadcast_structure(
                      kernel.feature_ndims, tf.float32
                  ),
              )
              dtype = dtype_util.common_dtype(
                  [
                      observations,
                      observation_noise_variance,
                      predictive_noise_variance,
                      df,
                  ],
                  tf.float32,
              )
          else:
              # If the index points are not nested, we assume they are of the same
              # dtype as the STPRM.
              dtype = dtype_util.common_dtype(
                  [
                      kernel,
                      index_points,
                      observation_index_points,
                      observations,
                      observation_noise_variance,
                      predictive_noise_variance,
                      df,
                  ],
                  tf.float32,
              )
              input_dtype = dtype
  
          if index_points is not None:
              index_points = nest_util.convert_to_nested_tensor(
                  index_points,
                  dtype=input_dtype,
                  convert_ref=False,
                  name="index_points",
                  allow_packing=True,
              )
          if observation_index_points is not None:
              observation_index_points = (
                  nest_util.convert_to_nested_tensor(
                      observation_index_points,
                      dtype=input_dtype,
                      convert_ref=False,
                      name="observation_index_points",
                      allow_packing=True,
                  )
              )
          df = tensor_util.convert_nonref_to_tensor(
              df, dtype=dtype, name="df"
          )
          observations = tensor_util.convert_nonref_to_tensor(
              observations, dtype=dtype, name="observations"
          )
          observation_noise_variance = (
              tensor_util.convert_nonref_to_tensor(
                  observation_noise_variance,
                  dtype=dtype,
                  name="observation_noise_variance",
              )
          )
          predictive_noise_variance = (
              tensor_util.convert_nonref_to_tensor(
                  predictive_noise_variance,
                  dtype=dtype,
                  name="predictive_noise_variance",
              )
          )
          if predictive_noise_variance is None:
              predictive_noise_variance = observation_noise_variance
          if (observation_index_points is None) != (
              observations is None
          ):
              raise ValueError(
                  "`observations` and `observation_index_points` must both be given "
                  "or None. Got {} and {}, respectively.".format(
                      observations, observation_index_points
                  )
              )
          # Default to a constant zero function, borrowing the dtype from
          # index_points to ensure consistency.
          mean_fn = stochastic_process_util.maybe_create_mean_fn(
              mean_fn, dtype
          )
          if cholesky_fn is None:
              cholesky_fn = cholesky_util.make_cholesky_with_jitter_fn()
  
          self._observation_index_points = observation_index_points
          self._observations = observations
          self._observation_noise_variance = observation_noise_variance
          self._predictive_noise_variance = predictive_noise_variance
  
          with tf.name_scope("init"):
              if _conditional_kernel is None:
                  _conditional_kernel = DampedSchurComplement(
                      df=df,
                      schur_complement=schur_complement_lib.SchurComplement(
                          base_kernel=kernel,
                          fixed_inputs=self._observation_index_points,
                          cholesky_fn=cholesky_fn,
                          diag_shift=observation_noise_variance,
                      ),
                      fixed_inputs_observations=self._observations,
                      validate_args=validate_args,
                  )
  
              # Special logic for mean_fn only; SchurComplement already handles the
              # case of empty observations (ie, falls back to base_kernel).
              if stochastic_process_util.is_empty_observation_data(
                  feature_ndims=kernel.feature_ndims,
                  observation_index_points=observation_index_points,
                  observations=observations,
              ):
                  if _conditional_mean_fn is None:
                      _conditional_mean_fn = mean_fn
              else:
                  stochastic_process_util.validate_observation_data(
                      kernel=kernel,
                      observation_index_points=observation_index_points,
                      observations=observations,
                  )
  
                  # If `__init__` is called for CompositeTensor/Pytree unflattening,
                  # `df` is already the `DeferredTensor`.
                  if _conditional_mean_fn is None:
                      n = tf.cast(
                          ps.shape(observations)[-1], dtype=dtype
                      )
                      df = tfp_util.DeferredTensor(df, lambda x: x + n)
  
                  if _conditional_mean_fn is None:
  
                      def conditional_mean_fn(x):
                          """Conditional mean."""
                          observations = tf.convert_to_tensor(
                              self._observations
                          )
                          observation_index_points = (
                              nest_util.convert_to_nested_tensor(
                                  self._observation_index_points,
                                  dtype_hint=self.kernel.dtype,
                                  allow_packing=True,
                              )
                          )
                          k_x_obs_linop = (
                              tf.linalg.LinearOperatorFullMatrix(
                                  kernel.matrix(
                                      x, observation_index_points
                                  )
                              )
                          )
                          chol_linop = tf.linalg.LinearOperatorLowerTriangular(
                              _conditional_kernel.divisor_matrix_cholesky(
                                  fixed_inputs=observation_index_points
                              )
                          )
                          diff = observations - mean_fn(
                              observation_index_points
                          )
                          return mean_fn(x) + k_x_obs_linop.matvec(
                              chol_linop.solvevec(
                                  chol_linop.solvevec(diff),
                                  adjoint=True,
                              )
                          )
  
                      _conditional_mean_fn = conditional_mean_fn
  
              # Store `_conditional_kernel` and `_conditional_mean_fn` as attributes
              # for `AutoCompositeTensor`.
              self._conditional_kernel = _conditional_kernel
              self._conditional_mean_fn = _conditional_mean_fn
              super(StudentTProcessRegressionModel, self).__init__(
                  df=df,
                  kernel=_conditional_kernel,
                  mean_fn=_conditional_mean_fn,
                  cholesky_fn=cholesky_fn,
                  index_points=index_points,
                  observation_noise_variance=predictive_noise_variance,
                  always_yield_multivariate_student_t=(
                      always_yield_multivariate_student_t
                  ),
                  validate_args=validate_args,
                  allow_nan_stats=allow_nan_stats,
                  name=name,
              )
              self._parameters = parameters
  
imports: import tensorflow.compat.v2
  from tensorflow_probability.python import util
  from tensorflow_probability.python.bijectors import softplus
  from tensorflow_probability.python.distributions import cholesky_util
  from tensorflow_probability.python.distributions import student_t_process
  from tensorflow_probability.python.distributions.internal import stochastic_process_util
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import nest_util
  from tensorflow_probability.python.internal import parameter_properties
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import tensor_util
  from tensorflow_probability.python.math.psd_kernels import positive_semidefinite_kernel
  from tensorflow_probability.python.math.psd_kernels import schur_complement
  from tensorflow.python.util import deprecation
label_desc: Use image node_id 1 to create a new StudentTProcessRegressionModel object from inherited base classes: student_t_process with example: obj = StudentTProcessRegressionModel(df, kernel, index_points, observation_index_points, observations, observation_noise_variance, predictive_noise_variance, mean_fn, cholesky_fn, marginal_fn, always_yield_multivariate_student_t, validate_args, allow_nan_stats, name, _conditional_kernel, _conditional_mean_fn)