'''simple docstring'''


import argparse
import hashlib
import os
import urllib
import warnings

import torch
from torch import nn
from tqdm import tqdm

from transformers import WhisperConfig, WhisperForConditionalGeneration


__lowerCAmelCase	:       Optional[Any]						       =	{
    "tiny.en": "https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt",
    "tiny": "https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt",
    "base.en": "https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt",
    "base": "https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt",
    "small.en": "https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt",
    "small": "https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt",
    "medium.en": "https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt",
    "medium": "https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt",
    "large": "https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt",
    "large-v2": "https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt",
}





def       lowerCAmelCase					(		UpperCamelCase__				:   str       ):


	"""simple docstring"""
	__UpperCAmelCase							=			['''layers''', '''blocks''']
	for k in ignore_keys:
		state_dict.pop(UpperCamelCase__    ,					UpperCamelCase__       )


__lowerCAmelCase	:       Dict						       =	{
    "blocks": "layers",
    "mlp.0": "fc1",
    "mlp.2": "fc2",
    "mlp_ln": "final_layer_norm",
    ".attn.query": ".self_attn.q_proj",
    ".attn.key": ".self_attn.k_proj",
    ".attn.value": ".self_attn.v_proj",
    ".attn_ln": ".self_attn_layer_norm",
    ".attn.out": ".self_attn.out_proj",
    ".cross_attn.query": ".encoder_attn.q_proj",
    ".cross_attn.key": ".encoder_attn.k_proj",
    ".cross_attn.value": ".encoder_attn.v_proj",
    ".cross_attn_ln": ".encoder_attn_layer_norm",
    ".cross_attn.out": ".encoder_attn.out_proj",
    "decoder.ln.": "decoder.layer_norm.",
    "encoder.ln.": "encoder.layer_norm.",
    "token_embedding": "embed_tokens",
    "encoder.positional_embedding": "encoder.embed_positions.weight",
    "decoder.positional_embedding": "decoder.embed_positions.weight",
    "ln_post": "layer_norm",
}





def       lowerCAmelCase					(		UpperCamelCase__				:   int       ):


	"""simple docstring"""
	__UpperCAmelCase							=			list(s_dict.keys()       )
	for key in keys:
		__UpperCAmelCase							=			key
		for k, v in WHISPER_MAPPING.items():
			if k in key:
				__UpperCAmelCase							=			new_key.replace(UpperCamelCase__    ,					UpperCamelCase__       )

		print(f"""{key} -> {new_key}"""       )

		__UpperCAmelCase							=			s_dict.pop(UpperCamelCase__       )
	return s_dict





def       lowerCAmelCase					(		UpperCamelCase__				:   Tuple       ):


	"""simple docstring"""
	__UpperCAmelCase				,			__UpperCAmelCase							=			emb.weight.shape
	__UpperCAmelCase							=			nn.Linear(UpperCamelCase__    ,					UpperCamelCase__    ,					bias=UpperCamelCase__       )
	__UpperCAmelCase							=			emb.weight.data
	return lin_layer





