





from typing import Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
      from PIL import Image

      from ..image_utils import load_image

if is_torch_available():
      from ..models.auto.modeling_auto import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING

SCREAMING_SNAKE_CASE_						   =       logging.get_logger(__name__)

@add_end_docstrings(lowerCAmelCase_   )
class 		UpperCamelCase__ (      lowerCAmelCase_   ):



     '''simple docstring'''

     def __init__(							self						:    Union[str, Any]						,*lowerCamelCase__						:    Tuple						,**lowerCamelCase__						:    Optional[Any]       )     ->		List[Any]:




           '''simple docstring'''


           super().__init__(*lowerCamelCase__						,**lowerCamelCase__       )
           self.check_model_type(lowerCamelCase__       )






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Optional[int]						,lowerCamelCase__						:    Union[str, Any]=None						,lowerCamelCase__						:    List[str]=None						,lowerCamelCase__						:    List[str]=None						,**lowerCamelCase__						:    Union[str, Any]       )     ->		Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE		=						{}, {}
           if padding is not None:
                 SCREAMING_SNAKE_CASE		=						padding
           if truncation is not None:
                 SCREAMING_SNAKE_CASE		=						truncation
           if top_k is not None:
                 SCREAMING_SNAKE_CASE		=						top_k
           return preprocess_params, {}, postprocess_params






     def __call__(							self						:    Dict						,lowerCamelCase__						:    Union["Image.Image", str]						,lowerCamelCase__						:    str = None						,**lowerCamelCase__						:    Any       )     ->		Tuple:




           '''simple docstring'''


           if isinstance(lowerCamelCase__						,(Image.Image, str)       ) and isinstance(lowerCamelCase__						,lowerCamelCase__       ):
                 SCREAMING_SNAKE_CASE		=						{"""image""": image, """question""": question}
           else:
                 SCREAMING_SNAKE_CASE		=						image
           SCREAMING_SNAKE_CASE		=						super().__call__(lowerCamelCase__						,**lowerCamelCase__       )
           return results






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Optional[Any]						,lowerCamelCase__						:    Union[str, Any]						,lowerCamelCase__						:    Any=False						,lowerCamelCase__						:    Optional[Any]=False       )     ->		List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						load_image(inputs["""image"""]       )
           SCREAMING_SNAKE_CASE		=						self.tokenizer(
               inputs["""question"""]						,return_tensors=self.framework						,padding=lowerCamelCase__						,truncation=lowerCamelCase__       )
           SCREAMING_SNAKE_CASE		=						self.image_processor(images=lowerCamelCase__						,return_tensors=self.framework       )
           model_inputs.update(lowerCamelCase__       )
           return model_inputs






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Tuple						,lowerCamelCase__						:    List[Any]       )     ->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.model(**lowerCamelCase__       )
           return model_outputs






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Optional[int]						,lowerCamelCase__						:    Tuple						,lowerCamelCase__						:    int=5       )     ->		Dict:




           '''simple docstring'''


           if top_k > self.model.config.num_labels:
                 SCREAMING_SNAKE_CASE		=						self.model.config.num_labels

           if self.framework == "pt":
                 SCREAMING_SNAKE_CASE		=						model_outputs.logits.sigmoid()[0]
                 SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE		=						probs.topk(lowerCamelCase__       )
           else:
                 raise ValueError(F"""Unsupported framework: {self.framework}"""       )

           SCREAMING_SNAKE_CASE		=						scores.tolist()
           SCREAMING_SNAKE_CASE		=						ids.tolist()
           return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase__						,lowerCamelCase__       )]









import dataclasses
import json
import warnings
from dataclasses import dataclass, field
from time import time
from typing import List

from ..utils import logging


SCREAMING_SNAKE_CASE_						   =       logging.get_logger(__name__)



def    __lowercase   (      _SCREAMING_SNAKE_CASE=None ,						_SCREAMING_SNAKE_CASE=None	) ->   List[str]:


      '''simple docstring'''


      return field(default_factory=lambda: default ,						metadata=_SCREAMING_SNAKE_CASE	)



