code: def get_label_quality_scores(
      labels: List[Dict[str, Any]],
      predictions: List[np.ndarray],
      *,
      aggregation_weights: Optional[Dict[str, float]] = None,
      overlapping_label_check: Optional[bool] = True,
      verbose: bool = True,
  ) -> np.ndarray:
      """Computes a label quality score for each image of the ``N`` images in the dataset.
  
      For object detection datasets, the label quality score for an image estimates how likely it has been correctly labeled.
      Lower scores indicate images whose annotation is more likely imperfect.
      Annotators may have mislabeled an image because they:
  
      - overlooked an object (missing annotated bounding box),
      - chose the wrong class label for an annotated box in the correct location,
      - imperfectly annotated the location/edges of a bounding box.
  
      Any of these annotation errors should lead to an image with a lower label quality score. This quality score is between 0 and 1.
  
      - 1 - clean label (given label is likely correct).
      - 0 - dirty label (given label is likely incorrect).
  
      Parameters
      ----------
      labels:
          A list of ``N`` dictionaries such that ``labels[i]`` contains the given labels for the `i`-th image.
          Refer to documentation for this argument in :py:func:`find_label_issues <cleanlab.object_detection.filter.find_label_issues>` for further details.
  
      predictions:
          A list of ``N`` ``np.ndarray`` such that ``predictions[i]`` corresponds to the model predictions for the `i`-th image.
          Refer to documentation for this argument in :py:func:`find_label_issues <cleanlab.object_detection.filter.find_label_issues>` for further details.
  
      verbose : bool, default = True
        Set to ``False`` to suppress all print statements.
  
      aggregation_weights:
         Optional dictionary to specify weights for aggregating quality scores for subtype of label issue into an overall label quality score for the image.
         Its keys are: "overlooked", "swap", "badloc", and values should be nonnegative weights that sum to 1.
         Increase one of these weights to prioritize images with bounding boxes that were either:
         missing in the annotations (overlooked object), annotated with the wrong class label (class for the object should be swapped to another class), or annotated in a suboptimal location (badly located).
  
         swapped examples, bad location examples, and overlooked examples.
         It is important to ensure that the weights are non-negative values and that their sum equals 1.0.
  
      overlapping_label_check : bool, default = True
          If True, boxes annotated with more than one class label have their swap score penalized. Set this to False if you are not concerned when two very similar boxes exist with different class labels in the given annotations.
  
      Returns
      ---------
      label_quality_scores:
          Array of shape ``(N, )`` of scores between 0 and 1, one per image in the object detection dataset.
          Lower scores indicate images that are more likely mislabeled.
      """
      method = "objectlab"
      probability_threshold = 0.0
  
      assert_valid_inputs(
          labels=labels,
          predictions=predictions,
          method=method,
          threshold=probability_threshold,
      )
      aggregation_weights = _get_aggregation_weights(
          aggregation_weights
      )
  
      return _compute_label_quality_scores(
          labels=labels,
          predictions=predictions,
          method=method,
          threshold=probability_threshold,
          aggregation_weights=aggregation_weights,
          overlapping_label_check=overlapping_label_check,
          verbose=verbose,
      )
  
imports: import warnings
  from cleanlab.internal.constants import ALPHA, CUSTOM_SCORE_WEIGHT_BADLOC, CUSTOM_SCORE_WEIGHT_OVERLOOKED, CUSTOM_SCORE_WEIGHT_SWAP, EUC_FACTOR, HIGH_PROBABILITY_THRESHOLD, LOW_PROBABILITY_THRESHOLD, MAX_ALLOWED_BOX_PRUNE, TINY_VALUE, TEMPERATURE, LABEL_OVERLAP_THRESHOLD
  import copy
  from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, TypeVar
  import numpy
  from cleanlab.internal.object_detection_utils import softmin1d, assert_valid_aggregation_weights, assert_valid_inputs
label_desc: Use image node_id 1 for calling a global function with example usage: get_label_quality_scores(labels, predictions) and returns: _compute_label_quality_scores