






import os
import re
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_a   			=						logging.get_logger(__name__)
_a   			=						{'''vocab_file''': '''spiece.model'''}

_a   			=						{
    '''vocab_file''': {
        '''google/fnet-base''': '''https://huggingface.co/google/fnet-base/resolve/main/spiece.model''',
        '''google/fnet-large''': '''https://huggingface.co/google/fnet-large/resolve/main/spiece.model''',
    },
}

_a   			=						{
    '''google/fnet-base''': 512,
    '''google/fnet-large''': 512,
}

_a   			=						'''▁'''





class __lowerCamelCase				(   snake_case__):





	"""simple docstring"""






	UpperCamelCase__			=   VOCAB_FILES_NAMES
	UpperCamelCase__			=   PRETRAINED_VOCAB_FILES_MAP
	UpperCamelCase__			=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	UpperCamelCase__			=   ["input_ids", "token_type_ids"]

	def __init__(							self ,					UpperCAmelCase ,					UpperCAmelCase=False ,					UpperCAmelCase=True ,					UpperCAmelCase=True ,					UpperCAmelCase="<unk>" ,					UpperCAmelCase="[SEP]" ,					UpperCAmelCase="<pad>" ,					UpperCAmelCase="[CLS]" ,					UpperCAmelCase="[MASK]" ,					UpperCAmelCase = None ,					**UpperCAmelCase ,					):
							"""simple docstring"""







							_UpperCAmelCase             =    (
							    AddedToken(UpperCAmelCase ,					lstrip=UpperCAmelCase ,					rstrip=UpperCAmelCase ,					normalized=UpperCAmelCase					)
							    if isinstance(UpperCAmelCase ,					UpperCAmelCase					)
							    else mask_token
							)

							_UpperCAmelCase             =    {} if sp_model_kwargs is None else sp_model_kwargs

							super().__init__(
							    do_lower_case=UpperCAmelCase ,					remove_space=UpperCAmelCase ,					keep_accents=UpperCAmelCase ,					unk_token=UpperCAmelCase ,					sep_token=UpperCAmelCase ,					pad_token=UpperCAmelCase ,					cls_token=UpperCAmelCase ,					mask_token=UpperCAmelCase ,					sp_model_kwargs=self.sp_model_kwargs ,					**UpperCAmelCase ,					)

							_UpperCAmelCase             =    do_lower_case
							_UpperCAmelCase             =    remove_space
							_UpperCAmelCase             =    keep_accents
							_UpperCAmelCase             =    vocab_file

							_UpperCAmelCase             =    spm.SentencePieceProcessor(**self.sp_model_kwargs					)
							self.sp_model.Load(UpperCAmelCase					)

	@property
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							return len(self.sp_model					)

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    {self.convert_ids_to_tokens(UpperCAmelCase					): i for i in range(self.vocab_size					)}
							vocab.update(self.added_tokens_encoder					)
							return vocab

	def __getstate__(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    self.__dict__.copy()
							_UpperCAmelCase             =    None
							return state

	def __setstate__(							self ,					UpperCAmelCase					):
							"""simple docstring"""







							_UpperCAmelCase             =    d

							# for backward compatibility
							if not hasattr(self ,					'sp_model_kwargs'					):
													_UpperCAmelCase             =    {}

							_UpperCAmelCase             =    spm.SentencePieceProcessor(**self.sp_model_kwargs					)
							self.sp_model.Load(self.vocab_file					)

	def  UpperCamelCase					(							self ,					UpperCAmelCase					):
							"""simple docstring"""







							if self.remove_space:
													_UpperCAmelCase             =    ' '.join(inputs.strip().split()					)
							else:
													_UpperCAmelCase             =    inputs
							_UpperCAmelCase             =    outputs.replace('``' ,					'"'					).replace('\'\'' ,					'"'					)

							if not self.keep_accents:
													_UpperCAmelCase             =    unicodedata.normalize('NFKD' ,					UpperCAmelCase					)
													_UpperCAmelCase             =    ''.join([c for c in outputs if not unicodedata.combining(UpperCAmelCase					)]					)
							if self.do_lower_case:
													_UpperCAmelCase             =    outputs.lower()

							return outputs

	def  UpperCamelCase					(							self ,					UpperCAmelCase					):
							"""simple docstring"""







							_UpperCAmelCase             =    self.preprocess_text(UpperCAmelCase					)
							_UpperCAmelCase             =    self.sp_model.encode(UpperCAmelCase ,					out_type=UpperCAmelCase					)
							_UpperCAmelCase             =    []
							for piece in pieces:
													if len(UpperCAmelCase					) > 1 and piece[-1] == str(','					) and piece[-2].isdigit():
																			_UpperCAmelCase             =    self.sp_model.EncodeAsPieces(piece[:-1].replace(UpperCAmelCase ,					''					)					)
																			if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
																									if len(cur_pieces[0]					) == 1:
																															_UpperCAmelCase             =    cur_pieces[1:]
																									else:
																															_UpperCAmelCase             =    cur_pieces[0][1:]
																			cur_pieces.append(piece[-1]					)
																			new_pieces.extend(UpperCAmelCase					)
													else:
																			new_pieces.append(UpperCAmelCase					)

							return new_pieces

	def  UpperCamelCase					(							self ,					UpperCAmelCase					):
							"""simple docstring"""







							return self.sp_model.PieceToId(UpperCAmelCase					)

	def  UpperCamelCase					(							self ,					UpperCAmelCase					):
							"""simple docstring"""







							return self.sp_model.IdToPiece(UpperCAmelCase					)

	def  UpperCamelCase					(							self ,					UpperCAmelCase					):
							"""simple docstring"""







							_UpperCAmelCase             =    []
							_UpperCAmelCase             =    ''
							_UpperCAmelCase             =    False
							for token in tokens:
													# make sure that special tokens are not decoded using sentencepiece model
													if token in self.all_special_tokens:
																			if not prev_is_special:
																									out_string += " "
																			out_string += self.sp_model.decode(UpperCAmelCase					) + token
																			_UpperCAmelCase             =    True
																			_UpperCAmelCase             =    []
													else:
																			current_sub_tokens.append(UpperCAmelCase					)
																			_UpperCAmelCase             =    False
							out_string += self.sp_model.decode(UpperCAmelCase					)
							return out_string.strip()

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = False ,					UpperCAmelCase = None ,					UpperCAmelCase = True ,					**UpperCAmelCase ,					):
							"""simple docstring"""







							_UpperCAmelCase             =    kwargs.pop('use_source_tokenizer' ,					UpperCAmelCase					)

							_UpperCAmelCase             =    self.convert_ids_to_tokens(UpperCAmelCase ,					skip_special_tokens=UpperCAmelCase					)

							# To avoid mixing byte-level and unicode for byte-level BPT
							# we need to build string separately for added tokens and byte-level tokens
							# cf. https://github.com/huggingface/transformers/issues/1133
							_UpperCAmelCase             =    []
							_UpperCAmelCase             =    []
							for token in filtered_tokens:
													if skip_special_tokens and token in self.all_special_ids:
																			continue
													if token in self.added_tokens_encoder:
																			if current_sub_text:
																									sub_texts.append(self.convert_tokens_to_string(UpperCAmelCase					)					)
																									_UpperCAmelCase             =    []
																			sub_texts.append(UpperCAmelCase					)
													else:
																			current_sub_text.append(UpperCAmelCase					)
							if current_sub_text:
													sub_texts.append(self.convert_tokens_to_string(UpperCAmelCase					)					)

							# Mimic the behavior of the Rust tokenizer:
							# No space after <unk>
							if spaces_between_special_tokens:
													_UpperCAmelCase             =    re.sub(R'(<unk>) ' ,					R'\1' ,					' '.join(UpperCAmelCase					)					)
							else:
													_UpperCAmelCase             =    ''.join(UpperCAmelCase					)

							_UpperCAmelCase             =    (
							    clean_up_tokenization_spaces
							    if clean_up_tokenization_spaces is not None
							    else self.clean_up_tokenization_spaces
							)
							if clean_up_tokenization_spaces:
													_UpperCAmelCase             =    self.clean_up_tokenization(UpperCAmelCase					)
													return clean_text
							else:
													return text

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = None					):
							"""simple docstring"""







							_UpperCAmelCase             =    [self.sep_token_id]
							_UpperCAmelCase             =    [self.cls_token_id]
							if token_ids_a is None:
													return cls + token_ids_a + sep
							return cls + token_ids_a + sep + token_ids_a + sep

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = None ,					UpperCAmelCase = False					):
							"""simple docstring"""







							if already_has_special_tokens:
													return super().get_special_tokens_mask(
													    token_ids_a=UpperCAmelCase ,					token_ids_a=UpperCAmelCase ,					already_has_special_tokens=UpperCAmelCase					)

							if token_ids_a is not None:
													return [1] + ([0] * len(UpperCAmelCase					)) + [1] + ([0] * len(UpperCAmelCase					)) + [1]
							return [1] + ([0] * len(UpperCAmelCase					)) + [1]

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = None					):
							"""simple docstring"""







							_UpperCAmelCase             =    [self.sep_token_id]
							_UpperCAmelCase             =    [self.cls_token_id]

							if token_ids_a is None:
													return len(cls + token_ids_a + sep					) * [0]
							return len(cls + token_ids_a + sep					) * [0] + len(token_ids_a + sep					) * [1]

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = None					):
							"""simple docstring"""







							if not os.path.isdir(UpperCAmelCase					):
													logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""					)
													return
							_UpperCAmelCase             =    os.path.join(
							    UpperCAmelCase ,					(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']					)

							if os.path.abspath(self.vocab_file					) != os.path.abspath(UpperCAmelCase					) and os.path.isfile(self.vocab_file					):
													copyfile(self.vocab_file ,					UpperCAmelCase					)
							elif not os.path.isfile(self.vocab_file					):
													with open(UpperCAmelCase ,					'wb'					) as fi:
																			_UpperCAmelCase             =    self.sp_model.serialized_model_proto()
																			fi.write(UpperCAmelCase					)

							return (out_vocab_file,)








from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers.models.swin.modeling_tf_swin import (
		    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFSwinForImageClassification,
		    TFSwinForMaskedImageModeling,
		    TFSwinModel,
		)


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor





class __lowerCamelCase				:





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					UpperCAmelCase=13 ,					UpperCAmelCase=32 ,					UpperCAmelCase=2 ,					UpperCAmelCase=3 ,					UpperCAmelCase=16 ,					UpperCAmelCase=[1, 2, 1] ,					UpperCAmelCase=[2, 2, 4] ,					UpperCAmelCase=2 ,					UpperCAmelCase=2.0 ,					UpperCAmelCase=True ,					UpperCAmelCase=0.0 ,					UpperCAmelCase=0.0 ,					UpperCAmelCase=0.1 ,					UpperCAmelCase="gelu" ,					UpperCAmelCase=False ,					UpperCAmelCase=True ,					UpperCAmelCase=0.02 ,					UpperCAmelCase=1e-5 ,					UpperCAmelCase=True ,					UpperCAmelCase=None ,					UpperCAmelCase=True ,					UpperCAmelCase=10 ,					UpperCAmelCase=8 ,					):
							"""simple docstring"""







							_UpperCAmelCase             =    parent
							_UpperCAmelCase             =    batch_size
							_UpperCAmelCase             =    image_size
							_UpperCAmelCase             =    patch_size
							_UpperCAmelCase             =    num_channels
							_UpperCAmelCase             =    embed_dim
							_UpperCAmelCase             =    depths
							_UpperCAmelCase             =    num_heads
							_UpperCAmelCase             =    window_size
							_UpperCAmelCase             =    mlp_ratio
							_UpperCAmelCase             =    qkv_bias
							_UpperCAmelCase             =    hidden_dropout_prob
							_UpperCAmelCase             =    attention_probs_dropout_prob
							_UpperCAmelCase             =    drop_path_rate
							_UpperCAmelCase             =    hidden_act
							_UpperCAmelCase             =    use_absolute_embeddings
							_UpperCAmelCase             =    patch_norm
							_UpperCAmelCase             =    layer_norm_eps
							_UpperCAmelCase             =    initializer_range
							_UpperCAmelCase             =    is_training
							_UpperCAmelCase             =    scope
							_UpperCAmelCase             =    use_labels
							_UpperCAmelCase             =    type_sequence_label_size
							_UpperCAmelCase             =    encoder_stride

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

							_UpperCAmelCase             =    None
							if self.use_labels:
													_UpperCAmelCase             =    ids_tensor([self.batch_size] ,					self.type_sequence_label_size					)

							_UpperCAmelCase             =    self.get_config()

							return config, pixel_values, labels

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							return SwinConfig(
							    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  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					):
							"""simple docstring"""







							_UpperCAmelCase             =    TFSwinModel(config=UpperCAmelCase					)
							_UpperCAmelCase             =    model(UpperCAmelCase					)

							_UpperCAmelCase             =    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
							_UpperCAmelCase             =    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  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					):
							"""simple docstring"""







							_UpperCAmelCase             =    TFSwinForMaskedImageModeling(config=UpperCAmelCase					)
							_UpperCAmelCase             =    model(UpperCAmelCase					)
							self.parent.assertEqual(
							    result.logits.shape ,					(self.batch_size, self.num_channels, self.image_size, self.image_size)					)

							# test greyscale images
							_UpperCAmelCase             =    1
							_UpperCAmelCase             =    TFSwinForMaskedImageModeling(UpperCAmelCase					)

							_UpperCAmelCase             =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
							_UpperCAmelCase             =    model(UpperCAmelCase					)
							self.parent.assertEqual(result.logits.shape ,					(self.batch_size, 1, self.image_size, self.image_size)					)

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					):
							"""simple docstring"""







							_UpperCAmelCase             =    self.type_sequence_label_size
							_UpperCAmelCase             =    TFSwinForImageClassification(UpperCAmelCase					)
							_UpperCAmelCase             =    model(UpperCAmelCase ,					labels=UpperCAmelCase					)
							self.parent.assertEqual(result.logits.shape ,					(self.batch_size, self.type_sequence_label_size)					)

							# test greyscale images
							_UpperCAmelCase             =    1
							_UpperCAmelCase             =    TFSwinForImageClassification(UpperCAmelCase					)
							_UpperCAmelCase             =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
							_UpperCAmelCase             =    model(UpperCAmelCase					)
							self.parent.assertEqual(result.logits.shape ,					(self.batch_size, self.type_sequence_label_size)					)

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    self.prepare_config_and_inputs()
							_UpperCAmelCase      ,				_UpperCAmelCase      ,				_UpperCAmelCase             =    config_and_inputs
							_UpperCAmelCase             =    {'pixel_values': pixel_values}
							return config, inputs_dict





