






"""simple docstring"""



import os
import unittest

from transformers import ElectraTokenizerFast
from transformers.models.electra.tokenization_electra import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    ElectraTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english






@require_tokenizers
class 				__SCREAMING_SNAKE_CASE    (					UpperCamelCase							,		unittest.TestCase		):
							snake_case_  =				ElectraTokenizer
							snake_case_  =				ElectraTokenizerFast
							snake_case_  =				True
							snake_case_  =				True
							snake_case_  =				filter_non_english


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													super().setUp()

													A__    :	str			=	[
													    '[UNK]',
													    '[CLS]',
													    '[SEP]',
													    '[PAD]',
													    '[MASK]',
													    'want',
													    '##want',
													    '##ed',
													    'wa',
													    'un',
													    'runn',
													    '##ing',
													    ',',
													    'low',
													    'lowest',
													]
													A__    :	Any			=	os.path.join(self.tmpdirname      ,     VOCAB_FILES_NAMES["""vocab_file"""]				)
													with open(self.vocab_file      ,     """w"""      ,     encoding="""utf-8"""				) as vocab_writer:
																			vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]				)				)


							def     _UpperCamelCase							(      self   :    List[str]      ,     snake_case   :    Optional[Any]				):
													'''simple docstring'''





													A__    :	Tuple			=	'UNwant\u00E9d,running'
													A__    :	Optional[int]			=	'unwanted, running'
													return input_text, output_text


							def     _UpperCamelCase							(      self   :    int				):
													'''simple docstring'''





													A__    :	Any			=	self.tokenizer_class(self.vocab_file				)

													A__    :	int			=	tokenizer.tokenize("""UNwant\u00E9d,running"""				)
													self.assertListEqual(snake_case      ,     ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""]				)
													self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case				)      ,     [9, 6, 7, 12, 10, 11]				)


							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													if not self.test_rust_tokenizer:
																			return

													A__    :	List[str]			=	self.get_tokenizer()
													A__    :	Tuple			=	self.get_rust_tokenizer()

													A__    :	Union[str, Any]			=	'UNwant\u00E9d,running'

													A__    :	Optional[int]			=	tokenizer.tokenize(snake_case				)
													A__    :	int			=	rust_tokenizer.tokenize(snake_case				)
													self.assertListEqual(snake_case      ,     snake_case				)

													A__    :	Dict			=	tokenizer.encode(snake_case      ,     add_special_tokens=snake_case				)
													A__    :	Tuple			=	rust_tokenizer.encode(snake_case      ,     add_special_tokens=snake_case				)
													self.assertListEqual(snake_case      ,     snake_case				)

													A__    :	str			=	self.get_rust_tokenizer()
													A__    :	Dict			=	tokenizer.encode(snake_case				)
													A__    :	List[str]			=	rust_tokenizer.encode(snake_case				)
													self.assertListEqual(snake_case      ,     snake_case				)

													# With lower casing
													A__    :	Union[str, Any]			=	self.get_tokenizer(do_lower_case=snake_case				)
													A__    :	Union[str, Any]			=	self.get_rust_tokenizer(do_lower_case=snake_case				)

													A__    :	List[str]			=	'UNwant\u00E9d,running'

													A__    :	Optional[Any]			=	tokenizer.tokenize(snake_case				)
													A__    :	Tuple			=	rust_tokenizer.tokenize(snake_case				)
													self.assertListEqual(snake_case      ,     snake_case				)

													A__    :	List[str]			=	tokenizer.encode(snake_case      ,     add_special_tokens=snake_case				)
													A__    :	Tuple			=	rust_tokenizer.encode(snake_case      ,     add_special_tokens=snake_case				)
													self.assertListEqual(snake_case      ,     snake_case				)

													A__    :	List[str]			=	self.get_rust_tokenizer()
													A__    :	List[str]			=	tokenizer.encode(snake_case				)
													A__    :	Tuple			=	rust_tokenizer.encode(snake_case				)
													self.assertListEqual(snake_case      ,     snake_case				)


							def     _UpperCamelCase							(      self   :    Dict				):
													'''simple docstring'''





													A__    :	Dict			=	BasicTokenizer()

													self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz"""				)      ,     ["""ah""", """\u535A""", """\u63A8""", """zz"""]				)


							def     _UpperCamelCase							(      self   :    Optional[Any]				):
													'''simple docstring'''





													A__    :	Any			=	BasicTokenizer(do_lower_case=snake_case				)

													self.assertListEqual(
													    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """				)      ,     ["""hello""", """!""", """how""", """are""", """you""", """?"""]				)
													self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""				)      ,     ["""hello"""]				)


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													A__    :	Tuple			=	BasicTokenizer(do_lower_case=snake_case      ,     strip_accents=snake_case				)

													self.assertListEqual(
													    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """				)      ,     ["""hällo""", """!""", """how""", """are""", """you""", """?"""]				)
													self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""				)      ,     ["""h\u00E9llo"""]				)


							def     _UpperCamelCase							(      self   :    List[str]				):
													'''simple docstring'''





													A__    :	List[str]			=	BasicTokenizer(do_lower_case=snake_case      ,     strip_accents=snake_case				)

													self.assertListEqual(
													    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """				)      ,     ["""hallo""", """!""", """how""", """are""", """you""", """?"""]				)
													self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""				)      ,     ["""hello"""]				)


							def     _UpperCamelCase							(      self   :    List[Any]				):
													'''simple docstring'''





													A__    :	List[Any]			=	BasicTokenizer(do_lower_case=snake_case				)

													self.assertListEqual(
													    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """				)      ,     ["""hallo""", """!""", """how""", """are""", """you""", """?"""]				)
													self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""				)      ,     ["""hello"""]				)


							def     _UpperCamelCase							(      self   :    int				):
													'''simple docstring'''





													A__    :	Tuple			=	BasicTokenizer(do_lower_case=snake_case				)

													self.assertListEqual(
													    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """				)      ,     ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""]				)


							def     _UpperCamelCase							(      self   :    Any				):
													'''simple docstring'''





													A__    :	List[str]			=	BasicTokenizer(do_lower_case=snake_case      ,     strip_accents=snake_case				)

													self.assertListEqual(
													    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """				)      ,     ["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""]				)


							def     _UpperCamelCase							(      self   :    List[Any]				):
													'''simple docstring'''





													A__    :	Union[str, Any]			=	BasicTokenizer(do_lower_case=snake_case      ,     strip_accents=snake_case				)

													self.assertListEqual(
													    tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """				)      ,     ["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""]				)


							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													A__    :	Optional[int]			=	BasicTokenizer(do_lower_case=snake_case      ,     never_split=["""[UNK]"""]				)

													self.assertListEqual(
													    tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU? [UNK]"""				)      ,     ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""]				)


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													A__    :	int			=	['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

													A__    :	Tuple			=	{}
													for i, token in enumerate(snake_case				):
																			A__    :	Union[str, Any]			=	i
													A__    :	List[Any]			=	WordpieceTokenizer(vocab=snake_case      ,     unk_token="""[UNK]"""				)

													self.assertListEqual(tokenizer.tokenize(""""""				)      ,     []				)

													self.assertListEqual(tokenizer.tokenize("""unwanted running"""				)      ,     ["""un""", """##want""", """##ed""", """runn""", """##ing"""]				)

													self.assertListEqual(tokenizer.tokenize("""unwantedX running"""				)      ,     ["""[UNK]""", """runn""", """##ing"""]				)


							def     _UpperCamelCase							(      self   :    Dict				):
													'''simple docstring'''





													self.assertTrue(_is_whitespace(""" """				)				)
													self.assertTrue(_is_whitespace("""\t"""				)				)
													self.assertTrue(_is_whitespace("""\r"""				)				)
													self.assertTrue(_is_whitespace("""\n"""				)				)
													self.assertTrue(_is_whitespace("""\u00A0"""				)				)

													self.assertFalse(_is_whitespace("""A"""				)				)
													self.assertFalse(_is_whitespace("""-"""				)				)


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													self.assertTrue(_is_control("""\u0005"""				)				)

													self.assertFalse(_is_control("""A"""				)				)
													self.assertFalse(_is_control(""" """				)				)
													self.assertFalse(_is_control("""\t"""				)				)
													self.assertFalse(_is_control("""\r"""				)				)


							def     _UpperCamelCase							(      self   :    Optional[Any]				):
													'''simple docstring'''





													self.assertTrue(_is_punctuation("""-"""				)				)
													self.assertTrue(_is_punctuation("""$"""				)				)
													self.assertTrue(_is_punctuation("""`"""				)				)
													self.assertTrue(_is_punctuation("""."""				)				)

													self.assertFalse(_is_punctuation("""A"""				)				)
													self.assertFalse(_is_punctuation(""" """				)				)


							def     _UpperCamelCase							(      self   :    Optional[Any]				):
													'''simple docstring'''





													A__    :	List[str]			=	self.get_tokenizer()
													A__    :	int			=	self.get_rust_tokenizer()

													# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
													self.assertListEqual([tokenizer.tokenize(snake_case				) for t in ["""Test""", """\xad""", """test"""]]      ,     [["""[UNK]"""], [], ["""[UNK]"""]]				)

													self.assertListEqual(
													    [rust_tokenizer.tokenize(snake_case				) for t in ["""Test""", """\xad""", """test"""]]      ,     [["""[UNK]"""], [], ["""[UNK]"""]]				)


							@slow
							def     _UpperCamelCase							(      self   :    Union[str, Any]				):
													'''simple docstring'''





													A__    :	str			=	self.tokenizer_class.from_pretrained("""google/electra-base-discriminator"""				)

													A__    :	str			=	tokenizer.encode("""sequence builders"""      ,     add_special_tokens=snake_case				)
													A__    :	Optional[int]			=	tokenizer.encode("""multi-sequence build"""      ,     add_special_tokens=snake_case				)

													A__    :	List[str]			=	tokenizer.build_inputs_with_special_tokens(snake_case				)
													A__    :	Optional[Any]			=	tokenizer.build_inputs_with_special_tokens(snake_case      ,     snake_case				)

													assert encoded_sentence == [101] + text + [102]
													assert encoded_pair == [101] + text + [102] + text_a + [102]


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																			with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'				):
																									A__    :	List[str]			=	self.rust_tokenizer_class.from_pretrained(snake_case      ,     **snake_case				)

																									A__    :	Optional[int]			=	F'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
																									A__    :	int			=	tokenizer_r.encode_plus(
																									    snake_case      ,     return_attention_mask=snake_case      ,     return_token_type_ids=snake_case      ,     return_offsets_mapping=snake_case      ,     add_special_tokens=snake_case      ,     )

																									A__    :	List[Any]			=	tokenizer_r.do_lower_case if hasattr(snake_case      ,     """do_lower_case"""				) else False
																									A__    :	List[Any]			=	(
																									    [
																									        ((0, 0), tokenizer_r.cls_token),
																									        ((0, 1), 'A'),
																									        ((1, 2), ','),
																									        ((3, 5), 'na'),
																									        ((5, 6), '##ï'),
																									        ((6, 8), '##ve'),
																									        ((9, 15), tokenizer_r.mask_token),
																									        ((16, 21), 'Allen'),
																									        ((21, 23), '##NL'),
																									        ((23, 24), '##P'),
																									        ((25, 33), 'sentence'),
																									        ((33, 34), '.'),
																									        ((0, 0), tokenizer_r.sep_token),
																									    ]
																									    if not do_lower_case
																									    else [
																									        ((0, 0), tokenizer_r.cls_token),
																									        ((0, 1), 'a'),
																									        ((1, 2), ','),
																									        ((3, 8), 'naive'),
																									        ((9, 15), tokenizer_r.mask_token),
																									        ((16, 21), 'allen'),
																									        ((21, 23), '##nl'),
																									        ((23, 24), '##p'),
																									        ((25, 33), 'sentence'),
																									        ((33, 34), '.'),
																									        ((0, 0), tokenizer_r.sep_token),
																									    ]
																									)

																									self.assertEqual(
																									    [e[1] for e in expected_results]      ,     tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""]				)				)
																									self.assertEqual([e[0] for e in expected_results]      ,     tokens["""offset_mapping"""]				)


							def     _UpperCamelCase							(      self   :    Union[str, Any]				):
													'''simple docstring'''





													A__    :	List[str]			=	['的', '人', '有']
													A__    :	int			=	''.join(snake_case				)
													for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																			with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'				):
																									A__    :	List[Any]			=	True
																									A__    :	Dict			=	self.tokenizer_class.from_pretrained(snake_case      ,     **snake_case				)
																									A__    :	str			=	self.rust_tokenizer_class.from_pretrained(snake_case      ,     **snake_case				)

																									A__    :	Optional[Any]			=	tokenizer_p.encode(snake_case      ,     add_special_tokens=snake_case				)
																									A__    :	str			=	tokenizer_r.encode(snake_case      ,     add_special_tokens=snake_case				)

																									A__    :	Union[str, Any]			=	tokenizer_r.convert_ids_to_tokens(snake_case				)
																									A__    :	List[Any]			=	tokenizer_p.convert_ids_to_tokens(snake_case				)

																									# it is expected that each Chinese character is not preceded by "##"
																									self.assertListEqual(snake_case      ,     snake_case				)
																									self.assertListEqual(snake_case      ,     snake_case				)

																									A__    :	List[str]			=	False
																									A__    :	Any			=	self.rust_tokenizer_class.from_pretrained(snake_case      ,     **snake_case				)
																									A__    :	Dict			=	self.tokenizer_class.from_pretrained(snake_case      ,     **snake_case				)

																									A__    :	List[str]			=	tokenizer_r.encode(snake_case      ,     add_special_tokens=snake_case				)
																									A__    :	Tuple			=	tokenizer_p.encode(snake_case      ,     add_special_tokens=snake_case				)

																									A__    :	Optional[Any]			=	tokenizer_r.convert_ids_to_tokens(snake_case				)
																									A__    :	Tuple			=	tokenizer_p.convert_ids_to_tokens(snake_case				)

																									# it is expected that only the first Chinese character is not preceded by "##".
																									A__    :	List[Any]			=	[
																									    F'##{token}' if idx != 0 else token for idx, token in enumerate(snake_case				)
																									]
																									self.assertListEqual(snake_case      ,     snake_case				)
																									self.assertListEqual(snake_case      ,     snake_case				)













