


import argparse
import os

import gluonnlp as nlp
import mxnet as mx
import numpy as np
import torch
from gluonnlp.base import get_home_dir
from gluonnlp.model.bert import BERTEncoder
from gluonnlp.model.utils import _load_vocab
from gluonnlp.vocab import Vocab
from packaging import version
from torch import nn

from transformers import BertConfig, BertForMaskedLM, BertModel, RobertaTokenizer
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.utils import logging


if version.parse(nlp.__version__) != version.parse('''0.8.3'''):
		raise Exception('''requires gluonnlp == 0.8.3''')

if version.parse(mx.__version__) != version.parse('''1.5.0'''):
		raise Exception('''requires mxnet == 1.5.0''')

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

lowerCamelCase						=		'''The Nymphenburg Palace is a beautiful palace in Munich!'''






def 					lowerCamelCase_   (	_a     ,       _a	):




		"""simple docstring"""






		lowerCAmelCase__       :      List[str]   					= {
		    '''attention_cell''': '''multi_head''',
		    '''num_layers''': 4,
		    '''units''': 1_024,
		    '''hidden_size''': 768,
		    '''max_length''': 512,
		    '''num_heads''': 8,
		    '''scaled''': True,
		    '''dropout''': 0.1,
		    '''use_residual''': True,
		    '''embed_size''': 1_024,
		    '''embed_dropout''': 0.1,
		    '''word_embed''': None,
		    '''layer_norm_eps''': 1e-5,
		    '''token_type_vocab_size''': 2,
		}

		lowerCAmelCase__       :      int   					= bort_4_8_768_1024_hparams

		# Let's construct the original Bort model here
		# Taken from official BERT implementation, see:
		# https://github.com/alexa/bort/blob/master/bort/bort.py
		lowerCAmelCase__       :      List[Any]   					= BERTEncoder(
		    attention_cell=predefined_args['''attention_cell''']     ,       num_layers=predefined_args['''num_layers''']     ,       units=predefined_args['''units''']     ,       hidden_size=predefined_args['''hidden_size''']     ,       max_length=predefined_args['''max_length''']     ,       num_heads=predefined_args['''num_heads''']     ,       scaled=predefined_args['''scaled''']     ,       dropout=predefined_args['''dropout''']     ,       output_attention=_a     ,       output_all_encodings=_a     ,       use_residual=predefined_args['''use_residual''']     ,       activation=predefined_args.get('''activation'''     ,       '''gelu'''	)     ,       layer_norm_eps=predefined_args.get('''layer_norm_eps'''     ,       _a	)     ,       )

		# Vocab information needs to be fetched first
		# It's the same as RoBERTa, so RobertaTokenizer can be used later
		lowerCAmelCase__       :      Union[str, Any]   					= '''openwebtext_ccnews_stories_books_cased'''

		# Specify download folder to Gluonnlp's vocab
		lowerCAmelCase__       :      Optional[Any]   					= os.path.join(get_home_dir()     ,       '''models'''	)
		lowerCAmelCase__       :      Optional[int]   					= _load_vocab(_a     ,       _a     ,       _a     ,       cls=_a	)

		lowerCAmelCase__       :      Any   					= nlp.model.BERTModel(
		    _a     ,       len(_a	)     ,       units=predefined_args['''units''']     ,       embed_size=predefined_args['''embed_size''']     ,       embed_dropout=predefined_args['''embed_dropout''']     ,       word_embed=predefined_args['''word_embed''']     ,       use_pooler=_a     ,       use_token_type_embed=_a     ,       token_type_vocab_size=predefined_args['''token_type_vocab_size''']     ,       use_classifier=_a     ,       use_decoder=_a     ,       )

		original_bort.load_parameters(_a     ,       cast_dtype=_a     ,       ignore_extra=_a	)
		lowerCAmelCase__       :      Tuple   					= original_bort._collect_params_with_prefix()

		# Build our config 🤗
		lowerCAmelCase__       :      int   					= {
		    '''architectures''': ['''BertForMaskedLM'''],
		    '''attention_probs_dropout_prob''': predefined_args['''dropout'''],
		    '''hidden_act''': '''gelu''',
		    '''hidden_dropout_prob''': predefined_args['''dropout'''],
		    '''hidden_size''': predefined_args['''embed_size'''],
		    '''initializer_range''': 0.02,
		    '''intermediate_size''': predefined_args['''hidden_size'''],
		    '''layer_norm_eps''': predefined_args['''layer_norm_eps'''],
		    '''max_position_embeddings''': predefined_args['''max_length'''],
		    '''model_type''': '''bort''',
		    '''num_attention_heads''': predefined_args['''num_heads'''],
		    '''num_hidden_layers''': predefined_args['''num_layers'''],
		    '''pad_token_id''': 1,  # 2 = BERT, 1 = RoBERTa
		    '''type_vocab_size''': 1,  # 2 = BERT, 1 = RoBERTa
		    '''vocab_size''': len(_a	),
		}

		lowerCAmelCase__       :      str   					= BertConfig.from_dict(_a	)
		lowerCAmelCase__       :      Optional[Any]   					= BertForMaskedLM(_a	)
		hf_bort_model.eval()

		# Parameter mapping table (Gluonnlp to Transformers)
		# * denotes layer index
		#
		# | Gluon Parameter                                                | Transformers Parameter
		# | -------------------------------------------------------------- | ----------------------
		# | `encoder.layer_norm.beta`                                      | `bert.embeddings.LayerNorm.bias`
		# | `encoder.layer_norm.gamma`                                     | `bert.embeddings.LayerNorm.weight`
		# | `encoder.position_weight`                                      | `bert.embeddings.position_embeddings.weight`
		# | `word_embed.0.weight`                                          | `bert.embeddings.word_embeddings.weight`
		# | `encoder.transformer_cells.*.attention_cell.proj_key.bias`     | `bert.encoder.layer.*.attention.self.key.bias`
		# | `encoder.transformer_cells.*.attention_cell.proj_key.weight`   | `bert.encoder.layer.*.attention.self.key.weight`
		# | `encoder.transformer_cells.*.attention_cell.proj_query.bias`   | `bert.encoder.layer.*.attention.self.query.bias`
		# | `encoder.transformer_cells.*.attention_cell.proj_query.weight` | `bert.encoder.layer.*.attention.self.query.weight`
		# | `encoder.transformer_cells.*.attention_cell.proj_value.bias`   | `bert.encoder.layer.*.attention.self.value.bias`
		# | `encoder.transformer_cells.*.attention_cell.proj_value.weight` | `bert.encoder.layer.*.attention.self.value.weight`
		# | `encoder.transformer_cells.*.ffn.ffn_2.bias`                   | `bert.encoder.layer.*.attention.output.dense.bias`
		# | `encoder.transformer_cells.*.ffn.ffn_2.weight`                 | `bert.encoder.layer.*.attention.output.dense.weight`
		# | `encoder.transformer_cells.*.layer_norm.beta`                  | `bert.encoder.layer.*.attention.output.LayerNorm.bias`
		# | `encoder.transformer_cells.*.layer_norm.gamma`                 | `bert.encoder.layer.*.attention.output.LayerNorm.weight`
		# | `encoder.transformer_cells.*.ffn.ffn_1.bias`                   | `bert.encoder.layer.*.intermediate.dense.bias`
		# | `encoder.transformer_cells.*.ffn.ffn_1.weight`                 | `bert.encoder.layer.*.intermediate.dense.weight`
		# | `encoder.transformer_cells.*.ffn.layer_norm.beta`              | `bert.encoder.layer.*.output.LayerNorm.bias`
		# | `encoder.transformer_cells.*.ffn.layer_norm.gamma`             | `bert.encoder.layer.*.output.LayerNorm.weight`
		# | `encoder.transformer_cells.*.proj.bias`                        | `bert.encoder.layer.*.output.dense.bias`
		# | `encoder.transformer_cells.*.proj.weight`                      | `bert.encoder.layer.*.output.dense.weight`

		# Helper function to convert MXNET Arrays to PyTorch
		def to_torch(_a	) -> nn.Parameter:
				return nn.Parameter(torch.FloatTensor(mx_array.data().asnumpy()	)	)

		# Check param shapes and map new HF param back
		def check_and_map_params(_a     ,       _a	):
				lowerCAmelCase__       :      Dict   					= hf_param.shape

				lowerCAmelCase__       :      List[str]   					= to_torch(params[gluon_param]	)
				lowerCAmelCase__       :      Any   					= gluon_param.shape

				assert (
				    shape_hf == shape_gluon
				), f'The gluon parameter {gluon_param} has shape {shape_gluon}, but expects shape {shape_hf} for Transformers'

				return gluon_param

		lowerCAmelCase__       :      List[Any]   					= check_and_map_params(
		    hf_bort_model.bert.embeddings.word_embeddings.weight     ,       '''word_embed.0.weight'''	)
		lowerCAmelCase__       :      List[Any]   					= check_and_map_params(
		    hf_bort_model.bert.embeddings.position_embeddings.weight     ,       '''encoder.position_weight'''	)
		lowerCAmelCase__       :      Any   					= check_and_map_params(
		    hf_bort_model.bert.embeddings.LayerNorm.bias     ,       '''encoder.layer_norm.beta'''	)
		lowerCAmelCase__       :      Union[str, Any]   					= check_and_map_params(
		    hf_bort_model.bert.embeddings.LayerNorm.weight     ,       '''encoder.layer_norm.gamma'''	)

		# Inspired by RoBERTa conversion script, we just zero them out (Bort does not use them)
		lowerCAmelCase__       :      Union[str, Any]   					= torch.zeros_like(
		    hf_bort_model.bert.embeddings.token_type_embeddings.weight.data	)

		for i in range(hf_bort_config.num_hidden_layers	):
				lowerCAmelCase__       :      BertLayer   					= hf_bort_model.bert.encoder.layer[i]

				# self attention
				lowerCAmelCase__       :      BertSelfAttention   					= layer.attention.self

				lowerCAmelCase__       :      Optional[Any]   					= check_and_map_params(
				    self_attn.key.bias.data     ,       f'encoder.transformer_cells.{i}.attention_cell.proj_key.bias'	)

				lowerCAmelCase__       :      str   					= check_and_map_params(
				    self_attn.key.weight.data     ,       f'encoder.transformer_cells.{i}.attention_cell.proj_key.weight'	)
				lowerCAmelCase__       :      int   					= check_and_map_params(
				    self_attn.query.bias.data     ,       f'encoder.transformer_cells.{i}.attention_cell.proj_query.bias'	)
				lowerCAmelCase__       :      Optional[Any]   					= check_and_map_params(
				    self_attn.query.weight.data     ,       f'encoder.transformer_cells.{i}.attention_cell.proj_query.weight'	)
				lowerCAmelCase__       :      Any   					= check_and_map_params(
				    self_attn.value.bias.data     ,       f'encoder.transformer_cells.{i}.attention_cell.proj_value.bias'	)
				lowerCAmelCase__       :      Any   					= check_and_map_params(
				    self_attn.value.weight.data     ,       f'encoder.transformer_cells.{i}.attention_cell.proj_value.weight'	)

				# self attention output
				lowerCAmelCase__       :      BertSelfOutput   					= layer.attention.output

				lowerCAmelCase__       :      Dict   					= check_and_map_params(
				    self_output.dense.bias     ,       f'encoder.transformer_cells.{i}.proj.bias'	)
				lowerCAmelCase__       :      Optional[int]   					= check_and_map_params(
				    self_output.dense.weight     ,       f'encoder.transformer_cells.{i}.proj.weight'	)
				lowerCAmelCase__       :      int   					= check_and_map_params(
				    self_output.LayerNorm.bias     ,       f'encoder.transformer_cells.{i}.layer_norm.beta'	)
				lowerCAmelCase__       :      List[str]   					= check_and_map_params(
				    self_output.LayerNorm.weight     ,       f'encoder.transformer_cells.{i}.layer_norm.gamma'	)

				# intermediate
				lowerCAmelCase__       :      BertIntermediate   					= layer.intermediate

				lowerCAmelCase__       :      Union[str, Any]   					= check_and_map_params(
				    intermediate.dense.bias     ,       f'encoder.transformer_cells.{i}.ffn.ffn_1.bias'	)
				lowerCAmelCase__       :      Union[str, Any]   					= check_and_map_params(
				    intermediate.dense.weight     ,       f'encoder.transformer_cells.{i}.ffn.ffn_1.weight'	)

				# output
				lowerCAmelCase__       :      BertOutput   					= layer.output

				lowerCAmelCase__       :      Optional[int]   					= check_and_map_params(
				    bert_output.dense.bias     ,       f'encoder.transformer_cells.{i}.ffn.ffn_2.bias'	)
				lowerCAmelCase__       :      int   					= check_and_map_params(
				    bert_output.dense.weight     ,       f'encoder.transformer_cells.{i}.ffn.ffn_2.weight'	)
				lowerCAmelCase__       :      Optional[int]   					= check_and_map_params(
				    bert_output.LayerNorm.bias     ,       f'encoder.transformer_cells.{i}.ffn.layer_norm.beta'	)
				lowerCAmelCase__       :      List[str]   					= check_and_map_params(
				    bert_output.LayerNorm.weight     ,       f'encoder.transformer_cells.{i}.ffn.layer_norm.gamma'	)

		# Save space and energy 🎄
		hf_bort_model.half()

		# Compare output of both models
		lowerCAmelCase__       :      Dict   					= RobertaTokenizer.from_pretrained('''roberta-base'''	)

		lowerCAmelCase__       :      List[str]   					= tokenizer.encode_plus(_a	)['''input_ids''']

		# Get gluon output
		lowerCAmelCase__       :      str   					= mx.nd.array([input_ids]	)
		lowerCAmelCase__       :      List[str]   					= original_bort(inputs=_a     ,       token_types=[]	)

		# Get Transformer output (save and reload model again)
		hf_bort_model.save_pretrained(_a	)
		lowerCAmelCase__       :      Optional[int]   					= BertModel.from_pretrained(_a	)
		hf_bort_model.eval()

		lowerCAmelCase__       :      Tuple   					= tokenizer.encode_plus(_a     ,       return_tensors='''pt'''	)
		lowerCAmelCase__       :      Optional[Any]   					= hf_bort_model(**_a	)[0]

		lowerCAmelCase__       :      str   					= output_gluon[0].asnumpy()
		lowerCAmelCase__       :      Optional[Any]   					= output_hf[0].detach().numpy()

		lowerCAmelCase__       :      str   					= np.max(np.abs(hf_layer - gluon_layer	)	).item()
		lowerCAmelCase__       :      int   					= np.allclose(_a     ,       _a     ,       atol=1e-3	)

		if success:
				print('''✔️ Both model do output the same tensors'''	)
		else:
				print('''❌ Both model do **NOT** output the same tensors'''	)
				print('''Absolute difference is:'''     ,       _a	)


