



"""simple docstring"""
import argparse

import pytorch_lightning as pl
import torch
from torch import nn

from transformers import LongformerForQuestionAnswering, LongformerModel
class 					a	(  pl.LightningModule       ):



  def __init__(						self :					List[Any]       ,		lowerCAmelCase :					List[str]		)     ->					Optional[Any]:


     '''simple docstring'''




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





  def 	lowerCamelCase__       (						self :					Optional[Any]		)     ->					Dict:


     '''simple docstring'''




     pass







def      __magic_name__				(							lowercase							,			lowercase							,			lowercase ):
   # load longformer model from model identifier
   SCREAMING_SNAKE_CASE_: Union[str, Any]     			=LongformerModel.from_pretrained(lowercase )
   SCREAMING_SNAKE_CASE_: Optional[Any]     			=LightningModel(lowercase )

   SCREAMING_SNAKE_CASE_: Union[str, Any]     			=torch.load(lowercase							,			map_location=torch.device("""cpu""" ) )
   lightning_model.load_state_dict(ckpt["""state_dict"""] )

   # init longformer question answering model
   SCREAMING_SNAKE_CASE_: int     			=LongformerForQuestionAnswering.from_pretrained(lowercase )

   # 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(lowercase )

   print(f'''Conversion successful. Model saved under {pytorch_dump_folder_path}''' )


if __name__ == "__main__":
   _UpperCAmelCase     =			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."""
   )
   _UpperCAmelCase     =			parser.parse_args()
   convert_longformer_qa_checkpoint_to_pytorch(
       args.longformer_model, args.longformer_question_answering_ckpt_path, args.pytorch_dump_folder_path
   )








"""simple docstring"""
def      __magic_name__				(							lowercase ):
   return str(lowercase ) == str(lowercase )[::-1]





def      __magic_name__				(							lowercase ):
   return int(lowercase ) + int(str(lowercase )[::-1] )





def      __magic_name__				(							lowercase = 1_0000 ):
   SCREAMING_SNAKE_CASE_: List[str]     			=[]
   for num in range(1							,			lowercase ):
      SCREAMING_SNAKE_CASE_: List[Any]     			=0
      SCREAMING_SNAKE_CASE_: int     			=num
      while iterations < 50:
         SCREAMING_SNAKE_CASE_: Optional[Any]     			=sum_reverse(lowercase )
         iterations += 1
         if is_palindrome(lowercase ):
            break
      else:
         lychrel_nums.append(lowercase )
   return len(lowercase )


if __name__ == "__main__":
   print(f"""{solution() = }""")



