






import argparse

import pytorch_lightning as pl
import torch
from torch import nn

from transformers import LongformerForQuestionAnswering, LongformerModel


class 							__UpperCamelCase     (  pl.LightningModule ):







	def __init__(	self   :				Any							,					_lowerCAmelCase   :				Optional[Any]      )		->			Dict:
		"""simple docstring"""







		super().__init__()
		__lowercase   							=	model
		__lowercase   							=	2
		__lowercase   							=	nn.Linear(self.model.config.hidden_size							,					self.num_labels      )







	def 			_a (	self   :				int      )		->			List[str]:
		"""simple docstring"""







		pass





def 					snake_case	(  lowerCamelCase					,	lowerCamelCase					,	lowerCamelCase       ):




	'''simple docstring'''







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

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

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

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

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


if __name__ == "__main__":
						__UpperCamelCase   :   Dict      =    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   :   List[str]      =    parser.parse_args()
						convert_longformer_qa_checkpoint_to_pytorch(
						    args.longformer_model, args.longformer_question_answering_ckpt_path, args.pytorch_dump_folder_path
						)



def 		UpperCamelCase     (       _UpperCAmelCase  :   str  )   ->			bool:






						'''simple docstring'''

						_lowercase       :	List[str]           =   [int(_UpperCAmelCase  ) for i in ip_va_address.split("."  ) if i.isdigit()]
						return len(_UpperCAmelCase  ) == 4 and all(0 <= int(_UpperCAmelCase  ) <= 254 for octet in octets  )


if __name__ == "__main__":
							UpperCamelCase_						:     Dict	       =							input().strip()
							UpperCamelCase_						:     List[Any]	       =							"""valid""" if is_ip_va_address_valid(ip) else """invalid"""
							print(f'''{ip} is a {valid_or_invalid} IP v4 address.''')