if __name__ == "__main__":
		lowerCamelCase						=		argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--bort_checkpoint_path''', default=None, type=str, required=True, help='''Path the official Bort params file.'''
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
		)
		lowerCamelCase						=		parser.parse_args()
		convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)








import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


lowerCamelCase						=		False





class  _a							(    unittest.TestCase):
	pass





@nightly
@require_torch_gpu
class  _a							(    unittest.TestCase):




	def 							UpperCAmelCase__( self						:		int		)->	int:
			# clean up the VRAM after each test
			super().tearDown()
			gc.collect()
			torch.cuda.empty_cache()




	def 							UpperCAmelCase__( self						:		Any		)->	Dict:
			lowerCAmelCase__       :      int   					= VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''		, torch_dtype=torch.floataa		)
			pipe.to(_SCREAMING_SNAKE_CASE		)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      List[str]   					= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''		)

			lowerCAmelCase__       :      List[str]   					= torch.manual_seed(0		)
			lowerCAmelCase__       :      List[str]   					= pipe.dual_guided(
			    prompt='''first prompt'''		, image=_SCREAMING_SNAKE_CASE		, text_to_image_strength=0.75		, generator=_SCREAMING_SNAKE_CASE		, guidance_scale=7.5		, num_inference_steps=2		, output_type='''numpy'''		, ).images

			with tempfile.TemporaryDirectory() as tmpdirname:
					pipe.save_pretrained(_SCREAMING_SNAKE_CASE		)
					lowerCAmelCase__       :      List[Any]   					= VersatileDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE		, torch_dtype=torch.floataa		)
			pipe.to(_SCREAMING_SNAKE_CASE		)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      List[str]   					= generator.manual_seed(0		)
			lowerCAmelCase__       :      str   					= pipe.dual_guided(
			    prompt='''first prompt'''		, image=_SCREAMING_SNAKE_CASE		, text_to_image_strength=0.75		, generator=_SCREAMING_SNAKE_CASE		, guidance_scale=7.5		, num_inference_steps=2		, output_type='''numpy'''		, ).images

			assert np.abs(image - new_image		).sum() < 1E-5, "Models don't have the same forward pass"




	def 							UpperCAmelCase__( self						:		Tuple		)->	List[Any]:
			lowerCAmelCase__       :      Optional[int]   					= VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''		, torch_dtype=torch.floataa		)
			pipe.to(_SCREAMING_SNAKE_CASE		)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      int   					= '''cyberpunk 2077'''
			lowerCAmelCase__       :      List[str]   					= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''		)
			lowerCAmelCase__       :      List[Any]   					= torch.manual_seed(0		)
			lowerCAmelCase__       :      Union[str, Any]   					= pipe.dual_guided(
			    prompt=_SCREAMING_SNAKE_CASE		, image=_SCREAMING_SNAKE_CASE		, text_to_image_strength=0.75		, generator=_SCREAMING_SNAKE_CASE		, guidance_scale=7.5		, num_inference_steps=50		, output_type='''numpy'''		, ).images

			lowerCAmelCase__       :      List[Any]   					= image[0, 253:256, 253:256, -1]

			assert image.shape == (1, 512, 512, 3)
			lowerCAmelCase__       :      List[str]   					= np.array([0.1448, 0.1619, 0.1741, 0.1086, 0.1147, 0.1128, 0.1199, 0.1165, 0.1001]		)

			assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-1

			lowerCAmelCase__       :      int   					= '''A painting of a squirrel eating a burger '''
			lowerCAmelCase__       :      Optional[Any]   					= torch.manual_seed(0		)
			lowerCAmelCase__       :      Union[str, Any]   					= pipe.text_to_image(
			    prompt=_SCREAMING_SNAKE_CASE		, generator=_SCREAMING_SNAKE_CASE		, guidance_scale=7.5		, num_inference_steps=50		, output_type='''numpy'''		).images

			lowerCAmelCase__       :      List[Any]   					= image[0, 253:256, 253:256, -1]

			assert image.shape == (1, 512, 512, 3)
			lowerCAmelCase__       :      Optional[Any]   					= np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778]		)

			assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-1

			lowerCAmelCase__       :      Optional[Any]   					= pipe.image_variation(_SCREAMING_SNAKE_CASE		, generator=_SCREAMING_SNAKE_CASE		, output_type='''numpy'''		).images

			lowerCAmelCase__       :      List[Any]   					= image[0, 253:256, 253:256, -1]

			assert image.shape == (1, 512, 512, 3)
			lowerCAmelCase__       :      Any   					= np.array([0.3076, 0.3123, 0.3284, 0.3782, 0.3770, 0.3894, 0.4297, 0.4331, 0.4456]		)

			assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-1




