class_docstr: A single-task exact GP model, supporting both known and inferred noise levels.
  
  A single-task exact GP using relatively strong priors on the Kernel
  hyperparameters, which work best when covariates are normalized to the unit
  cube and outcomes are standardized (zero mean, unit variance).
  
  This model works in batch mode (each batch having its own hyperparameters).
  When the training observations include multiple outputs, this model will use
  batching to model outputs independently.
  
  Use this model when you have independent output(s) and all outputs use the
  same training data. If outputs are independent and outputs have different
  training data, use the ModelListGP. When modeling correlations between
  outputs, use the MultiTaskGP.
  
  An example of a case in which noise levels are known is online
  experimentation, where noise can be measured using the variability of
  different observations from the same arm, or provided by outside software.
  Another use case is simulation optimization, where the evaluation can
  provide variance estimates, perhaps from bootstrapping. In any case, these
  noise levels can be provided to `SingleTaskGP` as `train_Yvar`.
  
  `SingleTaskGP` can also be used when the observations are known to be
  noise-free. Noise-free observations can be modeled using arbitrarily small
  noise values, such as `train_Yvar=torch.full_like(train_Y, 1e-6)`.
  
  Example:
      Model with inferred noise levels:
  
      >>> import torch
      >>> from botorch.models.gp_regression import SingleTaskGP
      >>> from botorch.models.transforms.outcome import Standardize
      >>>
      >>> train_X = torch.rand(20, 2, dtype=torch.float64)
      >>> train_Y = torch.sin(train_X).sum(dim=1, keepdim=True)
      >>> outcome_transform = Standardize(m=1)
      >>> inferred_noise_model = SingleTaskGP(
      ...     train_X, train_Y, outcome_transform=outcome_transform,
      ... )
  
      Model with a known observation variance of 0.2:
  
      >>> train_Yvar = torch.full_like(train_Y, 0.2)
      >>> observed_noise_model = SingleTaskGP(
      ...     train_X, train_Y, train_Yvar,
      ...     outcome_transform=outcome_transform,
      ... )
  
      With noise-free observations:
  
      >>> train_Yvar = torch.full_like(train_Y, 1e-6)
      >>> noise_free_model = SingleTaskGP(
      ...     train_X, train_Y, train_Yvar,
      ...     outcome_transform=outcome_transform,
      ... )
docstr: Args:
      train_X: A `batch_shape x n x d` tensor of training features.
      train_Y: A `batch_shape x n x m` tensor of training observations.
      train_Yvar: An optional `batch_shape x n x m` tensor of observed
          measurement noise.
      likelihood: A likelihood. If omitted, use a standard
          `GaussianLikelihood` with inferred noise level if `train_Yvar`
          is None, and a `FixedNoiseGaussianLikelihood` with the given
          noise observations if `train_Yvar` is not None.
      covar_module: The module computing the covariance (Kernel) matrix.
          If omitted, use a `MaternKernel`.
      mean_module: The mean function to be used. If omitted, use a
          `ConstantMean`.
      outcome_transform: An outcome transform that is applied to the
          training data during instantiation and to the posterior during
          inference (that is, the `Posterior` obtained by calling
          `.posterior` on the model will be on the original scale).
      input_transform: An input transform that is applied in the model's
          forward pass.
