

import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    BertTokenizer,
    ViltConfig,
    ViltForImageAndTextRetrieval,
    ViltForImagesAndTextClassification,
    ViltForMaskedLM,
    ViltForQuestionAnswering,
    ViltImageProcessor,
    ViltProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
A											=     logging.get_logger(__name__)





def a(lowercase__			, lowercase__=False			, lowercase__=False			, lowercase__=False	):





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

	# embeddings
	rename_keys.extend(
	    [
	        # text embeddings
	        ('text_embeddings.word_embeddings.weight', 'vilt.embeddings.text_embeddings.word_embeddings.weight'),
	        (
	            'text_embeddings.position_embeddings.weight',
	            'vilt.embeddings.text_embeddings.position_embeddings.weight',
	        ),
	        ('text_embeddings.position_ids', 'vilt.embeddings.text_embeddings.position_ids'),
	        (
	            'text_embeddings.token_type_embeddings.weight',
	            'vilt.embeddings.text_embeddings.token_type_embeddings.weight',
	        ),
	        ('text_embeddings.LayerNorm.weight', 'vilt.embeddings.text_embeddings.LayerNorm.weight'),
	        ('text_embeddings.LayerNorm.bias', 'vilt.embeddings.text_embeddings.LayerNorm.bias'),
	        # patch embeddings
	        ('transformer.cls_token', 'vilt.embeddings.cls_token'),
	        ('transformer.patch_embed.proj.weight', 'vilt.embeddings.patch_embeddings.projection.weight'),
	        ('transformer.patch_embed.proj.bias', 'vilt.embeddings.patch_embeddings.projection.bias'),
	        ('transformer.pos_embed', 'vilt.embeddings.position_embeddings'),
	        # token type embeddings
	        ('token_type_embeddings.weight', 'vilt.embeddings.token_type_embeddings.weight'),
	    ]	)

	# final layernorm + pooler
	rename_keys.extend(
	    [
	        ('transformer.norm.weight', 'vilt.layernorm.weight'),
	        ('transformer.norm.bias', 'vilt.layernorm.bias'),
	        ('pooler.dense.weight', 'vilt.pooler.dense.weight'),
	        ('pooler.dense.bias', 'vilt.pooler.dense.bias'),
	    ]	)

	# classifier head(s)
	if vqa_model:
		# classification head
		rename_keys.extend(
		    [
		        ('vqa_classifier.0.weight', 'classifier.0.weight'),
		        ('vqa_classifier.0.bias', 'classifier.0.bias'),
		        ('vqa_classifier.1.weight', 'classifier.1.weight'),
		        ('vqa_classifier.1.bias', 'classifier.1.bias'),
		        ('vqa_classifier.3.weight', 'classifier.3.weight'),
		        ('vqa_classifier.3.bias', 'classifier.3.bias'),
		    ]	)
	elif nlvr_model:
		# classification head
		rename_keys.extend(
		    [
		        ('nlvr2_classifier.0.weight', 'classifier.0.weight'),
		        ('nlvr2_classifier.0.bias', 'classifier.0.bias'),
		        ('nlvr2_classifier.1.weight', 'classifier.1.weight'),
		        ('nlvr2_classifier.1.bias', 'classifier.1.bias'),
		        ('nlvr2_classifier.3.weight', 'classifier.3.weight'),
		        ('nlvr2_classifier.3.bias', 'classifier.3.bias'),
		    ]	)
	else:
		pass

	return rename_keys





def a(lowercase__			, lowercase__	):





	'''simple docstring'''
	for i in range(config.num_hidden_layers	):
		snake_case_      		= 'vilt.'
		# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
		snake_case_      		= state_dict.pop(f"""transformer.blocks.{i}.attn.qkv.weight"""	)
		snake_case_      		= state_dict.pop(f"""transformer.blocks.{i}.attn.qkv.bias"""	)
		# next, add query, keys and values (in that order) to the state dict
		snake_case_      		= in_proj_weight[
		    : config.hidden_size, :
		]
		snake_case_      		= in_proj_bias[: config.hidden_size]
		snake_case_      		= in_proj_weight[
		    config.hidden_size : config.hidden_size * 2, :
		]
		snake_case_      		= in_proj_bias[
		    config.hidden_size : config.hidden_size * 2
		]
		snake_case_      		= in_proj_weight[
		    -config.hidden_size :, :
		]
		snake_case_      		= in_proj_bias[-config.hidden_size :]





