





'''simple docstring'''




import argparse

import huggingface_hub
import k_diffusion as K
import torch

from diffusers import UNetaDConditionModel


a__				: List[Any]									=    '''pcuenq/k-upscaler'''




def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_				,							*, UpperCAmelCase_				,							UpperCAmelCase_       )      ->Optional[int]:
	snake_case__  					=      {
	    # norm1
	    f'''{diffusers_resnet_prefix}.norm1.linear.weight''': checkpoint[f'''{resnet_prefix}.main.0.mapper.weight'''],
	    f'''{diffusers_resnet_prefix}.norm1.linear.bias''': checkpoint[f'''{resnet_prefix}.main.0.mapper.bias'''],
	    # conv1
	    f'''{diffusers_resnet_prefix}.conv1.weight''': checkpoint[f'''{resnet_prefix}.main.2.weight'''],
	    f'''{diffusers_resnet_prefix}.conv1.bias''': checkpoint[f'''{resnet_prefix}.main.2.bias'''],
	    # norm2
	    f'''{diffusers_resnet_prefix}.norm2.linear.weight''': checkpoint[f'''{resnet_prefix}.main.4.mapper.weight'''],
	    f'''{diffusers_resnet_prefix}.norm2.linear.bias''': checkpoint[f'''{resnet_prefix}.main.4.mapper.bias'''],
	    # conv2
	    f'''{diffusers_resnet_prefix}.conv2.weight''': checkpoint[f'''{resnet_prefix}.main.6.weight'''],
	    f'''{diffusers_resnet_prefix}.conv2.bias''': checkpoint[f'''{resnet_prefix}.main.6.bias'''],
	}

	if resnet.conv_shortcut is not None:
		rv.update(
		    {
		        f'''{diffusers_resnet_prefix}.conv_shortcut.weight''': checkpoint[f'''{resnet_prefix}.skip.weight'''],
		    }       )

	return rv




def 	__lowerCamelCase (  UpperCAmelCase_				,							*, UpperCAmelCase_				,							UpperCAmelCase_       )      ->Dict:
	snake_case__					,     snake_case__					,     snake_case__  					=      checkpoint[f'''{attention_prefix}.qkv_proj.weight'''].chunk(3				,							dim=0       )
	snake_case__					,     snake_case__					,     snake_case__  					=      checkpoint[f'''{attention_prefix}.qkv_proj.bias'''].chunk(3				,							dim=0       )
	snake_case__  					=      {
	    # norm
	    f'''{diffusers_attention_prefix}.norm1.linear.weight''': checkpoint[f'''{attention_prefix}.norm_in.mapper.weight'''],
	    f'''{diffusers_attention_prefix}.norm1.linear.bias''': checkpoint[f'''{attention_prefix}.norm_in.mapper.bias'''],
	    # to_q
	    f'''{diffusers_attention_prefix}.attn1.to_q.weight''': weight_q.squeeze(-1       ).squeeze(-1       ),
	    f'''{diffusers_attention_prefix}.attn1.to_q.bias''': bias_q,
	    # to_k
	    f'''{diffusers_attention_prefix}.attn1.to_k.weight''': weight_k.squeeze(-1       ).squeeze(-1       ),
	    f'''{diffusers_attention_prefix}.attn1.to_k.bias''': bias_k,
	    # to_v
	    f'''{diffusers_attention_prefix}.attn1.to_v.weight''': weight_v.squeeze(-1       ).squeeze(-1       ),
	    f'''{diffusers_attention_prefix}.attn1.to_v.bias''': bias_v,
	    # to_out
	    f'''{diffusers_attention_prefix}.attn1.to_out.0.weight''': checkpoint[f'''{attention_prefix}.out_proj.weight''']
	    .squeeze(-1       )
	    .squeeze(-1       ),
	    f'''{diffusers_attention_prefix}.attn1.to_out.0.bias''': checkpoint[f'''{attention_prefix}.out_proj.bias'''],
	}

	return rv




