






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


lowercase  							=					get_logger(__name__)


lowercase  							=					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(a					)
	def __call__(       self       ,			a       ,			a					)       ->    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(a					)
	def __call__(       self       ,			a       ,			a					)       ->    jnp.ndarray:
								raise NotImplementedError(
								    F'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.'''					)






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	@add_start_docstrings(a					)
	def __call__(       self       ,			a       ,			a       ,			a       ,			**a					)       ->    jnp.ndarray:
								for processor in self:
															snake_case_				=							inspect.signature(processor.__call__					).parameters
															if len(a					) > 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.'''					)
																						snake_case_				=							processor(a       ,			a       ,			a       ,			**a					)
															else:
																						snake_case_				=							processor(a       ,			a       ,			a					)
								return scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			a					)       ->    Tuple:
								if not isinstance(a       ,			a					) or not (temperature > 0):
															raise ValueError(F'''`temperature` has to be a strictly positive float, but is {temperature}'''					)

								snake_case_				=							temperature






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






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a = -float('Inf'					)       ,			a = 1					)       ->    Optional[int]:
								if not isinstance(a       ,			a					) 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(a       ,			a					) 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}'''					)

								snake_case_				=							top_p
								snake_case_				=							filter_value
								snake_case_				=							min_tokens_to_keep






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

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

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

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

								snake_case_				=							jnp.where(a       ,			a       ,			a					)
								snake_case_				=							jax.lax.sort_key_val(a       ,			a					)[-1]

								return next_scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




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

								snake_case_				=							max(a       ,			a					)
								snake_case_				=							filter_value






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

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

								snake_case_				=							next_scores_flat.at[topk_indices_flat].set(a					)
								snake_case_				=							next_scores_flat.reshape(a       ,			a					)
								return next_scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			a					)       ->    Dict:
								snake_case_				=							bos_token_id






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

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

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

								return scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a					)       ->    int:
								snake_case_				=							max_length
								snake_case_				=							eos_token_id






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

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

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

								return scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a					)       ->    Dict:
								if not isinstance(a       ,			a					) or min_length < 0:
															raise ValueError(F'''`min_length` has to be a positive integer, but is {min_length}'''					)

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

								snake_case_				=							min_length
								snake_case_				=							eos_token_id






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

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

								return scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a					)       ->    Dict:
								snake_case_				=							list(a					)
								snake_case_				=							begin_index






	def __call__(       self       ,			a       ,			a       ,			a					)       ->    Optional[Any]:
								snake_case_				=							1 - jnp.bool_(cur_len - self.begin_index					)

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

								return scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			a					)       ->    Optional[Any]:
								snake_case_				=							list(a					)






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

								return scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	def __init__(       self       ,			a					)       ->    List[Any]:
								snake_case_				=							dict(a					)
								# 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.
								snake_case_				=							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:
																						snake_case_				=							force_token_array.at[index].set(a					)
								snake_case_				=							jnp.intaa(a					)






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

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

								snake_case_				=							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(a					)       ,			lambda: scores       ,			)       ,			)
								return scores






class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




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

								snake_case_				=							decoder_input_length + 1

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






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

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

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

															return jnp.where(
															    a       ,			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'					)					)       ,			)       ,			a       ,			)

								snake_case_				=							jax.vmap(a					)(a       ,			a					)

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

								snake_case_				=							self.timestamp_begin + self.max_initial_timestamp_index

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

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

								def handle_cumulative_probs(a       ,			a					):
															snake_case_				=							jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]       ,			axis=-1					)
															snake_case_				=							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'					)					)       ,			a       ,			)

								snake_case_				=							jax.vmap(a					)(a       ,			a					)

								return scores













import unittest

import numpy as np

from transformers import RobertaConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
	from transformers.models.roberta.modeling_flax_roberta import (
	    FlaxRobertaForCausalLM,
	    FlaxRobertaForMaskedLM,
	    FlaxRobertaForMultipleChoice,
	    FlaxRobertaForQuestionAnswering,
	    FlaxRobertaForSequenceClassification,
	    FlaxRobertaForTokenClassification,
	    FlaxRobertaModel,
	)




