



import inspect

import jax
import jax.lax as lax
import jax.numpy as jnp

from ..utils import add_start_docstrings
from ..utils.logging import get_logger


a_      :      Dict    =     get_logger(__name__)


a_      :      Dict    =     R'\n    Args:\n        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):\n            Indices of input sequence tokens in the vocabulary.\n\n            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n            [`PreTrainedTokenizer.__call__`] for details.\n\n            [What are input IDs?](../glossary#input-ids)\n        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):\n            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam\n            search or log softmax for each vocabulary token when using beam search\n        kwargs (`Dict[str, Any]`, *optional*):\n            Additional logits processor specific kwargs.\n\n    Return:\n        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.\n\n'
class    __UpperCamelCase			:

 """simple docstring"""



 @add_start_docstrings(SCREAMING_SNAKE_CASE      )
 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  raise NotImplementedError(
      f"{self.__class__} is an abstract class. Only classes inheriting this class can be called."      )





class    __UpperCamelCase			:

 """simple docstring"""



 @add_start_docstrings(SCREAMING_SNAKE_CASE      )
 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  raise NotImplementedError(
      f"{self.__class__} is an abstract class. Only classes inheriting this class can be called."      )





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 @add_start_docstrings(SCREAMING_SNAKE_CASE      )
 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				**SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  for processor in self:
   a__												= inspect.signature(processor.__call__      ).parameters
   if len(SCREAMING_SNAKE_CASE      ) > 3:
    if not all(arg in kwargs for arg in list(function_args.keys()      )[2:]      ):
     raise ValueError(
         f"Make sure that all the required parameters: {list(function_args.keys()      )} for "
         f"{processor.__class__} are passed to the logits processor."      )
    a__												= processor(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				**SCREAMING_SNAKE_CASE      )
   else:
    a__												= processor(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
  return scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE      ) ->			Optional[Any]:
  if not isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) or not (temperature > 0):
   raise ValueError(f"`temperature` has to be a strictly positive float, but is {temperature}"      )

  a__												= temperature



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  a__												= scores / self.temperature
  return scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE = -float('''Inf'''      )		,				SCREAMING_SNAKE_CASE = 1      ) ->			Union[str, Any]:
  if not isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) or (top_p < 0 or top_p > 1.0):
   raise ValueError(f"`top_p` has to be a float > 0 and < 1, but is {top_p}"      )
  if not isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) or (min_tokens_to_keep < 1):
   raise ValueError(f"`min_tokens_to_keep` has to be a positive integer, but is {min_tokens_to_keep}"      )

  a__												= top_p
  a__												= filter_value
  a__												= min_tokens_to_keep



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  a__							,			a__												= lax.top_k(SCREAMING_SNAKE_CASE		,				scores.shape[-1]      )

  a__												= jnp.full_like(SCREAMING_SNAKE_CASE		,				self.filter_value      )
  a__												= jax.nn.softmax(SCREAMING_SNAKE_CASE		,				axis=-1      ).cumsum(axis=-1      )
  a__												= cumulative_probs < self.top_p

  # include the token that is higher than top_p as well
  a__												= jnp.roll(SCREAMING_SNAKE_CASE		,				1      )
  score_mask |= score_mask.at[:, 0].set(SCREAMING_SNAKE_CASE      )

  # min tokens to keep
  a__												= score_mask.at[:, : self.min_tokens_to_keep].set(SCREAMING_SNAKE_CASE      )

  a__												= jnp.where(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
  a__												= jax.lax.sort_key_val(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )[-1]

  return next_scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE = -float('''Inf'''      )		,				SCREAMING_SNAKE_CASE = 1      ) ->			Optional[int]:
  if not isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) or top_k <= 0:
   raise ValueError(f"`top_k` has to be a strictly positive integer, but is {top_k}"      )

  a__												= max(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
  a__												= filter_value



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  a__							,			a__												= scores.shape
  a__												= jnp.full(batch_size * vocab_size		,				self.filter_value      )

  a__												= min(self.top_k		,				scores.shape[-1]      )  # Safety check
  a__							,			a__												= lax.top_k(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
  a__												= jnp.broadcast_to((jnp.arange(SCREAMING_SNAKE_CASE      ) * vocab_size)[:, None]		,				(batch_size, topk)      ).flatten()
  a__												= topk_scores.flatten()
  a__												= topk_indices.flatten() + shift

  a__												= next_scores_flat.at[topk_indices_flat].set(SCREAMING_SNAKE_CASE      )
  a__												= next_scores_flat.reshape(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
  return next_scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE      ) ->			Union[str, Any]:
  a__												= bos_token_id



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  a__												= jnp.full(scores.shape		,				-float('''inf'''      )      )

  a__												= 1 - jnp.bool_(cur_len - 1      )

  a__												= jnp.where(SCREAMING_SNAKE_CASE		,				new_scores.at[:, self.bos_token_id].set(0      )		,				SCREAMING_SNAKE_CASE      )

  return scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Union[str, Any]:
  a__												= max_length
  a__												= eos_token_id



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  a__												= jnp.full(scores.shape		,				-float('''inf'''      )      )

  a__												= 1 - jnp.bool_(cur_len - self.max_length + 1      )

  a__												= jnp.where(SCREAMING_SNAKE_CASE		,				new_scores.at[:, self.eos_token_id].set(0      )		,				SCREAMING_SNAKE_CASE      )

  return scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Union[str, Any]:
  if not isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) or min_length < 0:
   raise ValueError(f"`min_length` has to be a positive integer, but is {min_length}"      )

  if not isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) or eos_token_id < 0:
   raise ValueError(f"`eos_token_id` has to be a positive integer, but is {eos_token_id}"      )

  a__												= min_length
  a__												= eos_token_id



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  # create boolean flag to decide if min length penalty should be applied
  a__												= 1 - jnp.clip(cur_len - self.min_length		,				0		,				1      )

  a__												= jnp.where(SCREAMING_SNAKE_CASE		,				scores.at[:, self.eos_token_id].set(-float('''inf'''      )      )		,				SCREAMING_SNAKE_CASE      )

  return scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Union[str, Any]:
  a__												= list(SCREAMING_SNAKE_CASE      )
  a__												= begin_index



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Tuple:
  a__												= 1 - jnp.bool_(cur_len - self.begin_index      )

  a__												= jnp.where(SCREAMING_SNAKE_CASE		,				scores.at[:, self.begin_suppress_tokens].set(-float('''inf'''      )      )		,				SCREAMING_SNAKE_CASE      )

  return scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE      ) ->			Optional[Any]:
  a__												= list(SCREAMING_SNAKE_CASE      )



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  a__												= scores.at[..., self.suppress_tokens].set(-float('''inf'''      )      )

  return scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE      ) ->			Tuple:
  a__												= dict(SCREAMING_SNAKE_CASE      )
  # Converts the dictionary of format {index: token} containing the tokens to be forced to an array, where the
  # index of the array corresponds to the index of the token to be forced, for XLA compatibility.
  # Indexes without forced tokens will have a negative value.
  a__												= jnp.ones((max(force_token_map.keys()      ) + 1)		,				dtype=jnp.intaa      ) * -1
  for index, token in force_token_map.items():
   if token is not None:
    a__												= force_token_array.at[index].set(SCREAMING_SNAKE_CASE      )
  a__												= jnp.intaa(SCREAMING_SNAKE_CASE      )



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			jnp.ndarray:
  def _force_token(SCREAMING_SNAKE_CASE      ):
   a__												= scores.shape[0]
   a__												= self.force_token_array[generation_idx]

   a__												= jnp.ones_like(SCREAMING_SNAKE_CASE		,				dtype=scores.dtype      ) * -float('''inf'''      )
   a__												= jnp.zeros((batch_size, 1)		,				dtype=scores.dtype      )
   a__												= lax.dynamic_update_slice(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				(0, current_token)      )
   return new_scores

  a__												= lax.cond(
      cur_len >= self.force_token_array.shape[0]		,				lambda: scores		,				lambda: lax.cond(
          self.force_token_array[cur_len] >= 0		,				lambda: _force_token(SCREAMING_SNAKE_CASE      )		,				lambda: scores		,				)		,				)
  return scores