@dataclass
class 		UpperCamelCase__ :



     '''simple docstring'''

     __snake_case    :	List[str]			=			list_field(
         default=[]							,      metadata={
             "help": (
                 "Model checkpoints to be provided to the AutoModel classes. Leave blank to benchmark the base version"
                 " of all available models"
             )
         }							,      )

     __snake_case    :	List[int]			=			list_field(
         default=[8]							,      metadata={"help": "List of batch sizes for which memory and time performance will be evaluated"}   )

     __snake_case    :	List[int]			=			list_field(
         default=[8, 32, 128, 512]							,      metadata={"help": "List of sequence lengths for which memory and time performance will be evaluated"}							,      )

     __snake_case    :	bool			=			field(
         default=lowerCAmelCase_							,      metadata={"help": "Whether to benchmark inference of model. Inference can be disabled via --no-inference."}							,      )
     __snake_case    :	bool			=			field(
         default=lowerCAmelCase_							,      metadata={"help": "Whether to run on available cuda devices. Cuda can be disabled via --no-cuda."}							,      )
     __snake_case    :	bool			=			field(
         default=lowerCAmelCase_							,      metadata={"help": "Whether to run on available tpu devices. TPU can be disabled via --no-tpu."}   )
     __snake_case    :	bool			=			field(default=lowerCAmelCase_							,      metadata={"help": "Use FP16 to accelerate inference."}   )
     __snake_case    :	bool			=			field(default=lowerCAmelCase_							,      metadata={"help": "Benchmark training of model"}   )
     __snake_case    :	bool			=			field(default=lowerCAmelCase_							,      metadata={"help": "Verbose memory tracing"}   )
     __snake_case    :	bool			=			field(
         default=lowerCAmelCase_							,      metadata={"help": "Whether to perform speed measurements. Speed measurements can be disabled via --no-speed."}							,      )
     __snake_case    :	bool			=			field(
         default=lowerCAmelCase_							,      metadata={
             "help": "Whether to perform memory measurements. Memory measurements can be disabled via --no-memory"
         }							,      )
     __snake_case    :	bool			=			field(default=lowerCAmelCase_							,      metadata={"help": "Trace memory line by line"}   )
     __snake_case    :	bool			=			field(default=lowerCAmelCase_							,      metadata={"help": "Save result to a CSV file"}   )
     __snake_case    :	bool			=			field(default=lowerCAmelCase_							,      metadata={"help": "Save all print statements in a log file"}   )
     __snake_case    :	bool			=			field(default=lowerCAmelCase_							,      metadata={"help": "Whether to print environment information"}   )
     __snake_case    :	bool			=			field(
         default=lowerCAmelCase_							,      metadata={
             "help": (
                 "Whether to use multiprocessing for memory and speed measurement. It is highly recommended to use"
                 " multiprocessing for accurate CPU and GPU memory measurements. This option should only be disabled"
                 " for debugging / testing and on TPU."
             )
         }							,      )
     __snake_case    :	str			=			field(
         default=F"inference_time_{round(time()   )}.csv"							,      metadata={"help": "CSV filename used if saving time results to csv."}							,      )
     __snake_case    :	str			=			field(
         default=F"inference_memory_{round(time()   )}.csv"							,      metadata={"help": "CSV filename used if saving memory results to csv."}							,      )
     __snake_case    :	str			=			field(
         default=F"train_time_{round(time()   )}.csv"							,      metadata={"help": "CSV filename used if saving time results to csv for training."}							,      )
     __snake_case    :	str			=			field(
         default=F"train_memory_{round(time()   )}.csv"							,      metadata={"help": "CSV filename used if saving memory results to csv for training."}							,      )
     __snake_case    :	str			=			field(
         default=F"env_info_{round(time()   )}.csv"							,      metadata={"help": "CSV filename used if saving environment information."}							,      )
     __snake_case    :	str			=			field(
         default=F"log_{round(time()   )}.csv"							,      metadata={"help": "Log filename used if print statements are saved in log."}							,      )
     __snake_case    :	int			=			field(default=3							,      metadata={"help": "Times an experiment will be run."}   )
     __snake_case    :	bool			=			field(
         default=lowerCAmelCase_							,      metadata={
             "help": (
                 "Instead of loading the model as defined in `config.architectures` if exists, just load the pretrain"
                 " model weights."
             )
         }							,      )






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Union[str, Any]       )     ->		Dict:




           '''simple docstring'''


           warnings.warn(
               F"""The class {self.__class__} is deprecated. Hugging Face Benchmarking utils"""
               """ are deprecated in general and it is advised to use external Benchmarking libraries """
               """ to benchmark Transformer models."""						,lowerCamelCase__						,)






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Optional[int]       )     ->		Any:




           '''simple docstring'''


           return json.dumps(dataclasses.asdict(self       )						,indent=2       )






     @property
     def 				SCREAMING_SNAKE_CASE__  (							self						:    Optional[Any]       )     ->		List[str]:




           '''simple docstring'''


           if len(self.models       ) <= 0:
                 raise ValueError(
                     """Please make sure you provide at least one model name / model identifier, *e.g.* `--models"""
                     """ bert-base-cased` or `args.models = ['bert-base-cased']."""       )
           return self.models






     @property
     def 				SCREAMING_SNAKE_CASE__  (							self						:    Optional[int]       )     ->		int:




           '''simple docstring'''


           if not self.multi_process:
                 return False
           elif self.is_tpu:
                 logger.info("""Multiprocessing is currently not possible on TPU."""       )
                 return False
           else:
                 return True


