
"""simple docstring"""
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						,    snake_case_     ):
						super().__init__()
						_snake_case     :						Optional[int]						=   model
						_snake_case     :						Optional[int]						=   2
						_snake_case     :						List[Any]						=   nn.Linear(self.model.config.hidden_size						,    self.num_labels     )


				def 					lowerCamelCase__	(    self     ):
						pass


def 				a__   (   a   :				str       ,     a   :				str       ,     a   :				str		):

		"""simple docstring"""







		_snake_case     :						List[str]						=   LongformerModel.from_pretrained(a		)
		_snake_case     :						Union[str, Any]						=   LightningModel(a		)

		_snake_case     :						Optional[Any]						=   torch.load(a       ,     map_location=torch.device("cpu"		)		)
		lightning_model.load_state_dict(ckpt["state_dict"]		)

		# init longformer question answering model
		_snake_case     :						Union[str, Any]						=   LongformerForQuestionAnswering.from_pretrained(a		)

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

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


if __name__ == "__main__":
				_a      :			List[Any]					=							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      :			Tuple					=							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 				a__   (   a   :				list       ,     a   :				int       ,     a   :				int = 0       ,     a   :				int = 0		):

  """simple docstring"""







  _snake_case     :						Optional[int]						=   right or len(a		) - 1
  if left > right:
    return -1
  elif list_data[left] == key:
    return left
  elif list_data[right] == key:
    return right
  else:
    return search(a       ,     a       ,     left + 1       ,     right - 1		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()