def       lowerCAmelCase					(		UpperCamelCase__				:   str    ,					UpperCamelCase__				:   str       ):


	"""simple docstring"""
	os.makedirs(UpperCamelCase__    ,					exist_ok=UpperCamelCase__       )
	__UpperCAmelCase							=			os.path.basename(UpperCamelCase__       )

	__UpperCAmelCase							=			url.split('''/'''       )[-2]
	__UpperCAmelCase							=			os.path.join(UpperCamelCase__    ,					UpperCamelCase__       )

	if os.path.exists(UpperCamelCase__       ) and not os.path.isfile(UpperCamelCase__       ):
		raise RuntimeError(f"""{download_target} exists and is not a regular file"""       )

	if os.path.isfile(UpperCamelCase__       ):
		__UpperCAmelCase							=			open(UpperCamelCase__    ,					'''rb'''       ).read()
		if hashlib.shaaaa(UpperCamelCase__       ).hexdigest() == expected_shaaaa:
			return model_bytes
		else:
			warnings.warn(f"""{download_target} exists, but the SHA256 checksum does not match; re-downloading the file"""       )

	with urllib.request.urlopen(UpperCamelCase__       ) as source, open(UpperCamelCase__    ,					'''wb'''       ) as output:
		with tqdm(
		    total=int(source.info().get('''Content-Length'''       )       )    ,					ncols=8_0    ,					unit='''iB'''    ,					unit_scale=UpperCamelCase__    ,					unit_divisor=1_0_2_4       ) as loop:
			while True:
				__UpperCAmelCase							=			source.read(8_1_9_2       )
				if not buffer:
					break

				output.write(UpperCamelCase__       )
				loop.update(len(UpperCamelCase__       )       )

	__UpperCAmelCase							=			open(UpperCamelCase__    ,					'''rb'''       ).read()
	if hashlib.shaaaa(UpperCamelCase__       ).hexdigest() != expected_shaaaa:
		raise RuntimeError(
		    '''Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model.'''       )

	return model_bytes





def       lowerCAmelCase					(		UpperCamelCase__				:   List[Any]    ,					UpperCamelCase__				:   Dict       ):


	"""simple docstring"""
	if ".pt" not in checkpoint_path:
		__UpperCAmelCase							=			_download(_MODELS[checkpoint_path]       )
	else:
		__UpperCAmelCase							=			torch.load(UpperCamelCase__    ,					map_location='''cpu'''       )
	__UpperCAmelCase							=			original_checkpoint['''dims''']
	__UpperCAmelCase							=			original_checkpoint['''model_state_dict''']
	__UpperCAmelCase							=			state_dict['''decoder.token_embedding.weight''']
	remove_ignore_keys_(UpperCamelCase__       )
	rename_keys(UpperCamelCase__       )
	__UpperCAmelCase							=			True
	__UpperCAmelCase							=			state_dict['''decoder.layers.0.fc1.weight'''].shape[0]

	__UpperCAmelCase							=			WhisperConfig(
	    vocab_size=dimensions['''n_vocab''']    ,					encoder_ffn_dim=UpperCamelCase__    ,					decoder_ffn_dim=UpperCamelCase__    ,					num_mel_bins=dimensions['''n_mels''']    ,					d_model=dimensions['''n_audio_state''']    ,					max_target_positions=dimensions['''n_text_ctx''']    ,					encoder_layers=dimensions['''n_audio_layer''']    ,					encoder_attention_heads=dimensions['''n_audio_head''']    ,					decoder_layers=dimensions['''n_text_layer''']    ,					decoder_attention_heads=dimensions['''n_text_state''']    ,					max_source_positions=dimensions['''n_audio_ctx''']    ,					)

	__UpperCAmelCase							=			WhisperForConditionalGeneration(UpperCamelCase__       )
	__UpperCAmelCase				,			__UpperCAmelCase							=			model.model.load_state_dict(UpperCamelCase__    ,					strict=UpperCamelCase__       )
	if len(UpperCamelCase__       ) > 0 and not set(UpperCamelCase__       ) <= {
	    "encoder.embed_positions.weights",
	    "decoder.embed_positions.weights",
	}:
		raise ValueError(
		    '''Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,'''
		    f""" but all the following weights are missing {missing}"""       )

	if tie_embeds:
		__UpperCAmelCase							=			make_linear_from_emb(model.model.decoder.embed_tokens       )
	else:
		__UpperCAmelCase							=			proj_out_weights

	model.save_pretrained(UpperCamelCase__       )


if __name__ == "__main__":
					__lowerCAmelCase	:       List[str]						       =	argparse.ArgumentParser()
					# # Required parameters
					parser.add_argument("--checkpoint_path", type=str, help="Patht to the downloaded checkpoints")
					parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
					__lowerCAmelCase	:       Optional[Any]						       =	parser.parse_args()

					convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)

