




import warnings

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase__					:  Tuple      							=				logging.get_logger(__name__)

lowerCamelCase__					:  int      							=				{
    'xlnet-base-cased': 'https://huggingface.co/xlnet-base-cased/resolve/main/config.json',
    'xlnet-large-cased': 'https://huggingface.co/xlnet-large-cased/resolve/main/config.json',
}





class 			lowerCamelCase_				( _SCREAMING_SNAKE_CASE   ):


 '''simple docstring'''







 lowercase_							       =       "xlnet"
 lowercase_							       =       ["mems"]
 lowercase_							       =       {
     "n_token": "vocab_size",  # Backward compatibility
     "hidden_size": "d_model",
     "num_attention_heads": "n_head",
     "num_hidden_layers": "n_layer",
 }



 def __init__(				self    :						str							,							_lowerCAmelCase    :						Optional[int]=32_000							,							_lowerCAmelCase    :						Optional[Any]=1_024							,							_lowerCAmelCase    :						str=24							,							_lowerCAmelCase    :						Any=16							,							_lowerCAmelCase    :						Union[str, Any]=4_096							,							_lowerCAmelCase    :						List[str]="gelu"							,							_lowerCAmelCase    :						Tuple=True							,							_lowerCAmelCase    :						Optional[int]="bi"							,							_lowerCAmelCase    :						Any=0.02							,							_lowerCAmelCase    :						List[Any]=1E-12							,							_lowerCAmelCase    :						Any=0.1							,							_lowerCAmelCase    :						List[Any]=512							,							_lowerCAmelCase    :						int=None							,							_lowerCAmelCase    :						Dict=True							,							_lowerCAmelCase    :						str=False							,							_lowerCAmelCase    :						str=False							,							_lowerCAmelCase    :						str=-1							,							_lowerCAmelCase    :						Dict=False							,							_lowerCAmelCase    :						int="last"							,							_lowerCAmelCase    :						List[Any]=True							,							_lowerCAmelCase    :						Optional[int]="tanh"							,							_lowerCAmelCase    :						Union[str, Any]=0.1							,							_lowerCAmelCase    :						Any=5							,							_lowerCAmelCase    :						List[Any]=5							,							_lowerCAmelCase    :						Optional[int]=5							,							_lowerCAmelCase    :						Optional[int]=1							,							_lowerCAmelCase    :						Dict=2							,							**_lowerCAmelCase    :						str							,							):
       SCREAMING_SNAKE_CASE_      		=     vocab_size
       SCREAMING_SNAKE_CASE_      		=     d_model
       SCREAMING_SNAKE_CASE_      		=     n_layer
       SCREAMING_SNAKE_CASE_      		=     n_head
       if d_model % n_head != 0:
             raise ValueError(F"'d_model % n_head' ({d_model % n_head}) should be equal to 0"		)
       if "d_head" in kwargs:
             if kwargs["d_head"] != d_model // n_head:
                   raise ValueError(
                       F"`d_head` ({kwargs['d_head']}) should be equal to `d_model // n_head` ({d_model // n_head})"		)
       SCREAMING_SNAKE_CASE_      		=     d_model // n_head
       SCREAMING_SNAKE_CASE_      		=     ff_activation
       SCREAMING_SNAKE_CASE_      		=     d_inner
       SCREAMING_SNAKE_CASE_      		=     untie_r
       SCREAMING_SNAKE_CASE_      		=     attn_type

       SCREAMING_SNAKE_CASE_      		=     initializer_range
       SCREAMING_SNAKE_CASE_      		=     layer_norm_eps

       SCREAMING_SNAKE_CASE_      		=     dropout
       SCREAMING_SNAKE_CASE_      		=     mem_len
       SCREAMING_SNAKE_CASE_      		=     reuse_len
       SCREAMING_SNAKE_CASE_      		=     bi_data
       SCREAMING_SNAKE_CASE_      		=     clamp_len
       SCREAMING_SNAKE_CASE_      		=     same_length

       SCREAMING_SNAKE_CASE_      		=     summary_type
       SCREAMING_SNAKE_CASE_      		=     summary_use_proj
       SCREAMING_SNAKE_CASE_      		=     summary_activation
       SCREAMING_SNAKE_CASE_      		=     summary_last_dropout
       SCREAMING_SNAKE_CASE_      		=     start_n_top
       SCREAMING_SNAKE_CASE_      		=     end_n_top

       SCREAMING_SNAKE_CASE_      		=     bos_token_id
       SCREAMING_SNAKE_CASE_      		=     pad_token_id
       SCREAMING_SNAKE_CASE_      		=     eos_token_id

       if "use_cache" in kwargs:
             warnings.warn(
                 'The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`'
                 ' instead.'							,							_lowerCAmelCase							,							)
             SCREAMING_SNAKE_CASE_      		=     kwargs['use_cache']

       SCREAMING_SNAKE_CASE_      		=     use_mems_eval
       SCREAMING_SNAKE_CASE_      		=     use_mems_train
       super().__init__(pad_token_id=_lowerCAmelCase							,							bos_token_id=_lowerCAmelCase							,							eos_token_id=_lowerCAmelCase							,							**_lowerCAmelCase		)



 @property
 def  lowerCAmelCase_    (				self    :						Union[str, Any]		):
       logger.info(F"The model {self.model_type} is one of the few models that has no sequence length limit."		)
       return -1




 @max_position_embeddings.setter
 def  lowerCAmelCase_    (				self    :						List[str]							,							_lowerCAmelCase    :						Optional[int]		):
       # Message copied from Transformer-XL documentation
       raise NotImplementedError(
           F"The model {self.model_type} is one of the few models that has no sequence length limit."		)