def a(lowercase__	):





	'''simple docstring'''
	snake_case_      		= ['head.weight', 'head.bias']
	for k in ignore_keys:
		state_dict.pop(lowercase__			, lowercase__	)





def a(lowercase__			, lowercase__			, lowercase__	):





	'''simple docstring'''
	snake_case_      		= dct.pop(lowercase__	)
	snake_case_      		= val





@torch.no_grad()
def a(lowercase__			, lowercase__	):





	'''simple docstring'''
	snake_case_      		= ViltConfig(image_size=384			, patch_size=32			, tie_word_embeddings=lowercase__	)
	snake_case_      		= False
	snake_case_      		= False
	snake_case_      		= False
	snake_case_      		= False
	if "vqa" in checkpoint_url:
		snake_case_      		= True
		snake_case_      		= 3129
		snake_case_      		= 'huggingface/label-files'
		snake_case_      		= 'vqa2-id2label.json'
		snake_case_      		= json.load(open(hf_hub_download(lowercase__			, lowercase__			, repo_type='dataset'	)			, 'r'	)	)
		snake_case_      		= {int(lowercase__	): v for k, v in idalabel.items()}
		snake_case_      		= idalabel
		snake_case_      		= {v: k for k, v in idalabel.items()}
		snake_case_      		= ViltForQuestionAnswering(lowercase__	)
	elif "nlvr" in checkpoint_url:
		snake_case_      		= True
		snake_case_      		= 2
		snake_case_      		= {0: 'False', 1: 'True'}
		snake_case_      		= {v: k for k, v in config.idalabel.items()}
		snake_case_      		= 3
		snake_case_      		= ViltForImagesAndTextClassification(lowercase__	)
	elif "irtr" in checkpoint_url:
		snake_case_      		= True
		snake_case_      		= ViltForImageAndTextRetrieval(lowercase__	)
	elif "mlm_itm" in checkpoint_url:
		snake_case_      		= True
		snake_case_      		= ViltForMaskedLM(lowercase__	)
	else:
		raise ValueError('Unknown model type'	)

	# load state_dict of original model, remove and rename some keys
	snake_case_      		= torch.hub.load_state_dict_from_url(lowercase__			, map_location='cpu'	)['state_dict']
	snake_case_      		= create_rename_keys(lowercase__			, lowercase__			, lowercase__			, lowercase__	)
	for src, dest in rename_keys:
		rename_key(lowercase__			, lowercase__			, lowercase__	)
	read_in_q_k_v(lowercase__			, lowercase__	)
	if mlm_model or irtr_model:
		snake_case_      		= ['itm_score.fc.weight', 'itm_score.fc.bias']
		for k in ignore_keys:
			state_dict.pop(lowercase__			, lowercase__	)

    # load state dict into HuggingFace model
	model.eval()
	if mlm_model:
		snake_case_		,       snake_case_      		= model.load_state_dict(lowercase__			, strict=lowercase__	)
		assert missing_keys == ["mlm_score.decoder.bias"]
	else:
		model.load_state_dict(lowercase__	)

	# Define processor
	snake_case_      		= ViltImageProcessor(size=384	)
	snake_case_      		= BertTokenizer.from_pretrained('bert-base-uncased'	)
	snake_case_      		= ViltProcessor(lowercase__			, lowercase__	)

	# Forward pass on example inputs (image + text)
	if nlvr_model:
		snake_case_      		= Image.open(requests.get('https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'			, stream=lowercase__	).raw	)
		snake_case_      		= Image.open(requests.get('https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'			, stream=lowercase__	).raw	)
		snake_case_      		= (
		    'The left image contains twice the number of dogs as the right image, and at least two dogs in total are'
		    ' standing.'
		)
		snake_case_      		= processor(lowercase__			, lowercase__			, return_tensors='pt'	)
		snake_case_      		= processor(lowercase__			, lowercase__			, return_tensors='pt'	)
		snake_case_      		= model(
		    input_ids=encoding_a.input_ids			, pixel_values=encoding_a.pixel_values			, pixel_values_a=encoding_a.pixel_values			, )
	else:
		snake_case_      		= Image.open(requests.get('http://images.cocodataset.org/val2017/000000039769.jpg'			, stream=lowercase__	).raw	)
		if mlm_model:
			snake_case_      		= 'a bunch of [MASK] laying on a [MASK].'
		else:
			snake_case_      		= 'How many cats are there?'
		snake_case_      		= processor(lowercase__			, lowercase__			, return_tensors='pt'	)
		snake_case_      		= model(**lowercase__	)

	# Verify outputs
	if mlm_model:
		snake_case_      		= torch.Size([1, 11, 30522]	)
		snake_case_      		= torch.tensor([-12.5061, -12.5123, -12.5174]	)
		assert outputs.logits.shape == expected_shape
		assert torch.allclose(outputs.logits[0, 0, :3]			, lowercase__			, atol=1e-4	)

		# verify masked token prediction equals "cats"
		snake_case_      		= outputs.logits[0, 4, :].argmax(-1	).item()
		assert tokenizer.decode([predicted_id]	) == "cats"
	elif vqa_model:
		snake_case_      		= torch.Size([1, 3129]	)
		snake_case_      		= torch.tensor([-15.9495, -18.1472, -10.3041]	)
		assert torch.allclose(outputs.logits[0, :3]			, lowercase__			, atol=1e-4	)
		assert outputs.logits.shape == expected_shape
		assert torch.allclose(outputs.logits[0, 0, :3]			, lowercase__			, atol=1e-4	)

		# verify vqa prediction equals "2"
		snake_case_      		= outputs.logits.argmax(-1	).item()
		assert model.config.idalabel[predicted_idx] == "2"
	elif nlvr_model:
		snake_case_      		= torch.Size([1, 2]	)
		snake_case_      		= torch.tensor([-2.8721, 2.1291]	)
		assert torch.allclose(outputs.logits[0, :3]			, lowercase__			, atol=1e-4	)
		assert outputs.logits.shape == expected_shape

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