class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Optional[int]:
  a__												= generate_config.eos_token_id
  a__												= generate_config.no_timestamps_token_id
  a__												= generate_config.no_timestamps_token_id + 1

  a__												= decoder_input_length + 1

  if generate_config.is_multilingual:
   # room for language token and task token
   self.begin_index += 2
  if hasattr(SCREAMING_SNAKE_CASE		,				'''max_initial_timestamp_index'''      ):
   a__												= generate_config.max_initial_timestamp_index
  else:
   a__												= model_config.vocab_size
  if self.max_initial_timestamp_index is None:
   a__												= model_config.vocab_size



 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) ->			Optional[int]:
  # suppress <|notimestamps|> which is handled by without_timestamps
  a__												= scores.at[:, self.no_timestamps_token_id].set(-float('''inf'''      )      )

  def handle_pairs(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ):
   a__												= jnp.where((cur_len - self.begin_index) >= 1		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
   a__												= jnp.where(
       input_ids_k[cur_len - 1] >= self.timestamp_begin		,				True and last_was_timestamp		,				SCREAMING_SNAKE_CASE		,				)

   a__												= jnp.where((cur_len - self.begin_index) < 2		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
   a__												= jnp.where(
       input_ids_k[cur_len - 2] >= self.timestamp_begin		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				)

   return jnp.where(
       SCREAMING_SNAKE_CASE		,				jnp.where(
           penultimate_was_timestamp > 0		,				scores_k.at[self.timestamp_begin :].set(-float('''inf'''      )      )		,				scores_k.at[: self.eos_token_id].set(-float('''inf'''      )      )		,				)		,				SCREAMING_SNAKE_CASE		,				)

  a__												= jax.vmap(SCREAMING_SNAKE_CASE      )(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )

  a__												= jnp.where(cur_len == self.begin_index		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )
  a__												= jnp.where(
      self.max_initial_timestamp_index is not None		,				True and apply_max_initial_timestamp		,				SCREAMING_SNAKE_CASE		,				)

  a__												= self.timestamp_begin + self.max_initial_timestamp_index

  a__												= jnp.where(
      SCREAMING_SNAKE_CASE		,				scores.at[:, last_allowed + 1 :].set(-float('''inf'''      )      )		,				SCREAMING_SNAKE_CASE		,				)

  # if sum of probability over timestamps is above any other token, sample timestamp
  a__												= jax.nn.log_softmax(SCREAMING_SNAKE_CASE		,				axis=-1      )

  def handle_cumulative_probs(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ):
   a__												= jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]		,				axis=-1      )
   a__												= jnp.max(logprobs_k[: self.timestamp_begin]      )
   return jnp.where(
       timestamp_logprob > max_text_token_logprob		,				scores_k.at[: self.timestamp_begin].set(-float('''inf'''      )      )		,				SCREAMING_SNAKE_CASE		,				)

  a__												= jax.vmap(SCREAMING_SNAKE_CASE      )(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      )

  return scores










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