'''simple docstring'''


import argparse
from pathlib import Path

import requests
import torch
from PIL import Image

from transformers import (
    RobertaTokenizer,
    TrOCRConfig,
    TrOCRForCausalLM,
    TrOCRProcessor,
    VisionEncoderDecoderModel,
    ViTConfig,
    ViTImageProcessor,
    ViTModel,
)
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCAmelCase	:       Dict						       =	logging.get_logger(__name__)





def       lowerCAmelCase					(		UpperCamelCase__				:   Optional[Any]    ,					UpperCamelCase__				:   Union[str, Any]       ):


	"""simple docstring"""
	__UpperCAmelCase							=			[]
	for i in range(encoder_config.num_hidden_layers       ):
		# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
		rename_keys.append(
		    (f"""encoder.deit.blocks.{i}.norm1.weight""", f"""encoder.encoder.layer.{i}.layernorm_before.weight""")       )
		rename_keys.append((f"""encoder.deit.blocks.{i}.norm1.bias""", f"""encoder.encoder.layer.{i}.layernorm_before.bias""")       )
		rename_keys.append(
		    (f"""encoder.deit.blocks.{i}.attn.proj.weight""", f"""encoder.encoder.layer.{i}.attention.output.dense.weight""")       )
		rename_keys.append(
		    (f"""encoder.deit.blocks.{i}.attn.proj.bias""", f"""encoder.encoder.layer.{i}.attention.output.dense.bias""")       )
		rename_keys.append(
		    (f"""encoder.deit.blocks.{i}.norm2.weight""", f"""encoder.encoder.layer.{i}.layernorm_after.weight""")       )
		rename_keys.append((f"""encoder.deit.blocks.{i}.norm2.bias""", f"""encoder.encoder.layer.{i}.layernorm_after.bias""")       )
		rename_keys.append(
		    (f"""encoder.deit.blocks.{i}.mlp.fc1.weight""", f"""encoder.encoder.layer.{i}.intermediate.dense.weight""")       )
		rename_keys.append(
		    (f"""encoder.deit.blocks.{i}.mlp.fc1.bias""", f"""encoder.encoder.layer.{i}.intermediate.dense.bias""")       )
		rename_keys.append(
		    (f"""encoder.deit.blocks.{i}.mlp.fc2.weight""", f"""encoder.encoder.layer.{i}.output.dense.weight""")       )
		rename_keys.append((f"""encoder.deit.blocks.{i}.mlp.fc2.bias""", f"""encoder.encoder.layer.{i}.output.dense.bias""")       )

	# cls token, position embeddings and patch embeddings of encoder
	rename_keys.extend(
	    [
	        ('''encoder.deit.cls_token''', '''encoder.embeddings.cls_token'''),
	        ('''encoder.deit.pos_embed''', '''encoder.embeddings.position_embeddings'''),
	        ('''encoder.deit.patch_embed.proj.weight''', '''encoder.embeddings.patch_embeddings.projection.weight'''),
	        ('''encoder.deit.patch_embed.proj.bias''', '''encoder.embeddings.patch_embeddings.projection.bias'''),
	        ('''encoder.deit.norm.weight''', '''encoder.layernorm.weight'''),
	        ('''encoder.deit.norm.bias''', '''encoder.layernorm.bias'''),
	    ]       )

	return rename_keys





def       lowerCAmelCase					(		UpperCamelCase__				:   Optional[Any]    ,					UpperCamelCase__				:   List[Any]       ):


	"""simple docstring"""
	for i in range(encoder_config.num_hidden_layers       ):
		# queries, keys and values (only weights, no biases)
		__UpperCAmelCase							=			state_dict.pop(f"""encoder.deit.blocks.{i}.attn.qkv.weight"""       )

		__UpperCAmelCase							=			in_proj_weight[
		    : encoder_config.hidden_size, :
		]
		__UpperCAmelCase							=			in_proj_weight[
		    encoder_config.hidden_size : encoder_config.hidden_size * 2, :
		]
		__UpperCAmelCase							=			in_proj_weight[
		    -encoder_config.hidden_size :, :
		]