code: def __init__(
      self,
      train_X: Tensor,
      train_Y: Tensor,
      train_Yvar: Optional[Tensor] = None,
      likelihood: Optional[Likelihood] = None,
      covar_module: Optional[Module] = None,
      mean_module: Optional[Mean] = None,
      outcome_transform: Optional[OutcomeTransform] = None,
      input_transform: Optional[InputTransform] = None,
  ) -> None:
      r"""
      Args:
          train_X: A `batch_shape x n x d` tensor of training features.
          train_Y: A `batch_shape x n x m` tensor of training observations.
          train_Yvar: An optional `batch_shape x n x m` tensor of observed
              measurement noise.
          likelihood: A likelihood. If omitted, use a standard
              `GaussianLikelihood` with inferred noise level if `train_Yvar`
              is None, and a `FixedNoiseGaussianLikelihood` with the given
              noise observations if `train_Yvar` is not None.
          covar_module: The module computing the covariance (Kernel) matrix.
              If omitted, use a `MaternKernel`.
          mean_module: The mean function to be used. If omitted, use a
              `ConstantMean`.
          outcome_transform: An outcome transform that is applied to the
              training data during instantiation and to the posterior during
              inference (that is, the `Posterior` obtained by calling
              `.posterior` on the model will be on the original scale).
          input_transform: An input transform that is applied in the model's
              forward pass.
      """
      with torch.no_grad():
          transformed_X = self.transform_inputs(
              X=train_X, input_transform=input_transform
          )
      if outcome_transform is not None:
          train_Y, train_Yvar = outcome_transform(train_Y, train_Yvar)
      self._validate_tensor_args(
          X=transformed_X, Y=train_Y, Yvar=train_Yvar
      )
      ignore_X_dims = getattr(
          self, "_ignore_X_dims_scaling_check", None
      )
      validate_input_scaling(
          train_X=transformed_X,
          train_Y=train_Y,
          train_Yvar=train_Yvar,
          ignore_X_dims=ignore_X_dims,
      )
      self._set_dimensions(train_X=train_X, train_Y=train_Y)
      train_X, train_Y, train_Yvar = self._transform_tensor_args(
          X=train_X, Y=train_Y, Yvar=train_Yvar
      )
      if likelihood is None:
          if train_Yvar is None:
              likelihood = get_gaussian_likelihood_with_gamma_prior(
                  batch_shape=self._aug_batch_shape
              )
          else:
              likelihood = FixedNoiseGaussianLikelihood(
                  noise=train_Yvar, batch_shape=self._aug_batch_shape
              )
      else:
          self._is_custom_likelihood = True
      ExactGP.__init__(
          self,
          train_inputs=train_X,
          train_targets=train_Y,
          likelihood=likelihood,
      )
      if mean_module is None:
          mean_module = ConstantMean(batch_shape=self._aug_batch_shape)
      self.mean_module = mean_module
      if covar_module is None:
          covar_module = get_matern_kernel_with_gamma_prior(
              ard_num_dims=transformed_X.shape[-1],
              batch_shape=self._aug_batch_shape,
          )
          self._subset_batch_dict = {
              "mean_module.raw_constant": -1,
              "covar_module.raw_outputscale": -1,
              "covar_module.base_kernel.raw_lengthscale": -3,
          }
          if train_Yvar is None:
              self._subset_batch_dict[
                  "likelihood.noise_covar.raw_noise"
              ] = -2
      self.covar_module = covar_module
      # TODO: Allow subsetting of other covar modules
      if outcome_transform is not None:
          self.outcome_transform = outcome_transform
      if input_transform is not None:
          self.input_transform = input_transform
      self.to(train_X)
  
imports: from __future__ import annotations
  import warnings
  from typing import NoReturn, Optional
  import torch
  from botorch.models.gpytorch import BatchedMultiOutputGPyTorchModel
  from botorch.models.model import FantasizeMixin
  from botorch.models.transforms.input import InputTransform
  from botorch.models.transforms.outcome import Log, OutcomeTransform
  from botorch.models.utils import validate_input_scaling
  from botorch.models.utils.gpytorch_modules import get_gaussian_likelihood_with_gamma_prior, get_matern_kernel_with_gamma_prior, MIN_INFERRED_NOISE_LEVEL
  from gpytorch.constraints.constraints import GreaterThan
  from gpytorch.distributions.multivariate_normal import MultivariateNormal
  from gpytorch.likelihoods.gaussian_likelihood import _GaussianLikelihoodBase, FixedNoiseGaussianLikelihood, GaussianLikelihood
  from gpytorch.likelihoods.likelihood import Likelihood
  from gpytorch.likelihoods.noise_models import HeteroskedasticNoise
  from gpytorch.means.constant_mean import ConstantMean
  from gpytorch.means.mean import Mean
  from gpytorch.mlls.noise_model_added_loss_term import NoiseModelAddedLossTerm
  from gpytorch.models.exact_gp import ExactGP
  from gpytorch.module import Module
  from gpytorch.priors.smoothed_box_prior import SmoothedBoxPrior
  from torch import Tensor
label_desc: Use image node_id 1 to create a new SingleTaskGP object from inherited base classes: BatchedMultiOutputGPyTorchModel, ExactGP, FantasizeMixin with example: obj = SingleTaskGP(train_X, train_Y, train_Yvar, likelihood, covar_module, mean_module, outcome_transform, input_transform)