def 	__lowerCamelCase (  UpperCAmelCase_				,							*, UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_       )      ->Tuple:
	snake_case__					,     snake_case__  					=      checkpoint[f'''{attention_prefix}.kv_proj.weight'''].chunk(2				,							dim=0       )
	snake_case__					,     snake_case__  					=      checkpoint[f'''{attention_prefix}.kv_proj.bias'''].chunk(2				,							dim=0       )

	snake_case__  					=      {
	    # norm2 (ada groupnorm)
	    f'''{diffusers_attention_prefix}.norm{diffusers_attention_index}.linear.weight''': checkpoint[
	        f'''{attention_prefix}.norm_dec.mapper.weight'''
	    ],
	    f'''{diffusers_attention_prefix}.norm{diffusers_attention_index}.linear.bias''': checkpoint[
	        f'''{attention_prefix}.norm_dec.mapper.bias'''
	    ],
	    # layernorm on encoder_hidden_state
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.norm_cross.weight''': checkpoint[
	        f'''{attention_prefix}.norm_enc.weight'''
	    ],
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.norm_cross.bias''': checkpoint[
	        f'''{attention_prefix}.norm_enc.bias'''
	    ],
	    # to_q
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_q.weight''': checkpoint[
	        f'''{attention_prefix}.q_proj.weight'''
	    ]
	    .squeeze(-1       )
	    .squeeze(-1       ),
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_q.bias''': checkpoint[
	        f'''{attention_prefix}.q_proj.bias'''
	    ],
	    # to_k
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_k.weight''': weight_k.squeeze(-1       ).squeeze(-1       ),
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_k.bias''': bias_k,
	    # to_v
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_v.weight''': weight_v.squeeze(-1       ).squeeze(-1       ),
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_v.bias''': bias_v,
	    # to_out
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_out.0.weight''': checkpoint[
	        f'''{attention_prefix}.out_proj.weight'''
	    ]
	    .squeeze(-1       )
	    .squeeze(-1       ),
	    f'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_out.0.bias''': checkpoint[
	        f'''{attention_prefix}.out_proj.bias'''
	    ],
	}

	return rv




def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_       )      ->List[str]:
	snake_case__  					=      'inner_model.u_net.u_blocks' if block_type == 'up' else 'inner_model.u_net.d_blocks'
	snake_case__  					=      f'''{block_prefix}.{block_idx}'''

	snake_case__  					=      {}

	if not hasattr(UpperCAmelCase_				,							'attentions'       ):
		snake_case__  					=      1  # resnet only
	elif not block.attentions[0].add_self_attention:
		snake_case__  					=      2  # resnet -> cross-attention
	else:
		snake_case__  					=      3  # resnet -> self-attention -> cross-attention)

	for resnet_idx, resnet in enumerate(block.resnets       ):
		# diffusers_resnet_prefix = f"{diffusers_up_block_prefix}.resnets.{resnet_idx}"
		snake_case__  					=      f'''{block_type}_blocks.{block_idx}.resnets.{resnet_idx}'''
		snake_case__  					=      n * resnet_idx if block_type == 'up' else n * resnet_idx + 1
		snake_case__  					=      f'''{block_prefix}.{idx}''' if block_type == 'up' else f'''{block_prefix}.{idx}'''

		diffusers_checkpoint.update(
		    resnet_to_diffusers_checkpoint(
		        UpperCAmelCase_				,							UpperCAmelCase_				,							diffusers_resnet_prefix=UpperCAmelCase_				,							resnet_prefix=UpperCAmelCase_       )       )

	if hasattr(UpperCAmelCase_				,							'attentions'       ):
		for attention_idx, attention in enumerate(block.attentions       ):
			snake_case__  					=      f'''{block_type}_blocks.{block_idx}.attentions.{attention_idx}'''
			snake_case__  					=      n * attention_idx + 1 if block_type == 'up' else n * attention_idx + 2
			snake_case__  					=      f'''{block_prefix}.{idx}'''
			snake_case__  					=      f'''{block_prefix}.{idx }'''
			snake_case__  					=      1 if not attention.add_self_attention else 2
			snake_case__  					=      (
			    n * attention_idx + cross_attention_index
			    if block_type == 'up'
			    else n * attention_idx + cross_attention_index + 1
			)
			snake_case__  					=      f'''{block_prefix}.{idx }'''

			diffusers_checkpoint.update(
			    cross_attn_to_diffusers_checkpoint(
			        UpperCAmelCase_				,							diffusers_attention_prefix=UpperCAmelCase_				,							diffusers_attention_index=2				,							attention_prefix=UpperCAmelCase_				,							)       )

			if attention.add_self_attention is True:
				diffusers_checkpoint.update(
				    self_attn_to_diffusers_checkpoint(
				        UpperCAmelCase_				,							diffusers_attention_prefix=UpperCAmelCase_				,							attention_prefix=UpperCAmelCase_				,							)       )

	return diffusers_checkpoint




