class_docstr: A single-task variational GP model following [hensman2013svgp]_.
  
  By default, the inducing points are initialized though the
  `GreedyVarianceReduction` of [burt2020svgp]_, which is known to be
  effective for building globally accurate models. However, custom
  inducing point allocators designed for specific down-stream tasks can also be
  provided (see [moss2023ipa]_ for details), e.g. `GreedyImprovementReduction`
  when the goal is to build a model suitable for standard BO.
  
  A single-task variational 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. However, batches of multi-output models
  are not supported at this time, if you need to use those, please use a
  ModelListGP.
  
  Use this model if you have a lot of data or if your responses are non-Gaussian.
  
  To train this model, you should use gpytorch.mlls.VariationalELBO and not
  the exact marginal log likelihood.
  
  Example:
      >>> import torch
      >>> from botorch.models import SingleTaskVariationalGP
      >>> from gpytorch.mlls import VariationalELBO
      >>>
      >>> train_X = torch.rand(20, 2)
      >>> model = SingleTaskVariationalGP(train_X)
      >>> mll = VariationalELBO(
      >>>     model.likelihood, model.model, num_data=train_X.shape[-2]
      >>> )
docstr: Reinitialize the inducing point locations in-place with the current kernel
  applied to `inputs` through the model's inducing point allocation strategy.
  The variational distribution and variational strategy caches are reset.
  
  Args:
      inputs: (\*batch_shape, n, d)-dim input data tensor.
  
  Returns:
      (\*batch_shape, m, d)-dim tensor of selected inducing point locations.
code: def init_inducing_points(
      self,
      inputs: Tensor,
  ) -> Tensor:
      r"""
      Reinitialize the inducing point locations in-place with the current kernel
      applied to `inputs` through the model's inducing point allocation strategy.
      The variational distribution and variational strategy caches are reset.
  
      Args:
          inputs: (\*batch_shape, n, d)-dim input data tensor.
  
      Returns:
          (\*batch_shape, m, d)-dim tensor of selected inducing point locations.
      """
      var_strat = self.model.variational_strategy
      clear_cache_hook(var_strat)
      if hasattr(var_strat, "base_variational_strategy"):
          var_strat = var_strat.base_variational_strategy
          clear_cache_hook(var_strat)
  
      with torch.no_grad():
          num_inducing = var_strat.inducing_points.size(-2)
          inducing_points = (
              self._inducing_point_allocator.allocate_inducing_points(
                  inputs=inputs,
                  covar_module=self.model.covar_module,
                  num_inducing=num_inducing,
                  input_batch_shape=self._input_batch_shape,
              )
          )
          var_strat.inducing_points.copy_(inducing_points)
          var_strat.variational_params_initialized.fill_(0)
  
      return inducing_points
  
imports: from __future__ import annotations
  import copy
  import warnings
  from typing import Optional, Type, TypeVar, Union
  import torch
  from botorch.models.gpytorch import GPyTorchModel
  from botorch.models.transforms.input import InputTransform
  from botorch.models.transforms.outcome import 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
  from botorch.models.utils.inducing_point_allocators import GreedyVarianceReduction, InducingPointAllocator
  from botorch.posteriors.gpytorch import GPyTorchPosterior
  from gpytorch.distributions import MultivariateNormal
  from gpytorch.kernels import Kernel
  from gpytorch.likelihoods import GaussianLikelihood, Likelihood, MultitaskGaussianLikelihood
  from gpytorch.means import ConstantMean, Mean
  from gpytorch.models import ApproximateGP
  from gpytorch.utils.memoize import clear_cache_hook
  from gpytorch.variational import _VariationalDistribution, _VariationalStrategy, CholeskyVariationalDistribution, IndependentMultitaskVariationalStrategy, VariationalStrategy
  from torch import Tensor
  from torch.nn import Module
label_desc: Use image node_id 3 for calling the SingleTaskVariationalGP obj's underlying member method code with example usage: obj.init_inducing_points(inputs) and returns: inducing_points