if __name__ == "__main__":
		A											=     argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '--checkpoint_url',
		    default='https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt',
		    type=str,
		    help='URL of the checkpoint you\'d like to convert.',
		)
		parser.add_argument(
		    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
		)

		A											=     parser.parse_args()
		convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)



import argparse

import intel_extension_for_pytorch as ipex
import torch

from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline


A											=     argparse.ArgumentParser('Stable Diffusion script with intel optimization', add_help=False)
parser.add_argument('--dpm', action='store_true', help='Enable DPMSolver or not')
parser.add_argument('--steps', default=None, type=int, help='Num inference steps')
A											=     parser.parse_args()


A											=     'cpu'
A											=     'a lovely <dicoo> in red dress and hat, in the snowly and brightly night, with many brighly buildings'

A											=     'path-to-your-trained-model'
A											=     StableDiffusionPipeline.from_pretrained(model_id)
if args.dpm:
		A											=     DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
A											=     pipe.to(device)

# to channels last
A											=     pipe.unet.to(memory_format=torch.channels_last)
A											=     pipe.vae.to(memory_format=torch.channels_last)
A											=     pipe.text_encoder.to(memory_format=torch.channels_last)
if pipe.requires_safety_checker:
		A											=     pipe.safety_checker.to(memory_format=torch.channels_last)

# optimize with ipex
A											=     torch.randn(2, 4, 64, 64)
A											=     torch.rand(1) * 999
A											=     torch.randn(2, 77, 768)
A											=     (sample, timestep, encoder_hidden_status)
try:
		A											=     ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True, sample_input=input_example)
except Exception:
		A											=     ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True)
A											=     ipex.optimize(pipe.vae.eval(), dtype=torch.bfloataa, inplace=True)
A											=     ipex.optimize(pipe.text_encoder.eval(), dtype=torch.bfloataa, inplace=True)
if pipe.requires_safety_checker:
		A											=     ipex.optimize(pipe.safety_checker.eval(), dtype=torch.bfloataa, inplace=True)

# compute
A											=     666
A											=     torch.Generator(device).manual_seed(seed)
A											=     {'generator': generator}
if args.steps is not None:
		A											=     args.steps

with torch.cpu.amp.autocast(enabled=True, dtype=torch.bfloataa):
		A											=     pipe(prompt, **generate_kwargs).images[0]

# save image
image.save('generated.png')
