class_docstr: Compute dice between final vs original tags
code: def __call__(self, request, datastore: Datastore):
      loader = LoadImage(image_only=True)
  
      tag_y = request.get("y", DefaultLabelTag.FINAL)
      tag_y_pred = request.get("y_pred", DefaultLabelTag.ORIGINAL)
  
      result = {}
      for image_id in datastore.list_images():
          y_i = (
              datastore.get_label_by_image_id(image_id, tag_y)
              if tag_y
              else None
          )
          y_pred_i = (
              datastore.get_label_by_image_id(image_id, tag_y_pred)
              if tag_y_pred
              else None
          )
  
          if y_i and y_pred_i:
              y = loader(datastore.get_label_uri(y_i, tag_y))
              y_pred = loader(
                  datastore.get_label_uri(y_pred_i, tag_y_pred)
              )
  
              y = y.flatten()
              if isinstance(y, torch.Tensor):
                  y = y.numpy()
              y_pred = y_pred.flatten()
              if isinstance(y_pred, torch.Tensor):
                  y_pred = y_pred.numpy()
              union = np.sum(y) + np.sum(y_pred)
              dice = (
                  2.0 * np.sum(y * y_pred) / union if union != 0 else 1
              )
  
              logger.info(f"Dice Score for {image_id} is {dice}")
              datastore.update_image_info(image_id, {"dice": dice})
              result[image_id] = dice
      return result
  
file_path: MONAILabel/monailabel/tasks/scoring/dice.py
imports: import logging
  import numpy
  import torch
  from monai.transforms import LoadImage
  from monailabel.interfaces.datastore import Datastore, DefaultLabelTag
  from monailabel.interfaces.tasks.scoring import ScoringMethod
label_desc: Use image node_id 2 for calling the Dice obj's underlying member method code with example usage: obj.__call__(request, datastore) and returns: result