class_docstr: MixAugmentationBase base class for customized mix augmentation implementations.
  
  For any augmentation, the implementation of "generate_parameters" and "apply_transform" are required.
  "apply_transform" will need to handle the probabilities internally.
  
  Args:
      p: probability for applying an augmentation. This param controls if to apply the augmentation for the batch.
      p_batch: probability for applying an augmentation to a batch. This param controls the augmentation
        probabilities batch-wise.
      same_on_batch: apply the same transformation across the batch.
      keepdim: whether to keep the output shape the same as input ``True`` or broadcast it
        to the batch form ``False``.
      data_keys: the input type sequential for applying augmentations.
          Accepts "input", "image", "mask", "bbox", "bbox_xyxy", "bbox_xywh", "keypoints".
code: def forward(  # type: ignore[override]
      self,
      *input: Tensor,
      params: Optional[Dict[str, Tensor]] = None,
      data_keys: Optional[List[Union[str, int, DataKey]]] = None,
  ) -> Union[Tensor, List[Tensor]]:
      keys: List[DataKey]
      if data_keys is None:
          keys = self.data_keys
      else:
          keys = [DataKey.get(inp) for inp in data_keys]
  
      if params is None:
          in_tensor_idx: int = keys.index(DataKey.INPUT)
          in_tensor: Tensor = input[in_tensor_idx]
          in_tensor = self.transform_tensor(in_tensor)
          self._params = self.forward_parameters(in_tensor.shape)
          self._params.update(
              {"dtype": tensor(DType.get(in_tensor.dtype).value)}
          )
      else:
          self._params = params
  
      outputs: List[Tensor] = []
      for dcate, _input in zip(keys, input):
          output: Tensor
          if dcate == DataKey.INPUT:
              output = self.transform_input(
                  _input, self._params, self.flags
              )
          elif dcate == DataKey.MASK:
              output = self.transform_mask(
                  _input, self._params, self.flags
              )
          elif dcate == DataKey.BBOX:
              box = Boxes.from_tensor(
                  _input, mode="vertices", validate_boxes=False
              )
              box = self.transform_boxes(box, self._params, self.flags)
              output = KORNIA_UNWRAP(box.to_tensor("vertices"), Tensor)
          elif dcate == DataKey.BBOX_XYXY:
              box = Boxes.from_tensor(
                  _input, mode="xyxy", validate_boxes=False
              )
              box = self.transform_boxes(box, self._params, self.flags)
              output = KORNIA_UNWRAP(box.to_tensor("xyxy"), Tensor)
          elif dcate == DataKey.BBOX_XYWH:
              box = Boxes.from_tensor(
                  _input, mode="xywh", validate_boxes=False
              )
              box = self.transform_boxes(box, self._params, self.flags)
              output = KORNIA_UNWRAP(box.to_tensor("xywh"), Tensor)
          elif dcate == DataKey.KEYPOINTS:
              output = self.transform_keypoint(
                  _input, self._params, self.flags
              )
          elif dcate == DataKey.CLASS:
              output = self.transform_class(
                  _input, self._params, self.flags
              )
          else:
              raise NotImplementedError
          outputs.append(output)
      if len(outputs) == 1:
          return outputs[0]
      return outputs
  
imports: from typing import Any, Dict, List, Optional, Union
  import torch
  from kornia.augmentation.base import _BasicAugmentationBase
  from kornia.augmentation.utils import _transform_input, _transform_output_shape, _validate_input_dtype
  from kornia.constants import DataKey, DType
  from kornia.core import Tensor, tensor
  from kornia.core.check import KORNIA_UNWRAP
  from kornia.geometry.boxes import Boxes
label_desc: Use image node_id 18 for calling the MixAugmentationBaseV2 obj's underlying member method code with example usage: obj.forward() and returns: outputs, outputs