'''simple docstring'''


import inspect
import unittest

from transformers import SwinaSRConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import SwinaSRForImageSuperResolution, SwinaSRModel
    from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import SwinaSRImageProcessor


class 		UpperCamelCase__     :
      '''simple docstring'''






      def __init__(     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE=13     , SCREAMING_SNAKE_CASE=32     , SCREAMING_SNAKE_CASE=1     , SCREAMING_SNAKE_CASE=3     , SCREAMING_SNAKE_CASE=16     , SCREAMING_SNAKE_CASE=[1, 2, 1]     , SCREAMING_SNAKE_CASE=[2, 2, 4]     , SCREAMING_SNAKE_CASE=2     , SCREAMING_SNAKE_CASE=2.0     , SCREAMING_SNAKE_CASE=True     , SCREAMING_SNAKE_CASE=0.0     , SCREAMING_SNAKE_CASE=0.0     , SCREAMING_SNAKE_CASE=0.1     , SCREAMING_SNAKE_CASE="gelu"     , SCREAMING_SNAKE_CASE=False     , SCREAMING_SNAKE_CASE=True     , SCREAMING_SNAKE_CASE=0.0_2     , SCREAMING_SNAKE_CASE=1e-5     , SCREAMING_SNAKE_CASE=True     , SCREAMING_SNAKE_CASE=None     , SCREAMING_SNAKE_CASE=False     , SCREAMING_SNAKE_CASE=2     , )				->  Tuple:
        __lowerCAmelCase		:    Optional[int]			     =  parent
        __lowerCAmelCase		:    List[str]			     =  batch_size
        __lowerCAmelCase		:    int			     =  image_size
        __lowerCAmelCase		:    List[Any]			     =  patch_size
        __lowerCAmelCase		:    List[Any]			     =  num_channels
        __lowerCAmelCase		:    Any			     =  embed_dim
        __lowerCAmelCase		:    List[str]			     =  depths
        __lowerCAmelCase		:    List[str]			     =  num_heads
        __lowerCAmelCase		:    Any			     =  window_size
        __lowerCAmelCase		:    Any			     =  mlp_ratio
        __lowerCAmelCase		:    Tuple			     =  qkv_bias
        __lowerCAmelCase		:    Optional[Any]			     =  hidden_dropout_prob
        __lowerCAmelCase		:    str			     =  attention_probs_dropout_prob
        __lowerCAmelCase		:    Optional[Any]			     =  drop_path_rate
        __lowerCAmelCase		:    Dict			     =  hidden_act
        __lowerCAmelCase		:    Dict			     =  use_absolute_embeddings
        __lowerCAmelCase		:    List[str]			     =  patch_norm
        __lowerCAmelCase		:    Dict			     =  layer_norm_eps
        __lowerCAmelCase		:    str			     =  initializer_range
        __lowerCAmelCase		:    int			     =  is_training
        __lowerCAmelCase		:    Optional[int]			     =  scope
        __lowerCAmelCase		:    str			     =  use_labels
        __lowerCAmelCase		:    int			     =  upscale

        # here we set some attributes to make tests pass
        __lowerCAmelCase		:    Any			     =  len(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Optional[int]			     =  embed_dim
        __lowerCAmelCase		:    Union[str, Any]			     =  (image_size // patch_size) ** 2




      def 	snake_case  (     self )				->  Tuple:
        __lowerCAmelCase		:    Union[str, Any]			     =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

        __lowerCAmelCase		:    Union[str, Any]			     =  None
        if self.use_labels:
          __lowerCAmelCase		:    int			     =  ids_tensor([self.batch_size]     , self.type_sequence_label_size )

        __lowerCAmelCase		:    List[Any]			     =  self.get_config()

        return config, pixel_values, labels




      def 	snake_case  (     self )				->  Any:
        return SwinaSRConfig(
            image_size=self.image_size     , patch_size=self.patch_size     , num_channels=self.num_channels     , embed_dim=self.embed_dim     , depths=self.depths     , num_heads=self.num_heads     , window_size=self.window_size     , mlp_ratio=self.mlp_ratio     , qkv_bias=self.qkv_bias     , hidden_dropout_prob=self.hidden_dropout_prob     , attention_probs_dropout_prob=self.attention_probs_dropout_prob     , drop_path_rate=self.drop_path_rate     , hidden_act=self.hidden_act     , use_absolute_embeddings=self.use_absolute_embeddings     , path_norm=self.patch_norm     , layer_norm_eps=self.layer_norm_eps     , initializer_range=self.initializer_range     , upscale=self.upscale     , )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Optional[Any]:
        __lowerCAmelCase		:    Dict			     =  SwinaSRModel(config=SCREAMING_SNAKE_CASE )
        model.to(SCREAMING_SNAKE_CASE )
        model.eval()
        __lowerCAmelCase		:    Dict			     =  model(SCREAMING_SNAKE_CASE )

        self.parent.assertEqual(
            result.last_hidden_state.shape     , (self.batch_size, self.embed_dim, self.image_size, self.image_size) )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Dict:
        __lowerCAmelCase		:    Any			     =  SwinaSRForImageSuperResolution(SCREAMING_SNAKE_CASE )
        model.to(SCREAMING_SNAKE_CASE )
        model.eval()
        __lowerCAmelCase		:    Tuple			     =  model(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Dict			     =  self.image_size * self.upscale
        self.parent.assertEqual(
            result.reconstruction.shape     , (self.batch_size, self.num_channels, expected_image_size, expected_image_size) )







      def 	snake_case  (     self )				->  Any:
        __lowerCAmelCase		:    List[Any]			     =  self.prepare_config_and_inputs()
        __lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase		:    Union[str, Any]			     =  config_and_inputs
        __lowerCAmelCase		:    str			     =  {'pixel_values': pixel_values}
        return config, inputs_dict



@require_torch
class 		UpperCamelCase__     (       a	,	a	,	unittest.TestCase							):
      '''simple docstring'''






      _snake_case           =				(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
      _snake_case           =				{'''feature-extraction''': SwinaSRModel} if is_torch_available() else {}

      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False




      def 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase		:    Optional[Any]			     =  SwinaSRModelTester(self )
        __lowerCAmelCase		:    List[str]			     =  ConfigTester(self     , config_class=SCREAMING_SNAKE_CASE     , embed_dim=37 )




      def 	snake_case  (     self )				->  Optional[int]:
        self.config_tester.create_and_test_config_to_json_string()
        self.config_tester.create_and_test_config_to_json_file()
        self.config_tester.create_and_test_config_from_and_save_pretrained()
        self.config_tester.create_and_test_config_with_num_labels()
        self.config_tester.check_config_can_be_init_without_params()
        self.config_tester.check_config_arguments_init()




      def 	snake_case  (     self )				->  Tuple:
        __lowerCAmelCase		:    Optional[int]			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Optional[Any]:
        __lowerCAmelCase		:    Union[str, Any]			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_super_resolution(*SCREAMING_SNAKE_CASE )




      @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.' )
      def 	snake_case  (     self )				->  Any:
        pass




      @unittest.skip(reason='Swin2SR does not use inputs_embeds' )
      def 	snake_case  (     self )				->  List[str]:
        pass




      @unittest.skip(reason='Swin2SR does not support training yet' )
      def 	snake_case  (     self )				->  int:
        pass




      @unittest.skip(reason='Swin2SR does not support training yet' )
      def 	snake_case  (     self )				->  List[str]:
        pass




      def 	snake_case  (     self )				->  int:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Any			     =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    List[str]			     =  model_class(SCREAMING_SNAKE_CASE )
          self.assertIsInstance(model.get_input_embeddings()     , (nn.Module) )
          __lowerCAmelCase		:    Union[str, Any]			     =  model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE     , nn.Linear ) )




      def 	snake_case  (     self )				->  int:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    str			     =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Optional[Any]			     =  model_class(SCREAMING_SNAKE_CASE )
          __lowerCAmelCase		:    List[str]			     =  inspect.signature(model.forward )
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          __lowerCAmelCase		:    Optional[int]			     =  [*signature.parameters.keys()]

          __lowerCAmelCase		:    Dict			     =  ['pixel_values']
          self.assertListEqual(arg_names[:1]     , SCREAMING_SNAKE_CASE )




      @slow
      def 	snake_case  (     self )				->  List[Any]:
        for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          __lowerCAmelCase		:    Any			     =  SwinaSRModel.from_pretrained(SCREAMING_SNAKE_CASE )
          self.assertIsNotNone(SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Union[str, Any]			     =  self.model_tester.prepare_config_and_inputs_for_common()

        __lowerCAmelCase		:    List[Any]			     =  _config_zero_init(SCREAMING_SNAKE_CASE )
        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Any			     =  model_class(config=SCREAMING_SNAKE_CASE )
          for name, param in model.named_parameters():
            if "logit_scale" in name:
              continue
            if param.requires_grad:
              self.assertIn(
                  ((param.data.mean() * 1e9).round() / 1e9).item()     , [0.0, 1.0]     , msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""     , )







      def 	snake_case  (     self )				->  Dict:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Dict			     =  self.model_tester.prepare_config_and_inputs_for_common()
        __lowerCAmelCase		:    Dict			     =  True

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Tuple			     =  True
          __lowerCAmelCase		:    int			     =  False
          __lowerCAmelCase		:    Dict			     =  True
          __lowerCAmelCase		:    Optional[int]			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    Any			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )
          __lowerCAmelCase		:    Dict			     =  outputs.attentions
          __lowerCAmelCase		:    Optional[Any]			     =  len(self.model_tester.depths )
          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          # check that output_attentions also work using config
          del inputs_dict["output_attentions"]
          __lowerCAmelCase		:    str			     =  True
          __lowerCAmelCase		:    Any			     =  config.window_size**2
          __lowerCAmelCase		:    int			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    Optional[int]			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )
          __lowerCAmelCase		:    Optional[Any]			     =  outputs.attentions
          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          self.assertListEqual(
              list(attentions[0].shape[-3:] )     , [self.model_tester.num_heads[0], window_size_squared, window_size_squared]     , )
          __lowerCAmelCase		:    Dict			     =  len(SCREAMING_SNAKE_CASE )

          # Check attention is always last and order is fine
          __lowerCAmelCase		:    Optional[int]			     =  True
          __lowerCAmelCase		:    List[Any]			     =  True
          __lowerCAmelCase		:    Union[str, Any]			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    List[str]			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )

          self.assertEqual(out_len + 1     , len(SCREAMING_SNAKE_CASE ) )

          __lowerCAmelCase		:    Optional[Any]			     =  outputs.attentions

          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          self.assertListEqual(
              list(self_attentions[0].shape[-3:] )     , [self.model_tester.num_heads[0], window_size_squared, window_size_squared]     , )



