

'''simple docstring'''



import argparse
import collections
from pathlib import Path

import torch
from torch.serialization import default_restore_location

from transformers import BertConfig, DPRConfig, DPRContextEncoder, DPRQuestionEncoder, DPRReader


UpperCAmelCase				: Union[str, Any]         =  collections.namedtuple(
    'CheckpointState', ['model_dict', 'optimizer_dict', 'scheduler_dict', 'offset', 'epoch', 'encoder_params']
)







def      a__ (						a__		):




     """simple docstring"""


     print(F'Reading saved model from {model_file}'		)
     __SCREAMING_SNAKE_CASE						     =   torch.load(a__   ,					map_location=lambda a__   ,					a__		: default_restore_location(a__   ,					"""cpu"""		)		)
     return CheckpointState(**a__		)







class 		lowerCAmelCase__     :



 """simple docstring"""



 def __init__(	self      : Tuple      ,							__SCREAMING_SNAKE_CASE      : Path    )						->				Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   src_file
 def    UpperCAmelCase__	(	self      : List[Any]    )						->				List[Any]:


      """simple docstring"""




      raise NotImplementedError


 @staticmethod
 def    UpperCAmelCase__	(	__SCREAMING_SNAKE_CASE      : str      ,							*__SCREAMING_SNAKE_CASE      : Optional[int]      ,							**__SCREAMING_SNAKE_CASE      : List[str]    )						->				"DPRState":


      """simple docstring"""




      if comp_type.startswith("""c"""    ):
           return DPRContextEncoderState(*__SCREAMING_SNAKE_CASE      ,							**__SCREAMING_SNAKE_CASE    )
      if comp_type.startswith("""q"""    ):
           return DPRQuestionEncoderState(*__SCREAMING_SNAKE_CASE      ,							**__SCREAMING_SNAKE_CASE    )
      if comp_type.startswith("""r"""    ):
           return DPRReaderState(*__SCREAMING_SNAKE_CASE      ,							**__SCREAMING_SNAKE_CASE    )
      else:
           raise ValueError("""Component type must be either 'ctx_encoder', 'question_encoder' or 'reader'."""    )







class 		lowerCAmelCase__     (   a      ):



 """simple docstring"""



 def    UpperCAmelCase__	(	self      : int    )						->				str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   DPRContextEncoder(DPRConfig(**BertConfig.get_config_dict("""bert-base-uncased"""    )[0]    )    )
      print(f'Loading DPR biencoder from {self.src_file}'    )
      __SCREAMING_SNAKE_CASE						     =   load_states_from_checkpoint(self.src_file    )
      __SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE						     =   model.ctx_encoder, """ctx_model."""
      # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
      __SCREAMING_SNAKE_CASE						     =   {"""bert_model.embeddings.position_ids""": model.ctx_encoder.bert_model.embeddings.position_ids}
      for key, value in saved_state.model_dict.items():
           if key.startswith(__SCREAMING_SNAKE_CASE    ):
                __SCREAMING_SNAKE_CASE						     =   key[len(__SCREAMING_SNAKE_CASE    ) :]
                if not key.startswith("""encode_proj."""    ):
                     __SCREAMING_SNAKE_CASE						     =   """bert_model.""" + key
                __SCREAMING_SNAKE_CASE						     =   value
      encoder.load_state_dict(__SCREAMING_SNAKE_CASE    )
      return model







class 		lowerCAmelCase__     (   a      ):



 """simple docstring"""



 def    UpperCAmelCase__	(	self      : Any    )						->				Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   DPRQuestionEncoder(DPRConfig(**BertConfig.get_config_dict("""bert-base-uncased"""    )[0]    )    )
      print(f'Loading DPR biencoder from {self.src_file}'    )
      __SCREAMING_SNAKE_CASE						     =   load_states_from_checkpoint(self.src_file    )
      __SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE						     =   model.question_encoder, """question_model."""
      # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
      __SCREAMING_SNAKE_CASE						     =   {"""bert_model.embeddings.position_ids""": model.question_encoder.bert_model.embeddings.position_ids}
      for key, value in saved_state.model_dict.items():
           if key.startswith(__SCREAMING_SNAKE_CASE    ):
                __SCREAMING_SNAKE_CASE						     =   key[len(__SCREAMING_SNAKE_CASE    ) :]
                if not key.startswith("""encode_proj."""    ):
                     __SCREAMING_SNAKE_CASE						     =   """bert_model.""" + key
                __SCREAMING_SNAKE_CASE						     =   value
      encoder.load_state_dict(__SCREAMING_SNAKE_CASE    )
      return model







