



import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



@skip_mps
class 				__snake_case						(     UpperCamelCase_						,UpperCamelCase_						,unittest.TestCase						):
							_a			      = IFImgaImgSuperResolutionPipeline
							_a			      = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
							_a			      = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}						)
							_a			      = PipelineTesterMixin.required_optional_params - {'''latents'''}




							def    UpperCAmelCase__			(       self     :       str):
									return self._get_superresolution_dummy_components()




							def    UpperCAmelCase__			(       self     :       str				,				A_     :       Any				,				A_     :       Optional[int]=0):
									if str(A_).startswith('''mps'''):
											lowerCAmelCase_			:     Dict									= torch.manual_seed(A_)
									else:
											lowerCAmelCase_			:     Optional[Any]									= torch.Generator(device=A_).manual_seed(A_)

									lowerCAmelCase_			:     Any									= floats_tensor((1, 3, 3_2, 3_2)				,				rng=random.Random(A_)).to(A_)
									lowerCAmelCase_			:     Optional[int]									= floats_tensor((1, 3, 1_6, 1_6)				,				rng=random.Random(A_)).to(A_)

									lowerCAmelCase_			:     Any									= {
									    '''prompt''': '''A painting of a squirrel eating a burger''',
									    '''image''': image,
									    '''original_image''': original_image,
									    '''generator''': generator,
									    '''num_inference_steps''': 2,
									    '''output_type''': '''numpy''',
									}

									return inputs




							@unittest.skipIf(
							    torch_device != '''cuda''' or not is_xformers_available()				,				reason='''XFormers attention is only available with CUDA and `xformers` installed'''				,				)
							def    UpperCAmelCase__			(       self     :       Tuple):
									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3)




							def    UpperCAmelCase__			(       self     :       List[Any]):
									self._test_save_load_optional_components()




							@unittest.skipIf(torch_device != '''cuda'''				,				reason='''float16 requires CUDA''')
							def    UpperCAmelCase__			(       self     :       Dict):
									# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
									super().test_save_load_floataa(expected_max_diff=1e-1)




							def    UpperCAmelCase__			(       self     :       str):
									self._test_attention_slicing_forward_pass(expected_max_diff=1e-2)




							def    UpperCAmelCase__			(       self     :       List[str]):
									self._test_save_load_local()







							def    UpperCAmelCase__			(       self     :       List[str]):
									self._test_inference_batch_single_identical(
									    expected_max_diff=1e-2				,				)







import argparse

import pytorch_lightning as pl
import torch
from torch import nn

from transformers import LongformerForQuestionAnswering, LongformerModel





class 	_lowerCAmelCase					(	pl.LightningModule       ):




				def __init__(					self				,				_UpperCamelCase     )				->      List[str]:
							super().__init__()
							lowerCAmelCase_						=	model
							lowerCAmelCase_						=	2
							lowerCAmelCase_						=	nn.Linear(self.model.config.hidden_size				,				self.num_labels     )




				def      __a						(					self     )				->      Tuple:
							pass






def    lowerCamelCase__				(				__lowerCAmelCase  :  str    ,							__lowerCAmelCase  :  str    ,							__lowerCAmelCase  :  str				):




			"""simple docstring"""


			lowerCAmelCase_						=	LongformerModel.from_pretrained(__lowerCAmelCase				)
			lowerCAmelCase_						=	LightningModel(__lowerCAmelCase				)

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

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