@require_tf
class __lowerCamelCase				(   snake_case__  , snake_case__  , unittest.TestCase):





	"""simple docstring"""






	UpperCamelCase__			=   (
	    (
	        TFSwinModel,
	        TFSwinForImageClassification,
	        TFSwinForMaskedImageModeling,
	    )
	    if is_tf_available()
	    else ()
	)
	UpperCamelCase__			=   (
	    {"feature-extraction": TFSwinModel, "image-classification": TFSwinForImageClassification}
	    if is_tf_available()
	    else {}
	)

	UpperCamelCase__			=   False
	UpperCamelCase__			=   False
	UpperCamelCase__			=   False
	UpperCamelCase__			=   False

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    TFSwinModelTester(self					)
							_UpperCAmelCase             =    ConfigTester(self ,					config_class=UpperCAmelCase ,					embed_dim=37					)

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							self.create_and_test_config_common_properties()
							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  UpperCamelCase					(							self					):
							"""simple docstring"""







							return

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*UpperCAmelCase					)

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase					)

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase					)

	@unittest.skip(reason='Swin does not use inputs_embeds'					)
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							pass

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase      ,				_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													_UpperCAmelCase             =    model_class(UpperCAmelCase					)
													self.assertIsInstance(model.get_input_embeddings() ,					tf.keras.layers.Layer					)
													_UpperCAmelCase             =    model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(UpperCAmelCase ,					tf.keras.layers.Dense					)					)

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase      ,				_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													_UpperCAmelCase             =    model_class(UpperCAmelCase					)
													_UpperCAmelCase             =    inspect.signature(model.call					)
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													_UpperCAmelCase             =    [*signature.parameters.keys()]

													_UpperCAmelCase             =    ['pixel_values']
													self.assertListEqual(arg_names[:1] ,					UpperCAmelCase					)

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase      ,				_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs_for_common()
							_UpperCAmelCase             =    True

							for model_class in self.all_model_classes:
													_UpperCAmelCase             =    True
													_UpperCAmelCase             =    False
													_UpperCAmelCase             =    True
													_UpperCAmelCase             =    model_class(UpperCAmelCase					)
													_UpperCAmelCase             =    model(**self._prepare_for_class(UpperCAmelCase ,					UpperCAmelCase					)					)
													_UpperCAmelCase             =    outputs.attentions
													_UpperCAmelCase             =    len(self.model_tester.depths					)
													self.assertEqual(len(UpperCAmelCase					) ,					UpperCAmelCase					)

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													_UpperCAmelCase             =    True
													_UpperCAmelCase             =    config.window_size**2
													_UpperCAmelCase             =    model_class(UpperCAmelCase					)
													_UpperCAmelCase             =    model(**self._prepare_for_class(UpperCAmelCase ,					UpperCAmelCase					)					)
													_UpperCAmelCase             =    outputs.attentions
													self.assertEqual(len(UpperCAmelCase					) ,					UpperCAmelCase					)

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

													# Check attention is always last and order is fine
													_UpperCAmelCase             =    True
													_UpperCAmelCase             =    True
													_UpperCAmelCase             =    model_class(UpperCAmelCase					)
													_UpperCAmelCase             =    model(**self._prepare_for_class(UpperCAmelCase ,					UpperCAmelCase					)					)

													if hasattr(self.model_tester ,					'num_hidden_states_types'					):
																			_UpperCAmelCase             =    self.model_tester.num_hidden_states_types
													else:
																			# also another +1 for reshaped_hidden_states
																			_UpperCAmelCase             =    2
													self.assertEqual(out_len + added_hidden_states ,					len(UpperCAmelCase					)					)

													_UpperCAmelCase             =    outputs.attentions

													self.assertEqual(len(UpperCAmelCase					) ,					UpperCAmelCase					)

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

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					):
							"""simple docstring"""







							_UpperCAmelCase             =    model_class(UpperCAmelCase					)
							_UpperCAmelCase             =    model(**self._prepare_for_class(UpperCAmelCase ,					UpperCAmelCase					)					)
							_UpperCAmelCase             =    outputs.hidden_states

							_UpperCAmelCase             =    getattr(
							    self.model_tester ,					'expected_num_hidden_layers' ,					len(self.model_tester.depths					) + 1					)
							self.assertEqual(len(UpperCAmelCase					) ,					UpperCAmelCase					)

							# Swin has a different seq_length
							_UpperCAmelCase             =    to_atuple(config.patch_size					)

							_UpperCAmelCase             =    (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] ,					)

							_UpperCAmelCase             =    outputs.reshaped_hidden_states
							self.assertEqual(len(UpperCAmelCase					) ,					UpperCAmelCase					)

							_UpperCAmelCase      ,				_UpperCAmelCase      ,				_UpperCAmelCase      ,				_UpperCAmelCase             =    reshaped_hidden_states[0].shape

							_UpperCAmelCase             =    tf.reshape(reshaped_hidden_states[0] ,					(batch_size, num_channels, height * width)					)
							_UpperCAmelCase             =    tf.transpose(UpperCAmelCase ,					(0, 2, 1)					)

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

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase      ,				_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs_for_common()

							_UpperCAmelCase             =    to_atuple(self.model_tester.image_size					)

							for model_class in self.all_model_classes:
													_UpperCAmelCase             =    True
													self.check_hidden_states_output(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					)

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													_UpperCAmelCase             =    True

													self.check_hidden_states_output(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					)

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase      ,				_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs_for_common()
							_UpperCAmelCase             =    3

							_UpperCAmelCase             =    to_atuple(self.model_tester.image_size					)
							_UpperCAmelCase             =    to_atuple(config.patch_size					)

							_UpperCAmelCase             =    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
							_UpperCAmelCase             =    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

							for model_class in self.all_model_classes:
													_UpperCAmelCase             =    True
													self.check_hidden_states_output(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase ,					(padded_height, padded_width)					)

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													_UpperCAmelCase             =    True
													self.check_hidden_states_output(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase ,					(padded_height, padded_width)					)

	@slow
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_UpperCAmelCase             =    TFSwinModel.from_pretrained(UpperCAmelCase					)
													self.assertIsNotNone(UpperCAmelCase					)





@require_vision
@require_tf
class __lowerCamelCase				(   unittest.TestCase):





	"""simple docstring"""






	@cached_property
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							return (
							    AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'					)
							    if is_vision_available()
							    else None
							)

	@slow
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'					)
							_UpperCAmelCase             =    self.default_image_processor

							_UpperCAmelCase             =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
							_UpperCAmelCase             =    image_processor(images=UpperCAmelCase ,					return_tensors='tf'					)

							# forward pass
							_UpperCAmelCase             =    model(UpperCAmelCase					)

							# verify the logits
							_UpperCAmelCase             =    tf.TensorShape((1, 1000)					)
							self.assertEqual(outputs.logits.shape ,					UpperCAmelCase					)
							_UpperCAmelCase             =    tf.constant([-0.09_48, -0.64_54, -0.09_21]					)
							self.assertTrue(np.allclose(outputs.logits[0, :3] ,					UpperCAmelCase ,					atol=1e-4					)					)
