






import unittest

import numpy as np

from transformers import is_flax_available
from transformers.testing_utils import require_flax

from ..test_modeling_flax_common import ids_tensor


if is_flax_available():
     import jax
     import jax.numpy as jnp

     from transformers.generation import (
         FlaxForcedBOSTokenLogitsProcessor,
         FlaxForcedEOSTokenLogitsProcessor,
         FlaxLogitsProcessorList,
         FlaxMinLengthLogitsProcessor,
         FlaxTemperatureLogitsWarper,
         FlaxTopKLogitsWarper,
         FlaxTopPLogitsWarper,
     )






@require_flax
class 						lowercase_   (      unittest.TestCase  ):






      '''simple docstring'''




      def  __lowerCAmelCase   ( self :		List[str]					,   __UpperCAmelCase :		int					,   __UpperCAmelCase :		int    )       ->Union[str, Any]:




       """simple docstring"""


       a						    = jnp.ones((batch_size, length)    ) / length
       return scores







      def  __lowerCAmelCase   ( self :		List[Any]    )       ->List[str]:




       """simple docstring"""


       a						    = None
       a						    = 20

       a						    = self._get_uniform_logits(batch_size=2					,   length=__UpperCAmelCase    )

       # tweak scores to not be uniform anymore
       a						    = scores.at[1, 5].set((1 / length) + 0.1    )  # peak, 1st batch
       a						    = scores.at[1, 10].set((1 / length) - 0.4    )  # valley, 1st batch

       # compute softmax
       a						    = jax.nn.softmax(__UpperCAmelCase					,   axis=-1    )

       a						    = FlaxTemperatureLogitsWarper(temperature=0.5    )
       a						    = FlaxTemperatureLogitsWarper(temperature=1.3    )

       a						    = jax.nn.softmax(temp_dist_warper_sharper(__UpperCAmelCase					,   scores.copy()					,   cur_len=__UpperCAmelCase    )					,   axis=-1    )
       a						    = jax.nn.softmax(temp_dist_warper_smoother(__UpperCAmelCase					,   scores.copy()					,   cur_len=__UpperCAmelCase    )					,   axis=-1    )

       # uniform distribution stays uniform
       self.assertTrue(jnp.allclose(probs[0, :]					,   warped_prob_sharp[0, :]					,   atol=1e-3    )    )
       self.assertTrue(jnp.allclose(probs[0, :]					,   warped_prob_smooth[0, :]					,   atol=1e-3    )    )

       # sharp peaks get higher, valleys get lower
       self.assertLess(probs[1, :].max()					,   warped_prob_sharp[1, :].max()    )
       self.assertGreater(probs[1, :].min()					,   warped_prob_sharp[1, :].min()    )

       # smooth peaks get lower, valleys get higher
       self.assertGreater(probs[1, :].max()					,   warped_prob_smooth[1, :].max()    )
       self.assertLess(probs[1, :].min()					,   warped_prob_smooth[1, :].min()    )







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




       """simple docstring"""


       a						    = None
       a						    = 10
       a						    = 2

       # create ramp distribution
       a						    = np.broadcast_to(np.arange(__UpperCAmelCase    )[None, :]					,   (batch_size, vocab_size)    ).copy()
       a						    = ramp_logits[1:, : vocab_size // 2] + vocab_size

       a						    = FlaxTopKLogitsWarper(3    )

       a						    = top_k_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )

       # check that correct tokens are filtered
       self.assertListEqual(jnp.isinf(scores[0]    ).tolist()					,   7 * [True] + 3 * [False]    )
       self.assertListEqual(jnp.isinf(scores[1]    ).tolist()					,   2 * [True] + 3 * [False] + 5 * [True]    )

       # check special case
       a						    = 5
       a						    = FlaxTopKLogitsWarper(top_k=1					,   filter_value=0.0					,   min_tokens_to_keep=3    )

       a						    = np.broadcast_to(np.arange(__UpperCAmelCase    )[None, :]					,   (batch_size, length)    ).copy()
       a						    = top_k_warp_safety_check(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )

       # min_tokens overwrites k: 3 tokens are kept => 2 tokens are nullified
       self.assertListEqual((scores == 0.0).sum(axis=-1    ).tolist()					,   [2, 2]    )







      def  __lowerCAmelCase   ( self :		str    )       ->Optional[int]:




       """simple docstring"""


       a						    = None
       a						    = 10
       a						    = 2

       # create distribution and take log (inverse to Softmax as taken in TopPLogitsWarper)
       a						    = np.log(np.array([[0.3, 0.1, 0.1, 0.5], [0.15, 0.3, 0.3, 0.25]]    )    )

       a						    = FlaxTopPLogitsWarper(0.8    )
       a						    = np.exp(top_p_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )    )

       # dist should be filtered to keep min num values so that sum is >= top_p
       # exp (-inf) => 0
       a						    = np.array([[0.3, 0.0, 0.0, 0.5], [0.0, 0.3, 0.3, 0.25]]    )
       self.assertTrue(np.allclose(__UpperCAmelCase					,   __UpperCAmelCase					,   atol=1e-3    )    )

       # check edge cases with negative and extreme logits
       a						    = np.broadcast_to(np.arange(__UpperCAmelCase    )[None, :]					,   (batch_size, vocab_size)    ).copy() - (
           vocab_size // 2
       )

       # make ramp_logits more extreme
       a						    = ramp_logits[1] * 100.0

       # make sure at least 2 tokens are kept
       a						    = FlaxTopPLogitsWarper(0.9					,   min_tokens_to_keep=2					,   filter_value=0.0    )
       a						    = top_p_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )

       # first batch should keep three tokens, second batch would keep only 1, but due to `min_tokens_to_keep=2` keeps 2.
       self.assertListEqual((filtered_dist != 0.0).sum(axis=-1    ).tolist()					,   [3, 2]    )







      def  __lowerCAmelCase   ( self :		int    )       ->Tuple:




       """simple docstring"""


       a						    = 20
       a						    = 4
       a						    = 0

       a						    = FlaxMinLengthLogitsProcessor(min_length=10					,   eos_token_id=__UpperCAmelCase    )

       # check that min length is applied at length 5
       a						    = ids_tensor((batch_size, 20)					,   vocab_size=20    )
       a						    = 5
       a						    = self._get_uniform_logits(__UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = min_dist_processor(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       self.assertListEqual(scores_before_min_length[:, eos_token_id].tolist()					,   4 * [-float('''inf'''    )]    )

       # check that min length is not applied anymore at length 15
       a						    = self._get_uniform_logits(__UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = 15
       a						    = min_dist_processor(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       self.assertFalse(jnp.isinf(__UpperCAmelCase    ).any()    )







      def  __lowerCAmelCase   ( self :		List[str]    )       ->int:




       """simple docstring"""


       a						    = 20
       a						    = 4
       a						    = 0

       a						    = FlaxForcedBOSTokenLogitsProcessor(bos_token_id=__UpperCAmelCase    )

       # check that all scores are -inf except the bos_token_id score
       a						    = ids_tensor((batch_size, 1)					,   vocab_size=20    )
       a						    = 1
       a						    = self._get_uniform_logits(__UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = logits_processor(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       self.assertTrue(jnp.isneginf(scores[:, bos_token_id + 1 :]    ).all()    )
       self.assertListEqual(scores[:, bos_token_id].tolist()					,   4 * [0]    )  # score for bos_token_id shold be zero

       # check that bos_token_id is not forced if current length is greater than 1
       a						    = 3
       a						    = self._get_uniform_logits(__UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = logits_processor(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       self.assertFalse(jnp.isinf(__UpperCAmelCase    ).any()    )







      def  __lowerCAmelCase   ( self :		List[Any]    )       ->Optional[Any]:




       """simple docstring"""


       a						    = 20
       a						    = 4
       a						    = 0
       a						    = 5

       a						    = FlaxForcedEOSTokenLogitsProcessor(max_length=__UpperCAmelCase					,   eos_token_id=__UpperCAmelCase    )

       # check that all scores are -inf except the eos_token_id when max_length is reached
       a						    = ids_tensor((batch_size, 4)					,   vocab_size=20    )
       a						    = 4
       a						    = self._get_uniform_logits(__UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = logits_processor(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       self.assertTrue(jnp.isneginf(scores[:, eos_token_id + 1 :]    ).all()    )
       self.assertListEqual(scores[:, eos_token_id].tolist()					,   4 * [0]    )  # score for eos_token_id should be zero

       # check that eos_token_id is not forced if max_length is not reached
       a						    = 3
       a						    = self._get_uniform_logits(__UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = logits_processor(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       self.assertFalse(jnp.isinf(__UpperCAmelCase    ).any()    )







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




       """simple docstring"""


       a						    = 4
       a						    = 10
       a						    = 15
       a						    = 2
       a						    = 1
       a						    = 15

       # dummy input_ids and scores
       a						    = ids_tensor((batch_size, sequence_length)					,   __UpperCAmelCase    )
       a						    = input_ids.copy()

       a						    = self._get_uniform_logits(__UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = scores.copy()

       # instantiate all dist processors
       a						    = FlaxTemperatureLogitsWarper(temperature=0.5    )
       a						    = FlaxTopKLogitsWarper(3    )
       a						    = FlaxTopPLogitsWarper(0.8    )

       # instantiate all logits processors
       a						    = FlaxMinLengthLogitsProcessor(min_length=10					,   eos_token_id=__UpperCAmelCase    )
       a						    = FlaxForcedBOSTokenLogitsProcessor(bos_token_id=__UpperCAmelCase    )
       a						    = FlaxForcedEOSTokenLogitsProcessor(max_length=__UpperCAmelCase					,   eos_token_id=__UpperCAmelCase    )

       a						    = 10

       # no processor list
       a						    = temp_dist_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       a						    = top_k_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       a						    = top_p_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       a						    = min_dist_proc(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       a						    = bos_dist_proc(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
       a						    = eos_dist_proc(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )

       # with processor list
       a						    = FlaxLogitsProcessorList(
           [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]    )
       a						    = processor(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )

       # scores should be equal
       self.assertTrue(jnp.allclose(__UpperCAmelCase					,   __UpperCAmelCase					,   atol=1e-3    )    )

       # input_ids should never be changed
       self.assertListEqual(input_ids.tolist()					,   input_ids_comp.tolist()    )







      def  __lowerCAmelCase   ( self :		List[Any]    )       ->List[str]:




       """simple docstring"""


       a						    = 4
       a						    = 10
       a						    = 15
       a						    = 2
       a						    = 1
       a						    = 15

       # dummy input_ids and scores
       a						    = ids_tensor((batch_size, sequence_length)					,   __UpperCAmelCase    )
       a						    = input_ids.copy()

       a						    = self._get_uniform_logits(__UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = scores.copy()

       # instantiate all dist processors
       a						    = FlaxTemperatureLogitsWarper(temperature=0.5    )
       a						    = FlaxTopKLogitsWarper(3    )
       a						    = FlaxTopPLogitsWarper(0.8    )

       # instantiate all logits processors
       a						    = FlaxMinLengthLogitsProcessor(min_length=10					,   eos_token_id=__UpperCAmelCase    )
       a						    = FlaxForcedBOSTokenLogitsProcessor(bos_token_id=__UpperCAmelCase    )
       a						    = FlaxForcedEOSTokenLogitsProcessor(max_length=__UpperCAmelCase					,   eos_token_id=__UpperCAmelCase    )

       a						    = 10

       # no processor list
       def run_no_processor_list(__UpperCAmelCase :		Optional[int]					,   __UpperCAmelCase :		Tuple					,   __UpperCAmelCase :		str    ):
        a						    = temp_dist_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
        a						    = top_k_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
        a						    = top_p_warp(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
        a						    = min_dist_proc(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
        a						    = bos_dist_proc(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
        a						    = eos_dist_proc(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
        return scores

       # with processor list
       def run_processor_list(__UpperCAmelCase :		Tuple					,   __UpperCAmelCase :		Tuple					,   __UpperCAmelCase :		int    ):
        a						    = FlaxLogitsProcessorList(
            [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]    )
        a						    = processor(__UpperCAmelCase					,   __UpperCAmelCase					,   cur_len=__UpperCAmelCase    )
        return scores

       a						    = jax.jit(__UpperCAmelCase    )
       a						    = jax.jit(__UpperCAmelCase    )

       a						    = jitted_run_no_processor_list(__UpperCAmelCase					,   __UpperCAmelCase					,   __UpperCAmelCase    )
       a						    = jitted_run_processor_list(__UpperCAmelCase					,   __UpperCAmelCase					,   __UpperCAmelCase    )

       # scores should be equal
       self.assertTrue(jnp.allclose(__UpperCAmelCase					,   __UpperCAmelCase					,   atol=1e-3    )    )

       # input_ids should never be changed
       self.assertListEqual(input_ids.tolist()					,   input_ids_comp.tolist()    )










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase__							  =						{
    "configuration_rag": ["RagConfig"],
    "retrieval_rag": ["RagRetriever"],
    "tokenization_rag": ["RagTokenizer"],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase__							  =						[
         "RagModel",
         "RagPreTrainedModel",
         "RagSequenceForGeneration",
         "RagTokenForGeneration",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase__							  =						[
         "TFRagModel",
         "TFRagPreTrainedModel",
         "TFRagSequenceForGeneration",
         "TFRagTokenForGeneration",
     ]


if TYPE_CHECKING:
     from .configuration_rag import RagConfig
     from .retrieval_rag import RagRetriever
     from .tokenization_rag import RagTokenizer

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_rag import RagModel, RagPreTrainedModel, RagSequenceForGeneration, RagTokenForGeneration

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_rag import (
              TFRagModel,
              TFRagPreTrainedModel,
              TFRagSequenceForGeneration,
              TFRagTokenForGeneration,
          )

else:
     import sys

     UpperCAmelCase__							  =						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


