





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


_lowerCAmelCase 				=     get_logger(__name__)


_lowerCAmelCase 				=     R"""
    Args:
        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):
            Indices of input sequence tokens in the vocabulary.

            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and
            [`PreTrainedTokenizer.__call__`] for details.

            [What are input IDs?](../glossary#input-ids)
        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):
            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam
            search or log softmax for each vocabulary token when using beam search
        kwargs (`Dict[str, Any]`, *optional*):
            Additional logits processor specific kwargs.

    Return:
        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.

"""

class    _UpperCAmelCase							:
      @add_start_docstrings(a__       )
      def __call__(		self      ,       a__      ,       a__       ):
         raise NotImplementedError(
             F"""{self.__class__} is an abstract class. Only classes inheriting this class can be called."""       )






class    _UpperCAmelCase							:
      @add_start_docstrings(a__       )
      def __call__(		self      ,       a__      ,       a__       ):
         raise NotImplementedError(
             F"""{self.__class__} is an abstract class. Only classes inheriting this class can be called."""       )






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      @add_start_docstrings(a__       )
      def __call__(		self      ,       a__      ,       a__      ,       a__      ,       **a__       ):
         for processor in self:
            A_     :				Tuple			      =	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."""       )
               A_     :				Union[str, Any]			      =	processor(a__      ,       a__      ,       a__      ,       **a__       )
            else:
               A_     :				str			      =	processor(a__      ,       a__      ,       a__       )
         return scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__       ):
         if not isinstance(a__      ,       a__       ) or not (temperature > 0):
            raise ValueError(F"""`temperature` has to be a strictly positive float, but is {temperature}"""       )

         A_     :				Dict			      =	temperature






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         A_     :				List[Any]			      =	scores / self.temperature
         return scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__      ,       a__ = -float("""Inf"""       )      ,       a__ = 1       ):
         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}"""       )

         A_     :				Optional[Any]			      =	top_p
         A_     :				Tuple			      =	filter_value
         A_     :				List[str]			      =	min_tokens_to_keep






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         A_      ,				A_     :				Optional[Any]			      =	lax.top_k(a__      ,       scores.shape[-1]       )

         A_     :				Union[str, Any]			      =	jnp.full_like(a__      ,       self.filter_value       )
         A_     :				Tuple			      =	jax.nn.softmax(a__      ,       axis=-1       ).cumsum(axis=-1       )
         A_     :				List[Any]			      =	cumulative_probs < self.top_p

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

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

         A_     :				Union[str, Any]			      =	jnp.where(a__      ,       a__      ,       a__       )
         A_     :				Tuple			      =	jax.lax.sort_key_val(a__      ,       a__       )[-1]

         return next_scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__      ,       a__ = -float("""Inf"""       )      ,       a__ = 1       ):
         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}"""       )

         A_     :				Optional[Any]			      =	max(a__      ,       a__       )
         A_     :				Optional[int]			      =	filter_value






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         A_      ,				A_     :				Dict			      =	scores.shape
         A_     :				Optional[Any]			      =	jnp.full(batch_size * vocab_size      ,       self.filter_value       )

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

         A_     :				Dict			      =	next_scores_flat.at[topk_indices_flat].set(a__       )
         A_     :				Dict			      =	next_scores_flat.reshape(a__      ,       a__       )
         return next_scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__       ):
         A_     :				int			      =	bos_token_id






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         A_     :				Union[str, Any]			      =	jnp.full(scores.shape      ,       -float("""inf"""       )       )

         A_     :				Any			      =	1 - jnp.bool_(cur_len - 1       )

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

         return scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__      ,       a__       ):
         A_     :				Union[str, Any]			      =	max_length
         A_     :				Optional[Any]			      =	eos_token_id






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         A_     :				List[Any]			      =	jnp.full(scores.shape      ,       -float("""inf"""       )       )

         A_     :				Optional[Any]			      =	1 - jnp.bool_(cur_len - self.max_length + 1       )

         A_     :				Union[str, Any]			      =	jnp.where(a__      ,       new_scores.at[:, self.eos_token_id].set(0       )      ,       a__       )

         return scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__      ,       a__       ):
         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}"""       )

         A_     :				List[str]			      =	min_length
         A_     :				Optional[Any]			      =	eos_token_id






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         # create boolean flag to decide if min length penalty should be applied
         A_     :				List[Any]			      =	1 - jnp.clip(cur_len - self.min_length      ,       0      ,       1       )

         A_     :				Union[str, Any]			      =	jnp.where(a__      ,       scores.at[:, self.eos_token_id].set(-float("""inf"""       )       )      ,       a__       )

         return scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__      ,       a__       ):
         A_     :				List[str]			      =	list(a__       )
         A_     :				Union[str, Any]			      =	begin_index






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         A_     :				Union[str, Any]			      =	1 - jnp.bool_(cur_len - self.begin_index       )

         A_     :				Union[str, Any]			      =	jnp.where(a__      ,       scores.at[:, self.begin_suppress_tokens].set(-float("""inf"""       )       )      ,       a__       )

         return scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__       ):
         A_     :				str			      =	list(a__       )






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         A_     :				int			      =	scores.at[..., self.suppress_tokens].set(-float("""inf"""       )       )

         return scores






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__       ):
         A_     :				Optional[int]			      =	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.
         A_     :				int			      =	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_     :				str			      =	force_token_array.at[index].set(a__       )
         A_     :				List[Any]			      =	jnp.intaa(a__       )






      def __call__(		self      ,       a__      ,       a__      ,       a__       ):
         def _force_token(a__       ):
            A_     :				Union[str, Any]			      =	scores.shape[0]
            A_     :				Any			      =	self.force_token_array[generation_idx]

            A_     :				Optional[int]			      =	jnp.ones_like(a__      ,       dtype=scores.dtype       ) * -float("""inf"""       )
            A_     :				List[str]			      =	jnp.zeros((batch_size, 1)      ,       dtype=scores.dtype       )
            A_     :				Tuple			      =	lax.dynamic_update_slice(a__      ,       a__      ,       (0, current_token)       )
            return new_scores

         A_     :				List[str]			      =	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							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__      ,       a__      ,       a__       ):
         A_     :				List[Any]			      =	generate_config.eos_token_id
         A_     :				int			      =	generate_config.no_timestamps_token_id
         A_     :				Tuple			      =	generate_config.no_timestamps_token_id + 1

         A_     :				Dict			      =	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"""       ):
            A_     :				Tuple			      =	generate_config.max_initial_timestamp_index
         else:
            A_     :				Tuple			      =	model_config.vocab_size
         if self.max_initial_timestamp_index is None:
            A_     :				Optional[Any]			      =	model_config.vocab_size






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

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

            A_     :				List[str]			      =	jnp.where((cur_len - self.begin_index) < 2      ,       a__      ,       a__       )
            A_     :				Any			      =	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__      ,       )

         A_     :				int			      =	jax.vmap(a__       )(a__      ,       a__       )

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

         A_     :				Tuple			      =	self.timestamp_begin + self.max_initial_timestamp_index

         A_     :				int			      =	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
         A_     :				List[Any]			      =	jax.nn.log_softmax(a__      ,       axis=-1       )

         def handle_cumulative_probs(a__      ,       a__       ):
            A_     :				Optional[int]			      =	jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]      ,       axis=-1       )
            A_     :				Dict			      =	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__      ,       )

         A_     :				str			      =	jax.vmap(a__       )(a__      ,       a__       )

         return scores













import baseaa
import io
import json
import os
from copy import deepcopy

from ..optimizer import AcceleratedOptimizer
from ..scheduler import AcceleratedScheduler

class    _UpperCAmelCase							:
      def __init__(		self      ,       a__       ):
         if isinstance(a__      ,       a__       ):
            # Don't modify user's data should they want to reuse it (e.g. in tests), because once we
            # modified it, it will not be accepted here again, since `auto` values would have been overridden
            A_     :				Optional[Any]			      =	deepcopy(a__       )
         elif os.path.exists(a__       ):
            with io.open(a__      ,       """r"""      ,       encoding="""utf-8"""       ) as f:
               A_     :				str			      =	json.load(a__       )
         else:
            try:
               A_     :				Dict			      =	baseaa.urlsafe_baadecode(a__       ).decode("""utf-8"""       )
               A_     :				List[Any]			      =	json.loads(a__       )
            except (UnicodeDecodeError, AttributeError, ValueError):
               raise ValueError(
                   F"""Expected a string path to an existing deepspeed config, or a dictionary, or a base64 encoded string. Received: {config_file_or_dict}"""       )

         A_     :				Any			      =	config

         self.set_stage_and_offload()
      def 		_lowerCamelCase      (		self       ):
         # zero stage - this is done as early as possible, before model is created, to allow
         # ``is_deepspeed_zero3_enabled`` query and getting to the early deepspeed config object
         # during ``zero.Init()`` which needs to know the dtype, and some other hparams.
         A_     :				List[str]			      =	self.get_value("""zero_optimization.stage"""      ,       -1       )

         # offload
         A_     :				Any			      =	False
         if self.is_zeroa() or self.is_zeroa():
            A_     :				Optional[int]			      =	set(["""cpu""", """nvme"""]       )
            A_     :				Dict			      =	set(
                [
                    self.get_value("""zero_optimization.offload_optimizer.device"""       ),
                    self.get_value("""zero_optimization.offload_param.device"""       ),
                ]       )
            if len(offload_devices & offload_devices_valid       ) > 0:
               A_     :				Tuple			      =	True
      def 		_lowerCamelCase      (		self      ,       a__       ):
         A_     :				List[Any]			      =	self.config

         # find the config node of interest if it exists
         A_     :				Optional[Any]			      =	ds_key_long.split("""."""       )
         A_     :				Union[str, Any]			      =	nodes.pop()
         for node in nodes:
            A_     :				List[str]			      =	config.get(a__       )
            if config is None:
               return None, ds_key

         return config, ds_key
      def 		_lowerCamelCase      (		self      ,       a__      ,       a__=None       ):
         A_      ,				A_     :				Union[str, Any]			      =	self.find_config_node(a__       )
         if config is None:
            return default
         return config.get(a__      ,       a__       )
      def 		_lowerCamelCase      (		self      ,       a__      ,       a__=False       ):
         A_     :				Union[str, Any]			      =	self.config

         # find the config node of interest if it exists
         A_     :				str			      =	ds_key_long.split("""."""       )
         for node in nodes:
            A_     :				int			      =	config
            A_     :				int			      =	config.get(a__       )
            if config is None:
               if must_exist:
                  raise ValueError(F"""Can't find {ds_key_long} entry in the config: {self.config}"""       )
               else:
                  return

        # if found remove it
         if parent_config is not None:
            parent_config.pop(a__       )
      def 		_lowerCamelCase      (		self      ,       a__       ):
         A_     :				Optional[Any]			      =	self.get_value(a__       )
         return False if value is None else bool(a__       )
      def 		_lowerCamelCase      (		self      ,       a__       ):
         A_     :				Optional[Any]			      =	self.get_value(a__       )
         return False if value is None else not bool(a__       )
      def 		_lowerCamelCase      (		self       ):
         return self._stage == 2
      def 		_lowerCamelCase      (		self       ):
         return self._stage == 3






      def 		_lowerCamelCase      (		self       ):
         return self._offload






