





"""simple docstring"""




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        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Tuple      					=DownBlockaD  # noqa F405
							lowerCamelCase   :					Dict      					="""down"""






							def     __a   (   self      )	-> Union[str, Any]:
								a      :		List[Any]	=				[-0.0_232, -0.9_869, 0.8_054, -0.0_637, -0.1_688, -1.4_264, 0.4_470, -1.3_394, 0.0_904]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					int      					=ResnetDownsampleBlockaD  # noqa F405
							lowerCamelCase   :					str      					="""down"""






							def     __a   (   self      )	-> List[str]:
								a      :		Union[str, Any]	=				[0.0_710, 0.2_410, -0.7_320, -1.0_757, -1.1_343, 0.3_540, -0.0_133, -0.2_576, 0.0_948]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Optional[int]      					=AttnDownBlockaD  # noqa F405
							lowerCamelCase   :					Optional[int]      					="""down"""






							def     __a   (   self      )	-> List[str]:
								a      :		str	=				[0.0_636, 0.8_964, -0.6_234, -1.0_131, 0.0_844, 0.4_935, 0.3_437, 0.0_911, -0.2_957]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Dict      					=CrossAttnDownBlockaD  # noqa F405
							lowerCamelCase   :					Any      					="""down"""






							def     __a   (   self      )	-> Any:
								a,       a      :		Optional[int]	=				super().prepare_init_args_and_inputs_for_common()
								a      :		Optional[Any]	=				32
								return init_dict, inputs_dict






							def     __a   (   self      )	-> List[str]:
								a      :		Optional[Any]	=				[0.2_238, -0.7_396, -0.2_255, -0.3_829, 0.1_925, 1.1_665, 0.0_603, -0.7_295, 0.1_983]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Optional[int]      					=SimpleCrossAttnDownBlockaD  # noqa F405
							lowerCamelCase   :					int      					="""down"""






							@property
							def     __a   (   self      )	-> List[str]:
								return super().get_dummy_input(include_encoder_hidden_states=lowerCAmelCase__      )






							def     __a   (   self      )	-> Any:
								a,       a      :		Optional[int]	=				super().prepare_init_args_and_inputs_for_common()
								a      :		str	=				32
								return init_dict, inputs_dict






							@unittest.skipIf(torch_device == "mps"      ,					"MPS result is not consistent"      )
							def     __a   (   self      )	-> Dict:
								a      :		Union[str, Any]	=				[0.7_921, -0.0_992, -0.1_962, -0.7_695, -0.4_242, 0.7_804, 0.4_737, 0.2_765, 0.3_338]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					int      					=SkipDownBlockaD  # noqa F405
							lowerCamelCase   :					Optional[int]      					="""down"""






							@property
							def     __a   (   self      )	-> Any:
								return super().get_dummy_input(include_skip_sample=lowerCAmelCase__      )






							def     __a   (   self      )	-> Dict:
								a      :		Any	=				[-0.0_845, -0.2_087, -0.2_465, 0.0_971, 0.1_900, -0.0_484, 0.2_664, 0.4_179, 0.5_069]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					List[Any]      					=AttnSkipDownBlockaD  # noqa F405
							lowerCamelCase   :					Tuple      					="""down"""






							@property
							def     __a   (   self      )	-> Union[str, Any]:
								return super().get_dummy_input(include_skip_sample=lowerCAmelCase__      )






							def     __a   (   self      )	-> Optional[Any]:
								a      :		Optional[Any]	=				[0.5_539, 0.1_609, 0.4_924, 0.0_537, -0.1_995, 0.4_050, 0.0_979, -0.2_721, -0.0_642]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					List[str]      					=DownEncoderBlockaD  # noqa F405
							lowerCamelCase   :					Optional[Any]      					="""down"""






							@property
							def     __a   (   self      )	-> int:
								return super().get_dummy_input(include_temb=lowerCAmelCase__      )






							def     __a   (   self      )	-> Union[str, Any]:
								a      :		Dict	=				{
								    "in_channels": 32,
								    "out_channels": 32,
								}
								a      :		Any	=				self.dummy_input
								return init_dict, inputs_dict






							def     __a   (   self      )	-> List[str]:
								a      :		List[str]	=				[1.1_102, 0.5_302, 0.4_872, -0.0_023, -0.8_042, 0.0_483, -0.3_489, -0.5_632, 0.7_626]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					List[Any]      					=AttnDownEncoderBlockaD  # noqa F405
							lowerCamelCase   :					Optional[Any]      					="""down"""






							@property
							def     __a   (   self      )	-> Any:
								return super().get_dummy_input(include_temb=lowerCAmelCase__      )






							def     __a   (   self      )	-> Optional[int]:
								a      :		Union[str, Any]	=				{
								    "in_channels": 32,
								    "out_channels": 32,
								}
								a      :		Union[str, Any]	=				self.dummy_input
								return init_dict, inputs_dict






							def     __a   (   self      )	-> str:
								a      :		List[Any]	=				[0.8_966, -0.1_486, 0.8_568, 0.8_141, -0.9_046, -0.1_342, -0.0_972, -0.7_417, 0.1_538]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Dict      					=UNetMidBlockaD  # noqa F405
							lowerCamelCase   :					Tuple      					="""mid"""






							def     __a   (   self      )	-> str:
								a      :		Optional[Any]	=				{
								    "in_channels": 32,
								    "temb_channels": 128,
								}
								a      :		Union[str, Any]	=				self.dummy_input
								return init_dict, inputs_dict






							def     __a   (   self      )	-> int:
								a      :		Optional[Any]	=				[-0.1_062, 1.7_248, 0.3_494, 1.4_569, -0.0_910, -1.2_421, -0.9_984, 0.6_736, 1.0_028]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Optional[int]      					=UNetMidBlockaDCrossAttn  # noqa F405
							lowerCamelCase   :					Optional[int]      					="""mid"""






							def     __a   (   self      )	-> Union[str, Any]:
								a,       a      :		Dict	=				super().prepare_init_args_and_inputs_for_common()
								a      :		Tuple	=				32
								return init_dict, inputs_dict






							def     __a   (   self      )	-> Optional[Any]:
								a      :		str	=				[0.0_187, 2.4_220, 0.4_484, 1.1_203, -0.6_121, -1.5_122, -0.8_270, 0.7_851, 1.8_335]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Optional[int]      					=UNetMidBlockaDSimpleCrossAttn  # noqa F405
							lowerCamelCase   :					str      					="""mid"""






							@property
							def     __a   (   self      )	-> int:
								return super().get_dummy_input(include_encoder_hidden_states=lowerCAmelCase__      )






							def     __a   (   self      )	-> Dict:
								a,       a      :		Union[str, Any]	=				super().prepare_init_args_and_inputs_for_common()
								a      :		Tuple	=				32
								return init_dict, inputs_dict






							def     __a   (   self      )	-> Union[str, Any]:
								a      :		str	=				[0.7_143, 1.9_974, 0.5_448, 1.3_977, 0.1_282, -1.1_237, -1.4_238, 0.5_530, 0.8_880]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Tuple      					=UpBlockaD  # noqa F405
							lowerCamelCase   :					int      					="""up"""






							@property
							def     __a   (   self      )	-> List[str]:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__      )






							def     __a   (   self      )	-> str:
								a      :		Optional[int]	=				[-0.2_041, -0.4_165, -0.3_022, 0.0_041, -0.6_628, -0.7_053, 0.1_928, -0.0_325, 0.0_523]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Dict      					=ResnetUpsampleBlockaD  # noqa F405
							lowerCamelCase   :					Any      					="""up"""






							@property
							def     __a   (   self      )	-> Any:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__      )






							def     __a   (   self      )	-> Dict:
								a      :		int	=				[0.2_287, 0.3_549, -0.1_346, 0.4_797, -0.1_715, -0.9_649, 0.7_305, -0.5_864, -0.6_244]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					int      					=CrossAttnUpBlockaD  # noqa F405
							lowerCamelCase   :					Optional[int]      					="""up"""






							@property
							def     __a   (   self      )	-> Any:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__      )






							def     __a   (   self      )	-> List[Any]:
								a,       a      :		Any	=				super().prepare_init_args_and_inputs_for_common()
								a      :		int	=				32
								return init_dict, inputs_dict






							def     __a   (   self      )	-> int:
								a      :		List[str]	=				[-0.1_403, -0.3_515, -0.0_420, -0.1_425, 0.3_167, 0.5_094, -0.2_181, 0.5_931, 0.5_582]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Any      					=SimpleCrossAttnUpBlockaD  # noqa F405
							lowerCamelCase   :					Any      					="""up"""






							@property
							def     __a   (   self      )	-> str:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__      ,					include_encoder_hidden_states=lowerCAmelCase__      )






							def     __a   (   self      )	-> Dict:
								a,       a      :		str	=				super().prepare_init_args_and_inputs_for_common()
								a      :		List[str]	=				32
								return init_dict, inputs_dict






							def     __a   (   self      )	-> Optional[Any]:
								a      :		Dict	=				[0.2_645, 0.1_480, 0.0_909, 0.8_044, -0.9_758, -0.9_083, 0.0_994, -1.1_453, -0.7_402]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Any      					=AttnUpBlockaD  # noqa F405
							lowerCamelCase   :					int      					="""up"""






							@property
							def     __a   (   self      )	-> Dict:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__      )






							@unittest.skipIf(torch_device == "mps"      ,					"MPS result is not consistent"      )
							def     __a   (   self      )	-> Optional[Any]:
								a      :		Any	=				[0.0_979, 0.1_326, 0.0_021, 0.0_659, 0.2_249, 0.0_059, 0.1_132, 0.5_952, 0.1_033]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Union[str, Any]      					=SkipUpBlockaD  # noqa F405
							lowerCamelCase   :					int      					="""up"""






							@property
							def     __a   (   self      )	-> List[Any]:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__      )






							def     __a   (   self      )	-> Optional[Any]:
								a      :		Optional[Any]	=				[-0.0_893, -0.1_234, -0.1_506, -0.0_332, 0.0_123, -0.0_211, 0.0_566, 0.0_143, 0.0_362]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					List[Any]      					=AttnSkipUpBlockaD  # noqa F405
							lowerCamelCase   :					Dict      					="""up"""






							@property
							def     __a   (   self      )	-> str:
								return super().get_dummy_input(include_res_hidden_states_tuple=lowerCAmelCase__      )






							def     __a   (   self      )	-> Dict:
								a      :		Optional[int]	=				[0.0_361, 0.0_617, 0.2_787, -0.0_350, 0.0_342, 0.3_421, -0.0_843, 0.0_913, 0.3_015]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Any      					=UpDecoderBlockaD  # noqa F405
							lowerCamelCase   :					Optional[int]      					="""up"""






							@property
							def     __a   (   self      )	-> List[str]:
								return super().get_dummy_input(include_temb=lowerCAmelCase__      )






							def     __a   (   self      )	-> List[str]:
								a      :		Optional[int]	=				{"in_channels": 32, "out_channels": 32}

								a      :		Any	=				self.dummy_input
								return init_dict, inputs_dict






							def     __a   (   self      )	-> Union[str, Any]:
								a      :		Union[str, Any]	=				[0.4_404, 0.1_998, -0.9_886, -0.3_320, -0.3_128, -0.7_034, -0.6_955, -0.2_338, -0.3_137]
								super().test_output(lowerCAmelCase__      )


