





import argparse
import json
from collections import OrderedDict
from pathlib import Path

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

from transformers import PoolFormerConfig, PoolFormerForImageClassification, PoolFormerImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
__UpperCAmelCase	:       Optional[int]    	=							logging.get_logger(__name__)






def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)       ->   Tuple:
  __snake_case:						Any			  =						original_name.split(""".""")[0]
  __snake_case:						Optional[int]			  =						key.split(""".""")
  __snake_case:						List[Any]			  =						int(key_list[key_list.index(snake_case_) - 2])
  __snake_case:						Optional[int]			  =						int(key_list[key_list.index(snake_case_) - 1])
  __snake_case:						str			  =						orig_block_num - offset

  __snake_case:						Tuple			  =						key.replace(F'''{orig_block_num}.{layer_num}.{original_name}''' , F'''block.{new_block_num}.{layer_num}.{new_name}''')
  return key






def       A__							(   SCREAMING_SNAKE_CASE__)       ->   str:
  __snake_case:						Union[str, Any]			  =						OrderedDict()
  __snake_case  ,       __snake_case:						Tuple			  =						0, 0
  for key, value in state_dict.items():
    if key.startswith("""network"""):
      __snake_case:						List[Any]			  =						key.replace("""network""" , """poolformer.encoder""")
    if "proj" in key:
      # Works for the first embedding as well as the internal embedding layers
      if key.endswith("""bias""") and "patch_embed" not in key:
        patch_emb_offset += 1
      __snake_case:						List[str]			  =						key[: key.find("""proj""")]
      __snake_case:						Optional[Any]			  =						key.replace(snake_case_ , F'''patch_embeddings.{total_embed_found}.''')
      __snake_case:						Union[str, Any]			  =						key.replace("""proj""" , """projection""")
      if key.endswith("""bias"""):
        total_embed_found += 1
    if "patch_embeddings" in key:
      __snake_case:						Any			  =						"""poolformer.encoder.""" + key
    if "mlp.fc1" in key:
      __snake_case:						Tuple			  =						replace_key_with_offset(snake_case_ , snake_case_ , """mlp.fc1""" , """output.conv1""")
    if "mlp.fc2" in key:
      __snake_case:						Dict			  =						replace_key_with_offset(snake_case_ , snake_case_ , """mlp.fc2""" , """output.conv2""")
    if "norm1" in key:
      __snake_case:						Optional[Any]			  =						replace_key_with_offset(snake_case_ , snake_case_ , """norm1""" , """before_norm""")
    if "norm2" in key:
      __snake_case:						Any			  =						replace_key_with_offset(snake_case_ , snake_case_ , """norm2""" , """after_norm""")
    if "layer_scale_1" in key:
      __snake_case:						Tuple			  =						replace_key_with_offset(snake_case_ , snake_case_ , """layer_scale_1""" , """layer_scale_1""")
    if "layer_scale_2" in key:
      __snake_case:						List[str]			  =						replace_key_with_offset(snake_case_ , snake_case_ , """layer_scale_2""" , """layer_scale_2""")
    if "head" in key:
      __snake_case:						Any			  =						key.replace("""head""" , """classifier""")
    __snake_case:						List[Any]			  =						value
  return new_state_dict






def       A__							(   )       ->   Any:
  __snake_case:						Tuple			  =						"""http://images.cocodataset.org/val2017/000000039769.jpg"""
  __snake_case:						Union[str, Any]			  =						Image.open(requests.get(snake_case_ , stream=snake_case_).raw)

  return image