class    _UpperCAmelCase							:
      def __init__(		self      ,       a__       ):
         A_     :				Any			      =	engine






      def 		_lowerCamelCase      (		self      ,       a__      ,       **a__       ):
         # runs backpropagation and handles mixed precision
         self.engine.backward(a__      ,       **a__       )

         # Deepspeed's `engine.step` performs the following operations:
         # - gradient accumulation check
         # - gradient clipping
         # - optimizer step
         # - zero grad
         # - checking overflow
         # - lr_scheduler step (only if engine.lr_scheduler is not None)
         self.engine.step()
         # and this plugin overrides the above calls with no-ops when Accelerate runs under
         # Deepspeed, but allows normal functionality for non-Deepspeed cases thus enabling a simple
         # training loop that works transparently under many training regimes.






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__       ):
         super().__init__(a__      ,       device_placement=a__      ,       scaler=a__       )
         A_     :				Dict			      =	hasattr(self.optimizer      ,       """overflow"""       )
      def 		_lowerCamelCase      (		self      ,       a__=None       ):
         pass  # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed
      def 		_lowerCamelCase      (		self       ):
         pass  # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed






      @property
      def 		_lowerCamelCase      (		self       ):
         if self.__has_overflow__:
            return self.optimizer.overflow
         return False






class    _UpperCAmelCase							(		_lowerCamelCase     ):
      def __init__(		self      ,       a__      ,       a__       ):
         super().__init__(a__      ,       a__       )






      def 		_lowerCamelCase      (		self       ):
         pass  # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed






class    _UpperCAmelCase							:
      def __init__(		self      ,       a__      ,       a__=0.001      ,       a__=0      ,       **a__       ):
         A_     :				List[str]			      =	params
         A_     :				Any			      =	lr
         A_     :				int			      =	weight_decay
         A_     :				Optional[int]			      =	kwargs






class    _UpperCAmelCase							:
      def __init__(		self      ,       a__      ,       a__=None      ,       a__=0      ,       **a__       ):
         A_     :				Union[str, Any]			      =	optimizer
         A_     :				int			      =	total_num_steps
         A_     :				Any			      =	warmup_num_steps
         A_     :				int			      =	kwargs