class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					List[str]      					=AttnUpDecoderBlockaD  # noqa F405
							lowerCamelCase   :					List[Any]      					="""up"""






							@property
							def     __a   (   self      )	-> Optional[int]:
								return super().get_dummy_input(include_temb=lowerCAmelCase__      )






							def     __a   (   self      )	-> Tuple:
								a      :		List[Any]	=				{"in_channels": 32, "out_channels": 32}

								a      :		int	=				self.dummy_input
								return init_dict, inputs_dict






							def     __a   (   self      )	-> Optional[Any]:
								a      :		Any	=				[0.6_738, 0.4_491, 0.1_055, 1.0_710, 0.7_316, 0.3_339, 0.3_352, 0.1_023, 0.3_568]
								super().test_output(lowerCAmelCase__      )



'''simple docstring'''





import logging
import os
from dataclasses import dataclass
from typing import List, Optional, Union

import tqdm
from filelock import FileLock

from transformers import (
    BartTokenizer,
    BartTokenizerFast,
    DataProcessor,
    PreTrainedTokenizer,
    RobertaTokenizer,
    RobertaTokenizerFast,
    XLMRobertaTokenizer,
    is_tf_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE_:     str  =logging.getLogger(__name__)




@dataclass(frozen=UpperCamelCase__	)
class        __A      :
    a__       :						str
    a__       :						str
    a__       :						Optional[str]          =  None
    a__       :						Optional[str]          =  None
    a__       :						Optional[str]          =  None




@dataclass(frozen=UpperCamelCase__	)
class        __A      :
    a__       :						List[int]
    a__       :						Optional[List[int]]          =  None
    a__       :						Optional[List[int]]          =  None
    a__       :						Optional[Union[int, float]]          =  None
    a__       :						Optional[int]          =  None


if is_torch_available():
    import torch
    from torch.utils.data import Dataset




    class        __A      ( UpperCamelCase__	):
        a__       :						List[InputFeatures]



        def __init__(self    :    Any   ,			__a    :    str   ,			__a    :    PreTrainedTokenizer   ,			__a    :    str   ,			__a    :    Optional[int] = None   ,			__a    :    Dict=False   ,			__a    :    bool = False   ,			):
             UpperCAmelCase_           =   hans_processors[task]()

             UpperCAmelCase_           =   os.path.join(
                 __a   ,			"cached_{}_{}_{}_{}".format(
                     "dev" if evaluate else "train"   ,			tokenizer.__class__.__name__   ,			str(__a )   ,			__a   ,			)   ,			)
             UpperCAmelCase_           =   processor.get_labels()
             if tokenizer.__class__ in (
                 RobertaTokenizer,
                 RobertaTokenizerFast,
                 XLMRobertaTokenizer,
                 BartTokenizer,
                 BartTokenizerFast,
             ):
                  # HACK(label indices are swapped in RoBERTa pretrained model)
                  UpperCAmelCase_    , UpperCAmelCase_           =   label_list[2], label_list[1]
             UpperCAmelCase_           =   label_list

             # Make sure only the first process in distributed training processes the dataset,
             # and the others will use the cache.
             UpperCAmelCase_           =   cached_features_file + ".lock"
             with FileLock(__a ):
                  if os.path.exists(__a ) and not overwrite_cache:
                       logger.info(f"""Loading features from cached file {cached_features_file}""" )
                       UpperCAmelCase_           =   torch.load(__a )
                  else:
                       logger.info(f"""Creating features from dataset file at {data_dir}""" )

                       UpperCAmelCase_           =   (
                           processor.get_dev_examples(__a ) if evaluate else processor.get_train_examples(__a )
                       )

                       logger.info("Training examples: %s"   ,			len(__a ) )
                       UpperCAmelCase_           =   hans_convert_examples_to_features(__a   ,			__a   ,			__a   ,			__a )
                       logger.info("Saving features into cached file %s"   ,			__a )
                       torch.save(self.features   ,			__a )



        def __len__(self    :    List[Any] ):
             return len(self.features )



        def __getitem__(self    :    Any   ,			__a    :    Optional[Any] ):
             return self.features[i]






        def 					_lowercase						(self    :    Union[str, Any] ):
             return self.label_list


if is_tf_available():
    import tensorflow as tf




    class        __A      :
        a__       :						List[InputFeatures]



        def __init__(self    :    Union[str, Any]   ,			__a    :    str   ,			__a    :    PreTrainedTokenizer   ,			__a    :    str   ,			__a    :    Optional[int] = 128   ,			__a    :    Any=False   ,			__a    :    bool = False   ,			):
             UpperCAmelCase_           =   hans_processors[task]()
             UpperCAmelCase_           =   processor.get_labels()
             if tokenizer.__class__ in (
                 RobertaTokenizer,
                 RobertaTokenizerFast,
                 XLMRobertaTokenizer,
                 BartTokenizer,
                 BartTokenizerFast,
             ):
                  # HACK(label indices are swapped in RoBERTa pretrained model)
                  UpperCAmelCase_    , UpperCAmelCase_           =   label_list[2], label_list[1]
             UpperCAmelCase_           =   label_list

             UpperCAmelCase_           =   processor.get_dev_examples(__a ) if evaluate else processor.get_train_examples(__a )
             UpperCAmelCase_           =   hans_convert_examples_to_features(__a   ,			__a   ,			__a   ,			__a )

             def gen():
                  for ex_index, ex in tqdm.tqdm(enumerate(self.features )   ,			desc="convert examples to features" ):
                       if ex_index % 10000 == 0:
                            logger.info("Writing example %d of %d" % (ex_index, len(__a )) )

                       yield (
                           {
                               "example_id": 0,
                               "input_ids": ex.input_ids,
                               "attention_mask": ex.attention_mask,
                               "token_type_ids": ex.token_type_ids,
                           },
                           ex.label,
                       )

             UpperCAmelCase_           =   tf.data.Dataset.from_generator(
                 __a   ,			(
                     {
                         "example_id": tf.intaa,
                         "input_ids": tf.intaa,
                         "attention_mask": tf.intaa,
                         "token_type_ids": tf.intaa,
                     },
                     tf.intaa,
                 )   ,			(
                     {
                         "example_id": tf.TensorShape([] ),
                         "input_ids": tf.TensorShape([None, None] ),
                         "attention_mask": tf.TensorShape([None, None] ),
                         "token_type_ids": tf.TensorShape([None, None] ),
                     },
                     tf.TensorShape([] ),
                 )   ,			)



        def 					_lowercase						(self    :    int ):
             return self.dataset



        def __len__(self    :    Any ):
             return len(self.features )



        def __getitem__(self    :    int   ,			__a    :    Union[str, Any] ):
             return self.features[i]






        def 					_lowercase						(self    :    int ):
             return self.label_list




class        __A      ( UpperCamelCase__	):



    def 					_lowercase						(self    :    List[Any]   ,			__a    :    Dict ):
         return self._create_examples(self._read_tsv(os.path.join(__a   ,			"heuristics_train_set.txt" ) )   ,			"train" )



    def 					_lowercase						(self    :    Any   ,			__a    :    List[Any] ):
         return self._create_examples(self._read_tsv(os.path.join(__a   ,			"heuristics_evaluation_set.txt" ) )   ,			"dev" )



    def 					_lowercase						(self    :    Any ):
         return ["contradiction", "entailment", "neutral"]






    def 					_lowercase						(self    :    Union[str, Any]   ,			__a    :    Optional[int]   ,			__a    :    Union[str, Any] ):
         UpperCAmelCase_           =   []
         for i, line in enumerate(__a ):
              if i == 0:
                   continue
              UpperCAmelCase_           =   "%s-%s" % (set_type, line[0])
              UpperCAmelCase_           =   line[5]
              UpperCAmelCase_           =   line[6]
              UpperCAmelCase_           =   line[7][2:] if line[7].startswith("ex" ) else line[7]
              UpperCAmelCase_           =   line[0]
              examples.append(InputExample(guid=__a   ,			text_a=__a   ,			text_b=__a   ,			label=__a   ,			pairID=__a ) )
         return examples





def 	lowerCAmelCase_				(					snake_case_       : List[InputExample]					,    snake_case_       : List[str]					,    snake_case_       : int					,    snake_case_       : PreTrainedTokenizer					,    )    ->      Optional[Any]:


     '''simple docstring'''




     UpperCAmelCase_           =   {label: i for i, label in enumerate(snake_case_			)}

     UpperCAmelCase_           =   []
     for ex_index, example in tqdm.tqdm(enumerate(snake_case_			)					,    desc="convert examples to features"			):
          if ex_index % 1_00_00 == 0:
               logger.info("Writing example %d" % (ex_index)			)

          UpperCAmelCase_           =   tokenizer(
              example.text_a					,    example.text_b					,    add_special_tokens=snake_case_					,    max_length=snake_case_					,    padding="max_length"					,    truncation=snake_case_					,    return_overflowing_tokens=snake_case_					,    )

          UpperCAmelCase_           =   label_map[example.label] if example.label in label_map else 0

          UpperCAmelCase_           =   int(example.pairID			)

          features.append(InputFeatures(**snake_case_					,    label=snake_case_					,    pairID=snake_case_			)			)

     for i, example in enumerate(examples[:5]			):
          logger.info("*** Example ***"			)
          logger.info(f"""guid: {example}"""			)
          logger.info(f"""features: {features[i]}"""			)

     return features


SCREAMING_SNAKE_CASE_:     int  ={
    'hans': 3,
}






SCREAMING_SNAKE_CASE_:     Any  ={
    'hans': HansProcessor,
}




