


from typing import List

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


SCREAMING_SNAKE_CASE       :      List[str]												= logging.get_logger(__name__)

SCREAMING_SNAKE_CASE       :      int												= {
    "snap-research/efficientformer-l1-300": (
        "https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json"
    ),
}






class _lowerCamelCase(						_a   ):
       lowercase_ :	List[Any]     =			"""efficientformer"""
       def __init__(					self,      lowerCamelCase = [3, 2, 6, 4],      lowerCamelCase = [48, 96, 2_24, 4_48],      lowerCamelCase = [True, True, True, True],      lowerCamelCase = 4_48,      lowerCamelCase = 32,      lowerCamelCase = 4,      lowerCamelCase = 7,      lowerCamelCase = 5,      lowerCamelCase = 8,      lowerCamelCase = 4,      lowerCamelCase = 0.0,      lowerCamelCase = 16,      lowerCamelCase = 3,      lowerCamelCase = 3,      lowerCamelCase = 3,      lowerCamelCase = 2,      lowerCamelCase = 1,      lowerCamelCase = 0.0,      lowerCamelCase = 1,      lowerCamelCase = True,      lowerCamelCase = True,      lowerCamelCase = 1E-5,      lowerCamelCase = "gelu",      lowerCamelCase = 0.0_2,      lowerCamelCase = 1E-12,      lowerCamelCase = 2_24,      lowerCamelCase = 1E-05,      **lowerCamelCase,      )       ->   None:




           """simple docstring"""

           super().__init__(**lowerCamelCase)

           _lowercase       :							Dict      		=		hidden_act
           _lowercase       :							Union[str, Any]      		=		hidden_dropout_prob
           _lowercase       :							int      		=		hidden_sizes
           _lowercase       :							Union[str, Any]      		=		num_hidden_layers
           _lowercase       :							List[Any]      		=		num_attention_heads
           _lowercase       :							Dict      		=		initializer_range
           _lowercase       :							int      		=		layer_norm_eps
           _lowercase       :							Optional[Any]      		=		patch_size
           _lowercase       :							List[str]      		=		num_channels
           _lowercase       :							Tuple      		=		depths
           _lowercase       :							Tuple      		=		mlp_expansion_ratio
           _lowercase       :							str      		=		downsamples
           _lowercase       :							Tuple      		=		dim
           _lowercase       :							Tuple      		=		key_dim
           _lowercase       :							Union[str, Any]      		=		attention_ratio
           _lowercase       :							int      		=		resolution
           _lowercase       :							Optional[Any]      		=		pool_size
           _lowercase       :							Optional[int]      		=		downsample_patch_size
           _lowercase       :							Dict      		=		downsample_stride
           _lowercase       :							Optional[Any]      		=		downsample_pad
           _lowercase       :							Optional[int]      		=		drop_path_rate
           _lowercase       :							List[str]      		=		num_metaad_blocks
           _lowercase       :							List[Any]      		=		distillation
           _lowercase       :							List[str]      		=		use_layer_scale
           _lowercase       :							Dict      		=		layer_scale_init_value
           _lowercase       :							Union[str, Any]      		=		image_size
           _lowercase       :							Dict      		=		batch_norm_eps









from typing import Any, Dict, List, Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_vision_available():
     from PIL import Image

     from ..image_utils import load_image

if is_torch_available():
     import torch

     from transformers.modeling_outputs import BaseModelOutput

     from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

__A									=				logging.get_logger(__name__)



