'''simple docstring'''


import argparse
import json
from pathlib import Path

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

from transformers import DeiTConfig, DeiTForImageClassificationWithTeacher, DeiTImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCAmelCase	:       Union[str, Any]						       =	logging.get_logger(__name__)





def       lowerCAmelCase					(		UpperCamelCase__				:   Tuple    ,					UpperCamelCase__				:   Union[str, Any]=False       ):


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

	# projection layer + position embeddings
	rename_keys.extend(
	    [
	        ('''cls_token''', '''deit.embeddings.cls_token'''),
	        ('''dist_token''', '''deit.embeddings.distillation_token'''),
	        ('''patch_embed.proj.weight''', '''deit.embeddings.patch_embeddings.projection.weight'''),
	        ('''patch_embed.proj.bias''', '''deit.embeddings.patch_embeddings.projection.bias'''),
	        ('''pos_embed''', '''deit.embeddings.position_embeddings'''),
	    ]       )

	if base_model:
		# layernorm + pooler
		rename_keys.extend(
		    [
		        ('''norm.weight''', '''layernorm.weight'''),
		        ('''norm.bias''', '''layernorm.bias'''),
		        ('''pre_logits.fc.weight''', '''pooler.dense.weight'''),
		        ('''pre_logits.fc.bias''', '''pooler.dense.bias'''),
		    ]       )

		# if just the base model, we should remove "deit" from all keys that start with "deit"
		__UpperCAmelCase							=			[(pair[0], pair[1][4:]) if pair[1].startswith('''deit'''       ) else pair for pair in rename_keys]
	else:
		# layernorm + classification heads
		rename_keys.extend(
		    [
		        ('''norm.weight''', '''deit.layernorm.weight'''),
		        ('''norm.bias''', '''deit.layernorm.bias'''),
		        ('''head.weight''', '''cls_classifier.weight'''),
		        ('''head.bias''', '''cls_classifier.bias'''),
		        ('''head_dist.weight''', '''distillation_classifier.weight'''),
		        ('''head_dist.bias''', '''distillation_classifier.bias'''),
		    ]       )

	return rename_keys





def       lowerCAmelCase					(		UpperCamelCase__				:   Any    ,					UpperCamelCase__				:   Tuple    ,					UpperCamelCase__				:   str=False       ):


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





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


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





def       lowerCAmelCase					(		):


	"""simple docstring"""
	__UpperCAmelCase							=			'''http://images.cocodataset.org/val2017/000000039769.jpg'''
	__UpperCAmelCase							=			Image.open(requests.get(UpperCamelCase__    ,					stream=UpperCamelCase__       ).raw       )
	return im





@torch.no_grad()
def       lowerCAmelCase					(		UpperCamelCase__				:   Dict    ,					UpperCamelCase__				:   Tuple       ):


	"""simple docstring"""
	__UpperCAmelCase							=			DeiTConfig()
	# all deit models have fine-tuned heads
	__UpperCAmelCase							=			False
	# dataset (fine-tuned on ImageNet 2012), patch_size and image_size
	__UpperCAmelCase							=			1_0_0_0
	__UpperCAmelCase							=			'''huggingface/label-files'''
	__UpperCAmelCase							=			'''imagenet-1k-id2label.json'''
	__UpperCAmelCase							=			json.load(open(hf_hub_download(UpperCamelCase__    ,					UpperCamelCase__    ,					repo_type='''dataset'''       )    ,					'''r'''       )       )
	__UpperCAmelCase							=			{int(UpperCamelCase__       ): v for k, v in idalabel.items()}
	__UpperCAmelCase							=			idalabel
	__UpperCAmelCase							=			{v: k for k, v in idalabel.items()}
	__UpperCAmelCase							=			int(deit_name[-6:-4]       )
	__UpperCAmelCase							=			int(deit_name[-3:]       )
	# size of the architecture
	if deit_name[9:].startswith('''tiny'''       ):
		__UpperCAmelCase							=			1_9_2
		__UpperCAmelCase							=			7_6_8
		__UpperCAmelCase							=			1_2
		__UpperCAmelCase							=			3
	elif deit_name[9:].startswith('''small'''       ):
		__UpperCAmelCase							=			3_8_4
		__UpperCAmelCase							=			1_5_3_6
		__UpperCAmelCase							=			1_2
		__UpperCAmelCase							=			6
	if deit_name[9:].startswith('''base'''       ):
		pass
	elif deit_name[4:].startswith('''large'''       ):
		__UpperCAmelCase							=			1_0_2_4
		__UpperCAmelCase							=			4_0_9_6
		__UpperCAmelCase							=			2_4
		__UpperCAmelCase							=			1_6

	# load original model from timm
	__UpperCAmelCase							=			timm.create_model(UpperCamelCase__    ,					pretrained=UpperCamelCase__       )
	timm_model.eval()

	# load state_dict of original model, remove and rename some keys
	__UpperCAmelCase							=			timm_model.state_dict()
	__UpperCAmelCase							=			create_rename_keys(UpperCamelCase__    ,					UpperCamelCase__       )
	for src, dest in rename_keys:
		rename_key(UpperCamelCase__    ,					UpperCamelCase__    ,					UpperCamelCase__       )
	read_in_q_k_v(UpperCamelCase__    ,					UpperCamelCase__    ,					UpperCamelCase__       )

	# load HuggingFace model
	__UpperCAmelCase							=			DeiTForImageClassificationWithTeacher(UpperCamelCase__       ).eval()
	model.load_state_dict(UpperCamelCase__       )

	# Check outputs on an image, prepared by DeiTImageProcessor
	__UpperCAmelCase							=			int(
	    (2_5_6 / 2_2_4) * config.image_size       )  # to maintain same ratio w.r.t. 224 images, see https://github.com/facebookresearch/deit/blob/ab5715372db8c6cad5740714b2216d55aeae052e/datasets.py#L103
	__UpperCAmelCase							=			DeiTImageProcessor(size=UpperCamelCase__    ,					crop_size=config.image_size       )
	__UpperCAmelCase							=			image_processor(images=prepare_img()    ,					return_tensors='''pt'''       )
	__UpperCAmelCase							=			encoding['''pixel_values''']
	__UpperCAmelCase							=			model(UpperCamelCase__       )

	__UpperCAmelCase							=			timm_model(UpperCamelCase__       )
	assert timm_logits.shape == outputs.logits.shape
	assert torch.allclose(UpperCamelCase__    ,					outputs.logits    ,					atol=1E-3       )

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


