class_docstr: Defines an evaluator for the LVIS dataset.
  
  This evaluator is usually used through a metric returned by
  :func:`make_lvis_metrics`.
  
  This mostly acts a wrapper around :class:`LVISEval` from the `lvis` library.
code: def prepare_for_lvis_detection(
      self, predictions: TCommonDetectionOutput
  ):
      lvis_results: List[Dict[str, Any]] = []
      for original_id, prediction in predictions.items():
          if len(prediction) == 0:
              continue
  
          scores = prediction["scores"].tolist()
          labels = prediction["labels"].tolist()
  
          has_mask = "mask" in prediction
          has_bbox = "boxes" in prediction
          has_keypoint = "keypoints" in prediction
  
          if has_bbox:
              boxes = prediction["boxes"]
              boxes = convert_to_xywh(boxes).tolist()
  
          if has_mask:
              masks = prediction["masks"]
              masks = masks > 0.5
              rles = [
                  mask_util.encode(
                      np.array(
                          mask[0, :, :, np.newaxis],
                          dtype=np.uint8,
                          order="F",
                      )
                  )[0]
                  for mask in masks
              ]
              for rle in rles:
                  rle["counts"] = rle["counts"].decode("utf-8")
  
          if has_keypoint:
              keypoints = prediction["keypoints"]
              keypoints = keypoints.flatten(start_dim=1).tolist()
  
          for pred_idx in range(len(labels)):
              lvis_pred = {
                  "image_id": original_id,
                  "category_id": labels[pred_idx],
                  "score": scores[pred_idx],
              }
  
              if has_bbox:
                  lvis_pred["bbox"] = boxes[pred_idx]
  
              if has_mask:
                  lvis_pred["segmentation"] = rles[pred_idx]
  
              if has_keypoint:
                  lvis_pred["keypoints"] = keypoints[pred_idx]
  
              lvis_results.append(lvis_pred)
  
      return lvis_results
  
imports: import copy
  import itertools
  import logging
  from typing import Any, Dict, List, Optional, Tuple, Union
  import numpy
  import pycocotools.mask
  import torch
  import torch.distributed
  from lvis import LVISEval, LVISResults, LVIS
  from avalanche.evaluation.metrics.detection import DetectionEvaluator, TCommonDetectionOutput
label_desc: Use image node_id 6 for calling the LvisEvaluator obj's underlying member method code with example usage: obj.prepare_for_lvis_detection(predictions) and returns: lvis_results