



import argparse

import pytorch_lightning as pl
import torch
from torch import nn

from transformers import LongformerForQuestionAnswering, LongformerModel



class 				snake_case__(pl.LightningModule      ):

					"""simple docstring"""






					def __init__(							self :     str				,       SCREAMING_SNAKE_CASE :     Optional[Any]					):
									super().__init__()
									lowercase__					:   Union[str, Any]													=					model
									lowercase__					:   Tuple													=					2
									lowercase__					:   List[str]													=					nn.Linear(self.model.config.hidden_size				,       self.num_labels					)







					def 			snake_case					(							self :     List[str]					):
									pass






def  __lowerCamelCase (       lowerCamelCase__					,			lowerCamelCase__					,			lowerCamelCase__						):

				"""simple docstring"""


				lowercase__					:   List[str]													=					LongformerModel.from_pretrained(_UpperCAmelCase						)
				lowercase__					:   int													=					LightningModel(_UpperCAmelCase						)

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

				# init longformer question answering model
				lowercase__					:   Any													=					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__":
				lowerCAmelCase__					  =  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.'''
				)
				lowerCAmelCase__					  =  parser.parse_args()
				convert_longformer_qa_checkpoint_to_pytorch(
				    args.longformer_model, args.longformer_question_answering_ckpt_path, args.pytorch_dump_folder_path
				)









from math import ceil, sqrt


def  __lowerCamelCase (       lowerCamelCase__ = 1_000_000						):

				"""simple docstring"""


				lowercase__					:   int													=					0

				for outer_width in range(3					,			(limit // 4) + 2						):
								if outer_width**2 > limit:
												lowercase__					:   List[str]													=					max(ceil(sqrt(outer_width**2 - limit						)						)					,			1						)
								else:
												lowercase__					:   List[str]													=					1
								if (outer_width - hole_width_lower_bound) % 2:
												hole_width_lower_bound += 1

								answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

				return answer


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