def 	__lowerCamelCase (  UpperCAmelCase_				,							UpperCAmelCase_       )      ->Any:
	snake_case__  					=      {}

	# pre-processing
	diffusers_checkpoint.update(
	    {
	        'conv_in.weight': checkpoint['inner_model.proj_in.weight'],
	        'conv_in.bias': checkpoint['inner_model.proj_in.bias'],
	    }       )

	# timestep and class embedding
	diffusers_checkpoint.update(
	    {
	        'time_proj.weight': checkpoint['inner_model.timestep_embed.weight'].squeeze(-1       ),
	        'time_embedding.linear_1.weight': checkpoint['inner_model.mapping.0.weight'],
	        'time_embedding.linear_1.bias': checkpoint['inner_model.mapping.0.bias'],
	        'time_embedding.linear_2.weight': checkpoint['inner_model.mapping.2.weight'],
	        'time_embedding.linear_2.bias': checkpoint['inner_model.mapping.2.bias'],
	        'time_embedding.cond_proj.weight': checkpoint['inner_model.mapping_cond.weight'],
	    }       )

	# down_blocks
	for down_block_idx, down_block in enumerate(model.down_blocks       ):
		diffusers_checkpoint.update(block_to_diffusers_checkpoint(UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							'down'       )       )

	# up_blocks
	for up_block_idx, up_block in enumerate(model.up_blocks       ):
		diffusers_checkpoint.update(block_to_diffusers_checkpoint(UpperCAmelCase_				,							UpperCAmelCase_				,							UpperCAmelCase_				,							'up'       )       )

	# post-processing
	diffusers_checkpoint.update(
	    {
	        'conv_out.weight': checkpoint['inner_model.proj_out.weight'],
	        'conv_out.bias': checkpoint['inner_model.proj_out.bias'],
	    }       )

	return diffusers_checkpoint




def 	__lowerCamelCase (  UpperCAmelCase_       )      ->Optional[int]:
	snake_case__  					=      original_config['input_channels'] + original_config['unet_cond_dim']
	snake_case__  					=      original_config['input_channels'] + (1 if original_config['has_variance'] else 0)

	snake_case__  					=      original_config['channels']

	assert (
	    len(set(original_config['depths']       )       ) == 1
	), "UNet2DConditionModel currently do not support blocks with different number of layers"
	snake_case__  					=      original_config['depths'][0]

	snake_case__  					=      original_config['mapping_cond_dim']
	snake_case__  					=      original_config['cross_cond_dim']

	snake_case__  					=      []
	snake_case__  					=      []
	for s, c in zip(original_config['self_attn_depths']				,							original_config['cross_attn_depths']       ):
		if s:
			snake_case__  					=      'self'
			snake_case__  					=      'cross' if c else None
		elif c:
			snake_case__  					=      'cross'
			snake_case__  					=      None
		else:
			snake_case__  					=      None
			snake_case__  					=      None
		attna_types.append(UpperCAmelCase_       )
		attna_types.append(UpperCAmelCase_       )

	snake_case__  					=      UNetaDConditionModel(
	    in_channels=UpperCAmelCase_				,							out_channels=UpperCAmelCase_				,							down_block_types=('KDownBlock2D', 'KCrossAttnDownBlock2D', 'KCrossAttnDownBlock2D', 'KCrossAttnDownBlock2D')				,							mid_block_type=UpperCAmelCase_				,							up_block_types=('KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KUpBlock2D')				,							block_out_channels=UpperCAmelCase_				,							layers_per_block=UpperCAmelCase_				,							act_fn='gelu'				,							norm_num_groups=UpperCAmelCase_				,							cross_attention_dim=UpperCAmelCase_				,							attention_head_dim=64				,							time_cond_proj_dim=UpperCAmelCase_				,							resnet_time_scale_shift='scale_shift'				,							time_embedding_type='fourier'				,							timestep_post_act='gelu'				,							conv_in_kernel=1				,							conv_out_kernel=1				,							)

	return unet