@require_vision
@require_torch
@slow
class 		UpperCamelCase__     (       unittest.TestCase							):
      '''simple docstring'''






      def 	snake_case  (     self )				->  str:
        __lowerCAmelCase		:    int			     =  SwinaSRImageProcessor()
        __lowerCAmelCase		:    Optional[Any]			     =  SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64' ).to(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    int			     =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
        __lowerCAmelCase		:    Union[str, Any]			     =  processor(images=SCREAMING_SNAKE_CASE     , return_tensors='pt' ).to(SCREAMING_SNAKE_CASE )

        # forward pass
        with torch.no_grad():
          __lowerCAmelCase		:    List[Any]			     =  model(**SCREAMING_SNAKE_CASE )

        # verify the logits
        __lowerCAmelCase		:    Dict			     =  torch.Size([1, 3, 9_76, 12_96] )
        self.assertEqual(outputs.reconstruction.shape     , SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Optional[int]			     =  torch.tensor(
            [[0.5_4_5_8, 0.5_5_4_6, 0.5_6_3_8], [0.5_5_2_6, 0.5_5_6_5, 0.5_6_5_1], [0.5_3_9_6, 0.5_4_2_6, 0.5_6_2_1]] ).to(SCREAMING_SNAKE_CASE )
        self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]     , SCREAMING_SNAKE_CASE     , atol=1e-4 ) )





