def METHOD_NAME(
        self,
        batched_input: List[Dict[str, Any]],
        multimask_output: bool, ) -> List[Dict[str, paddle.Tensor]]:
    """
    Predicts masks end-to-end from provided images and prompts.
    If prompts are not known in advance, using SamPredictor is
    recommended over calling the model directly.
    Arguments:
      batched_input (list(dict)): A list over input images, each a
        dictionary with the following keys. A prompt key can be
        excluded if it is not present.
          'image': The image as a paddle tensor in 3xHxW format,
            already transformed for input to the model.
          'original_size': (tuple(int, int)) The original size of
            the image before transformation, as (H, W).
          'point_coords': (paddle.Tensor) Batched point prompts for
            this image, with shape BxNx2. Already transformed to the
            input frame of the model.
          'point_labels': (paddle.Tensor) Batched labels for point prompts,
            with shape BxN.
          'boxes': (paddle.Tensor) Batched box inputs, with shape Bx4.
            Already transformed to the input frame of the model.
          'mask_inputs': (paddle.Tensor) Batched mask inputs to the model,
            in the form Bx1xHxW.
      multimask_output (bool): Whether the model should predict multiple
        disambiguating masks, or return a single mask.
    Returns:
      (list(dict)): A list over input images, where each element is
        as dictionary with the following keys.
          'masks': (paddle.Tensor) Batched binary mask predictions,
            with shape BxCxHxW, where B is the number of input promts,
            C is determiend by multimask_output, and (H, W) is the
            original size of the image.
          'iou_predictions': (paddle.Tensor) The model's predictions
            of mask quality, in shape BxC.
          'low_res_logits': (paddle.Tensor) Low resolution logits with
            shape BxCxHxW, where H=W=256. Can be passed as mask input
            to subsequent iterations of prediction.
    """
    input_images = paddle.stack(
        [self.preprocess(x["image"]) for x in batched_input], axis=0)
    image_embeddings = self.image_encoder(input_images)
    outputs = []
    for image_record, curr_embedding in zip(batched_input,
                                            image_embeddings):
        if "point_coords" in image_record:
            points = (image_record["point_coords"],
                      image_record["point_labels"])
        else:
            points = None
        sparse_embeddings, dense_embeddings = self.prompt_encoder(
            points=points,
            boxes=image_record.get("boxes", None),
            masks=image_record.get("mask_inputs", None), )
        low_res_masks, iou_predictions = self.mask_decoder(
            image_embeddings=curr_embedding.unsqueeze(0),
            image_pe=self.prompt_encoder.get_dense_pe(),
            sparse_prompt_embeddings=sparse_embeddings,
            dense_prompt_embeddings=dense_embeddings,
            multimask_output=multimask_output, )
        masks = self.postprocess_masks(
            low_res_masks,
            input_size=image_record["image"].shape[-2:],
            original_size=image_record["original_size"], )
        masks = masks > self.mask_threshold
        outputs.append({
            "masks": masks,
            "iou_predictions": iou_predictions,
            "low_res_logits": low_res_masks,
        })
    return outputs