if __name__ == "__main__":
					__lowerCAmelCase	:       List[str]						       =	argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    "--deit_name",
					    default="vit_deit_base_distilled_patch16_224",
					    type=str,
					    help="Name of the DeiT timm model you'd like to convert.",
					)
					parser.add_argument(
					    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
					)

					__lowerCAmelCase	:       List[str]						       =	parser.parse_args()
					convert_deit_checkpoint(args.deit_name, args.pytorch_dump_folder_path)

'''simple docstring'''


from ..utils import DummyObject, requires_backends






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							int     ,		**__a				:							List[Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Optional[Any]     ,		**__a				:							Tuple	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Tuple     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							str     ,		**__a				:							Tuple	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							Any	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							List[str]	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Any     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Optional[int]     ,		**__a				:							Optional[int]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[str]     ,		**__a				:							List[str]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Optional[int]     ,		**__a				:							Dict	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Tuple     ,		**__a				:							Any	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							int     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							str     ,		**__a				:							Tuple	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[str]     ,		**__a				:							Optional[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Optional[int]     ,		**__a				:							Union[str, Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Union[str, Any]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Union[str, Any]     ,		**__a				:							Any	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[int]     ,		**__a				:							int	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Tuple     ,		**__a				:							str	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)





def       lowerCAmelCase					(		*UpperCamelCase__				:   int    ,					**UpperCamelCase__				:   Optional[int]       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





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


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





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


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





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


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Dict    ,					**UpperCamelCase__				:   Dict       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Tuple    ,					**UpperCamelCase__				:   int       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





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


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							str     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							List[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Tuple     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Optional[Any]     ,		**__a				:							Tuple	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							str     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							str     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							str	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							int     ,		**__a				:							Tuple	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Tuple     ,		**__a				:							str	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Dict	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							str     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							int     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							int     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							List[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Optional[Any]     ,		**__a				:							Any	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Dict	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							int     ,		**__a				:							Dict	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Tuple     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							str     ,		**__a				:							Any	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							Union[str, Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Optional[Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Any     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							int     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							Union[str, Any]	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							int	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Tuple     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							Tuple	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							int	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							int     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Any     ,		**__a				:							int	)							->	Tuple:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Union[str, Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							Dict	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Optional[int]	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Tuple     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Dict     ,		**__a				:							Optional[int]	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Any     ,		**__a				:							Dict	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Any     ,		**__a				:							Any	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Optional[Any]     ,		**__a				:							Optional[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							Dict	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Any     ,		**__a				:							Optional[int]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Dict     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[int]     ,		**__a				:							Union[str, Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Union[str, Any]     ,		**__a				:							int	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[Any]     ,		**__a				:							Optional[int]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Tuple     ,		**__a				:							Tuple	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[str]     ,		**__a				:							Tuple	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Tuple     ,		**__a				:							Optional[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Any     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Any     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							int     ,		**__a				:							str	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							str     ,		**__a				:							Optional[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[Any]     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[str]     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							str     ,		**__a				:							Any	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Any     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Any     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							int     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							int     ,		**__a				:							Optional[Any]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Optional[int]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[str]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[str]     ,		**__a				:							List[str]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)