def       lowerCAmelCase					(		UpperCamelCase__				:   Any    ,					UpperCamelCase__				:   Optional[Any]    ,					UpperCamelCase__				:   List[str]       ):


	"""simple docstring"""
	__UpperCAmelCase							=			dct.pop(UpperCamelCase__       )
	__UpperCAmelCase							=			val





def       lowerCAmelCase					(		UpperCamelCase__				:   Dict       ):


	"""simple docstring"""
	if "handwritten" in checkpoint_url:
		__UpperCAmelCase							=			'''https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg'''  # industry
		# url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-12.jpg" # have
		# url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-10.jpg" # let
		# url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"  #
		# url = "https://fki.tic.heia-fr.ch/static/img/a01-122.jpg"
	elif "printed" in checkpoint_url or "stage1" in checkpoint_url:
		__UpperCAmelCase							=			'''https://www.researchgate.net/profile/Dinh-Sang/publication/338099565/figure/fig8/AS:840413229350922@1577381536857/An-receipt-example-in-the-SROIE-2019-dataset_Q640.jpg'''
	__UpperCAmelCase							=			Image.open(requests.get(UpperCamelCase__    ,					stream=UpperCamelCase__       ).raw       ).convert('''RGB'''       )
	return im





@torch.no_grad()
def       lowerCAmelCase					(		UpperCamelCase__				:   Dict    ,					UpperCamelCase__				:   Union[str, Any]       ):


	"""simple docstring"""
	__UpperCAmelCase							=			ViTConfig(image_size=3_8_4    ,					qkv_bias=UpperCamelCase__       )
	__UpperCAmelCase							=			TrOCRConfig()

	# size of the architecture
	if "base" in checkpoint_url:
		__UpperCAmelCase							=			7_6_8
	elif "large" in checkpoint_url:
		# use ViT-large encoder
		__UpperCAmelCase							=			1_0_2_4
		__UpperCAmelCase							=			4_0_9_6
		__UpperCAmelCase							=			2_4
		__UpperCAmelCase							=			1_6
		__UpperCAmelCase							=			1_0_2_4
	else:
		raise ValueError('''Should either find \'base\' or \'large\' in checkpoint URL'''       )

	# the large-printed + stage1 checkpoints uses sinusoidal position embeddings, no layernorm afterwards
	if "large-printed" in checkpoint_url or "stage1" in checkpoint_url:
		__UpperCAmelCase							=			False
		__UpperCAmelCase							=			'''relu'''
		__UpperCAmelCase							=			1_0_2_4
		__UpperCAmelCase							=			True
		__UpperCAmelCase							=			False
		__UpperCAmelCase							=			False

	# load HuggingFace model
	__UpperCAmelCase							=			ViTModel(UpperCamelCase__    ,					add_pooling_layer=UpperCamelCase__       )
	__UpperCAmelCase							=			TrOCRForCausalLM(UpperCamelCase__       )
	__UpperCAmelCase							=			VisionEncoderDecoderModel(encoder=UpperCamelCase__    ,					decoder=UpperCamelCase__       )
	model.eval()

	# load state_dict of original model, rename some keys
	__UpperCAmelCase							=			torch.hub.load_state_dict_from_url(UpperCamelCase__    ,					map_location='''cpu'''    ,					check_hash=UpperCamelCase__       )['''model''']

	__UpperCAmelCase							=			create_rename_keys(UpperCamelCase__    ,					UpperCamelCase__       )
	for src, dest in rename_keys:
		rename_key(UpperCamelCase__    ,					UpperCamelCase__    ,					UpperCamelCase__       )
	read_in_q_k_v(UpperCamelCase__    ,					UpperCamelCase__       )

	# remove parameters we don't need
	del state_dict["encoder.deit.head.weight"]
	del state_dict["encoder.deit.head.bias"]
	del state_dict["decoder.version"]

	# add prefix to decoder keys
	for key, val in state_dict.copy().items():
		__UpperCAmelCase							=			state_dict.pop(UpperCamelCase__       )
		if key.startswith('''decoder'''       ) and "output_projection" not in key:
			__UpperCAmelCase							=			val
		else:
			__UpperCAmelCase							=			val

    # load state dict
	model.load_state_dict(UpperCamelCase__       )

	# Check outputs on an image
	__UpperCAmelCase							=			ViTImageProcessor(size=encoder_config.image_size       )
	__UpperCAmelCase							=			RobertaTokenizer.from_pretrained('''roberta-large'''       )
	__UpperCAmelCase							=			TrOCRProcessor(UpperCamelCase__    ,					UpperCamelCase__       )

	__UpperCAmelCase							=			processor(images=prepare_img(UpperCamelCase__       )    ,					return_tensors='''pt'''       ).pixel_values

	# verify logits
	__UpperCAmelCase							=			torch.tensor([[model.config.decoder.decoder_start_token_id]]       )
	__UpperCAmelCase							=			model(pixel_values=UpperCamelCase__    ,					decoder_input_ids=UpperCamelCase__       )
	__UpperCAmelCase							=			outputs.logits

	__UpperCAmelCase							=			torch.Size([1, 1, 5_0_2_6_5]       )
	if "trocr-base-handwritten" in checkpoint_url:
		__UpperCAmelCase							=			torch.tensor(
		    [-1.45_02, -4.66_83, -0.53_47, -2.92_91, 9.14_35, -3.05_71, 8.97_64, 1.75_60, 8.73_58, -1.53_11]       )
	elif "trocr-large-handwritten" in checkpoint_url:
		__UpperCAmelCase							=			torch.tensor(
		    [-2.64_37, -1.31_29, -2.25_96, -5.34_55, 6.35_39, 1.76_04, 5.49_91, 1.47_02, 5.61_13, 2.01_70]       )
	elif "trocr-base-printed" in checkpoint_url:
		__UpperCAmelCase							=			torch.tensor(
		    [-5.68_16, -5.83_88, 1.13_98, -6.90_34, 6.85_05, -2.43_93, 1.22_84, -1.02_32, -1.96_61, -3.92_10]       )
	elif "trocr-large-printed" in checkpoint_url:
		__UpperCAmelCase							=			torch.tensor(
		    [-6.01_62, -7.09_59, 4.41_55, -5.10_63, 7.04_68, -3.16_31, 2.64_66, -0.30_81, -0.81_06, -1.75_35]       )

	if "stage1" not in checkpoint_url:
		assert logits.shape == expected_shape, "Shape of logits not as expected"
		assert torch.allclose(logits[0, 0, :1_0]    ,					UpperCamelCase__    ,					atol=1E-3       ), "First elements of logits not as expected"

	Path(UpperCamelCase__       ).mkdir(exist_ok=UpperCamelCase__       )
	print(f"""Saving model to {pytorch_dump_folder_path}"""       )
	model.save_pretrained(UpperCamelCase__       )
	print(f"""Saving processor to {pytorch_dump_folder_path}"""       )
	processor.save_pretrained(UpperCamelCase__       )


if __name__ == "__main__":
					__lowerCAmelCase	:       Any						       =	argparse.ArgumentParser()

					parser.add_argument(
					    "--checkpoint_url",
					    default="https://layoutlm.blob.core.windows.net/trocr/model_zoo/fairseq/trocr-base-handwritten.pt",
					    type=str,
					    help="URL to the original PyTorch checkpoint (.pth file).",
					)
					parser.add_argument(
					    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
					)
					__lowerCAmelCase	:       Optional[int]						       =	parser.parse_args()
					convert_tr_ocr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