a_      :      str    =     logging.get_logger(__name__)
@add_end_docstrings(_lowercase				)
class    __UpperCamelCase			(       _lowercase				):

 """simple docstring"""



 def __init__(	self		,				*SCREAMING_SNAKE_CASE		,				**SCREAMING_SNAKE_CASE      ) ->			int:
  super().__init__(*SCREAMING_SNAKE_CASE		,				**SCREAMING_SNAKE_CASE      )
  self.check_model_type(SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE=None		,				SCREAMING_SNAKE_CASE=None		,				SCREAMING_SNAKE_CASE=None		,				**SCREAMING_SNAKE_CASE      ) ->			Union[str, Any]:
  a__							,			a__												= {}, {}
  if padding is not None:
   a__												= padding
  if truncation is not None:
   a__												= truncation
  if top_k is not None:
   a__												= top_k
  return preprocess_params, {}, postprocess_params

 def __call__(	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE = None		,				**SCREAMING_SNAKE_CASE      ) ->			Optional[int]:
  if isinstance(SCREAMING_SNAKE_CASE		,				(Image.Image, str)      ) and isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ):
   a__												= {'''image''': image, '''question''': question}
  else:
   a__												= image
  a__												= super().__call__(SCREAMING_SNAKE_CASE		,				**SCREAMING_SNAKE_CASE      )
  return results

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE=False		,				SCREAMING_SNAKE_CASE=False      ) ->			Dict:
  a__												= load_image(inputs['''image''']      )
  a__												= self.tokenizer(
      inputs['''question''']		,				return_tensors=self.framework		,				padding=SCREAMING_SNAKE_CASE		,				truncation=SCREAMING_SNAKE_CASE      )
  a__												= self.image_processor(images=SCREAMING_SNAKE_CASE		,				return_tensors=self.framework      )
  model_inputs.update(SCREAMING_SNAKE_CASE      )
  return model_inputs

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			Union[str, Any]:
  a__												= self.model(**SCREAMING_SNAKE_CASE      )
  return model_outputs



 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE=5      ) ->			Optional[Any]:
  if top_k > self.model.config.num_labels:
   a__												= self.model.config.num_labels

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

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





