from typing import List, Optional, Union

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


UpperCamelCase__											=					logging.get_logger(__name__)

UpperCamelCase__											=					{
    'huggingface/informer-tourism-monthly': (
        'https://huggingface.co/huggingface/informer-tourism-monthly/resolve/main/config.json'
    ),
    # See all Informer models at https://huggingface.co/models?filter=informer
}





class      A							(				UpperCAmelCase_     ):
   __UpperCAmelCase : Optional[Any]      =			'informer'
   __UpperCAmelCase : List[Any]      =			{
       'hidden_size': 'd_model',
       'num_attention_heads': 'encoder_attention_heads',
       'num_hidden_layers': 'encoder_layers',
   }


   def __init__(self     :						Union[str, Any]       ,  __UpperCAmelCase     :						Optional[int] = None       ,  __UpperCAmelCase     :						Optional[int] = None       ,  __UpperCAmelCase     :						str = "student_t"       ,  __UpperCAmelCase     :						str = "nll"       ,  __UpperCAmelCase     :						int = 1       ,  __UpperCAmelCase     :						List[int] = None       ,  __UpperCAmelCase     :						Optional[Union[str, bool]] = "mean"       ,  __UpperCAmelCase     :						int = 0       ,  __UpperCAmelCase     :						int = 0       ,  __UpperCAmelCase     :						int = 0       ,  __UpperCAmelCase     :						int = 0       ,  __UpperCAmelCase     :						Optional[List[int]] = None       ,  __UpperCAmelCase     :						Optional[List[int]] = None       ,  __UpperCAmelCase     :						int = 6_4       ,  __UpperCAmelCase     :						int = 3_2       ,  __UpperCAmelCase     :						int = 3_2       ,  __UpperCAmelCase     :						int = 2       ,  __UpperCAmelCase     :						int = 2       ,  __UpperCAmelCase     :						int = 2       ,  __UpperCAmelCase     :						int = 2       ,  __UpperCAmelCase     :						bool = True       ,  __UpperCAmelCase     :						str = "gelu"       ,  __UpperCAmelCase     :						float = 0.05       ,  __UpperCAmelCase     :						float = 0.1       ,  __UpperCAmelCase     :						float = 0.1       ,  __UpperCAmelCase     :						float = 0.1       ,  __UpperCAmelCase     :						float = 0.1       ,  __UpperCAmelCase     :						int = 1_0_0       ,  __UpperCAmelCase     :						float = 0.02       ,  __UpperCAmelCase     :						Any=True       ,  __UpperCAmelCase     :						str = "prob"       ,  __UpperCAmelCase     :						int = 5       ,  __UpperCAmelCase     :						bool = True       ,  **__UpperCAmelCase     :						Optional[Any]       ,  )						->				Dict:
         """simple docstring"""



         UpperCAmelCase__								=  prediction_length
         UpperCAmelCase__								=  context_length or prediction_length
         UpperCAmelCase__								=  distribution_output
         UpperCAmelCase__								=  loss
         UpperCAmelCase__								=  input_size
         UpperCAmelCase__								=  num_time_features
         UpperCAmelCase__								=  lags_sequence if lags_sequence is not None else [1, 2, 3, 4, 5, 6, 7]
         UpperCAmelCase__								=  scaling
         UpperCAmelCase__								=  num_dynamic_real_features
         UpperCAmelCase__								=  num_static_real_features
         UpperCAmelCase__								=  num_static_categorical_features

         # set cardinality
         if cardinality and num_static_categorical_features > 0:
               if len(__UpperCAmelCase		) != num_static_categorical_features:
                     raise ValueError(
                         "The cardinality should be a list of the same length as `num_static_categorical_features`"		)
               UpperCAmelCase__								=  cardinality
         else:
               UpperCAmelCase__								=  [0]

         # set embedding_dimension
         if embedding_dimension and num_static_categorical_features > 0:
               if len(__UpperCAmelCase		) != num_static_categorical_features:
                     raise ValueError(
                         "The embedding dimension should be a list of the same length as `num_static_categorical_features`"		)
               UpperCAmelCase__								=  embedding_dimension
         else:
               UpperCAmelCase__								=  [min(5_0       ,  (cat + 1) // 2		) for cat in self.cardinality]

         UpperCAmelCase__								=  num_parallel_samples

         # Transformer architecture configuration
         UpperCAmelCase__								=  input_size * len(self.lags_sequence		) + self._number_of_features
         UpperCAmelCase__								=  d_model
         UpperCAmelCase__								=  encoder_attention_heads
         UpperCAmelCase__								=  decoder_attention_heads
         UpperCAmelCase__								=  encoder_ffn_dim
         UpperCAmelCase__								=  decoder_ffn_dim
         UpperCAmelCase__								=  encoder_layers
         UpperCAmelCase__								=  decoder_layers

         UpperCAmelCase__								=  dropout
         UpperCAmelCase__								=  attention_dropout
         UpperCAmelCase__								=  activation_dropout
         UpperCAmelCase__								=  encoder_layerdrop
         UpperCAmelCase__								=  decoder_layerdrop

         UpperCAmelCase__								=  activation_function
         UpperCAmelCase__								=  init_std

         UpperCAmelCase__								=  use_cache

         # Informer
         UpperCAmelCase__								=  attention_type
         UpperCAmelCase__								=  sampling_factor
         UpperCAmelCase__								=  distil

         super().__init__(is_encoder_decoder=__UpperCAmelCase       ,  **__UpperCAmelCase		)





   @property
   def 			lowercase_      (self     :						Union[str, Any]		)						->				int:
         """simple docstring"""



         return (
             sum(self.embedding_dimension		)
             + self.num_dynamic_real_features
             + self.num_time_features
             + self.num_static_real_features
             + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
         )










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