class 		lowerCAmelCase__     (   a      ):



 """simple docstring"""



 def    UpperCAmelCase__	(	self      : Tuple    )						->				Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   DPRReader(DPRConfig(**BertConfig.get_config_dict("""bert-base-uncased"""    )[0]    )    )
      print(f'Loading DPR reader from {self.src_file}'    )
      __SCREAMING_SNAKE_CASE						     =   load_states_from_checkpoint(self.src_file    )
      # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
      __SCREAMING_SNAKE_CASE						     =   {
          """encoder.bert_model.embeddings.position_ids""": model.span_predictor.encoder.bert_model.embeddings.position_ids
      }
      for key, value in saved_state.model_dict.items():
           if key.startswith("""encoder."""    ) and not key.startswith("""encoder.encode_proj"""    ):
                __SCREAMING_SNAKE_CASE						     =   """encoder.bert_model.""" + key[len("""encoder."""    ) :]
           __SCREAMING_SNAKE_CASE						     =   value
      model.span_predictor.load_state_dict(__SCREAMING_SNAKE_CASE    )
      return model







def      a__ (						a__   ,					a__   ,					a__		):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE						     =   Path(a__		)
     dest_dir.mkdir(exist_ok=a__		)

     __SCREAMING_SNAKE_CASE						     =   DPRState.from_type(a__   ,					src_file=a__		)
     __SCREAMING_SNAKE_CASE						     =   dpr_state.load_dpr_model()
     model.save_pretrained(a__		)
     model.from_pretrained(a__		)  # sanity check


if __name__ == "__main__":
  UpperCAmelCase				: Any         =  argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '--type', type=str, help='Type of the component to convert: \'ctx_encoder\', \'question_encoder\' or \'reader\'.'
  )
  parser.add_argument(
      '--src',
      type=str,
      help=(
          'Path to the dpr checkpoint file. They can be downloaded from the official DPR repo'
          ' https://github.com/facebookresearch/DPR. Note that in the official repo, both encoders are stored in the'
          ' \'retriever\' checkpoints.'
      ),
  )
  parser.add_argument('--dest', type=str, default=None, help='Path to the output PyTorch model directory.')
  UpperCAmelCase				: List[str]         =  parser.parse_args()

  UpperCAmelCase				: Tuple         =  Path(args.src)
  UpperCAmelCase				: Any         =  f"""converted-{src_file.name}""" if args.dest is None else args.dest
  UpperCAmelCase				: Tuple         =  Path(dest_dir)
  assert src_file.exists()
  assert (
      args.type is not None
  ), "Please specify the component type of the DPR model to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
  convert(args.type, src_file, dest_dir)








