



import argparse

import torch
from datasets import load_dataset
from donut import DonutModel

from transformers import (
    DonutImageProcessor,
    DonutProcessor,
    DonutSwinConfig,
    DonutSwinModel,
    MBartConfig,
    MBartForCausalLM,
    VisionEncoderDecoderModel,
    XLMRobertaTokenizerFast,
)






def  UpperCAmelCase__    (    lowercase__   ) ->      List[str]:
						__lowercase					=				model.config

						__lowercase					=				DonutSwinConfig(
						    image_size=original_config.input_size						,       patch_size=4						,       depths=original_config.encoder_layer						,       num_heads=[4, 8, 16, 32]						,       window_size=original_config.window_size						,       embed_dim=128						,       )
						__lowercase					=				MBartConfig(
						    is_decoder=lowercase__						,       is_encoder_decoder=lowercase__						,       add_cross_attention=lowercase__						,       decoder_layers=original_config.decoder_layer						,       max_position_embeddings=original_config.max_position_embeddings						,       vocab_size=len(
						        model.decoder.tokenizer   )						,       scale_embedding=lowercase__						,       add_final_layer_norm=lowercase__						,       )

						return encoder_config, decoder_config






def  UpperCAmelCase__    (    lowercase__   ) ->      int:
						if "encoder.model" in name:
												__lowercase					=				name.replace("""encoder.model"""						,       """encoder"""   )
						if "decoder.model" in name:
												__lowercase					=				name.replace("""decoder.model"""						,       """decoder"""   )
						if "patch_embed.proj" in name:
												__lowercase					=				name.replace("""patch_embed.proj"""						,       """embeddings.patch_embeddings.projection"""   )
						if "patch_embed.norm" in name:
												__lowercase					=				name.replace("""patch_embed.norm"""						,       """embeddings.norm"""   )
						if name.startswith("""encoder"""   ):
												if "layers" in name:
																		__lowercase					=				"""encoder.""" + name
												if "attn.proj" in name:
																		__lowercase					=				name.replace("""attn.proj"""						,       """attention.output.dense"""   )
												if "attn" in name and "mask" not in name:
																		__lowercase					=				name.replace("""attn"""						,       """attention.self"""   )
												if "norm1" in name:
																		__lowercase					=				name.replace("""norm1"""						,       """layernorm_before"""   )
												if "norm2" in name:
																		__lowercase					=				name.replace("""norm2"""						,       """layernorm_after"""   )
												if "mlp.fc1" in name:
																		__lowercase					=				name.replace("""mlp.fc1"""						,       """intermediate.dense"""   )
												if "mlp.fc2" in name:
																		__lowercase					=				name.replace("""mlp.fc2"""						,       """output.dense"""   )

												if name == "encoder.norm.weight":
																		__lowercase					=				"""encoder.layernorm.weight"""
												if name == "encoder.norm.bias":
																		__lowercase					=				"""encoder.layernorm.bias"""

						return name






def  UpperCAmelCase__    (    lowercase__						,       lowercase__   ) ->      Any:
						for key in orig_state_dict.copy().keys():
												__lowercase					=				orig_state_dict.pop(lowercase__   )

												if "qkv" in key:
																		__lowercase					=				key.split("""."""   )
																		__lowercase					=				int(key_split[3]   )
																		__lowercase					=				int(key_split[5]   )
																		__lowercase					=				model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

																		if "weight" in key:
																								__lowercase					=				val[:dim, :]
																								__lowercase					=				val[dim : dim * 2, :]
																								__lowercase					=				val[-dim:, :]
																		else:
																								__lowercase					=				val[:dim]
																								__lowercase					=				val[dim : dim * 2]
																								__lowercase					=				val[-dim:]
												elif "attn_mask" in key or key in ["encoder.model.norm.weight", "encoder.model.norm.bias"]:
																		# HuggingFace implementation doesn't use attn_mask buffer
																		# and model doesn't use final LayerNorms for the encoder
																		pass
												else:
																		__lowercase					=				val

						return orig_state_dict






