



'''simple docstring'''


from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
						import tensorflow as tf


lowercase_      :				List[Any]   					=    logging.get_logger(__name__)




@dataclass
class      __UpperCamelCase       (snake_case_			):
	__A			  =					[
	    """no_inference""",
	    """no_cuda""",
	    """no_tpu""",
	    """no_speed""",
	    """no_memory""",
	    """no_env_print""",
	    """no_multi_process""",
	]







	def __init__(    self ,				**_lowerCAmelCase						)    ->    str:
							'''simple docstring'''






							for deprecated_arg in self.deprecated_args:
													if deprecated_arg in kwargs:
																			lowercase        =							deprecated_arg[3:]
																			lowercase        =							not kwargs.pop(_lowerCAmelCase						)
																			logger.warning(
																			    F"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
																			    F""" {positive_arg}={kwargs[positive_arg]}"""						)
							lowercase        =							kwargs.pop("""tpu_name""" ,				self.tpu_name						)
							lowercase        =							kwargs.pop("""device_idx""" ,				self.device_idx						)
							lowercase        =							kwargs.pop("""eager_mode""" ,				self.eager_mode						)
							lowercase        =							kwargs.pop("""use_xla""" ,				self.use_xla						)
							super().__init__(**_lowerCAmelCase						)

	__A			  =					field(
	    default=snake_case_			,   metadata={'''help''': '''Name of TPU'''}			,   )
	__A			  =					field(
	    default=0			,   metadata={'''help''': '''CPU / GPU device index. Defaults to 0.'''}			,   )
	__A			  =					field(default=snake_case_			,   metadata={'''help''': '''Benchmark models in eager model.'''}			)
	__A			  =					field(
	    default=snake_case_			,   metadata={
	        '''help''': '''Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`.'''
	    }			,   )







	@cached_property
	def   _a   (    self						)    ->    Tuple:
							'''simple docstring'''






							requires_backends(self ,				["""tf"""]						)
							lowercase        =							None
							if self.tpu:
													try:
																			if self.tpu_name:
																									lowercase        =							tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name						)
																			else:
																									lowercase        =							tf.distribute.cluster_resolver.TPUClusterResolver()
													except ValueError:
																			lowercase        =							None
							return tpu







	@cached_property
	def   _a   (    self						)    ->    Optional[Any]:
							'''simple docstring'''






							requires_backends(self ,				["""tf"""]						)
							if self.is_tpu:
													tf.config.experimental_connect_to_cluster(self._setup_tpu						)
													tf.tpu.experimental.initialize_tpu_system(self._setup_tpu						)

													lowercase        =							tf.distribute.TPUStrategy(self._setup_tpu						)
							else:
													# currently no multi gpu is allowed
													if self.is_gpu:
																			# TODO: Currently only single GPU is supported
																			tf.config.set_visible_devices(self.gpu_list[self.device_idx] ,				"""GPU"""						)
																			lowercase        =							tf.distribute.OneDeviceStrategy(device=F"""/gpu:{self.device_idx}"""						)
													else:
																			tf.config.set_visible_devices([] ,				"""GPU"""						)  # disable GPU
																			lowercase        =							tf.distribute.OneDeviceStrategy(device=F"""/cpu:{self.device_idx}"""						)

							return strategy







	@property
	def   _a   (    self						)    ->    int:
							'''simple docstring'''






							requires_backends(self ,				["""tf"""]						)
							return self._setup_tpu is not None







	@property
	def   _a   (    self						)    ->    Optional[int]:
							'''simple docstring'''






							requires_backends(self ,				["""tf"""]						)
							return self._setup_strategy







	@property
	def   _a   (    self						)    ->    List[str]:
							'''simple docstring'''






							requires_backends(self ,				["""tf"""]						)
							return tf.config.list_physical_devices("""GPU"""						)







	@property
	def   _a   (    self						)    ->    Any:
							'''simple docstring'''






							requires_backends(self ,				["""tf"""]						)
							if self.cuda:
													return len(self.gpu_list						)
							return 0







	@property
	def   _a   (    self						)    ->    Optional[int]:
							'''simple docstring'''






							return self.n_gpu > 0










'''simple docstring'''


from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
						from PIL import Image

						from ..image_utils import load_image

if is_tf_available():
						from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING

if is_torch_available():
						import torch

						from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING

lowercase_      :				Union[str, Any]   					=    logging.get_logger(__name__)




