


'''simple docstring'''



import argparse

import pytorch_lightning as pl
import torch
from torch import nn

from transformers import LongformerForQuestionAnswering, LongformerModel





class    UpperCAmelCase_  (pl.LightningModule  ):





    """simple docstring"""






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







    def       lowercase_				(							self	)				->     Union[str, Any]:
         pass







def 			UpperCAmelCase__					(	UpperCAmelCase_    :				str      ,    UpperCAmelCase_    :				str      ,    UpperCAmelCase_    :				str							)     ->		List[Any]:
     # load longformer model from model identifier
     __lowerCamelCase   :	Tuple								=		LongformerModel.from_pretrained(UpperCAmelCase_							)
     __lowerCamelCase   :	int								=		LightningModel(UpperCAmelCase_							)

     __lowerCamelCase   :	Union[str, Any]								=		torch.load(UpperCAmelCase_      ,    map_location=torch.device('cpu'							)							)
     lightning_model.load_state_dict(ckpt['state_dict']							)

     # init longformer question answering model
     __lowerCamelCase   :	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__":
      A__		:					Optional[int]												=  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__		:					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
      )










'''simple docstring'''



from math import isqrt



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				int							)     ->		bool:
     return all(number % divisor != 0 for divisor in range(2      ,    isqrt(UpperCAmelCase_							) + 1							)							)



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				int = 10**6							)     ->		int:
     __lowerCamelCase   :	Optional[Any]								=		0
     __lowerCamelCase   :	Optional[int]								=		1
     __lowerCamelCase   :	List[str]								=		7
     while prime_candidate < max_prime:
          primes_count += is_prime(UpperCAmelCase_							)

          cube_index += 1
          prime_candidate += 6 * cube_index

     return primes_count


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