@add_end_docstrings(__SCREAMING_SNAKE_CASE    )
class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ):







 '''simple docstring'''

 def __init__(self				:   Tuple       , **UpperCAmelCase_				:   Tuple)       ->Any:



   '''simple docstring'''



   super().__init__(**UpperCAmelCase_)

   if self.framework == "tf":
     raise ValueError(F"""The {self.__class__} is only available in PyTorch.""")

   requires_backends(self       , "vision")
   self.check_model_type(UpperCAmelCase_)

 def __call__(self				:   Optional[int]       , UpperCAmelCase_				:   Union[str, "Image.Image", List[Dict[str, Any]]]       , UpperCAmelCase_				:   Union[str, List[str]] = None       , **UpperCAmelCase_				:   List[str]       , )       ->Union[str, Any]:



   '''simple docstring'''



   if "text_queries" in kwargs:
     lowerCamelCase__:      Any			  =kwargs.pop("text_queries")

   if isinstance(UpperCAmelCase_       , (str, Image.Image)):
     lowerCamelCase__:      List[Any]			  ={"image": image, "candidate_labels": candidate_labels}
   else:
     lowerCamelCase__:      Any			  =image
   lowerCamelCase__:      Dict			  =super().__call__(UpperCAmelCase_       , **UpperCAmelCase_)
   return results

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int]       , **UpperCAmelCase_				:   Union[str, Any])       ->Dict:



   '''simple docstring'''



   lowerCamelCase__:      List[str]			  ={}
   if "threshold" in kwargs:
     lowerCamelCase__:      List[Any]			  =kwargs["threshold"]
   if "top_k" in kwargs:
     lowerCamelCase__:      Any			  =kwargs["top_k"]
   return {}, {}, postprocess_params

 def 							SCREAMING_SNAKE_CASE_					(self				:   str       , UpperCAmelCase_				:   List[Any])       ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:      List[Any]			  =load_image(inputs["image"])
   lowerCamelCase__:      Dict			  =inputs["candidate_labels"]
   if isinstance(UpperCAmelCase_       , UpperCAmelCase_):
     lowerCamelCase__:      Any			  =candidate_labels.split(",")

   lowerCamelCase__:      Optional[int]			  =torch.tensor([[image.height, image.width]]       , dtype=torch.intaa)
   for i, candidate_label in enumerate(UpperCAmelCase_):
     lowerCamelCase__:      Dict			  =self.tokenizer(UpperCAmelCase_       , return_tensors=self.framework)
     lowerCamelCase__:      Union[str, Any]			  =self.image_processor(UpperCAmelCase_       , return_tensors=self.framework)
     yield {
         "is_last": i == len(UpperCAmelCase_) - 1,
         "target_size": target_size,
         "candidate_label": candidate_label,
         **text_inputs,
         **image_features,
     }

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[Any]       , UpperCAmelCase_				:   Tuple)       ->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__:      Dict			  =model_inputs.pop("target_size")
   lowerCamelCase__:      Dict			  =model_inputs.pop("candidate_label")
   lowerCamelCase__:      Dict			  =model_inputs.pop("is_last")

   lowerCamelCase__:      Union[str, Any]			  =self.model(**UpperCAmelCase_)

   lowerCamelCase__:      Dict			  ={"target_size": target_size, "candidate_label": candidate_label, "is_last": is_last, **outputs}
   return model_outputs

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int]       , UpperCAmelCase_				:   int       , UpperCAmelCase_				:   Any=0.1       , UpperCAmelCase_				:   str=None)       ->Tuple:



   '''simple docstring'''



   lowerCamelCase__:      Union[str, Any]			  =[]
   for model_output in model_outputs:
     lowerCamelCase__:      Optional[Any]			  =model_output["candidate_label"]
     lowerCamelCase__:      Tuple			  =BaseModelOutput(UpperCAmelCase_)
     lowerCamelCase__:      Dict			  =self.image_processor.post_process_object_detection(
         outputs=UpperCAmelCase_       , threshold=UpperCAmelCase_       , target_sizes=model_output["target_size"])[0]

     for index in outputs["scores"].nonzero():
       lowerCamelCase__:      Dict			  =outputs["scores"][index].item()
       lowerCamelCase__:      Dict			  =self._get_bounding_box(outputs["boxes"][index][0])

       lowerCamelCase__:      Optional[Any]			  ={"score": score, "label": label, "box": box}
       results.append(UpperCAmelCase_)

   lowerCamelCase__:      List[str]			  =sorted(UpperCAmelCase_       , key=lambda UpperCAmelCase_: x["score"]       , reverse=UpperCAmelCase_)
   if top_k:
     lowerCamelCase__:      Dict			  =results[:top_k]

   return results







 def 							SCREAMING_SNAKE_CASE_					(self				:   str       , UpperCAmelCase_				:   "torch.Tensor")       ->Dict[str, int]:



   '''simple docstring'''



   if self.framework != "pt":
     raise ValueError("The ZeroShotObjectDetectionPipeline is only available in PyTorch.")
   lowerCamelCase__  ,					lowerCamelCase__  ,					lowerCamelCase__  ,					lowerCamelCase__:      Optional[Any]			  =box.int().tolist()
   lowerCamelCase__:      Optional[int]			  ={
       "xmin": xmin,
       "ymin": ymin,
       "xmax": xmax,
       "ymax": ymax,
   }
   return bbox