@torch.no_grad()
def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)       ->   Optional[int]:
  __snake_case:						Dict			  =						PoolFormerConfig()

  # set attributes based on model_name
  __snake_case:						str			  =						"""huggingface/label-files"""
  __snake_case:						Dict			  =						model_name[-3:]
  __snake_case:						Optional[int]			  =						1000
  __snake_case:						Dict			  =						"""imagenet-1k-id2label.json"""
  __snake_case:						Optional[Any]			  =						(1, 1000)

  # set config attributes
  __snake_case:						Optional[int]			  =						json.load(open(hf_hub_download(snake_case_ , snake_case_ , repo_type="""dataset""") , """r"""))
  __snake_case:						str			  =						{int(snake_case_): v for k, v in idalabel.items()}
  __snake_case:						List[str]			  =						idalabel
  __snake_case:						Optional[int]			  =						{v: k for k, v in idalabel.items()}
  if size == "s12":
    __snake_case:						List[Any]			  =						[2, 2, 6, 2]
    __snake_case:						int			  =						[64, 128, 320, 512]
    __snake_case:						Dict			  =						4.0
    __snake_case:						Any			  =						0.9
  elif size == "s24":
    __snake_case:						Optional[Any]			  =						[4, 4, 12, 4]
    __snake_case:						Optional[Any]			  =						[64, 128, 320, 512]
    __snake_case:						Dict			  =						4.0
    __snake_case:						List[str]			  =						0.9
  elif size == "s36":
    __snake_case:						Optional[Any]			  =						[6, 6, 18, 6]
    __snake_case:						List[Any]			  =						[64, 128, 320, 512]
    __snake_case:						int			  =						4.0
    __snake_case:						List[Any]			  =						1e-6
    __snake_case:						Any			  =						0.9
  elif size == "m36":
    __snake_case:						str			  =						[6, 6, 18, 6]
    __snake_case:						str			  =						[96, 192, 384, 768]
    __snake_case:						Any			  =						4.0
    __snake_case:						Tuple			  =						1e-6
    __snake_case:						Union[str, Any]			  =						0.95
  elif size == "m48":
    __snake_case:						List[str]			  =						[8, 8, 24, 8]
    __snake_case:						List[Any]			  =						[96, 192, 384, 768]
    __snake_case:						str			  =						4.0
    __snake_case:						List[Any]			  =						1e-6
    __snake_case:						List[Any]			  =						0.95
  else:
    raise ValueError(F'''Size {size} not supported''')

  # load image processor
  __snake_case:						int			  =						PoolFormerImageProcessor(crop_pct=snake_case_)

  # Prepare image
  __snake_case:						Optional[Any]			  =						prepare_img()
  __snake_case:						Any			  =						image_processor(images=snake_case_ , return_tensors="""pt""").pixel_values

  logger.info(F'''Converting model {model_name}...''')

  # load original state dict
  __snake_case:						List[Any]			  =						torch.load(snake_case_ , map_location=torch.device("""cpu"""))

  # rename keys
  __snake_case:						Optional[int]			  =						rename_keys(snake_case_)

  # create HuggingFace model and load state dict
  __snake_case:						List[str]			  =						PoolFormerForImageClassification(snake_case_)
  model.load_state_dict(snake_case_)
  model.eval()

  # Define image processor
  __snake_case:						Any			  =						PoolFormerImageProcessor(crop_pct=snake_case_)
  __snake_case:						List[str]			  =						image_processor(images=prepare_img() , return_tensors="""pt""").pixel_values

  # forward pass
  __snake_case:						int			  =						model(snake_case_)
  __snake_case:						Optional[Any]			  =						outputs.logits

  # define expected logit slices for different models
  if size == "s12":
    __snake_case:						List[str]			  =						torch.tensor([-0.3_045, -0.6_758, -0.4_869])
  elif size == "s24":
    __snake_case:						Any			  =						torch.tensor([0.4_402, -0.1_374, -0.8_045])
  elif size == "s36":
    __snake_case:						List[Any]			  =						torch.tensor([-0.6_080, -0.5_133, -0.5_898])
  elif size == "m36":
    __snake_case:						Optional[int]			  =						torch.tensor([0.3_952, 0.2_263, -1.2_668])
  elif size == "m48":
    __snake_case:						Union[str, Any]			  =						torch.tensor([0.1_167, -0.0_656, -0.3_423])
  else:
    raise ValueError(F'''Size {size} not supported''')

  # verify logits
  assert logits.shape == expected_shape
  assert torch.allclose(logits[0, :3] , snake_case_ , atol=1e-2)

  # finally, save model and image processor
  logger.info(F'''Saving PyTorch model and image processor to {pytorch_dump_folder_path}...''')
  Path(snake_case_).mkdir(exist_ok=snake_case_)
  model.save_pretrained(snake_case_)
  print(F'''Saving image processor to {pytorch_dump_folder_path}''')
  image_processor.save_pretrained(snake_case_)


