code: def testPrecomputedWithMasking(self):
      amplitude = np.array([1.0, 2.0], np.float64)
      length_scale = np.array([[0.1], [0.2], [0.3]], np.float64)
      observation_noise_variance = np.array(
          [[1e-1], [2e-1], [3e-1]], np.float64
      )
  
      rng = test_util.test_np_rng()
      observations_is_missing = np.array(
          [
              [False, True, False, True, False, True],
              [False, False, False, False, False, False],
              [True, True, False, False, True, True],
          ]
      ).reshape((3, 1, 6))
      observation_index_points = np.where(
          observations_is_missing[..., np.newaxis],
          np.nan,
          rng.uniform(-1.0, 1.0, (3, 1, 6, 2)).astype(np.float64),
      )
      observations = np.where(
          observations_is_missing,
          np.nan,
          rng.uniform(-1.0, 1.0, (3, 1, 6)).astype(np.float64),
      )
  
      index_points = rng.uniform(-1.0, 1.0, (5, 2)).astype(np.float64)
  
      kernel = exponentiated_quadratic.ExponentiatedQuadratic(
          amplitude, length_scale
      )
      dist = stprm.StudentTProcessRegressionModel.precompute_regression_model(
          df=40.4,
          kernel=kernel,
          index_points=index_points,
          observation_index_points=observation_index_points,
          observations=observations,
          observations_is_missing=observations_is_missing,
          observation_noise_variance=observation_noise_variance,
          validate_args=True,
      )
  
      self.assertAllNotNan(dist.mean())
      self.assertAllNotNan(dist.variance())
      self.assertAllNotNan(dist.covariance())
  
      # For each batch member of `gprm`, check that the distribution is the same
      # as a StudentTProcessRegressionModel with no masking but conditioned on
      # only the not-masked-out index points.
      x = dist.sample(seed=test_util.test_seed())
      for i in range(3):
          observation_index_points_i = tf.gather(
              observation_index_points[i, 0],
              (~observations_is_missing[i, 0]).nonzero()[0],
          )
          observations_i = tf.gather(
              observations[i, 0],
              (~observations_is_missing[i, 0]).nonzero()[0],
          )
          dist_i = stprm.StudentTProcessRegressionModel.precompute_regression_model(
              df=40.4,
              kernel=kernel[i],
              index_points=index_points,
              observation_index_points=observation_index_points_i,
              observations=observations_i,
              observation_noise_variance=observation_noise_variance[
                  i, 0
              ],
              validate_args=True,
          )
  
          self.assertAllClose(dist.mean()[i], dist_i.mean())
          self.assertAllClose(dist.variance()[i], dist_i.variance())
          self.assertAllClose(dist.covariance()[i], dist_i.covariance())
          self.assertAllClose(
              dist.log_prob(x)[i], dist_i.log_prob(x[i])
          )
  
imports: from unittest import mock
  import numpy
  import tensorflow.compat.v2
  from tensorflow_probability.python.distributions import gaussian_process_regression_model
  from tensorflow_probability.python.distributions import student_t_process
  from tensorflow_probability.python.distributions import student_t_process_regression_model
  from tensorflow_probability.python.internal import test_util
  from tensorflow_probability.python.math.psd_kernels import exp_sin_squared
  from tensorflow_probability.python.math.psd_kernels import exponentiated_quadratic
  from tensorflow_probability.python.math.psd_kernels.internal import test_util
label_desc: Use image node_id 11 for calling the StudentTProcessRegressionModelTest obj's underlying member method code with example usage: obj.testPrecomputedWithMasking() without return types