class  UpperCamelCase_      (			unittest.TestCase				):



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a=13       ,			a=7       ,			a=True       ,			a=True       ,			a=True       ,			a=True       ,			a=99       ,			a=32       ,			a=5       ,			a=4       ,			a=37       ,			a="gelu"       ,			a=0.1       ,			a=0.1       ,			a=5_12       ,			a=16       ,			a=2       ,			a=0.02       ,			a=4       ,			)       ->    int:
								snake_case_				=							parent
								snake_case_				=							batch_size
								snake_case_				=							seq_length
								snake_case_				=							is_training
								snake_case_				=							use_attention_mask
								snake_case_				=							use_token_type_ids
								snake_case_				=							use_labels
								snake_case_				=							vocab_size
								snake_case_				=							hidden_size
								snake_case_				=							num_hidden_layers
								snake_case_				=							num_attention_heads
								snake_case_				=							intermediate_size
								snake_case_				=							hidden_act
								snake_case_				=							hidden_dropout_prob
								snake_case_				=							attention_probs_dropout_prob
								snake_case_				=							max_position_embeddings
								snake_case_				=							type_vocab_size
								snake_case_				=							type_sequence_label_size
								snake_case_				=							initializer_range
								snake_case_				=							num_choices




	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								snake_case_				=							ids_tensor([self.batch_size, self.seq_length]       ,			self.vocab_size					)

								snake_case_				=							None
								if self.use_attention_mask:
															snake_case_				=							random_attention_mask([self.batch_size, self.seq_length]					)

								snake_case_				=							None
								if self.use_token_type_ids:
															snake_case_				=							ids_tensor([self.batch_size, self.seq_length]       ,			self.type_vocab_size					)

								snake_case_				=							RobertaConfig(
								    vocab_size=self.vocab_size       ,			hidden_size=self.hidden_size       ,			num_hidden_layers=self.num_hidden_layers       ,			num_attention_heads=self.num_attention_heads       ,			intermediate_size=self.intermediate_size       ,			hidden_act=self.hidden_act       ,			hidden_dropout_prob=self.hidden_dropout_prob       ,			attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,			max_position_embeddings=self.max_position_embeddings       ,			type_vocab_size=self.type_vocab_size       ,			is_decoder=a       ,			initializer_range=self.initializer_range       ,			)

								return config, input_ids, token_type_ids, attention_mask




	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								snake_case_				=							self.prepare_config_and_inputs()
								snake_case_			,		snake_case_			,		snake_case_			,		snake_case_				=							config_and_inputs
								snake_case_				=							{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
								return config, inputs_dict






	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								snake_case_				=							self.prepare_config_and_inputs()
								snake_case_			,		snake_case_			,		snake_case_			,		snake_case_				=							config_and_inputs

								snake_case_				=							True
								snake_case_				=							floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
								snake_case_				=							ids_tensor([self.batch_size, self.seq_length]       ,			vocab_size=2					)

								return (
								    config,
								    input_ids,
								    token_type_ids,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)






@require_flax
class  UpperCamelCase_      (			snake_case_       ,					unittest.TestCase				):



	'''simple docstring'''




	lowerCAmelCase													= True

	lowerCAmelCase													= (
	    (
	        FlaxRobertaModel,
	        FlaxRobertaForCausalLM,
	        FlaxRobertaForMaskedLM,
	        FlaxRobertaForSequenceClassification,
	        FlaxRobertaForTokenClassification,
	        FlaxRobertaForMultipleChoice,
	        FlaxRobertaForQuestionAnswering,
	    )
	    if is_flax_available()
	    else ()
	)




	def 							_UpperCamelCase			(       self					)       ->    List[str]:
								snake_case_				=							FlaxRobertaModelTester(self					)






	@slow
	def 							_UpperCamelCase			(       self					)       ->    str:
								for model_class_name in self.all_model_classes:
															snake_case_				=							model_class_name.from_pretrained('roberta-base'       ,			from_pt=a					)
															snake_case_				=							model(np.ones((1, 1)					)					)
															self.assertIsNotNone(a					)