def 	__lowerCamelCase (  UpperCAmelCase_       )      ->Union[str, Any]:
	snake_case__  					=      torch.device('cuda' if torch.cuda.is_available() else 'cpu'       )

	snake_case__  					=      huggingface_hub.hf_hub_download(UpperCAmelCase_				,							'config_laion_text_cond_latent_upscaler_2.json'       )
	snake_case__  					=      huggingface_hub.hf_hub_download(
	    UpperCAmelCase_				,							'laion_text_cond_latent_upscaler_2_1_00470000_slim.pth'       )
	print(f'''loading original model configuration from {orig_config_path}'''       )
	print(f'''loading original model checkpoint from {orig_weights_path}'''       )

	print('converting to diffusers unet'       )
	snake_case__  					=      K.config.load_config(open(UpperCAmelCase_       )       )['model']
	snake_case__  					=      unet_model_from_original_config(UpperCAmelCase_       )

	snake_case__  					=      torch.load(UpperCAmelCase_				,							map_location=UpperCAmelCase_       )['model_ema']
	snake_case__  					=      unet_to_diffusers_checkpoint(UpperCAmelCase_				,							UpperCAmelCase_       )

	model.load_state_dict(UpperCAmelCase_				,							strict=UpperCAmelCase_       )
	model.save_pretrained(args.dump_path       )
	print(f'''saving converted unet model in {args.dump_path}'''       )


if __name__ == "__main__":
			a__				: List[str]									=    argparse.ArgumentParser()

			parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')
			a__				: int									=    parser.parse_args()

			main(args)










'''simple docstring'''




import shutil
import tempfile
import unittest

import pytest

from transformers import WhisperTokenizer, is_speech_available
from transformers.testing_utils import require_sentencepiece, require_torch, require_torchaudio

from .test_feature_extraction_whisper import floats_list


if is_speech_available():
			from transformers import WhisperFeatureExtractor, WhisperProcessor


a__				: Tuple									=    5_0358
a__				: str									=    5_0362






