"""simple docstring"""






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


__A			   = logging.get_logger(__name__)

__A			   = {
    "facebook/s2t-wav2vec2-large-en-de": (
        "https://huggingface.co/facebook/s2t-wav2vec2-large-en-de/resolve/main/config.json"
    ),
    # See all Speech2Text models at https://huggingface.co/models?filter=speech2text2
}


class     UpperCAmelCase						(__lowerCamelCase  ):



    """simple docstring"""

    _UpperCAmelCase	:List[str]						    = 'speech_to_text_2'
    _UpperCAmelCase	:Dict						    = ['past_key_values']
    _UpperCAmelCase	:Tuple						    = {'num_attention_heads': 'decoder_attention_heads', 'hidden_size': 'd_model'}






    def __init__(   self    ,			_UpperCAmelCase=10000    ,			_UpperCAmelCase=6    ,			_UpperCAmelCase=2048    ,			_UpperCAmelCase=4    ,			_UpperCAmelCase=0.0    ,			_UpperCAmelCase=True    ,			_UpperCAmelCase="relu"    ,			_UpperCAmelCase=256    ,			_UpperCAmelCase=0.1    ,			_UpperCAmelCase=0.0    ,			_UpperCAmelCase=0.0    ,			_UpperCAmelCase=0.02    ,			_UpperCAmelCase=2    ,			_UpperCAmelCase=True    ,			_UpperCAmelCase=1    ,			_UpperCAmelCase=0    ,			_UpperCAmelCase=2    ,			_UpperCAmelCase=1024    ,			**_UpperCAmelCase    ,			):
       lowercase__:   Tuple					=      vocab_size
       lowercase__:   Union[str, Any]					=      d_model
       lowercase__:   Any					=      decoder_ffn_dim
       lowercase__:   List[Any]					=      decoder_layers
       lowercase__:   int					=      decoder_attention_heads
       lowercase__:   str					=      dropout
       lowercase__:   int					=      attention_dropout
       lowercase__:   Optional[Any]					=      activation_dropout
       lowercase__:   List[Any]					=      activation_function
       lowercase__:   Optional[Any]					=      init_std
       lowercase__:   Dict					=      decoder_layerdrop
       lowercase__:   Any					=      use_cache
       lowercase__:   Optional[int]					=      decoder_layers
       lowercase__:   Optional[Any]					=      scale_embedding  # scale factor will be sqrt(d_model) if True
       lowercase__:   Dict					=      max_target_positions

       super().__init__(
           pad_token_id=UpperCamelCase_    ,			bos_token_id=UpperCamelCase_    ,			eos_token_id=UpperCamelCase_    ,			decoder_start_token_id=UpperCamelCase_    ,			**UpperCamelCase_    ,			)






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


UpperCAmelCase_									=	get_logger(__name__)




def 					lowerCamelCase__       (						A__       :					Union[str, Any]  ,			A__       :					str  ,			A__       :					Any  ,			A__       :					Dict  ,			A__       :					Any=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	):
              __lowerCamelCase   =						model.state_dict()
              if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
                     __lowerCamelCase   =						f'{MODEL_NAME}.bin' if model_index == 0 else f'{MODEL_NAME}_{model_index}.bin'
                     __lowerCamelCase   =						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:
                     __lowerCamelCase   =						(
                         f'{MODEL_NAME}_rank{accelerator.process_index}.bin'
                         if model_index == 0
                         else f'{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin'
                     )
                     __lowerCamelCase   =						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:
                     __lowerCamelCase   =						os.path.join(A__  ,			f'{MODEL_NAME}_{model_index}'	)
                     os.makedirs(A__  ,			exist_ok=A__	)
                     logger.info(f'Saving model to {ckpt_dir}'	)
                     __lowerCamelCase   =						{"""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 					lowerCamelCase__       (						A__       :					int  ,			A__       :					Dict  ,			A__       :					int  ,			A__       :					List[str]  ,			A__       :					Any=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
                     __lowerCamelCase   =						f'{MODEL_NAME}.bin' if model_index == 0 else f'{MODEL_NAME}_{model_index}.bin'
                     __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                     logger.info(f'Loading model from {input_model_file}'	)
                     __lowerCamelCase   =						torch.load(A__	)
                     logger.info(f'Model loaded from {input_model_file}'	)
              elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
                     __lowerCamelCase   =						(
                         f'{MODEL_NAME}_rank{accelerator.process_index}.bin'
                         if model_index == 0
                         else f'{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin'
                     )
                     __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                     logger.info(f'Loading model from {input_model_file}'	)
                     __lowerCamelCase   =						torch.load(A__	)
                     logger.info(f'Model loaded from {input_model_file}'	)
              elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
                     __lowerCamelCase   =						(
                         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}'	)
                     __lowerCamelCase   =						{"""model""": model.state_dict()}
                     dist_cp.load_state_dict(
                         state_dict=A__  ,			storage_reader=dist_cp.FileSystemReader(A__	)  ,			planner=DefaultLoadPlanner()  ,			)
                     __lowerCamelCase   =						state_dict["""model"""]
                     logger.info(f'Model loaded from {ckpt_dir}'	)
              model.load_state_dict(A__	)




def 					lowerCamelCase__       (						A__       :					List[str]  ,			A__       :					List[str]  ,			A__       :					str  ,			A__       :					Dict  ,			A__       :					Optional[Any]  ,			A__       :					Optional[int]=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	):
              __lowerCamelCase   =						FSDP.optim_state_dict(A__  ,			A__	)
              if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
                     if accelerator.process_index == 0:
                            __lowerCamelCase   =						(
                                f'{OPTIMIZER_NAME}.bin' if optimizer_index == 0 else f'{OPTIMIZER_NAME}_{optimizer_index}.bin'
                            )
                            __lowerCamelCase   =						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:
                     __lowerCamelCase   =						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 					lowerCamelCase__       (						A__       :					int  ,			A__       :					List[str]  ,			A__       :					int  ,			A__       :					Any  ,			A__       :					Union[str, Any]  ,			A__       :					List[Any]=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:
                     __lowerCamelCase   =						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:
                     __lowerCamelCase   =						(
                         f'{OPTIMIZER_NAME}.bin' if optimizer_index == 0 else f'{OPTIMIZER_NAME}_{optimizer_index}.bin'
                     )
                     __lowerCamelCase   =						os.path.join(A__  ,			A__	)
                     logger.info(f'Loading Optimizer state from {input_optimizer_file}'	)
                     __lowerCamelCase   =						torch.load(A__	)
                     logger.info(f'Optimizer state loaded from {input_optimizer_file}'	)
              else:
                     __lowerCamelCase   =						(
                         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}'	)
                     __lowerCamelCase   =						load_sharded_optimizer_state_dict(
                         model_state_dict=model.state_dict()  ,			optimizer_key="""optimizer"""  ,			storage_reader=dist_cp.FileSystemReader(A__	)  ,			)
                     __lowerCamelCase   =						optim_state["""optimizer"""]
                     logger.info(f'Optimizer loaded from {ckpt_dir}'	)
              __lowerCamelCase   =						FSDP.optim_state_dict_to_load(A__  ,			A__  ,			A__	)
              optimizer.load_state_dict(A__	)