def  UpperCAmelCase__    (    lowercase__						,       lowercase__=None						,       lowercase__=False   ) ->      List[Any]:
						# load original model
						__lowercase					=				DonutModel.from_pretrained(lowercase__   ).eval()

						# load HuggingFace model
						__lowercase	,			__lowercase					=				get_configs(lowercase__   )
						__lowercase					=				DonutSwinModel(lowercase__   )
						__lowercase					=				MBartForCausalLM(lowercase__   )
						__lowercase					=				VisionEncoderDecoderModel(encoder=lowercase__						,       decoder=lowercase__   )
						model.eval()

						__lowercase					=				original_model.state_dict()
						__lowercase					=				convert_state_dict(lowercase__						,       lowercase__   )
						model.load_state_dict(lowercase__   )

						# verify results on scanned document
						__lowercase					=				load_dataset("""hf-internal-testing/example-documents"""   )
						__lowercase					=				dataset["""test"""][0]["""image"""].convert("""RGB"""   )

						__lowercase					=				XLMRobertaTokenizerFast.from_pretrained(lowercase__						,       from_slow=lowercase__   )
						__lowercase					=				DonutImageProcessor(
						    do_align_long_axis=original_model.config.align_long_axis						,       size=original_model.config.input_size[::-1]   )
						__lowercase					=				DonutProcessor(lowercase__						,       lowercase__   )
						__lowercase					=				processor(lowercase__						,       return_tensors="""pt"""   ).pixel_values

						if model_name == "naver-clova-ix/donut-base-finetuned-docvqa":
												__lowercase					=				"""<s_docvqa><s_question>{user_input}</s_question><s_answer>"""
												__lowercase					=				"""When is the coffee break?"""
												__lowercase					=				task_prompt.replace("""{user_input}"""						,       lowercase__   )
						elif model_name == "naver-clova-ix/donut-base-finetuned-rvlcdip":
												__lowercase					=				"""<s_rvlcdip>"""
						elif model_name in [
						    "naver-clova-ix/donut-base-finetuned-cord-v1",
						    "naver-clova-ix/donut-base-finetuned-cord-v1-2560",
						]:
												__lowercase					=				"""<s_cord>"""
						elif model_name == "naver-clova-ix/donut-base-finetuned-cord-v2":
												__lowercase					=				"""s_cord-v2>"""
						elif model_name == "naver-clova-ix/donut-base-finetuned-zhtrainticket":
												__lowercase					=				"""<s_zhtrainticket>"""
						elif model_name in ["naver-clova-ix/donut-proto", "naver-clova-ix/donut-base"]:
												# use a random prompt
												__lowercase					=				"""hello world"""
						else:
												raise ValueError("""Model name not supported"""   )
						__lowercase					=				original_model.decoder.tokenizer(lowercase__						,       add_special_tokens=lowercase__						,       return_tensors="""pt"""   )[
						    """input_ids"""
						]

						__lowercase					=				original_model.encoder.model.patch_embed(lowercase__   )
						__lowercase	,			__lowercase					=				model.encoder.embeddings(lowercase__   )
						assert torch.allclose(lowercase__						,       lowercase__						,       atol=1E-3   )

						# verify encoder hidden states
						__lowercase					=				original_model.encoder(lowercase__   )
						__lowercase					=				model.encoder(lowercase__   ).last_hidden_state
						assert torch.allclose(lowercase__						,       lowercase__						,       atol=1E-2   )

						# verify decoder hidden states
						__lowercase					=				original_model(lowercase__						,       lowercase__						,       lowercase__   ).logits
						__lowercase					=				model(lowercase__						,       decoder_input_ids=lowercase__   ).logits
						assert torch.allclose(lowercase__						,       lowercase__						,       atol=1E-3   )
						print("""Looks ok!"""   )

						if pytorch_dump_folder_path is not None:
												print(F"Saving model and processor to {pytorch_dump_folder_path}"   )
												model.save_pretrained(lowercase__   )
												processor.save_pretrained(lowercase__   )

						if push_to_hub:
												model.push_to_hub("""nielsr/""" + model_name.split("""/"""   )[-1]						,       commit_message="""Update model"""   )
												processor.push_to_hub("""nielsr/""" + model_name.split("""/"""   )[-1]						,       commit_message="""Update model"""   )


if __name__ == "__main__":
			UpperCamelCase__ =						argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    "--model_name",
			    default="naver-clova-ix/donut-base-finetuned-docvqa",
			    required=False,
			    type=str,
			    help="Name of the original model you'd like to convert.",
			)
			parser.add_argument(
			    "--pytorch_dump_folder_path",
			    default=None,
			    required=False,
			    type=str,
			    help="Path to the output PyTorch model directory.",
			)
			parser.add_argument(
			    "--push_to_hub",
			    action="store_true",
			    help="Whether or not to push the converted model and processor to the 🤗 hub.",
			)

			UpperCamelCase__ =						parser.parse_args()
			convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)










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 			_lowerCAmelCase   ( _UpperCAmelCase    ,					_UpperCAmelCase    ,					unittest.TestCase			):






			"""simple docstring"""





			lowercase__      :  int      =			IFImgaImgSuperResolutionPipeline
			lowercase__      :  Optional[int]      =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
			lowercase__      :  Optional[int]      =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}			)
			lowercase__      :  Tuple      =			PipelineTesterMixin.required_optional_params - {"""latents"""}





			def 		snake_case__			(				self	:       Tuple   )						->					Any:
									"""simple docstring"""







									return self._get_superresolution_dummy_components()





			def 		snake_case__			(				self	:       List[str]			,     lowercase	:       Optional[int]			,     lowercase	:       Optional[Any]=0   )						->					Union[str, Any]:
									"""simple docstring"""







									if str(lowercase   ).startswith("""mps"""   ):
															__lowercase					=				torch.manual_seed(lowercase   )
									else:
															__lowercase					=				torch.Generator(device=lowercase   ).manual_seed(lowercase   )

									__lowercase					=				floats_tensor((1, 3, 32, 32)			,     rng=random.Random(lowercase   )   ).to(lowercase   )
									__lowercase					=				floats_tensor((1, 3, 16, 16)			,     rng=random.Random(lowercase   )   ).to(lowercase   )

									__lowercase					=				{
									    """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 		snake_case__			(				self	:       Optional[Any]   )						->					Tuple:
									"""simple docstring"""







									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )





			def 		snake_case__			(				self	:       List[Any]   )						->					Union[str, Any]:
									"""simple docstring"""







									self._test_save_load_optional_components()





			@unittest.skipIf(torch_device != """cuda"""			,     reason="""float16 requires CUDA"""   )
			def 		snake_case__			(				self	:       List[Any]   )						->					Dict:
									"""simple docstring"""







									super().test_save_load_floataa(expected_max_diff=1E-1   )





			def 		snake_case__			(				self	:       Dict   )						->					int:
									"""simple docstring"""







									self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )





			def 		snake_case__			(				self	:       Optional[Any]   )						->					int:
									"""simple docstring"""







									self._test_save_load_local()







			def 		snake_case__			(				self	:       Optional[int]   )						->					Optional[int]:
									"""simple docstring"""







									self._test_inference_batch_single_identical(
									    expected_max_diff=1E-2			,     )





