class_docstr: Implementation of the hard-label GRAPHITE attack from Feng et al. (2022). This is a physical, black-box attack
  that only requires final class prediction and generates robust physical perturbations that can be applied as
  stickers.
  
  | Paper link: https://arxiv.org/abs/2002.07088
  | Original github link: https://github.com/ryan-feng/GRAPHITE
code: def _check_params(self) -> None:
      if self.noise_size < self.heat_patch_size:
          raise ValueError(
              "Heatmap patch size must be smaller than the noise size."
          )
  
      if min(self.heat_patch_size) <= 0:
          raise ValueError("Heatmap patch size must be positive.")
  
      if not isinstance(self.heat_patch_size[0], int) or not isinstance(
          self.heat_patch_size[1], int
      ):
          raise ValueError(
              "Heatmap patch size must be a tuple of two integers."
          )
  
      if (
          min(self.heat_patch_stride) <= 0
          or not isinstance(self.heat_patch_stride[0], int)
          or not isinstance(self.heat_patch_stride[1], int)
      ):
          raise ValueError(
              "Heatmap patch stride must be a tuple of two positive integers."
          )
  
      if self.heatmap_mode not in ["Target", "Random"]:
          raise ValueError("Heatmap mode must be 'Target' or 'Random'.")
  
      if self.tr_lo < 0 or self.tr_lo > 1:
          raise ValueError("tr_lo must be between 0 and 1.")
  
      if self.tr_hi < 0 or self.tr_hi > 1:
          raise ValueError("tr_hi must be between 0 and 1.")
  
      if self.tr_hi < self.tr_lo:
          raise ValueError("tr_hi must be at least as high as tr_lo.")
  
      if self.num_xforms_mask < 0 or not isinstance(
          self.num_xforms_mask, int
      ):
          raise ValueError(
              "num_xforms_mask must be non-negative integer."
          )
  
      if self.beta <= 0:
          raise ValueError("beta must be positive.")
  
      if self.eta <= 0:
          raise ValueError("eta must be positive.")
  
      if self.num_xforms_boost < 0 or not isinstance(
          self.num_xforms_boost, int
      ):
          raise ValueError("num_xforms_boost must be positive integer.")
  
      if self.num_boost_queries <= 0 or not isinstance(
          self.num_boost_queries, int
      ):
          raise ValueError("num_boost_queries must be positive.")
  
      if (
          self.rotation_range[0] <= -90
          or self.rotation_range[1] >= 90
          or self.rotation_range[1] < self.rotation_range[0]
      ):
          raise ValueError("rotation range must be within (-90, 90).")
  
      if (
          self.dist_range[1] < self.dist_range[0]
          or self.dist_range[0] < 0
      ):
          raise ValueError(
              "distance range invalid. max must be greater than min, and must be nonnegative."
          )
  
      if (
          self.gamma_range[1] < self.gamma_range[0]
          or self.gamma_range[0] < 1
      ):
          raise ValueError(
              "gamma range max must be greater than min and the range must be at 1.0 or greater."
          )
  
      if self.crop_percent_range[1] < self.crop_percent_range[0]:
          raise ValueError(
              "max of crop percent range must be greater or equal to the min."
          )
  
      if self.off_x_range[1] < self.off_x_range[0]:
          raise ValueError(
              "max of off x range must be greater or equal to the min."
          )
  
      if self.off_y_range[1] < self.off_y_range[0]:
          raise ValueError(
              "max of off y range must be greater or equal to the min."
          )
  
      if min(self.blur_kernels) < 0:
          raise ValueError("blur kernels must be positive.")
  
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import logging
  from typing import Optional, Tuple, Union, TYPE_CHECKING, List
  import random
  import numpy
  from art.config import ART_NUMPY_DTYPE
  from art.attacks.attack import EvasionAttack
  from art.estimators.estimator import BaseEstimator
  from art.estimators.classification import ClassifierMixin
  from art.utils import compute_success, to_categorical, check_and_transform_label_format
  from art.attacks.evasion.graphite.utils import convert_to_network, get_transform_params, add_noise, get_transformed_images, run_predictions, score_fn
label_desc: Use image node_id 10 for calling the GRAPHITEBlackbox obj's underlying member method code with example usage: obj._check_params() without return types