import os

import torch

from ..logging import get_logger
from .constants import FSDP_PYTORCH_VERSION, MODEL_NAME, OPTIMIZER_NAME
from .versions import is_torch_version


if is_torch_version(">=", FSDP_PYTORCH_VERSION):
		import torch.distributed.checkpoint as dist_cp
		from torch.distributed.checkpoint.default_planner import DefaultLoadPlanner, DefaultSavePlanner
		from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
		from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
		from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType


SCREAMING_SNAKE_CASE__     					=			get_logger(__name__)


def     lowercase	(    a     , a     , a     , a     , a=0 ):



		'''simple docstring'''




		os.makedirs(a     , exist_ok=a )
		with FSDP.state_dict_type(
		    a     , fsdp_plugin.state_dict_type     , fsdp_plugin.state_dict_config     , fsdp_plugin.optim_state_dict_config ):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						model.state_dict()
				if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
						SCREAMING_SNAKE_CASE_				:Optional[int]				     =						F"{MODEL_NAME}.bin" if model_index == 0 else F"{MODEL_NAME}_{model_index}.bin"
						SCREAMING_SNAKE_CASE_				:str				     =						os.path.join(a     , a )
						if accelerator.process_index == 0:
								logger.info(F"Saving model to {output_model_file}" )
								torch.save(a     , a )
								logger.info(F"Model saved to {output_model_file}" )
				elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
						SCREAMING_SNAKE_CASE_				:Tuple				     =						(
						    F"{MODEL_NAME}_rank{accelerator.process_index}.bin"
						    if model_index == 0
						    else F"{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin"
						)
						SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						os.path.join(a     , a )
						logger.info(F"Saving model to {output_model_file}" )
						torch.save(a     , a )
						logger.info(F"Model saved to {output_model_file}" )
				elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
						SCREAMING_SNAKE_CASE_				:Dict				     =						os.path.join(a     , F"{MODEL_NAME}_{model_index}" )
						os.makedirs(a     , exist_ok=a )
						logger.info(F"Saving model to {ckpt_dir}" )
						SCREAMING_SNAKE_CASE_				:int				     =						{"model": state_dict}

						dist_cp.save_state_dict(
						    state_dict=a     , storage_writer=dist_cp.FileSystemWriter(a )     , planner=DefaultSavePlanner()     , )
						logger.info(F"Model saved to {ckpt_dir}" )


def     lowercase	(    a     , a     , a     , a     , a=0 ):



		'''simple docstring'''




		accelerator.wait_for_everyone()
		with FSDP.state_dict_type(
		    a     , fsdp_plugin.state_dict_type     , fsdp_plugin.state_dict_config     , fsdp_plugin.optim_state_dict_config ):
				if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
						if type(a ) != FSDP and accelerator.process_index != 0:
								if not fsdp_plugin.sync_module_states:
										raise ValueError(
										    "Set the `sync_module_states` flag to `True` so that model states are synced across processes when "
										    "initializing FSDP object" )
								return
						SCREAMING_SNAKE_CASE_				:List[Any]				     =						F"{MODEL_NAME}.bin" if model_index == 0 else F"{MODEL_NAME}_{model_index}.bin"
						SCREAMING_SNAKE_CASE_				:int				     =						os.path.join(a     , a )
						logger.info(F"Loading model from {input_model_file}" )
						SCREAMING_SNAKE_CASE_				:Dict				     =						torch.load(a )
						logger.info(F"Model loaded from {input_model_file}" )
				elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
						SCREAMING_SNAKE_CASE_				:int				     =						(
						    F"{MODEL_NAME}_rank{accelerator.process_index}.bin"
						    if model_index == 0
						    else F"{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin"
						)
						SCREAMING_SNAKE_CASE_				:int				     =						os.path.join(a     , a )
						logger.info(F"Loading model from {input_model_file}" )
						SCREAMING_SNAKE_CASE_				:Dict				     =						torch.load(a )
						logger.info(F"Model loaded from {input_model_file}" )
				elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
						SCREAMING_SNAKE_CASE_				:List[str]				     =						(
						    os.path.join(a     , F"{MODEL_NAME}_{model_index}" )
						    if F"{MODEL_NAME}" not in input_dir
						    else input_dir
						)
						logger.info(F"Loading model from {ckpt_dir}" )
						SCREAMING_SNAKE_CASE_				:Any				     =						{"model": model.state_dict()}
						dist_cp.load_state_dict(
						    state_dict=a     , storage_reader=dist_cp.FileSystemReader(a )     , planner=DefaultLoadPlanner()     , )
						SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						state_dict["model"]
						logger.info(F"Model loaded from {ckpt_dir}" )
				model.load_state_dict(a )