if __name__ == "__main__":
      __UpperCAmelCase	:       Optional[int]    	=							argparse.ArgumentParser()

      parser.add_argument(
          "--model_name",
          default="poolformer_s12",
          type=str,
          help="Name of the model you\'d like to convert.",
      )
      parser.add_argument(
          "--checkpoint_path", default=None, type=str, help="Path to the original PyTorch checkpoint (.pth file)."
      )
      parser.add_argument(
          "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
      )
      __UpperCAmelCase	:       Optional[int]    	=							parser.parse_args()
      convert_poolformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)













import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					DownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						str			  =						[-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					ResnetDownsampleBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Union[str, Any]			  =						[0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Union[str, Any]			  =						[0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					CrossAttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case  ,       __snake_case:						List[str]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						List[Any]			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						[0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SimpleCrossAttnDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case  ,       __snake_case:						Union[str, Any]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						Optional[Any]			  =						32
         return init_dict, inputs_dict






       @unittest.skipIf(torch_device == """mps"""							,    """MPS result is not consistent"""		)
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Optional[Any]			  =						[0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SkipDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Any		):
         return super().get_dummy_input(include_skip_sample=A		)






       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Optional[Any]			  =						[-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnSkipDownBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         return super().get_dummy_input(include_skip_sample=A		)






       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						str			  =						[0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					DownEncoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						str			  =						{
             """in_channels""": 32,
             """out_channels""": 32,
         }
         __snake_case:						Dict			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Optional[int]			  =						[1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnDownEncoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""down"""




       @property
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Optional[Any]			  =						{
             """in_channels""": 32,
             """out_channels""": 32,
         }
         __snake_case:						Tuple			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						Dict			  =						[0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaD  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Optional[int]			  =						{
             """in_channels""": 32,
             """temb_channels""": 128,
         }
         __snake_case:						List[str]			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Tuple			  =						[-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaDCrossAttn  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						int			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						int			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						[0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UNetMidBlockaDSimpleCrossAttn  # noqa F405
       lowerCAmelCase__						=					"""mid"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case  ,       __snake_case:						Any			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						str			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[Any]			  =						[0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Tuple		):
         __snake_case:						Tuple			  =						[-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					ResnetUpsampleBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Tuple		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						int			  =						[0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					CrossAttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case  ,       __snake_case:						Any			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						Optional[int]			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						List[Any]			  =						[-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SimpleCrossAttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A							,    include_encoder_hidden_states=A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case  ,       __snake_case:						Optional[Any]			  =						super().prepare_init_args_and_inputs_for_common()
         __snake_case:						str			  =						32
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						Union[str, Any]			  =						[0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   int		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       @unittest.skipIf(torch_device == """mps"""							,    """MPS result is not consistent"""		)
       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						Optional[Any]			  =						[0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SkipUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   str		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						Optional[int]			  =						[-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnSkipUpBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   str		):
         return super().get_dummy_input(include_res_hidden_states_tuple=A		)






       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						[0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					UpDecoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						Union[str, Any]			  =						{"""in_channels""": 32, """out_channels""": 32}

         __snake_case:						Dict			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Dict			  =						[0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
         super().test_output(A		)







class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					AttnUpDecoderBlockaD  # noqa F405
       lowerCAmelCase__						=					"""up"""




       @property
       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         return super().get_dummy_input(include_temb=A		)




       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						Optional[Any]			  =						{"""in_channels""": 32, """out_channels""": 32}

         __snake_case:						Any			  =						self.dummy_input
         return init_dict, inputs_dict






       def 							UpperCAmelCase__			(  self			:   int		):
         __snake_case:						Any			  =						[0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
         super().test_output(A		)






