

"""simple docstring"""





import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment




def   _A  (  UpperCamelCase_     :       Dict,			UpperCamelCase_     :       Dict=(),			UpperCamelCase_     :       int=None,			UpperCamelCase_     :       List[str]="no",			UpperCamelCase_     :       int="29500")	->						Dict:
   '''simple docstring'''


   __lowercase								=						False
   __lowercase								=						False
   if any(key.startswith("KAGGLE") for key in os.environ.keys()):
      __lowercase								=						True
   elif "IPython" in sys.modules:
      __lowercase								=						"google.colab" in str(sys.modules["IPython"].get_ipython())

   try:
      __lowercase								=						PrecisionType(mixed_precision.lower())
   except ValueError:
      raise ValueError(
          F"""Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.""")

   if (in_colab or in_kaggle) and (os.environ.get("TPU_NAME",			UpperCamelCase_) is not None):
      # TPU launch
      import torch_xla.distributed.xla_multiprocessing as xmp

      if len(AcceleratorState._shared_state) > 0:
         raise ValueError(
             "To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside "
             "your training function. Restart your notebook and make sure no cells initializes an "
             "`Accelerator`.")
      if num_processes is None:
         __lowercase								=						8

      __lowercase								=						PrepareForLaunch(UpperCamelCase_,			distributed_type="TPU")
      print(F"""Launching a training on {num_processes} TPU cores.""")
      xmp.spawn(UpperCamelCase_,			args=UpperCamelCase_,			nprocs=UpperCamelCase_,			start_method="fork")
   elif in_colab:
      # No need for a distributed launch otherwise as it's either CPU or one GPU.
      if torch.cuda.is_available():
         print("Launching training on one GPU.")
      else:
         print("Launching training on one CPU.")
      function(*UpperCamelCase_)
   else:
      if num_processes is None:
         raise ValueError(
             "You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.")

      if num_processes > 1:
         # Multi-GPU launch
         from torch.multiprocessing import start_processes
         from torch.multiprocessing.spawn import ProcessRaisedException

         if len(AcceleratorState._shared_state) > 0:
            raise ValueError(
                "To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized "
                "inside your training function. Restart your notebook and make sure no cells initializes an "
                "`Accelerator`.")

         if torch.cuda.is_initialized():
            raise ValueError(
                "To launch a multi-GPU training from your notebook, you need to avoid running any instruction "
                "using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA "
                "function.")

         # torch.distributed will expect a few environment variable to be here. We set the ones common to each
         # process here (the other ones will be set be the launcher).
         with patch_environment(
             world_size=UpperCamelCase_,			master_addr="127.0.01",			master_port=UpperCamelCase_,			mixed_precision=UpperCamelCase_):
            __lowercase								=						PrepareForLaunch(UpperCamelCase_,			distributed_type="MULTI_GPU")
            print(F"""Launching training on {num_processes} GPUs.""")
            try:
               start_processes(UpperCamelCase_,			args=UpperCamelCase_,			nprocs=UpperCamelCase_,			start_method="fork")
            except ProcessRaisedException as e:
               if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
                  raise RuntimeError(
                      "CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. "
                      "This likely stems from an outside import causing issues once the `notebook_launcher()` is called. "
                      "Please review your imports and test them when running the `notebook_launcher()` to identify "
                      "which one is problematic.") from e

      else:
         # No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
         if is_mps_available():
            __lowercase								=						"1"
            print("Launching training on MPS.")
         elif torch.cuda.is_available():
            print("Launching training on one GPU.")
         else:
            print("Launching training on CPU.")
         function(*UpperCamelCase_)




def   _A  (  UpperCamelCase_     :       Optional[Any],			UpperCamelCase_     :       List[Any]=(),			UpperCamelCase_     :       Optional[int]=2)	->						Optional[Any]:
   '''simple docstring'''


   from torch.multiprocessing import start_processes

   with tempfile.NamedTemporaryFile() as tmp_file:
      # torch.distributed will expect a few environment variable to be here. We set the ones common to each
      # process here (the other ones will be set be the launcher).
      with patch_environment(
          world_size=UpperCamelCase_,			master_addr="127.0.01",			master_port="29500",			accelerate_mixed_precision="no",			accelerate_debug_rdv_file=tmp_file.name,			accelerate_use_cpu="yes",			):
         __lowercase								=						PrepareForLaunch(UpperCamelCase_,			debug=UpperCamelCase_)
         start_processes(UpperCamelCase_,			args=UpperCamelCase_,			nprocs=UpperCamelCase_,			start_method="fork")







"""simple docstring"""





import argparse

import pytorch_lightning as pl
import torch
from torch import nn

from transformers import LongformerForQuestionAnswering, LongformerModel




class 					_lowerCAmelCase  (	pl.LightningModule   ):







 """simple docstring"""







 def __init__(			self							:			Optional[Any],					UpperCAmelCase__							:			str	):
    super().__init__()
    __lowercase								=						model
    __lowercase								=						2
    __lowercase								=						nn.Linear(self.model.config.hidden_size,					self.num_labels	)



 def 					_lowercase (			self							:			Optional[int]	):
    pass







def   _A  (  UpperCamelCase_     :       str,			UpperCamelCase_     :       str,			UpperCamelCase_     :       str)	->						str:
   '''simple docstring'''


   __lowercase								=						LongformerModel.from_pretrained(UpperCamelCase_)
   __lowercase								=						LightningModel(UpperCamelCase_)

   __lowercase								=						torch.load(UpperCamelCase_,			map_location=torch.device("cpu"))
   lightning_model.load_state_dict(ckpt["state_dict"])

   # init longformer question answering model
   __lowercase								=						LongformerForQuestionAnswering.from_pretrained(UpperCamelCase_)

   # transfer weights
   longformer_for_qa.longformer.load_state_dict(lightning_model.model.state_dict())
   longformer_for_qa.qa_outputs.load_state_dict(lightning_model.qa_outputs.state_dict())
   longformer_for_qa.eval()

   # save model
   longformer_for_qa.save_pretrained(UpperCamelCase_)

   print(F"""Conversion successful. Model saved under {pytorch_dump_folder_path}""")


if __name__ == "__main__":
   _a       =							argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--longformer_model',
       default=None,
       type=str,
       required=True,
       help='model identifier of longformer. Should be either `longformer-base-4096` or `longformer-large-4096`.',
   )
   parser.add_argument(
       '--longformer_question_answering_ckpt_path',
       default=None,
       type=str,
       required=True,
       help='Path the official PyTorch Lightning Checkpoint.',
   )
   parser.add_argument(
       '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
   )
   _a       =							parser.parse_args()
   convert_longformer_qa_checkpoint_to_pytorch(
       args.longformer_model, args.longformer_question_answering_ckpt_path, args.pytorch_dump_folder_path
   )