def     lowercase	(    a     , a     , a     , a     , a     , a=0 ):



		'''simple docstring'''




		os.makedirs(a     , exist_ok=a )
		with FSDP.state_dict_type(
		    a     , fsdp_plugin.state_dict_type     , fsdp_plugin.state_dict_config     , fsdp_plugin.optim_state_dict_config ):
				SCREAMING_SNAKE_CASE_				:str				     =						FSDP.optim_state_dict(a     , a )
				if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
						if accelerator.process_index == 0:
								SCREAMING_SNAKE_CASE_				:List[str]				     =						(
								    F"{OPTIMIZER_NAME}.bin" if optimizer_index == 0 else F"{OPTIMIZER_NAME}_{optimizer_index}.bin"
								)
								SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						os.path.join(a     , a )
								logger.info(F"Saving Optimizer state to {output_optimizer_file}" )
								torch.save(a     , a )
								logger.info(F"Optimizer state saved in {output_optimizer_file}" )
				else:
						SCREAMING_SNAKE_CASE_				:Any				     =						os.path.join(a     , F"{OPTIMIZER_NAME}_{optimizer_index}" )
						os.makedirs(a     , exist_ok=a )
						logger.info(F"Saving Optimizer state to {ckpt_dir}" )
						dist_cp.save_state_dict(
						    state_dict={"optimizer": optim_state}     , storage_writer=dist_cp.FileSystemWriter(a )     , planner=DefaultSavePlanner()     , )
						logger.info(F"Optimizer state saved in {ckpt_dir}" )


def     lowercase	(    a     , a     , a     , a     , a     , a=0 ):



		'''simple docstring'''




		accelerator.wait_for_everyone()
		with FSDP.state_dict_type(
		    a     , fsdp_plugin.state_dict_type     , fsdp_plugin.state_dict_config     , fsdp_plugin.optim_state_dict_config ):
				if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
						SCREAMING_SNAKE_CASE_				:List[str]				     =						None
						# below check should work but currently it isn't working (mostly opytorch issue),
						# in the meantime disabling it at the cost of excess memory usage
						# if accelerator.process_index == 0 or not fsdp_plugin.optim_state_dict_config.rank0_only:
						SCREAMING_SNAKE_CASE_				:List[Any]				     =						(
						    F"{OPTIMIZER_NAME}.bin" if optimizer_index == 0 else F"{OPTIMIZER_NAME}_{optimizer_index}.bin"
						)
						SCREAMING_SNAKE_CASE_				:Dict				     =						os.path.join(a     , a )
						logger.info(F"Loading Optimizer state from {input_optimizer_file}" )
						SCREAMING_SNAKE_CASE_				:str				     =						torch.load(a )
						logger.info(F"Optimizer state loaded from {input_optimizer_file}" )
				else:
						SCREAMING_SNAKE_CASE_				:Any				     =						(
						    os.path.join(a     , F"{OPTIMIZER_NAME}_{optimizer_index}" )
						    if F"{OPTIMIZER_NAME}" not in input_dir
						    else input_dir
						)
						logger.info(F"Loading Optimizer from {ckpt_dir}" )
						SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						load_sharded_optimizer_state_dict(
						    model_state_dict=model.state_dict()     , optimizer_key="optimizer"     , storage_reader=dist_cp.FileSystemReader(a )     , )
						SCREAMING_SNAKE_CASE_				:List[str]				     =						optim_state["optimizer"]
						logger.info(F"Optimizer loaded from {ckpt_dir}" )
				SCREAMING_SNAKE_CASE_				:int				     =						FSDP.optim_state_dict_to_load(a     , a     , a )
				optimizer.load_state_dict(a )