@add_end_docstrings(_UpperCAmelCase			)
class      __UpperCamelCase       (_UpperCAmelCase			):







	def __init__(    self ,				*_lowerCAmelCase ,				**_lowerCAmelCase						)    ->    Dict:
							'''simple docstring'''






							super().__init__(*_lowerCAmelCase ,				**_lowerCAmelCase						)
							requires_backends(self ,				"""vision"""						)
							self.check_model_type(
							    TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == """tf""" else MODEL_FOR_VISION_2_SEQ_MAPPING						)







	def   _a   (    self ,				_lowerCAmelCase=None ,				_lowerCAmelCase=None ,				_lowerCAmelCase=None						)    ->    str:
							'''simple docstring'''






							lowercase        =							{}
							lowercase        =							{}

							if prompt is not None:
													lowercase        =							prompt

							if generate_kwargs is not None:
													lowercase        =							generate_kwargs
							if max_new_tokens is not None:
													if "generate_kwargs" not in forward_kwargs:
																			lowercase        =							{}
													if "max_new_tokens" in forward_kwargs["generate_kwargs"]:
																			raise ValueError(
																			    """'max_new_tokens' is defined twice, once in 'generate_kwargs' and once as a direct parameter,"""
																			    """ please use only one"""						)
													lowercase        =							max_new_tokens
							return preprocess_params, forward_kwargs, {}







	def __call__(    self ,				_lowerCAmelCase ,				**_lowerCAmelCase						)    ->    Any:
							'''simple docstring'''






							return super().__call__(_lowerCAmelCase ,				**_lowerCAmelCase						)







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase=None						)    ->    List[str]:
							'''simple docstring'''






							lowercase        =							load_image(_lowerCAmelCase						)

							if prompt is not None:
													if not isinstance(_lowerCAmelCase ,				_lowerCAmelCase						):
																			raise ValueError(
																			    F"""Received an invalid text input, got - {type(_lowerCAmelCase						)} - but expected a single string. """
																			    """Note also that one single text can be provided for conditional image to text generation."""						)

													lowercase        =							self.model.config.model_type

													if model_type == "git":
																			lowercase        =							self.image_processor(images=_lowerCAmelCase ,				return_tensors=self.framework						)
																			lowercase        =							self.tokenizer(text=_lowerCAmelCase ,				add_special_tokens=_lowerCAmelCase						).input_ids
																			lowercase        =							[self.tokenizer.cls_token_id] + input_ids
																			lowercase        =							torch.tensor(_lowerCAmelCase						).unsqueeze(0						)
																			model_inputs.update({"""input_ids""": input_ids}						)

													elif model_type == "pix2struct":
																			lowercase        =							self.image_processor(images=_lowerCAmelCase ,				header_text=_lowerCAmelCase ,				return_tensors=self.framework						)

													elif model_type != "vision-encoder-decoder":
																			# vision-encoder-decoder does not support conditional generation
																			lowercase        =							self.image_processor(images=_lowerCAmelCase ,				return_tensors=self.framework						)
																			lowercase        =							self.tokenizer(_lowerCAmelCase ,				return_tensors=self.framework						)
																			model_inputs.update(_lowerCAmelCase						)

													else:
																			raise ValueError(F"""Model type {model_type} does not support conditional text generation"""						)

							else:
													lowercase        =							self.image_processor(images=_lowerCAmelCase ,				return_tensors=self.framework						)

							if self.model.config.model_type == "git" and prompt is None:
													lowercase        =							None

							return model_inputs







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase=None						)    ->    Union[str, Any]:
							'''simple docstring'''






							if (
							    "input_ids" in model_inputs
							    and isinstance(model_inputs["""input_ids"""] ,				_lowerCAmelCase						)
							    and all(x is None for x in model_inputs["""input_ids"""]						)
							):
													lowercase        =							None

							if generate_kwargs is None:
													lowercase        =							{}
							# FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py`
							#  parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas
							#  the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name`
							#  in the `_prepare_model_inputs` method.
							lowercase        =							model_inputs.pop(self.model.main_input_name						)
							lowercase        =							self.model.generate(_lowerCAmelCase ,				**_lowerCAmelCase ,				**_lowerCAmelCase						)
							return model_outputs







	def   _a   (    self ,				_lowerCAmelCase						)    ->    List[str]:
							'''simple docstring'''






							lowercase        =							[]
							for output_ids in model_outputs:
													lowercase        =							{
													    """generated_text""": self.tokenizer.decode(
													        _lowerCAmelCase ,				skip_special_tokens=_lowerCAmelCase ,				)
													}
													records.append(_lowerCAmelCase						)
							return records


