





import inspect
import warnings

import torch

from .state import AcceleratorState, GradientState
from .utils import DistributedType, honor_type, is_tpu_available


if is_tpu_available(check_device=False):
				import torch_xla.core.xla_model as xm

def      a    (   _lowercase :  Tuple			,    _lowercase :  Any							)  ->List[str]:






		if isinstance(__A			,    (list, tuple)							):
				return honor_type(__A			,    (move_to_device(__A			,    __A							) for t in state)							)
		elif isinstance(__A			,    __A							):
				return type(__A							)({k: move_to_device(__A			,    __A							) for k, v in state.items()}							)
		elif isinstance(__A			,    torch.Tensor							):
				return state.to(__A							)
		return state




class 	_UpperCAmelCase						( torch.optim.Optimizer       ):




					def __init__(    self     ,   __lowerCAmelCase     ,   __lowerCAmelCase=True     ,   __lowerCAmelCase=None							)    ->	str:
							UpperCamelCase__								=						optimizer
							UpperCamelCase__								=						scaler
							UpperCamelCase__								=						AcceleratorState()
							UpperCamelCase__								=						GradientState()
							UpperCamelCase__								=						device_placement
							UpperCamelCase__								=						False
							UpperCamelCase__								=						None

							# Handle device placement
							if device_placement:
									UpperCamelCase__								=						self.optimizer.state_dict()
									if self.accelerator_state.distributed_type == DistributedType.TPU:
											xm.send_cpu_data_to_device(lowerCamelCase_     ,   self.accelerator_state.device							)
									else:
											UpperCamelCase__								=						move_to_device(lowerCamelCase_     ,   self.accelerator_state.device							)
									self.optimizer.load_state_dict(lowerCamelCase_							)




					@property
					def 						snake_case_		(    self							)    ->	int:
							return self.optimizer.state




					@state.setter
					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	int:
							UpperCamelCase__								=						state




					@property
					def 						snake_case_		(    self							)    ->	str:
							return self.optimizer.param_groups




					@param_groups.setter
					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	List[str]:
							UpperCamelCase__								=						param_groups




					@property
					def 						snake_case_		(    self							)    ->	Optional[Any]:
							return self.optimizer.defaults




					@defaults.setter
					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	Union[str, Any]:
							UpperCamelCase__								=						defaults




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	List[str]:
							self.optimizer.add_param_group(lowerCamelCase_							)




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	Tuple:
							if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
									xm.send_cpu_data_to_device(lowerCamelCase_     ,   self.accelerator_state.device							)
							self.optimizer.load_state_dict(lowerCamelCase_							)




					def 						snake_case_		(    self							)    ->	Tuple:
							return self.optimizer.state_dict()




					def 						snake_case_		(    self     ,   __lowerCAmelCase=None							)    ->	List[str]:
							if self.gradient_state.sync_gradients:
									UpperCamelCase__								=						'''set_to_none''' in inspect.signature(self.optimizer.zero_grad							).parameters
									if accept_arg:
											if set_to_none is None:
													UpperCamelCase__								=						False
											self.optimizer.zero_grad(set_to_none=lowerCamelCase_							)
									else:
											if set_to_none is not None:
													raise ValueError("""`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer."""							)
											self.optimizer.zero_grad()




					def 						snake_case_		(    self     ,   __lowerCAmelCase=None							)    ->	Any:
							if self.gradient_state.sync_gradients:
									if self.accelerator_state.distributed_type == DistributedType.TPU:
											UpperCamelCase__								=						{'''closure''': closure} if closure is not None else {}
											xm.optimizer_step(self.optimizer     ,   optimizer_args=lowerCamelCase_							)
									elif self.scaler is not None:
											UpperCamelCase__								=						False
											if self._last_scale is None:
													# `get_scale` is an async operation requiring full synchronization
													# on CPU and GPUs before finishing. As a result, we store away
													# the prior one to reduce the call overhead
													UpperCamelCase__								=						self.scaler.get_scale()
													UpperCamelCase__								=						True
											self.scaler.step(self.optimizer     ,   lowerCamelCase_							)
											self.scaler.update()
											UpperCamelCase__								=						self.scaler.get_scale()
											if not new_scale:
													# If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.
													UpperCamelCase__								=						scale_after < self._last_scale
											UpperCamelCase__								=						scale_after

									else:
											self.optimizer.step(lowerCamelCase_							)




					def 						snake_case_		(    self     ,   __lowerCAmelCase							)    ->	List[str]:
							for param_group in self.optimizer.param_groups:
									UpperCamelCase__								=						[parameters_map.get(lowerCamelCase_     ,   lowerCamelCase_							) for p in param_group['''params''']]




					@property
					def 						snake_case_		(    self							)    ->	Optional[Any]:
							warnings.warn(
							    """The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use """
							    """`optimizer.step_was_skipped` instead."""     ,   lowerCamelCase_     ,   )
							return self._is_overflow




					@property
					def 						snake_case_		(    self							)    ->	Dict:
							return self._is_overflow




					def __getstate__(    self							)    ->	int:
							return self.__dict__.copy()




					def __setstate__(    self     ,   __lowerCAmelCase							)    ->	int:
							self.__dict__.update(lowerCamelCase_							)











