code: def _bilinear_derivative(self, left_vecs, right_vecs):
      # This _bilinear_derivative computes the kernel in chunks
      # It is only used when we are using kernel checkpointing
      # It won't be called if checkpointing is off
      split_size = beta_features.checkpoint_kernel.value()
      if not split_size:
          raise RuntimeError(
              "Should not have ended up in LazyEvaluatedKernelTensor._bilinear_derivative without kernel "
              "checkpointing. This is probably a bug in GPyTorch."
          )
  
      x1 = self.x1.detach().requires_grad_(True)
      x2 = self.x2.detach().requires_grad_(True)
  
      # Break objects into chunks
      sub_x1s = [
          sub_x1.detach()
          for sub_x1 in torch.split(x1, split_size, dim=-2)
      ]
      sub_left_vecss = torch.split(left_vecs, split_size, dim=-2)
      # Compute the gradient in chunks
      for sub_x1, sub_left_vecs in zip(sub_x1s, sub_left_vecss):
          sub_x1.requires_grad_(True)
          with torch.enable_grad(), settings.lazily_evaluate_kernels(
              False
          ):
              sub_kernel_matrix = to_linear_operator(
                  self.kernel(
                      sub_x1,
                      x2,
                      diag=False,
                      last_dim_is_batch=self.last_dim_is_batch,
                      **self.params,
                  )
              )
          sub_grad_outputs = tuple(
              sub_kernel_matrix._bilinear_derivative(
                  sub_left_vecs, right_vecs
              )
          )
          sub_kernel_outputs = tuple(sub_kernel_matrix.representation())
          torch.autograd.backward(sub_kernel_outputs, sub_grad_outputs)
  
      x1.grad = torch.cat(
          [sub_x1.grad.data for sub_x1 in sub_x1s], dim=-2
      )
      return x1.grad, x2.grad
  
imports: import functools
  from typing import Callable
  import torch
  from linear_operator import LinearOperator, to_linear_operator
  from linear_operator.utils.getitem import _noop_index
  from ..None import beta_features, settings
  from ..utils import deprecation
  from ..utils.memoize import cached
label_desc: Use image node_id 7 for calling the LazyEvaluatedKernelTensor obj's underlying member method code with example usage: obj._bilinear_derivative(left_vecs, right_vecs) and returns: x1,  x2