docstr: Configure the test statistic thresholds via bootstrapping.
docstr_tok: ["Configure","the","test","statistic","thresholds","via","bootstrapping","."]
code: def _configure_thresholds(self):
      """
      Configure the test statistic thresholds via bootstrapping.
      """
      # Each bootstrap sample splits the reference samples into a sub-reference sample (x)
      # and an extended test window (y). The extended test window will be treated as W overlapping
      # test windows of size W (so 2W-1 test samples in total)
  
      w_size = self.window_size
      etw_size = 2 * w_size - 1  # etw = extended test window
      nkc_size = (
          self.n - self.n_kernel_centers
      )  # nkc = non-kernel-centers
      rw_size = nkc_size - etw_size  # rw = ref-window
  
      perms = [
          torch.randperm(nkc_size) for _ in range(self.n_bootstraps)
      ]
      x_inds_all = [perm[:rw_size] for perm in perms]
      y_inds_all = [perm[rw_size:] for perm in perms]
  
      # For stability in high dimensions we don't divide H by (pi*sigma^2)^(d/2)
      # Results in an alternative test-stat of LSDD*(pi*sigma^2)^(d/2). Same p-vals etc.
      H = GaussianRBF(np.sqrt(2.0) * self.kernel.sigma)(
          self.kernel_centers, self.kernel_centers
      )
  
      # Compute lsdds for first test-window. We infer regularisation constant lambda here.
      y_inds_all_0 = [y_inds[:w_size] for y_inds in y_inds_all]
      lsdds_0, H_lam_inv = permed_lsdds(
          self.k_xc,
          x_inds_all,
          y_inds_all_0,
          H,
          lam_rd_max=self.lambda_rd_max,
      )
  
      # Can compute threshold for first window
      thresholds = [quantile(lsdds_0, 1 - self.fpr)]
      # And now to iterate through the other W-1 overlapping windows
      p_bar = (
          tqdm(range(1, w_size), "Computing thresholds")
          if self.verbose
          else range(1, w_size)
      )
      for w in p_bar:
          y_inds_all_w = [
              y_inds[w : (w + w_size)] for y_inds in y_inds_all
          ]
          lsdds_w, _ = permed_lsdds(
              self.k_xc,
              x_inds_all,
              y_inds_all_w,
              H,
              H_lam_inv=H_lam_inv,
          )
          thresholds.append(quantile(lsdds_w, 1 - self.fpr))
          x_inds_all = [
              x_inds_all[i]
              for i in range(len(x_inds_all))
              if lsdds_w[i] < thresholds[-1]
          ]
          y_inds_all = [
              y_inds_all[i]
              for i in range(len(y_inds_all))
              if lsdds_w[i] < thresholds[-1]
          ]
  
      self.thresholds = thresholds
      self.H_lam_inv = H_lam_inv
  
file_path: alibi-detect/alibi_detect/cd/pytorch/lsdd_online.py
imports: from tqdm import tqdm
  import numpy
  import torch
  from typing import Any, Callable, Optional, Union
  from alibi_detect.cd.base_online import BaseMultiDriftOnline
  from alibi_detect.utils.pytorch import get_device
  from alibi_detect.utils.pytorch import GaussianRBF, permed_lsdds, quantile
  from alibi_detect.utils.frameworks import Framework
  from alibi_detect.utils._types import TorchDeviceType
label_desc: Use image node_id 4 for calling the LSDDDriftOnlineTorch obj's underlying member method code with example usage: obj._configure_thresholds() without return types