from typing import TYPE_CHECKING

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


__lowerCamelCase :    Tuple      						=      {
    '''configuration_utils''': ['''GenerationConfig'''],
    '''streamers''': ['''TextIteratorStreamer''', '''TextStreamer'''],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__lowerCamelCase :    Any      						=      [
	    '''Constraint''',
	    '''ConstraintListState''',
	    '''DisjunctiveConstraint''',
	    '''PhrasalConstraint''',
	]
	__lowerCamelCase :    int      						=      [
	    '''BeamHypotheses''',
	    '''BeamScorer''',
	    '''BeamSearchScorer''',
	    '''ConstrainedBeamSearchScorer''',
	]
	__lowerCamelCase :    Union[str, Any]      						=      [
	    '''EpsilonLogitsWarper''',
	    '''EtaLogitsWarper''',
	    '''ForcedBOSTokenLogitsProcessor''',
	    '''ForcedEOSTokenLogitsProcessor''',
	    '''HammingDiversityLogitsProcessor''',
	    '''InfNanRemoveLogitsProcessor''',
	    '''LogitsProcessor''',
	    '''LogitsProcessorList''',
	    '''LogitsWarper''',
	    '''MinLengthLogitsProcessor''',
	    '''MinNewTokensLengthLogitsProcessor''',
	    '''NoBadWordsLogitsProcessor''',
	    '''NoRepeatNGramLogitsProcessor''',
	    '''PrefixConstrainedLogitsProcessor''',
	    '''RepetitionPenaltyLogitsProcessor''',
	    '''SequenceBiasLogitsProcessor''',
	    '''EncoderRepetitionPenaltyLogitsProcessor''',
	    '''TemperatureLogitsWarper''',
	    '''TopKLogitsWarper''',
	    '''TopPLogitsWarper''',
	    '''TypicalLogitsWarper''',
	    '''EncoderNoRepeatNGramLogitsProcessor''',
	    '''ExponentialDecayLengthPenalty''',
	    '''LogitNormalization''',
	]
	__lowerCamelCase :    Union[str, Any]      						=      [
	    '''MaxNewTokensCriteria''',
	    '''MaxLengthCriteria''',
	    '''MaxTimeCriteria''',
	    '''StoppingCriteria''',
	    '''StoppingCriteriaList''',
	    '''validate_stopping_criteria''',
	]
	__lowerCamelCase :    Union[str, Any]      						=      [
	    '''GenerationMixin''',
	    '''top_k_top_p_filtering''',
	    '''GreedySearchEncoderDecoderOutput''',
	    '''GreedySearchDecoderOnlyOutput''',
	    '''SampleEncoderDecoderOutput''',
	    '''SampleDecoderOnlyOutput''',
	    '''BeamSearchEncoderDecoderOutput''',
	    '''BeamSearchDecoderOnlyOutput''',
	    '''BeamSampleEncoderDecoderOutput''',
	    '''BeamSampleDecoderOnlyOutput''',
	    '''ContrastiveSearchEncoderDecoderOutput''',
	    '''ContrastiveSearchDecoderOnlyOutput''',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__lowerCamelCase :    Tuple      						=      [
	    '''TFForcedBOSTokenLogitsProcessor''',
	    '''TFForcedEOSTokenLogitsProcessor''',
	    '''TFLogitsProcessor''',
	    '''TFLogitsProcessorList''',
	    '''TFLogitsWarper''',
	    '''TFMinLengthLogitsProcessor''',
	    '''TFNoBadWordsLogitsProcessor''',
	    '''TFNoRepeatNGramLogitsProcessor''',
	    '''TFRepetitionPenaltyLogitsProcessor''',
	    '''TFTemperatureLogitsWarper''',
	    '''TFTopKLogitsWarper''',
	    '''TFTopPLogitsWarper''',
	    '''TFForceTokensLogitsProcessor''',
	    '''TFSuppressTokensAtBeginLogitsProcessor''',
	    '''TFSuppressTokensLogitsProcessor''',
	]
	__lowerCamelCase :    Any      						=      [
	    '''TFGenerationMixin''',
	    '''tf_top_k_top_p_filtering''',
	    '''TFGreedySearchDecoderOnlyOutput''',
	    '''TFGreedySearchEncoderDecoderOutput''',
	    '''TFSampleEncoderDecoderOutput''',
	    '''TFSampleDecoderOnlyOutput''',
	    '''TFBeamSearchEncoderDecoderOutput''',
	    '''TFBeamSearchDecoderOnlyOutput''',
	    '''TFBeamSampleEncoderDecoderOutput''',
	    '''TFBeamSampleDecoderOnlyOutput''',
	    '''TFContrastiveSearchEncoderDecoderOutput''',
	    '''TFContrastiveSearchDecoderOnlyOutput''',
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__lowerCamelCase :    Optional[int]      						=      [
	    '''FlaxForcedBOSTokenLogitsProcessor''',
	    '''FlaxForcedEOSTokenLogitsProcessor''',
	    '''FlaxLogitsProcessor''',
	    '''FlaxLogitsProcessorList''',
	    '''FlaxLogitsWarper''',
	    '''FlaxMinLengthLogitsProcessor''',
	    '''FlaxTemperatureLogitsWarper''',
	    '''FlaxTopKLogitsWarper''',
	    '''FlaxTopPLogitsWarper''',
	]
	__lowerCamelCase :    Union[str, Any]      						=      [
	    '''FlaxGenerationMixin''',
	    '''FlaxGreedySearchOutput''',
	    '''FlaxSampleOutput''',
	    '''FlaxBeamSearchOutput''',
	]

if TYPE_CHECKING:
	from .configuration_utils import GenerationConfig
	from .streamers import TextIteratorStreamer, TextStreamer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
		from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
		from .logits_process import (
		    EncoderNoRepeatNGramLogitsProcessor,
		    EncoderRepetitionPenaltyLogitsProcessor,
		    EpsilonLogitsWarper,
		    EtaLogitsWarper,
		    ExponentialDecayLengthPenalty,
		    ForcedBOSTokenLogitsProcessor,
		    ForcedEOSTokenLogitsProcessor,
		    HammingDiversityLogitsProcessor,
		    InfNanRemoveLogitsProcessor,
		    LogitNormalization,
		    LogitsProcessor,
		    LogitsProcessorList,
		    LogitsWarper,
		    MinLengthLogitsProcessor,
		    MinNewTokensLengthLogitsProcessor,
		    NoBadWordsLogitsProcessor,
		    NoRepeatNGramLogitsProcessor,
		    PrefixConstrainedLogitsProcessor,
		    RepetitionPenaltyLogitsProcessor,
		    SequenceBiasLogitsProcessor,
		    TemperatureLogitsWarper,
		    TopKLogitsWarper,
		    TopPLogitsWarper,
		    TypicalLogitsWarper,
		)
		from .stopping_criteria import (
		    MaxLengthCriteria,
		    MaxNewTokensCriteria,
		    MaxTimeCriteria,
		    StoppingCriteria,
		    StoppingCriteriaList,
		    validate_stopping_criteria,
		)
		from .utils import (
		    BeamSampleDecoderOnlyOutput,
		    BeamSampleEncoderDecoderOutput,
		    BeamSearchDecoderOnlyOutput,
		    BeamSearchEncoderDecoderOutput,
		    ContrastiveSearchDecoderOnlyOutput,
		    ContrastiveSearchEncoderDecoderOutput,
		    GenerationMixin,
		    GreedySearchDecoderOnlyOutput,
		    GreedySearchEncoderDecoderOutput,
		    SampleDecoderOnlyOutput,
		    SampleEncoderDecoderOutput,
		    top_k_top_p_filtering,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tf_logits_process import (
		    TFForcedBOSTokenLogitsProcessor,
		    TFForcedEOSTokenLogitsProcessor,
		    TFForceTokensLogitsProcessor,
		    TFLogitsProcessor,
		    TFLogitsProcessorList,
		    TFLogitsWarper,
		    TFMinLengthLogitsProcessor,
		    TFNoBadWordsLogitsProcessor,
		    TFNoRepeatNGramLogitsProcessor,
		    TFRepetitionPenaltyLogitsProcessor,
		    TFSuppressTokensAtBeginLogitsProcessor,
		    TFSuppressTokensLogitsProcessor,
		    TFTemperatureLogitsWarper,
		    TFTopKLogitsWarper,
		    TFTopPLogitsWarper,
		)
		from .tf_utils import (
		    TFBeamSampleDecoderOnlyOutput,
		    TFBeamSampleEncoderDecoderOutput,
		    TFBeamSearchDecoderOnlyOutput,
		    TFBeamSearchEncoderDecoderOutput,
		    TFContrastiveSearchDecoderOnlyOutput,
		    TFContrastiveSearchEncoderDecoderOutput,
		    TFGenerationMixin,
		    TFGreedySearchDecoderOnlyOutput,
		    TFGreedySearchEncoderDecoderOutput,
		    TFSampleDecoderOnlyOutput,
		    TFSampleEncoderDecoderOutput,
		    tf_top_k_top_p_filtering,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .flax_logits_process import (
		    FlaxForcedBOSTokenLogitsProcessor,
		    FlaxForcedEOSTokenLogitsProcessor,
		    FlaxLogitsProcessor,
		    FlaxLogitsProcessorList,
		    FlaxLogitsWarper,
		    FlaxMinLengthLogitsProcessor,
		    FlaxTemperatureLogitsWarper,
		    FlaxTopKLogitsWarper,
		    FlaxTopPLogitsWarper,
		)
		from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
	import sys

	__lowerCamelCase :    int      						=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