@require_torch
@require_torchaudio
@require_sentencepiece
class 							__snake_case    (				unittest.TestCase       ):





	def      _snake_case      (		self		)			->		Dict:
		snake_case__  					=      'openai/whisper-small.en'
		snake_case__  					=      tempfile.mkdtemp()





	def      _snake_case      (		self			,					**UpperCamelCase_		)			->		Optional[int]:
		return WhisperTokenizer.from_pretrained(self.checkpoint			,					**UpperCamelCase_		)





	def      _snake_case      (		self			,					**UpperCamelCase_		)			->		Any:
		return WhisperFeatureExtractor.from_pretrained(self.checkpoint			,					**UpperCamelCase_		)





	def      _snake_case      (		self		)			->		Tuple:
		shutil.rmtree(self.tmpdirname		)





	def      _snake_case      (		self		)			->		Any:
		snake_case__  					=      self.get_tokenizer()
		snake_case__  					=      self.get_feature_extractor()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		processor.save_pretrained(self.tmpdirname		)
		snake_case__  					=      WhisperProcessor.from_pretrained(self.tmpdirname		)

		self.assertEqual(processor.tokenizer.get_vocab()			,					tokenizer.get_vocab()		)
		self.assertIsInstance(processor.tokenizer			,					UpperCamelCase_		)

		self.assertEqual(processor.feature_extractor.to_json_string()			,					feature_extractor.to_json_string()		)
		self.assertIsInstance(processor.feature_extractor			,					UpperCamelCase_		)





	def      _snake_case      (		self		)			->		Dict:
		snake_case__  					=      WhisperProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor()		)
		processor.save_pretrained(self.tmpdirname		)

		snake_case__  					=      self.get_tokenizer(bos_token='(BOS)'			,					eos_token='(EOS)'		)
		snake_case__  					=      self.get_feature_extractor(do_normalize=UpperCamelCase_			,					padding_value=1.0		)

		snake_case__  					=      WhisperProcessor.from_pretrained(
		    self.tmpdirname			,					bos_token='(BOS)'			,					eos_token='(EOS)'			,					do_normalize=UpperCamelCase_			,					padding_value=1.0		)

		self.assertEqual(processor.tokenizer.get_vocab()			,					tokenizer_add_kwargs.get_vocab()		)
		self.assertIsInstance(processor.tokenizer			,					UpperCamelCase_		)

		self.assertEqual(processor.feature_extractor.to_json_string()			,					feature_extractor_add_kwargs.to_json_string()		)
		self.assertIsInstance(processor.feature_extractor			,					UpperCamelCase_		)





	def      _snake_case      (		self		)			->		List[str]:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		snake_case__  					=      floats_list((3, 1000)		)

		snake_case__  					=      feature_extractor(UpperCamelCase_			,					return_tensors='np'		)
		snake_case__  					=      processor(UpperCamelCase_			,					return_tensors='np'		)

		for key in input_feat_extract.keys():
			self.assertAlmostEqual(input_feat_extract[key].sum()			,					input_processor[key].sum()			,					delta=1E-2		)





	def      _snake_case      (		self		)			->		Union[str, Any]:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		snake_case__  					=      'This is a test string'

		snake_case__  					=      processor(text=UpperCamelCase_		)

		snake_case__  					=      tokenizer(UpperCamelCase_		)

		for key in encoded_tok.keys():
			self.assertListEqual(encoded_tok[key]			,					encoded_processor[key]		)





	def      _snake_case      (		self		)			->		Tuple:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		snake_case__  					=      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

		snake_case__  					=      processor.batch_decode(UpperCamelCase_		)
		snake_case__  					=      tokenizer.batch_decode(UpperCamelCase_		)

		self.assertListEqual(UpperCamelCase_			,					UpperCamelCase_		)





	def      _snake_case      (		self		)			->		List[str]:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		self.assertListEqual(
		    processor.model_input_names			,					feature_extractor.model_input_names			,					msg='`processor` and `feature_extractor` model input names do not match'			,					)





	def      _snake_case      (		self		)			->		Dict:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)
		snake_case__  					=      processor.get_decoder_prompt_ids(task='transcribe'			,					no_timestamps=UpperCamelCase_		)

		self.assertIsInstance(UpperCamelCase_			,					UpperCamelCase_		)
		for ids in forced_decoder_ids:
			self.assertIsInstance(UpperCamelCase_			,					(list, tuple)		)

		snake_case__  					=      [TRANSCRIBE, NOTIMESTAMPS]
		self.assertListEqual([ids[-1] for ids in forced_decoder_ids]			,					UpperCamelCase_		)





	def      _snake_case      (		self		)			->		List[str]:
		snake_case__  					=      WhisperProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor()		)
		snake_case__  					=      processor.get_prompt_ids('Mr. Quilter'		)
		snake_case__  					=      processor.tokenizer.decode(UpperCamelCase_		)

		self.assertListEqual(prompt_ids.tolist()			,					[5_0360, 1770, 13, 2264, 346, 353]		)
		self.assertEqual(UpperCamelCase_			,					'<|startofprev|> Mr. Quilter'		)





	def      _snake_case      (		self		)			->		Dict:
		snake_case__  					=      WhisperProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor()		)
		snake_case__  					=      processor.get_prompt_ids(''		)
		snake_case__  					=      processor.tokenizer.decode(UpperCamelCase_		)

		self.assertListEqual(prompt_ids.tolist()			,					[5_0360, 220]		)
		self.assertEqual(UpperCamelCase_			,					'<|startofprev|> '		)





	def      _snake_case      (		self		)			->		int:
		snake_case__  					=      WhisperProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor()		)

		def _test_prompt_error_raised_helper(UpperCamelCase_			,					UpperCamelCase_		):
			with pytest.raises(UpperCamelCase_		) as excinfo:
				processor.get_prompt_ids(UpperCamelCase_		)
			snake_case__  					=      F'''Encountered text in the prompt corresponding to disallowed special token: {special_token}.'''
			self.assertEqual(UpperCamelCase_			,					str(excinfo.value		)		)

		_test_prompt_error_raised_helper('<|startofprev|> test'			,					'<|startofprev|>'		)
		_test_prompt_error_raised_helper('test <|notimestamps|>'			,					'<|notimestamps|>'		)
		_test_prompt_error_raised_helper('test <|zh|> test <|transcribe|>'			,					'<|zh|>'		)



