


from collections import defaultdict
from typing import Optional

from ..image_utils import load_image
from ..utils import (
    add_end_docstrings,
    is_torch_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_torch_available():
   import torch

   from ..models.auto.modeling_auto import MODEL_FOR_MASK_GENERATION_MAPPING

_A			=						logging.get_logger(__name__)






@add_end_docstrings(A_		)
class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    def __init__(      self ,       **A_   )  ->	Optional[Any]:
         super().__init__(**A_   )
         requires_backends(self ,       'vision'   )
         requires_backends(self ,       'torch'   )

         if self.framework != "pt":
              raise ValueError(f'The {self.__class__} is only available in PyTorch.'   )

         self.check_model_type(A_   )






    def _a (      self ,       **A_   )  ->	Union[str, Any]:
         __UpperCamelCase   							={}
         __UpperCamelCase   							={}
         __UpperCamelCase   							={}
         # preprocess args
         if "points_per_batch" in kwargs:
              __UpperCamelCase   							=kwargs['points_per_batch']
         if "points_per_crop" in kwargs:
              __UpperCamelCase   							=kwargs['points_per_crop']
         if "crops_n_layers" in kwargs:
              __UpperCamelCase   							=kwargs['crops_n_layers']
         if "crop_overlap_ratio" in kwargs:
              __UpperCamelCase   							=kwargs['crop_overlap_ratio']
         if "crop_n_points_downscale_factor" in kwargs:
              __UpperCamelCase   							=kwargs['crop_n_points_downscale_factor']
         # postprocess args
         if "pred_iou_thresh" in kwargs:
              __UpperCamelCase   							=kwargs['pred_iou_thresh']
         if "stability_score_offset" in kwargs:
              __UpperCamelCase   							=kwargs['stability_score_offset']
         if "mask_threshold" in kwargs:
              __UpperCamelCase   							=kwargs['mask_threshold']
         if "stability_score_thresh" in kwargs:
              __UpperCamelCase   							=kwargs['stability_score_thresh']
         if "crops_nms_thresh" in kwargs:
              __UpperCamelCase   							=kwargs['crops_nms_thresh']
         if "output_rle_mask" in kwargs:
              __UpperCamelCase   							=kwargs['output_rle_mask']
         if "output_bboxes_mask" in kwargs:
              __UpperCamelCase   							=kwargs['output_bboxes_mask']
         return preprocess_kwargs, forward_params, postprocess_kwargs






    def __call__(      self ,       A_ ,       *A_ ,       A_=None ,       A_=None ,       **A_   )  ->	Optional[int]:
         return super().__call__(A_ ,       *A_ ,       num_workers=A_ ,       batch_size=A_ ,       **A_   )






    def _a (      self ,       A_ ,       A_=64 ,       A_ = 0 ,       A_ = 512 / 1500 ,       A_ = 32 ,       A_ = 1 ,       )  ->	List[str]:
         __UpperCamelCase   							=load_image(A_   )
         __UpperCamelCase   							=self.image_processor.size['longest_edge']
         __UpperCamelCase							,				__UpperCamelCase							,				__UpperCamelCase							,				__UpperCamelCase   							=self.image_processor.generate_crop_boxes(
             A_ ,       A_ ,       A_ ,       A_ ,       A_ ,       A_   )
         __UpperCamelCase   							=self.image_processor(images=A_ ,       return_tensors='pt'   )

         with self.device_placement():
              if self.framework == "pt":
                   __UpperCamelCase   							=self.get_inference_context()
                   with inference_context():
                        __UpperCamelCase   							=self._ensure_tensor_on_device(A_ ,       device=self.device   )
                        __UpperCamelCase   							=self.model.get_image_embeddings(model_inputs.pop('pixel_values'   )   )
                        __UpperCamelCase   							=image_embeddings

         __UpperCamelCase   							=grid_points.shape[1]
         __UpperCamelCase   							=points_per_batch if points_per_batch is not None else n_points

         if points_per_batch <= 0:
              raise ValueError(
                  'Cannot have points_per_batch<=0. Must be >=1 to returned batched outputs. '
                  'To return all points at once, set points_per_batch to None'   )

         for i in range(0 ,       A_ ,       A_   ):
              __UpperCamelCase   							=grid_points[:, i : i + points_per_batch, :, :]
              __UpperCamelCase   							=input_labels[:, i : i + points_per_batch]
              __UpperCamelCase   							=i == n_points - points_per_batch
              yield {
                  "input_points": batched_points,
                  "input_labels": labels,
                  "input_boxes": crop_boxes,
                  "is_last": is_last,
                  **model_inputs,
              }






    def _a (      self ,       A_ ,       A_=0.88 ,       A_=0.95 ,       A_=0 ,       A_=1 ,       )  ->	Any:
         __UpperCamelCase   							=model_inputs.pop('input_boxes'   )
         __UpperCamelCase   							=model_inputs.pop('is_last'   )
         __UpperCamelCase   							=model_inputs.pop('original_sizes'   ).tolist()
         __UpperCamelCase   							=model_inputs.pop('reshaped_input_sizes'   ).tolist()

         __UpperCamelCase   							=self.model(**A_   )

         # post processing happens here in order to avoid CPU GPU copies of ALL the masks
         __UpperCamelCase   							=model_outputs['pred_masks']
         __UpperCamelCase   							=self.image_processor.post_process_masks(
             A_ ,       A_ ,       A_ ,       A_ ,       binarize=A_   )
         __UpperCamelCase   							=model_outputs['iou_scores']
         __UpperCamelCase							,				__UpperCamelCase							,				__UpperCamelCase   							=self.image_processor.filter_masks(
             masks[0] ,       iou_scores[0] ,       original_sizes[0] ,       input_boxes[0] ,       A_ ,       A_ ,       A_ ,       A_ ,       )
         return {
             "masks": masks,
             "is_last": is_last,
             "boxes": boxes,
             "iou_scores": iou_scores,
         }






    def _a (      self ,       A_ ,       A_=False ,       A_=False ,       A_=0.7 ,       )  ->	List[str]:
         __UpperCamelCase   							=[]
         __UpperCamelCase   							=[]
         __UpperCamelCase   							=[]
         for model_output in model_outputs:
              all_scores.append(model_output.pop('iou_scores'   )   )
              all_masks.extend(model_output.pop('masks'   )   )
              all_boxes.append(model_output.pop('boxes'   )   )

         __UpperCamelCase   							=torch.cat(A_   )
         __UpperCamelCase   							=torch.cat(A_   )
         __UpperCamelCase							,				__UpperCamelCase							,				__UpperCamelCase							,				__UpperCamelCase   							=self.image_processor.post_process_for_mask_generation(
             A_ ,       A_ ,       A_ ,       A_   )

         __UpperCamelCase   							=defaultdict(A_   )
         for output in model_outputs:
              for k, v in output.items():
                   extra[k].append(A_   )

         __UpperCamelCase   							={}
         if output_rle_mask:
              __UpperCamelCase   							=rle_mask

         if output_bboxes_mask:
              __UpperCamelCase   							=bounding_boxes

         return {"masks": output_masks, "scores": iou_scores, **optional, **extra}









from ...configuration_utils import PretrainedConfig
from ...utils import logging


_A			=						logging.get_logger(__name__)

_A			=						{
    'google/realm-cc-news-pretrained-embedder': (
        'https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/config.json'
    ),
    'google/realm-cc-news-pretrained-encoder': (
        'https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/config.json'
    ),
    'google/realm-cc-news-pretrained-scorer': (
        'https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/config.json'
    ),
    'google/realm-cc-news-pretrained-openqa': (
        'https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/config.json'
    ),
    'google/realm-orqa-nq-openqa': 'https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/config.json',
    'google/realm-orqa-nq-reader': 'https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/config.json',
    'google/realm-orqa-wq-openqa': 'https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/config.json',
    'google/realm-orqa-wq-reader': 'https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/config.json',
    # See all REALM models at https://huggingface.co/models?filter=realm
}






class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    UpperCAmelCase__						:		str              =  "realm"






    def __init__(      self ,       A_=30522 ,       A_=768 ,       A_=128 ,       A_=12 ,       A_=12 ,       A_=8 ,       A_=3072 ,       A_="gelu_new" ,       A_=0.1 ,       A_=0.1 ,       A_=512 ,       A_=2 ,       A_=0.02 ,       A_=1E-12 ,       A_=256 ,       A_=10 ,       A_=1E-3 ,       A_=5 ,       A_=320 ,       A_=13353718 ,       A_=5000 ,       A_=1 ,       A_=0 ,       A_=2 ,       **A_ ,       )  ->	Dict:
         super().__init__(pad_token_id=A_ ,       bos_token_id=A_ ,       eos_token_id=A_ ,       **A_   )

         # Common config
         __UpperCamelCase   							=vocab_size
         __UpperCamelCase   							=max_position_embeddings
         __UpperCamelCase   							=hidden_size
         __UpperCamelCase   							=retriever_proj_size
         __UpperCamelCase   							=num_hidden_layers
         __UpperCamelCase   							=num_attention_heads
         __UpperCamelCase   							=num_candidates
         __UpperCamelCase   							=intermediate_size
         __UpperCamelCase   							=hidden_act
         __UpperCamelCase   							=hidden_dropout_prob
         __UpperCamelCase   							=attention_probs_dropout_prob
         __UpperCamelCase   							=initializer_range
         __UpperCamelCase   							=type_vocab_size
         __UpperCamelCase   							=layer_norm_eps

         # Reader config
         __UpperCamelCase   							=span_hidden_size
         __UpperCamelCase   							=max_span_width
         __UpperCamelCase   							=reader_layer_norm_eps
         __UpperCamelCase   							=reader_beam_size
         __UpperCamelCase   							=reader_seq_len

         # Retrieval config
         __UpperCamelCase   							=num_block_records
         __UpperCamelCase   							=searcher_beam_size





