



'''simple docstring'''






import argparse

import pytorch_lightning as pl
import torch
from torch import nn

from transformers import LongformerForQuestionAnswering, LongformerModel

class        SCREAMING_SNAKE_CASE(							pl.LightningModule    ):







	"""simple docstring"""






	def __init__(		self    :  Any	,    __snake_case    :  Any	)    ->	Any:
								super().__init__()
								UpperCAmelCase				: Optional[int]											=	model
								UpperCAmelCase				: List[str]											=	2
								UpperCAmelCase				: Tuple											=	nn.Linear(self.model.config.hidden_size	,    self.num_labels	)







	def   A			(		self    :  List[str]	)    ->	Tuple:
								pass


def 				snake_case_  (      _lowerCAmelCase						:		str     ,   _lowerCAmelCase						:		str     ,   _lowerCAmelCase						:		str						)   ->     Tuple:

							'''simple docstring'''





							UpperCAmelCase				: List[Any]											=	LongformerModel.from_pretrained(_lowerCAmelCase						)
							UpperCAmelCase				: Optional[int]											=	LightningModel(_lowerCAmelCase						)

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

							# init longformer question answering model
							UpperCAmelCase				: Dict											=	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__:     str										=    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__:     Dict										=    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'''






UpperCamelCase__:     dict[tuple[int, int, int], int]										=    {}


def 				snake_case_  (      _lowerCAmelCase						:		int     ,   _lowerCAmelCase						:		int     ,   _lowerCAmelCase						:		int						)   ->     int:

							# if we are absent twice, or late 3 consecutive days,
							# no further prize strings are possible
							if late == 3 or absent == 2:
														return 0

							# if we have no days left, and have not failed any other rules,
							# we have a prize string
							if days == 0:
														return 1

							# No easy solution, so now we need to do the recursive calculation

							# First, check if the combination is already in the cache, and
							# if yes, return the stored value from there since we already
							# know the number of possible prize strings from this point on
							UpperCAmelCase				: List[Any]											=	(days, absent, late)
							if key in cache:
														return cache[key]

							# now we calculate the three possible ways that can unfold from
							# this point on, depending on our attendance today

							# 1) if we are late (but not absent), the "absent" counter stays as
							# it is, but the "late" counter increases by one
							UpperCAmelCase				: int											=	_calculate(days - 1     ,   _lowerCAmelCase     ,   late + 1						)

							# 2) if we are absent, the "absent" counter increases by 1, and the
							# "late" counter resets to 0
							UpperCAmelCase				: Optional[Any]											=	_calculate(days - 1     ,   absent + 1     ,   0						)

							# 3) if we are on time, this resets the "late" counter and keeps the
							# absent counter
							UpperCAmelCase				: Tuple											=	_calculate(days - 1     ,   _lowerCAmelCase     ,   0						)

							UpperCAmelCase				: str											=	state_late + state_absent + state_ontime

							UpperCAmelCase				: List[Any]											=	prizestrings
							return prizestrings


def 				snake_case_  (      _lowerCAmelCase						:		int = 30						)   ->     int:
							return _calculate(_lowerCAmelCase     ,   absent=0     ,   late=0						)


if __name__ == "__main__":
						print(solution())