'''simple docstring'''



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__ (						a__   ,					a__		):




     """simple docstring"""


     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 		lowerCAmelCase__     (   torch.optim.Optimizer      ):



 """simple docstring"""



 def __init__(	self      : Tuple      ,							__SCREAMING_SNAKE_CASE      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : Dict=True      ,							__SCREAMING_SNAKE_CASE      : List[Any]=None    )						->				str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   optimizer
      __SCREAMING_SNAKE_CASE						     =   scaler
      __SCREAMING_SNAKE_CASE						     =   AcceleratorState()
      __SCREAMING_SNAKE_CASE						     =   GradientState()
      __SCREAMING_SNAKE_CASE						     =   device_placement
      __SCREAMING_SNAKE_CASE						     =   False
      __SCREAMING_SNAKE_CASE						     =   None

      # Handle device placement
      if device_placement:
           __SCREAMING_SNAKE_CASE						     =   self.optimizer.state_dict()
           if self.accelerator_state.distributed_type == DistributedType.TPU:
                xm.send_cpu_data_to_device(__SCREAMING_SNAKE_CASE      ,							self.accelerator_state.device    )
           else:
                __SCREAMING_SNAKE_CASE						     =   move_to_device(__SCREAMING_SNAKE_CASE      ,							self.accelerator_state.device    )
           self.optimizer.load_state_dict(__SCREAMING_SNAKE_CASE    )
 @property
 def    UpperCAmelCase__	(	self      : str    )						->				Union[str, Any]:


      """simple docstring"""




      return self.optimizer.state
 @state.setter
 def    UpperCAmelCase__	(	self      : List[str]      ,							__SCREAMING_SNAKE_CASE      : Optional[Any]    )						->				List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   state
 @property
 def    UpperCAmelCase__	(	self      : Optional[int]    )						->				str:


      """simple docstring"""




      return self.optimizer.param_groups
 @param_groups.setter
 def    UpperCAmelCase__	(	self      : Dict      ,							__SCREAMING_SNAKE_CASE      : str    )						->				List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   param_groups
 @property
 def    UpperCAmelCase__	(	self      : List[Any]    )						->				Any:


      """simple docstring"""




      return self.optimizer.defaults
 @defaults.setter
 def    UpperCAmelCase__	(	self      : Any      ,							__SCREAMING_SNAKE_CASE      : Dict    )						->				Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE						     =   defaults
 def    UpperCAmelCase__	(	self      : Any      ,							__SCREAMING_SNAKE_CASE      : Any    )						->				List[str]:


      """simple docstring"""




      self.optimizer.add_param_group(__SCREAMING_SNAKE_CASE    )
 def    UpperCAmelCase__	(	self      : List[str]      ,							__SCREAMING_SNAKE_CASE      : List[str]    )						->				Dict:


      """simple docstring"""




      if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
           xm.send_cpu_data_to_device(__SCREAMING_SNAKE_CASE      ,							self.accelerator_state.device    )
      self.optimizer.load_state_dict(__SCREAMING_SNAKE_CASE    )
 def    UpperCAmelCase__	(	self      : Union[str, Any]    )						->				Union[str, Any]:


      """simple docstring"""




      return self.optimizer.state_dict()
 def    UpperCAmelCase__	(	self      : List[str]      ,							__SCREAMING_SNAKE_CASE      : List[str]=None    )						->				Any:


      """simple docstring"""




      if self.gradient_state.sync_gradients:
           __SCREAMING_SNAKE_CASE						     =   """set_to_none""" in inspect.signature(self.optimizer.zero_grad    ).parameters
           if accept_arg:
                if set_to_none is None:
                     __SCREAMING_SNAKE_CASE						     =   False
                self.optimizer.zero_grad(set_to_none=__SCREAMING_SNAKE_CASE    )
           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    UpperCAmelCase__	(	self      : List[str]      ,							__SCREAMING_SNAKE_CASE      : List[Any]=None    )						->				Dict:


      """simple docstring"""




      if self.gradient_state.sync_gradients:
           if self.accelerator_state.distributed_type == DistributedType.TPU:
                __SCREAMING_SNAKE_CASE						     =   {"""closure""": closure} if closure is not None else {}
                xm.optimizer_step(self.optimizer      ,							optimizer_args=__SCREAMING_SNAKE_CASE    )
           elif self.scaler is not None:
                __SCREAMING_SNAKE_CASE						     =   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
                     __SCREAMING_SNAKE_CASE						     =   self.scaler.get_scale()
                     __SCREAMING_SNAKE_CASE						     =   True
                self.scaler.step(self.optimizer      ,							__SCREAMING_SNAKE_CASE    )
                self.scaler.update()
                __SCREAMING_SNAKE_CASE						     =   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.
                     __SCREAMING_SNAKE_CASE						     =   scale_after < self._last_scale
                __SCREAMING_SNAKE_CASE						     =   scale_after

           else:
                self.optimizer.step(__SCREAMING_SNAKE_CASE    )
 def    UpperCAmelCase__	(	self      : Union[str, Any]      ,							__SCREAMING_SNAKE_CASE      : Any    )						->				Any:


      """simple docstring"""




      for param_group in self.optimizer.param_groups:
           __SCREAMING_SNAKE_CASE						     =   [parameters_map.get(__SCREAMING_SNAKE_CASE      ,							__SCREAMING_SNAKE_CASE    ) for p in param_group["""params"""]]
 @property
 def    UpperCAmelCase__	(	self      : int    )						->				Any:


      """simple docstring"""




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


      """simple docstring"""




      return self._is_overflow
 def __getstate__(	self      : Tuple    )						->				str:


      """simple docstring"""




      return self.__dict__.copy()


 def __setstate__(	self      : str      ,							__SCREAMING_SNAKE_CASE      : Optional[int]    )						->				Any:


      """simple docstring"""




      self.__dict__.update(__SCREAMING_SNAKE_CASE    )






