



"""simple docstring"""






import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, PerceiverTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
   lowerCAmelCase__        =				'''pt'''
elif is_tf_available():
   lowerCAmelCase__        =				'''tf'''
else:
   lowerCAmelCase__        =				'''jax'''






class        __snake_case       (	_lowercase  ,     unittest.TestCase):
  snake_case__				:   Union[str, Any]  			=						PerceiverTokenizer
  snake_case__				:   Union[str, Any]  			=						False




  def 						SCREAMING_SNAKE_CASE				( self     :						str		):






         """simple docstring"""






         super().setUp()
         _lowerCamelCase						:				Any    			= PerceiverTokenizer()
         tokenizer.save_pretrained(self.tmpdirname		)




  @cached_property
  def 						SCREAMING_SNAKE_CASE				( self     :						Tuple		):






         """simple docstring"""






         return PerceiverTokenizer.from_pretrained('''deepmind/language-perceiver'''		)




  def 						SCREAMING_SNAKE_CASE				( self     :						int						,					**__lowerCAmelCase     :						Optional[Any]		):






         """simple docstring"""






         return self.tokenizer_class.from_pretrained(self.tmpdirname						,					**__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE				( self     :						Union[str, Any]						,					__lowerCAmelCase     :						int						,					__lowerCAmelCase     :						List[Any]=False						,					__lowerCAmelCase     :						Tuple=2_0						,					__lowerCAmelCase     :						List[str]=5		):






         """simple docstring"""






         _lowerCamelCase						:				Optional[int]    			= []
         for i in range(len(__lowerCAmelCase		)		):
                try:
                       _lowerCamelCase						:				Optional[Any]    			= tokenizer.decode([i]						,					clean_up_tokenization_spaces=__lowerCAmelCase		)
                except UnicodeDecodeError:
                       pass
                toks.append((i, tok)		)

         _lowerCamelCase						:				Any    			= list(filter(lambda __lowerCAmelCase		: re.match(R'''^[ a-zA-Z]+$'''						,					t[1]		)						,					__lowerCAmelCase		)		)
         _lowerCamelCase						:				Optional[Any]    			= list(filter(lambda __lowerCAmelCase		: [t[0]] == tokenizer.encode(t[1]						,					add_special_tokens=__lowerCAmelCase		)						,					__lowerCAmelCase		)		)
         if max_length is not None and len(__lowerCAmelCase		) > max_length:
                _lowerCamelCase						:				Optional[Any]    			= toks[:max_length]
         if min_length is not None and len(__lowerCAmelCase		) < min_length and len(__lowerCAmelCase		) > 0:
                while len(__lowerCAmelCase		) < min_length:
                       _lowerCamelCase						:				Tuple    			= toks + toks
        # toks_str = [t[1] for t in toks]
         _lowerCamelCase						:				List[Any]    			= [t[0] for t in toks]

         # Ensure consistency
         _lowerCamelCase						:				Any    			= tokenizer.decode(__lowerCAmelCase						,					clean_up_tokenization_spaces=__lowerCAmelCase		)
         if " " not in output_txt and len(__lowerCAmelCase		) > 1:
                _lowerCamelCase						:				int    			= (
                    tokenizer.decode([toks_ids[0]]						,					clean_up_tokenization_spaces=__lowerCAmelCase		)
                    + ''' '''
                    + tokenizer.decode(toks_ids[1:]						,					clean_up_tokenization_spaces=__lowerCAmelCase		)
                )
         if with_prefix_space:
                _lowerCamelCase						:				Any    			= ''' ''' + output_txt
         _lowerCamelCase						:				int    			= tokenizer.encode(__lowerCAmelCase						,					add_special_tokens=__lowerCAmelCase		)
         return output_txt, output_ids




  def 						SCREAMING_SNAKE_CASE				( self     :						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:				Tuple    			= self.perceiver_tokenizer
         _lowerCamelCase						:				Optional[Any]    			= '''Unicode €.'''
         _lowerCamelCase						:				str    			= tokenizer(__lowerCAmelCase		)
         _lowerCamelCase						:				List[Any]    			= [4, 9_1, 1_1_6, 1_1_1, 1_0_5, 1_1_7, 1_0_6, 1_0_7, 3_8, 2_3_2, 1_3_6, 1_7_8, 5_2, 5]
         self.assertEqual(encoded['''input_ids''']						,					__lowerCAmelCase		)

         # decoding
         _lowerCamelCase						:				Union[str, Any]    			= tokenizer.decode(__lowerCAmelCase		)
         self.assertEqual(__lowerCAmelCase						,					'''[CLS]Unicode €.[SEP]'''		)

         _lowerCamelCase						:				Union[str, Any]    			= tokenizer('''e è é ê ë'''		)
         _lowerCamelCase						:				int    			= [4, 1_0_7, 3_8, 2_0_1, 1_7_4, 3_8, 2_0_1, 1_7_5, 3_8, 2_0_1, 1_7_6, 3_8, 2_0_1, 1_7_7, 5]
         self.assertEqual(encoded['''input_ids''']						,					__lowerCAmelCase		)
         # decoding
         _lowerCamelCase						:				List[Any]    			= tokenizer.decode(__lowerCAmelCase		)
         self.assertEqual(__lowerCAmelCase						,					'''[CLS]e è é ê ë[SEP]'''		)

         # encode/decode, but with `encode` instead of `__call__`
         self.assertEqual(tokenizer.decode(tokenizer.encode('''e è é ê ë'''		)		)						,					'''[CLS]e è é ê ë[SEP]'''		)




  def 						SCREAMING_SNAKE_CASE				( self     :						Dict		):






         """simple docstring"""






         _lowerCamelCase						:				List[str]    			= self.perceiver_tokenizer
         _lowerCamelCase						:				List[Any]    			= ['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
         # fmt: off
         _lowerCamelCase						:				Dict    			= [4, 7_1, 3_8, 1_1_4, 1_1_7, 1_1_6, 1_0_9, 3_8, 1_1_8, 1_0_3, 1_2_0, 1_0_3, 1_0_9, 1_2_0, 1_0_3, 1_1_8, 1_1_0, 3_8, 1_0_8, 1_1_7, 1_2_0, 3_8, 1_2_1, 1_2_3, 1_1_5, 1_1_5, 1_0_3, 1_2_0, 1_1_1, 1_2_8, 1_0_3, 1_2_2, 1_1_1, 1_1_7, 1_1_6, 5_2, 5, 0]
         # fmt: on
         _lowerCamelCase						:				Optional[Any]    			= tokenizer(__lowerCAmelCase						,					padding=__lowerCAmelCase						,					return_tensors=__lowerCAmelCase		)
         self.assertIsInstance(__lowerCAmelCase						,					__lowerCAmelCase		)

         if FRAMEWORK != "jax":
                _lowerCamelCase						:				str    			= list(batch.input_ids.numpy()[0]		)
         else:
                _lowerCamelCase						:				Any    			= list(batch.input_ids.tolist()[0]		)

         self.assertListEqual(__lowerCAmelCase						,					__lowerCAmelCase		)

         self.assertEqual((2, 3_8)						,					batch.input_ids.shape		)
         self.assertEqual((2, 3_8)						,					batch.attention_mask.shape		)




  def 						SCREAMING_SNAKE_CASE				( self     :						Union[str, Any]		):






         """simple docstring"""






         _lowerCamelCase						:				List[Any]    			= self.perceiver_tokenizer
         _lowerCamelCase						:				Optional[int]    			= ['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
         _lowerCamelCase						:				Union[str, Any]    			= tokenizer(__lowerCAmelCase						,					padding=__lowerCAmelCase						,					return_tensors=__lowerCAmelCase		)
         # check if input_ids are returned and no decoder_input_ids
         self.assertIn('''input_ids'''						,					__lowerCAmelCase		)
         self.assertIn('''attention_mask'''						,					__lowerCAmelCase		)
         self.assertNotIn('''decoder_input_ids'''						,					__lowerCAmelCase		)
         self.assertNotIn('''decoder_attention_mask'''						,					__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE				( self     :						Optional[Any]		):






         """simple docstring"""






         _lowerCamelCase						:				Optional[int]    			= self.perceiver_tokenizer
         _lowerCamelCase						:				str    			= [
             '''Summary of the text.''',
             '''Another summary.''',
         ]
         _lowerCamelCase						:				int    			= tokenizer(
             text_target=__lowerCAmelCase						,					max_length=3_2						,					padding='''max_length'''						,					truncation=__lowerCAmelCase						,					return_tensors=__lowerCAmelCase		)
         self.assertEqual(3_2						,					targets['''input_ids'''].shape[1]		)




  def 						SCREAMING_SNAKE_CASE				( self     :						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:				int    			= self.get_tokenizers()
         for tokenizer in tokenizers:
                with self.subTest(f'''{tokenizer.__class__.__name__}'''		):
                       self.assertNotEqual(tokenizer.model_max_length						,					4_2		)

        # Now let's start the test
         _lowerCamelCase						:				List[str]    			= self.get_tokenizers()
         for tokenizer in tokenizers:
                with self.subTest(f'''{tokenizer.__class__.__name__}'''		):
                       # Isolate this from the other tests because we save additional tokens/etc
                       _lowerCamelCase						:				Optional[int]    			= tempfile.mkdtemp()

                       _lowerCamelCase						:				Optional[int]    			= ''' He is very happy, UNwant\u00E9d,running'''
                       _lowerCamelCase						:				Dict    			= tokenizer.encode(__lowerCAmelCase						,					add_special_tokens=__lowerCAmelCase		)
                       tokenizer.save_pretrained(__lowerCAmelCase		)

                       _lowerCamelCase						:				Any    			= tokenizer.__class__.from_pretrained(__lowerCAmelCase		)
                       _lowerCamelCase						:				List[str]    			= after_tokenizer.encode(__lowerCAmelCase						,					add_special_tokens=__lowerCAmelCase		)
                       self.assertListEqual(__lowerCAmelCase						,					__lowerCAmelCase		)

                       shutil.rmtree(__lowerCAmelCase		)

         _lowerCamelCase						:				str    			= self.get_tokenizers(model_max_length=4_2		)
         for tokenizer in tokenizers:
                with self.subTest(f'''{tokenizer.__class__.__name__}'''		):
                       # Isolate this from the other tests because we save additional tokens/etc
                       _lowerCamelCase						:				List[Any]    			= tempfile.mkdtemp()

                       _lowerCamelCase						:				Optional[Any]    			= ''' He is very happy, UNwant\u00E9d,running'''
                       tokenizer.add_tokens(['''bim''', '''bambam''']		)
                       _lowerCamelCase						:				Tuple    			= tokenizer.additional_special_tokens
                       additional_special_tokens.append('''new_additional_special_token'''		)
                       tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens}		)
                       _lowerCamelCase						:				Any    			= tokenizer.encode(__lowerCAmelCase						,					add_special_tokens=__lowerCAmelCase		)
                       tokenizer.save_pretrained(__lowerCAmelCase		)

                       _lowerCamelCase						:				Optional[Any]    			= tokenizer.__class__.from_pretrained(__lowerCAmelCase		)
                       _lowerCamelCase						:				Dict    			= after_tokenizer.encode(__lowerCAmelCase						,					add_special_tokens=__lowerCAmelCase		)
                       self.assertListEqual(__lowerCAmelCase						,					__lowerCAmelCase		)
                       self.assertIn('''new_additional_special_token'''						,					after_tokenizer.additional_special_tokens		)
                       self.assertEqual(after_tokenizer.model_max_length						,					4_2		)

                       _lowerCamelCase						:				Tuple    			= tokenizer.__class__.from_pretrained(__lowerCAmelCase						,					model_max_length=4_3		)
                       self.assertEqual(tokenizer.model_max_length						,					4_3		)

                       shutil.rmtree(__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE				( self     :						Optional[Any]		):






         """simple docstring"""






         _lowerCamelCase						:				List[str]    			= []
         if self.test_slow_tokenizer:
                tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())		)

         if self.test_rust_tokenizer:
                tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())		)

         for tokenizer_class, tokenizer_utils in tokenizer_list:
                with tempfile.TemporaryDirectory() as tmp_dir:
                       tokenizer_utils.save_pretrained(__lowerCAmelCase		)

                       with open(os.path.join(__lowerCAmelCase						,					'''special_tokens_map.json'''		)						,					encoding='''utf-8'''		) as json_file:
                              _lowerCamelCase						:				Union[str, Any]    			= json.load(__lowerCAmelCase		)

                       with open(os.path.join(__lowerCAmelCase						,					'''tokenizer_config.json'''		)						,					encoding='''utf-8'''		) as json_file:
                              _lowerCamelCase						:				Optional[int]    			= json.load(__lowerCAmelCase		)

                       _lowerCamelCase						:				str    			= [f'''<extra_id_{i}>''' for i in range(1_2_5		)]

                       _lowerCamelCase						:				Optional[int]    			= added_tokens_extra_ids + [
                           '''an_additional_special_token'''
                       ]
                       _lowerCamelCase						:				Any    			= added_tokens_extra_ids + [
                           '''an_additional_special_token'''
                       ]

                       with open(os.path.join(__lowerCAmelCase						,					'''special_tokens_map.json'''		)						,					'''w'''						,					encoding='''utf-8'''		) as outfile:
                              json.dump(__lowerCAmelCase						,					__lowerCAmelCase		)
                       with open(os.path.join(__lowerCAmelCase						,					'''tokenizer_config.json'''		)						,					'''w'''						,					encoding='''utf-8'''		) as outfile:
                              json.dump(__lowerCAmelCase						,					__lowerCAmelCase		)

                       # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
                       # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
                       # "special_tokens_map.json" files
                       _lowerCamelCase						:				Dict    			= tokenizer_class.from_pretrained(
                           __lowerCAmelCase						,					)
                       self.assertIn(
                           '''an_additional_special_token'''						,					tokenizer_without_change_in_init.additional_special_tokens		)
                       self.assertEqual(
                           ['''an_additional_special_token''']						,					tokenizer_without_change_in_init.convert_ids_to_tokens(
                               tokenizer_without_change_in_init.convert_tokens_to_ids(['''an_additional_special_token''']		)		)						,					)

                       # Now we test that we can change the value of additional_special_tokens in the from_pretrained
                       _lowerCamelCase						:				Union[str, Any]    			= added_tokens_extra_ids + [AddedToken('''a_new_additional_special_token'''						,					lstrip=__lowerCAmelCase		)]
                       _lowerCamelCase						:				int    			= tokenizer_class.from_pretrained(
                           __lowerCAmelCase						,					additional_special_tokens=__lowerCAmelCase						,					)

                       self.assertIn('''a_new_additional_special_token'''						,					tokenizer.additional_special_tokens		)
                       self.assertEqual(
                           ['''a_new_additional_special_token''']						,					tokenizer.convert_ids_to_tokens(
                               tokenizer.convert_tokens_to_ids(['''a_new_additional_special_token''']		)		)						,					)




  def 						SCREAMING_SNAKE_CASE				( self     :						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:				Optional[Any]    			= self.perceiver_tokenizer
         self.assertEqual(tokenizer.decode([1_7_8]		)						,					'''�'''		)




  def 						SCREAMING_SNAKE_CASE				( self     :						Dict		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE				( self     :						Optional[int]		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE				( self     :						str		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE				( self     :						Tuple		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE				( self     :						Any		):






         """simple docstring"""






         _lowerCamelCase						:				Optional[int]    			= self.get_tokenizers(fast=__lowerCAmelCase						,					do_lower_case=__lowerCAmelCase		)
         for tokenizer in tokenizers:
                with self.subTest(f'''{tokenizer.__class__.__name__}'''		):
                       _lowerCamelCase						:				Any    			= ['''[CLS]''', '''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''s''', '''t''', '''[SEP]''']
                       _lowerCamelCase						:				Dict    			= tokenizer.convert_tokens_to_string(__lowerCAmelCase		)

                       self.assertIsInstance(__lowerCAmelCase						,					__lowerCAmelCase		)







"""simple docstring"""
import collections
import inspect
import unittest

from transformers import SwinvaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, 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 SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
						from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor
class 				lowerCamelCase  :






					'''simple docstring'''





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






					def    lowerCAmelCase_				(       self:							int						)   ->	int:
											snake_case_ :List[str]						=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

											snake_case_ :int						=			self.get_config()

											return config, pixel_values, labels






					def    lowerCAmelCase_				(       self:							str						)   ->	Union[str, Any]:
											return SwinvaConfig(
											    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						,     encoder_stride=self.encoder_stride						,     )






					def    lowerCAmelCase_				(       self:							str						,     snake_case:							Optional[int]						,     snake_case:							Dict						,     snake_case:							str						)   ->	List[Any]:
											snake_case_ :Union[str, Any]						=			SwinvaModel(config=snake_case						)
											model.to(snake_case						)
											model.eval()
											snake_case_ :Optional[int]						=			model(snake_case						)

											snake_case_ :Optional[Any]						=			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
											snake_case_ :int						=			int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

											self.parent.assertEqual(result.last_hidden_state.shape						,     (self.batch_size, expected_seq_len, expected_dim)						)






					def    lowerCAmelCase_				(       self:							int						,     snake_case:							List[str]						,     snake_case:							Tuple						,     snake_case:							int						)   ->	Any:
											snake_case_ :Dict						=			SwinvaForMaskedImageModeling(config=snake_case						)
											model.to(snake_case						)
											model.eval()
											snake_case_ :Tuple						=			model(snake_case						)
											self.parent.assertEqual(
											    result.logits.shape						,     (self.batch_size, self.num_channels, self.image_size, self.image_size)						)

											# test greyscale images
											snake_case_ :List[Any]						=			1
											snake_case_ :int						=			SwinvaForMaskedImageModeling(snake_case						)
											model.to(snake_case						)
											model.eval()

											snake_case_ :Union[str, Any]						=			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
											snake_case_ :int						=			model(snake_case						)
											self.parent.assertEqual(result.logits.shape						,     (self.batch_size, 1, self.image_size, self.image_size)						)






					def    lowerCAmelCase_				(       self:							List[Any]						,     snake_case:							Any						,     snake_case:							List[str]						,     snake_case:							Union[str, Any]						)   ->	Tuple:
											snake_case_ :int						=			self.type_sequence_label_size
											snake_case_ :List[Any]						=			SwinvaForImageClassification(snake_case						)
											model.to(snake_case						)
											model.eval()
											snake_case_ :Dict						=			model(snake_case						,     labels=snake_case						)
											self.parent.assertEqual(result.logits.shape						,     (self.batch_size, self.type_sequence_label_size)						)






					def    lowerCAmelCase_				(       self:							int						)   ->	str:
											snake_case_ :Any						=			self.prepare_config_and_inputs()
											snake_case_,       snake_case_,       snake_case_ :List[str]						=			config_and_inputs
											snake_case_ :List[Any]						=			{"""pixel_values""": pixel_values}
											return config, inputs_dict

@require_torch
class 				lowerCamelCase  (			_lowerCAmelCase    ,						_lowerCAmelCase    ,						unittest.TestCase				):






					'''simple docstring'''





					_A		:			Optional[Any]						=     (
					    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
					)
					_A		:			Any						=     (
					    {"""feature-extraction""": SwinvaModel, """image-classification""": SwinvaForImageClassification}
					    if is_torch_available()
					    else {}
					)

					_A		:			List[Any]						=     False
					_A		:			List[str]						=     False
					_A		:			Tuple						=     False
					_A		:			List[str]						=     False






					def    lowerCAmelCase_				(       self:							Dict						)   ->	List[Any]:
											snake_case_ :Optional[int]						=			SwinvaModelTester(self						)
											snake_case_ :List[str]						=			ConfigTester(self						,     config_class=snake_case						,     embed_dim=37						)






					def    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	List[Any]:
											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    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	Tuple:
											snake_case_ :List[str]						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case						)






					@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""						)
					def    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	str:
											pass






					@unittest.skip(reason="""Swinv2 does not use inputs_embeds"""						)
					def    lowerCAmelCase_				(       self:							int						)   ->	Dict:
											pass






					def    lowerCAmelCase_				(       self:							List[str]						)   ->	Union[str, Any]:
											snake_case_,       snake_case_ :List[str]						=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	snake_case_ :Optional[int]						=			model_class(snake_case						)
																	self.assertIsInstance(model.get_input_embeddings()						,     (nn.Module)						)
																	snake_case_ :List[Any]						=			model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(snake_case						,     nn.Linear						)						)






					def    lowerCAmelCase_				(       self:							Dict						)   ->	Optional[int]:
											snake_case_,       snake_case_ :Union[str, Any]						=			self.model_tester.prepare_config_and_inputs_for_common()

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

																	snake_case_ :List[Any]						=			["""pixel_values"""]
																	self.assertListEqual(arg_names[:1]						,     snake_case						)






					def    lowerCAmelCase_				(       self:							List[str]						)   ->	Optional[Any]:
											snake_case_,       snake_case_ :List[str]						=			self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_ :List[str]						=			True

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

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

																	self.assertListEqual(
																	    list(attentions[0].shape[-3:]						)						,     [self.model_tester.num_heads[0], window_size_squared, window_size_squared]						,     )
																	snake_case_ :Any						=			len(snake_case						)

																	# Check attention is always last and order is fine
																	snake_case_ :int						=			True
																	snake_case_ :Dict						=			True
																	snake_case_ :Optional[int]						=			model_class(snake_case						)
																	model.to(snake_case						)
																	model.eval()
																	with torch.no_grad():
																							snake_case_ :Dict						=			model(**self._prepare_for_class(snake_case						,     snake_case						)						)

																	if hasattr(self.model_tester						,     """num_hidden_states_types"""						):
																							snake_case_ :Any						=			self.model_tester.num_hidden_states_types
																	else:
																							# also another +1 for reshaped_hidden_states
																							snake_case_ :int						=			2
																	self.assertEqual(out_len + added_hidden_states						,     len(snake_case						)						)

																	snake_case_ :str						=			outputs.attentions

																	self.assertEqual(len(snake_case						)						,     snake_case						)

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






					def    lowerCAmelCase_				(       self:							int						,     snake_case:							Dict						,     snake_case:							Dict						,     snake_case:							Optional[Any]						,     snake_case:							Dict						)   ->	List[str]:
											snake_case_ :Dict						=			model_class(snake_case						)
											model.to(snake_case						)
											model.eval()

											with torch.no_grad():
																	snake_case_ :Optional[int]						=			model(**self._prepare_for_class(snake_case						,     snake_case						)						)

											snake_case_ :str						=			outputs.hidden_states

											snake_case_ :List[Any]						=			getattr(
											    self.model_tester						,     """expected_num_hidden_layers"""						,     len(self.model_tester.depths						) + 1						)
											self.assertEqual(len(snake_case						)						,     snake_case						)

											# Swinv2 has a different seq_length
											snake_case_ :List[Any]						=			(
											    config.patch_size
											    if isinstance(config.patch_size						,     collections.abc.Iterable						)
											    else (config.patch_size, config.patch_size)
											)

											snake_case_ :Optional[int]						=			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

											self.assertListEqual(
											    list(hidden_states[0].shape[-2:]						)						,     [num_patches, self.model_tester.embed_dim]						,     )

											snake_case_ :str						=			outputs.reshaped_hidden_states
											self.assertEqual(len(snake_case						)						,     snake_case						)

											snake_case_,       snake_case_,       snake_case_,       snake_case_ :Any						=			reshaped_hidden_states[0].shape
											snake_case_ :int						=			(
											    reshaped_hidden_states[0].view(snake_case						,     snake_case						,     height * width						).permute(0						,     2						,     1						)
											)
											self.assertListEqual(
											    list(reshaped_hidden_states.shape[-2:]						)						,     [num_patches, self.model_tester.embed_dim]						,     )






					def    lowerCAmelCase_				(       self:							Any						)   ->	Any:
											snake_case_,       snake_case_ :List[Any]						=			self.model_tester.prepare_config_and_inputs_for_common()

											snake_case_ :Union[str, Any]						=			(
											    self.model_tester.image_size
											    if isinstance(self.model_tester.image_size						,     collections.abc.Iterable						)
											    else (self.model_tester.image_size, self.model_tester.image_size)
											)

											for model_class in self.all_model_classes:
																	snake_case_ :Union[str, Any]						=			True
																	self.check_hidden_states_output(snake_case						,     snake_case						,     snake_case						,     snake_case						)

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	snake_case_ :List[str]						=			True

																	self.check_hidden_states_output(snake_case						,     snake_case						,     snake_case						,     snake_case						)






					def    lowerCAmelCase_				(       self:							Tuple						)   ->	Any:
											snake_case_,       snake_case_ :Union[str, Any]						=			self.model_tester.prepare_config_and_inputs_for_common()
											snake_case_ :Optional[int]						=			3

											snake_case_ :Union[str, Any]						=			(
											    self.model_tester.image_size
											    if isinstance(self.model_tester.image_size						,     collections.abc.Iterable						)
											    else (self.model_tester.image_size, self.model_tester.image_size)
											)
											snake_case_ :str						=			(
											    config.patch_size
											    if isinstance(config.patch_size						,     collections.abc.Iterable						)
											    else (config.patch_size, config.patch_size)
											)

											snake_case_ :Any						=			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
											snake_case_ :int						=			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

											for model_class in self.all_model_classes:
																	snake_case_ :str						=			True
																	self.check_hidden_states_output(snake_case						,     snake_case						,     snake_case						,     (padded_height, padded_width)						)

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	snake_case_ :Tuple						=			True
																	self.check_hidden_states_output(snake_case						,     snake_case						,     snake_case						,     (padded_height, padded_width)						)






					def    lowerCAmelCase_				(       self:							Any						)   ->	Tuple:
											snake_case_ :int						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*snake_case						)






					def    lowerCAmelCase_				(       self:							Optional[int]						)   ->	Dict:
											snake_case_ :Any						=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*snake_case						)






					@slow
					def    lowerCAmelCase_				(       self:							List[Any]						)   ->	Dict:
											for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_ :List[str]						=			SwinvaModel.from_pretrained(snake_case						)
																	self.assertIsNotNone(snake_case						)






					def    lowerCAmelCase_				(       self:							Optional[int]						)   ->	List[Any]:
											snake_case_,       snake_case_ :str						=			self.model_tester.prepare_config_and_inputs_for_common()

											snake_case_ :Optional[int]						=			_config_zero_init(snake_case						)
											for model_class in self.all_model_classes:
																	snake_case_ :Tuple						=			model_class(config=snake_case						)
																	for name, param in model.named_parameters():
																							if "embeddings" not in name and "logit_scale" not in name and 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"""						,     )

@require_vision
@require_torch
class 				lowerCamelCase  (			unittest.TestCase				):






					'''simple docstring'''





					@cached_property
					def    lowerCAmelCase_				(       self:							Optional[int]						)   ->	List[Any]:
											return (
											    AutoImageProcessor.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""						)
											    if is_vision_available()
											    else None
											)






					@slow
					def    lowerCAmelCase_				(       self:							List[str]						)   ->	List[str]:
											snake_case_ :Tuple						=			SwinvaForImageClassification.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""						).to(
											    snake_case						)
											snake_case_ :str						=			self.default_image_processor

											snake_case_ :List[Any]						=			Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
											snake_case_ :str						=			image_processor(images=snake_case						,     return_tensors="""pt"""						).to(snake_case						)

											# forward pass
											with torch.no_grad():
																	snake_case_ :Tuple						=			model(**snake_case						)

											# verify the logits
											snake_case_ :Dict						=			torch.Size((1, 1_000)						)
											self.assertEqual(outputs.logits.shape						,     snake_case						)
											snake_case_ :int						=			torch.tensor([-0.3_9_4_7, -0.4_3_0_6, 0.0_0_2_6]						).to(snake_case						)
											self.assertTrue(torch.allclose(outputs.logits[0, :3]						,     snake_case						,     atol=1E-4						)						)
