
import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


sys.path.append(str(Path(__file__).parent.parent / """utils"""))

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
				from test_module.custom_tokenization_fast import CustomTokenizerFast




class 		lowercase__    (		unittest.TestCase    ):
	def 	A_							(     self				:  List[str]				):
						SCREAMING_SNAKE_CASE__						=					mock.Mock()
						SCREAMING_SNAKE_CASE__						=					500
						SCREAMING_SNAKE_CASE__						=					{}
						SCREAMING_SNAKE_CASE__						=					HTTPError
						SCREAMING_SNAKE_CASE__						=					{}

						# Download this model to make sure it's in the cache.
						SCREAMING_SNAKE_CASE__						=					BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'				)

						# Under the mock environment we get a 500 error when trying to reach the tokenizer.
						with mock.patch('requests.Session.request'			,  return_value=snake_case_				) as mock_head:
											SCREAMING_SNAKE_CASE__						=					BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'				)
											# This check we did call the fake head request
											mock_head.assert_called()
	@require_tokenizers
	def 	A_							(     self				:  Tuple				):
						SCREAMING_SNAKE_CASE__						=					mock.Mock()
						SCREAMING_SNAKE_CASE__						=					500
						SCREAMING_SNAKE_CASE__						=					{}
						SCREAMING_SNAKE_CASE__						=					HTTPError
						SCREAMING_SNAKE_CASE__						=					{}

						# Download this model to make sure it's in the cache.
						SCREAMING_SNAKE_CASE__						=					GPTaTokenizerFast.from_pretrained('gpt2'				)

						# Under the mock environment we get a 500 error when trying to reach the tokenizer.
						with mock.patch('requests.Session.request'			,  return_value=snake_case_				) as mock_head:
											SCREAMING_SNAKE_CASE__						=					GPTaTokenizerFast.from_pretrained('gpt2'				)
											# This check we did call the fake head request
											mock_head.assert_called()
	def 	A_							(     self				:  str				):

						try:
											SCREAMING_SNAKE_CASE__						=					tempfile.mktemp()
											with open(snake_case_			,  'wb'				) as f:
																http_get('https://huggingface.co/albert-base-v1/resolve/main/spiece.model'			,  snake_case_				)

											SCREAMING_SNAKE_CASE__						=					AlbertTokenizer.from_pretrained(snake_case_				)
						finally:
											os.remove(snake_case_				)

						# Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
						# the current folder and have the right name.
						if os.path.isfile('tokenizer.json'				):
											# We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
											return
						try:
											with open('tokenizer.json'			,  'wb'				) as f:
																http_get('https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json'			,  snake_case_				)
											SCREAMING_SNAKE_CASE__						=					AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'				)
											# The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
											self.assertEqual(tokenizer.vocab_size			,  1000				)
											# Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

						finally:
											os.remove('tokenizer.json'				)





	def 	A_							(     self				:  Union[str, Any]				):
						SCREAMING_SNAKE_CASE__						=					AlbertTokenizer.from_pretrained('https://huggingface.co/albert-base-v1/resolve/main/spiece.model'				)





@is_staging_test
class 		lowercase__    (		unittest.TestCase    ):
	A__       :  List[str]										=["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""]
	@classmethod
	def 	A_							(     cls				:  Optional[int]				):
						SCREAMING_SNAKE_CASE__						=					TOKEN
						HfFolder.save_token(snake_case_				)
	@classmethod
	def 	A_							(     cls				:  Optional[Any]				):

						try:
											delete_repo(token=cls._token			,  repo_id='test-tokenizer'				)
						except HTTPError:
											pass

						try:
											delete_repo(token=cls._token			,  repo_id='valid_org/test-tokenizer-org'				)
						except HTTPError:
											pass

						try:
											delete_repo(token=cls._token			,  repo_id='test-dynamic-tokenizer'				)
						except HTTPError:
											pass
	def 	A_							(     self				:  Dict				):

						with tempfile.TemporaryDirectory() as tmp_dir:
											SCREAMING_SNAKE_CASE__						=					os.path.join(snake_case_			,  'vocab.txt'				)
											with open(snake_case_			,  'w'			,  encoding='utf-8'				) as vocab_writer:
																vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]				)				)
											SCREAMING_SNAKE_CASE__						=					BertTokenizer(snake_case_				)

						tokenizer.push_to_hub('test-tokenizer'			,  use_auth_token=self._token				)
						SCREAMING_SNAKE_CASE__						=					BertTokenizer.from_pretrained(F'{USER}/test-tokenizer'				)
						self.assertDictEqual(new_tokenizer.vocab			,  tokenizer.vocab				)

						# Reset repo
						delete_repo(token=self._token			,  repo_id='test-tokenizer'				)

						# Push to hub via save_pretrained
						with tempfile.TemporaryDirectory() as tmp_dir:
											tokenizer.save_pretrained(snake_case_			,  repo_id='test-tokenizer'			,  push_to_hub=snake_case_			,  use_auth_token=self._token				)

						SCREAMING_SNAKE_CASE__						=					BertTokenizer.from_pretrained(F'{USER}/test-tokenizer'				)
						self.assertDictEqual(new_tokenizer.vocab			,  tokenizer.vocab				)
	def 	A_							(     self				:  Optional[int]				):

						with tempfile.TemporaryDirectory() as tmp_dir:
											SCREAMING_SNAKE_CASE__						=					os.path.join(snake_case_			,  'vocab.txt'				)
											with open(snake_case_			,  'w'			,  encoding='utf-8'				) as vocab_writer:
																vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]				)				)
											SCREAMING_SNAKE_CASE__						=					BertTokenizer(snake_case_				)

						tokenizer.push_to_hub('valid_org/test-tokenizer-org'			,  use_auth_token=self._token				)
						SCREAMING_SNAKE_CASE__						=					BertTokenizer.from_pretrained('valid_org/test-tokenizer-org'				)
						self.assertDictEqual(new_tokenizer.vocab			,  tokenizer.vocab				)

						# Reset repo
						delete_repo(token=self._token			,  repo_id='valid_org/test-tokenizer-org'				)

						# Push to hub via save_pretrained
						with tempfile.TemporaryDirectory() as tmp_dir:
											tokenizer.save_pretrained(
											    snake_case_			,  repo_id='valid_org/test-tokenizer-org'			,  push_to_hub=snake_case_			,  use_auth_token=self._token				)

						SCREAMING_SNAKE_CASE__						=					BertTokenizer.from_pretrained('valid_org/test-tokenizer-org'				)
						self.assertDictEqual(new_tokenizer.vocab			,  tokenizer.vocab				)





	@require_tokenizers
	def 	A_							(     self				:  int				):
						CustomTokenizer.register_for_auto_class()
						with tempfile.TemporaryDirectory() as tmp_dir:
											SCREAMING_SNAKE_CASE__						=					os.path.join(snake_case_			,  'vocab.txt'				)
											with open(snake_case_			,  'w'			,  encoding='utf-8'				) as vocab_writer:
																vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]				)				)
											SCREAMING_SNAKE_CASE__						=					CustomTokenizer(snake_case_				)

						# No fast custom tokenizer
						tokenizer.push_to_hub('test-dynamic-tokenizer'			,  use_auth_token=self._token				)

						SCREAMING_SNAKE_CASE__						=					AutoTokenizer.from_pretrained(F'{USER}/test-dynamic-tokenizer'			,  trust_remote_code=snake_case_				)
						# Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
						self.assertEqual(tokenizer.__class__.__name__			,  'CustomTokenizer'				)

						# Fast and slow custom tokenizer
						CustomTokenizerFast.register_for_auto_class()
						with tempfile.TemporaryDirectory() as tmp_dir:
											SCREAMING_SNAKE_CASE__						=					os.path.join(snake_case_			,  'vocab.txt'				)
											with open(snake_case_			,  'w'			,  encoding='utf-8'				) as vocab_writer:
																vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]				)				)

											SCREAMING_SNAKE_CASE__						=					BertTokenizerFast.from_pretrained(snake_case_				)
											bert_tokenizer.save_pretrained(snake_case_				)
											SCREAMING_SNAKE_CASE__						=					CustomTokenizerFast.from_pretrained(snake_case_				)

						tokenizer.push_to_hub('test-dynamic-tokenizer'			,  use_auth_token=self._token				)

						SCREAMING_SNAKE_CASE__						=					AutoTokenizer.from_pretrained(F'{USER}/test-dynamic-tokenizer'			,  trust_remote_code=snake_case_				)
						# Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
						self.assertEqual(tokenizer.__class__.__name__			,  'CustomTokenizerFast'				)
						SCREAMING_SNAKE_CASE__						=					AutoTokenizer.from_pretrained(
						    F'{USER}/test-dynamic-tokenizer'			,  use_fast=snake_case_			,  trust_remote_code=snake_case_				)
						# Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
						self.assertEqual(tokenizer.__class__.__name__			,  'CustomTokenizer'				)





class 		lowercase__    (		unittest.TestCase    ):
	def 	A_							(     self				:  List[Any]				):
						SCREAMING_SNAKE_CASE__						=					Trie()
						trie.add('Hello 友達'				)
						self.assertEqual(trie.data			,  {'H': {'e': {'l': {'l': {'o': {' ': {'友': {'達': {'': 1}}}}}}}}}				)
						trie.add('Hello'				)
						trie.data
						self.assertEqual(trie.data			,  {'H': {'e': {'l': {'l': {'o': {'': 1, ' ': {'友': {'達': {'': 1}}}}}}}}}				)
	def 	A_							(     self				:  Optional[int]				):
						SCREAMING_SNAKE_CASE__						=					Trie()
						self.assertEqual(trie.split('[CLS] This is a extra_id_100'				)			,  ['[CLS] This is a extra_id_100']				)
						trie.add('[CLS]'				)
						trie.add('extra_id_1'				)
						trie.add('extra_id_100'				)
						self.assertEqual(trie.split('[CLS] This is a extra_id_100'				)			,  ['[CLS]', ' This is a ', 'extra_id_100']				)
	def 	A_							(     self				:  Optional[int]				):
						SCREAMING_SNAKE_CASE__						=					Trie()
						trie.add('A'				)
						self.assertEqual(trie.split('ABC'				)			,  ['A', 'BC']				)
						self.assertEqual(trie.split('BCA'				)			,  ['BC', 'A']				)
	def 	A_							(     self				:  Tuple				):
						SCREAMING_SNAKE_CASE__						=					Trie()
						trie.add('TOKEN]'				)
						trie.add('[SPECIAL_TOKEN]'				)
						self.assertEqual(trie.split('This is something [SPECIAL_TOKEN]'				)			,  ['This is something ', '[SPECIAL_TOKEN]']				)
	def 	A_							(     self				:  int				):
						SCREAMING_SNAKE_CASE__						=					Trie()
						trie.add('A'				)
						trie.add('P'				)
						trie.add('[SPECIAL_TOKEN]'				)
						self.assertEqual(trie.split('This is something [SPECIAL_TOKEN]'				)			,  ['This is something ', '[SPECIAL_TOKEN]']				)
	def 	A_							(     self				:  Union[str, Any]				):
						SCREAMING_SNAKE_CASE__						=					Trie()
						trie.add('AB'				)
						trie.add('B'				)
						trie.add('C'				)
						self.assertEqual(trie.split('ABC'				)			,  ['AB', 'C']				)
	def 	A_							(     self				:  str				):
						SCREAMING_SNAKE_CASE__						=					Trie()
						trie.add('ABC'				)
						trie.add('B'				)
						trie.add('CD'				)
						self.assertEqual(trie.split('ABCD'				)			,  ['ABC', 'D']				)





	def 	A_							(     self				:  Tuple				):
						SCREAMING_SNAKE_CASE__						=					Trie()
						SCREAMING_SNAKE_CASE__						=					trie.cut_text('ABC'			,  [0, 0, 2, 1, 2, 3]				)
						self.assertEqual(snake_case_			,  ['AB', 'C']				)









import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
	import torch

	from transformers import (
	    MODEL_MAPPING,
	    SegformerForImageClassification,
	    SegformerForSemanticSegmentation,
	    SegformerModel,
	)
	from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import SegformerImageProcessor
class 						lowerCamelCase_							(					lowerCAmelCase__					):



					'''simple docstring'''







					def A   (					self    ) ->      List[str]:







								'''simple docstring'''

								__lowercase			       = self.config_class(**self.inputs_dict    )
								self.parent.assertTrue(hasattr(snake_case_			,							'''hidden_sizes'''    )    )
								self.parent.assertTrue(hasattr(snake_case_			,							'''num_attention_heads'''    )    )
								self.parent.assertTrue(hasattr(snake_case_			,							'''num_encoder_blocks'''    )    )




class 						lowerCamelCase_							:



					'''simple docstring'''







					def __init__(					self			,							snake_case_			,							snake_case_=1_3			,							snake_case_=6_4			,							snake_case_=3			,							snake_case_=4			,							snake_case_=[2, 2, 2, 2]			,							snake_case_=[8, 4, 2, 1]			,							snake_case_=[1_6, 3_2, 6_4, 1_2_8]			,							snake_case_=[1, 4, 8, 1_6]			,							snake_case_=[1, 2, 4, 8]			,							snake_case_=True			,							snake_case_=True			,							snake_case_="gelu"			,							snake_case_=0.1			,							snake_case_=0.1			,							snake_case_=0.0_2			,							snake_case_=3			,							snake_case_=None			,							) ->      int:







								'''simple docstring'''

								__lowercase			       = parent
								__lowercase			       = batch_size
								__lowercase			       = image_size
								__lowercase			       = num_channels
								__lowercase			       = num_encoder_blocks
								__lowercase			       = sr_ratios
								__lowercase			       = depths
								__lowercase			       = hidden_sizes
								__lowercase			       = downsampling_rates
								__lowercase			       = num_attention_heads
								__lowercase			       = is_training
								__lowercase			       = use_labels
								__lowercase			       = hidden_act
								__lowercase			       = hidden_dropout_prob
								__lowercase			       = attention_probs_dropout_prob
								__lowercase			       = initializer_range
								__lowercase			       = num_labels
								__lowercase			       = scope






					def A   (					self    ) ->      Optional[int]:







								'''simple docstring'''

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

								__lowercase			       = None
								if self.use_labels:
											__lowercase			       = ids_tensor([self.batch_size, self.image_size, self.image_size]			,							self.num_labels    )

								__lowercase			       = self.get_config()
								return config, pixel_values, labels






					def A   (					self    ) ->      Union[str, Any]:







								'''simple docstring'''

								return SegformerConfig(
								    image_size=self.image_size			,							num_channels=self.num_channels			,							num_encoder_blocks=self.num_encoder_blocks			,							depths=self.depths			,							hidden_sizes=self.hidden_sizes			,							num_attention_heads=self.num_attention_heads			,							hidden_act=self.hidden_act			,							hidden_dropout_prob=self.hidden_dropout_prob			,							attention_probs_dropout_prob=self.attention_probs_dropout_prob			,							initializer_range=self.initializer_range			,							)






					def A   (					self			,							snake_case_			,							snake_case_			,							snake_case_    ) ->      Tuple:







								'''simple docstring'''

								__lowercase			       = SegformerModel(config=snake_case_    )
								model.to(snake_case_    )
								model.eval()
								__lowercase			       = model(snake_case_    )
								__lowercase			       = __lowercase			       = self.image_size // (self.downsampling_rates[-1] * 2)
								self.parent.assertEqual(
								    result.last_hidden_state.shape			,							(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)    )






					def A   (					self			,							snake_case_			,							snake_case_			,							snake_case_    ) ->      str:







								'''simple docstring'''

								__lowercase			       = self.num_labels
								__lowercase			       = SegformerForSemanticSegmentation(snake_case_    )
								model.to(snake_case_    )
								model.eval()
								__lowercase			       = model(snake_case_    )
								self.parent.assertEqual(
								    result.logits.shape			,							(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)    )
								__lowercase			       = model(snake_case_			,							labels=snake_case_    )
								self.parent.assertEqual(
								    result.logits.shape			,							(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)    )
								self.parent.assertGreater(result.loss			,							0.0    )






					def A   (					self			,							snake_case_			,							snake_case_			,							snake_case_    ) ->      Optional[int]:







								'''simple docstring'''

								__lowercase			       = 1
								__lowercase			       = SegformerForSemanticSegmentation(config=snake_case_    )
								model.to(snake_case_    )
								model.eval()
								__lowercase			       = torch.randint(0			,							1			,							(self.batch_size, self.image_size, self.image_size)    ).to(snake_case_    )
								__lowercase			       = model(snake_case_			,							labels=snake_case_    )
								self.parent.assertGreater(result.loss			,							0.0    )






					def A   (					self    ) ->      List[Any]:







								'''simple docstring'''

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




@require_torch
class 						lowerCamelCase_							(					lowerCAmelCase__  ,  lowerCAmelCase__  ,  unittest.TestCase					):



					'''simple docstring'''







					__UpperCAmelCase							  =					(
					    (
					        SegformerModel,
					        SegformerForSemanticSegmentation,
					        SegformerForImageClassification,
					    )
					    if is_torch_available()
					    else ()
					)
					__UpperCAmelCase							  =					(
					    {
					        "feature-extraction": SegformerModel,
					        "image-classification": SegformerForImageClassification,
					        "image-segmentation": SegformerForSemanticSegmentation,
					    }
					    if is_torch_available()
					    else {}
					)

					__UpperCAmelCase							  =					True
					__UpperCAmelCase							  =					False
					__UpperCAmelCase							  =					False
					__UpperCAmelCase							  =					False






					def A   (					self    ) ->      Any:







								'''simple docstring'''

								__lowercase			       = SegformerModelTester(self    )
								__lowercase			       = SegformerConfigTester(self			,							config_class=snake_case_    )






					def A   (					self    ) ->      Dict:







								'''simple docstring'''

								self.config_tester.run_common_tests()






					def A   (					self    ) ->      Dict:







								'''simple docstring'''

								__lowercase			       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case_    )






					def A   (					self    ) ->      Optional[Any]:







								'''simple docstring'''

								__lowercase			       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_binary_image_segmentation(*snake_case_    )






					def A   (					self    ) ->      int:







								'''simple docstring'''

								__lowercase			       = self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_segmentation(*snake_case_    )






					@unittest.skip('''SegFormer does not use inputs_embeds'''    )
					def A   (					self    ) ->      List[Any]:







								'''simple docstring'''

								pass






					@unittest.skip('''SegFormer does not have get_input_embeddings method and get_output_embeddings methods'''    )
					def A   (					self    ) ->      str:







								'''simple docstring'''

								pass






					def A   (					self    ) ->      Union[str, Any]:







								'''simple docstring'''

								__lowercase       ,			__lowercase			       = self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowercase			       = ['''pixel_values''']
											self.assertListEqual(arg_names[:1]			,							snake_case_    )






					def A   (					self    ) ->      List[str]:







								'''simple docstring'''

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

								for model_class in self.all_model_classes:
											__lowercase			       = True
											__lowercase			       = False
											__lowercase			       = True
											__lowercase			       = model_class(snake_case_    )
											model.to(snake_case_    )
											model.eval()
											with torch.no_grad():
														__lowercase			       = model(**self._prepare_for_class(snake_case_			,							snake_case_    )    )
											__lowercase			       = outputs.attentions

											__lowercase			       = sum(self.model_tester.depths    )
											self.assertEqual(len(snake_case_    )			,							snake_case_    )

											# check that output_attentions also work using config
											del inputs_dict["output_attentions"]
											__lowercase			       = True
											__lowercase			       = model_class(snake_case_    )
											model.to(snake_case_    )
											model.eval()
											with torch.no_grad():
														__lowercase			       = model(**self._prepare_for_class(snake_case_			,							snake_case_    )    )
											__lowercase			       = outputs.attentions

											self.assertEqual(len(snake_case_    )			,							snake_case_    )

											# verify the first attentions (first block, first layer)
											__lowercase			       = (self.model_tester.image_size // 4) ** 2
											__lowercase			       = (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
											self.assertListEqual(
											    list(attentions[0].shape[-3:]    )			,							[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]			,							)

											# verify the last attentions (last block, last layer)
											__lowercase			       = (self.model_tester.image_size // 3_2) ** 2
											__lowercase			       = (self.model_tester.image_size // (3_2 * self.model_tester.sr_ratios[-1])) ** 2
											self.assertListEqual(
											    list(attentions[-1].shape[-3:]    )			,							[self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]			,							)
											__lowercase			       = len(snake_case_    )

											# Check attention is always last and order is fine
											__lowercase			       = True
											__lowercase			       = True
											__lowercase			       = model_class(snake_case_    )
											model.to(snake_case_    )
											model.eval()
											with torch.no_grad():
														__lowercase			       = model(**self._prepare_for_class(snake_case_			,							snake_case_    )    )

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

											__lowercase			       = outputs.attentions

											self.assertEqual(len(snake_case_    )			,							snake_case_    )
											# verify the first attentions (first block, first layer)
											__lowercase			       = (self.model_tester.image_size // 4) ** 2
											__lowercase			       = (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
											self.assertListEqual(
											    list(self_attentions[0].shape[-3:]    )			,							[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]			,							)






					def A   (					self    ) ->      Dict:







								'''simple docstring'''

								def check_hidden_states_output(snake_case_			,							snake_case_			,							snake_case_    ):
											__lowercase			       = model_class(snake_case_    )
											model.to(snake_case_    )
											model.eval()

											with torch.no_grad():
														__lowercase			       = model(**self._prepare_for_class(snake_case_			,							snake_case_    )    )

											__lowercase			       = outputs.hidden_states

											__lowercase			       = self.model_tester.num_encoder_blocks
											self.assertEqual(len(snake_case_    )			,							snake_case_    )

											# verify the first hidden states (first block)
											self.assertListEqual(
											    list(hidden_states[0].shape[-3:]    )			,							[
											        self.model_tester.hidden_sizes[0],
											        self.model_tester.image_size // 4,
											        self.model_tester.image_size // 4,
											    ]			,							)

								__lowercase       ,			__lowercase			       = self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											__lowercase			       = True
											check_hidden_states_output(snake_case_			,							snake_case_			,							snake_case_    )

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

											check_hidden_states_output(snake_case_			,							snake_case_			,							snake_case_    )






					def A   (					self    ) ->      str:







								'''simple docstring'''

								if not self.model_tester.is_training:
											return

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

								for model_class in self.all_model_classes:
											if model_class in get_values(snake_case_    ):
														continue

											__lowercase			       = model_class(snake_case_    )
											model.to(snake_case_    )
											model.train()
											__lowercase			       = self._prepare_for_class(snake_case_			,							snake_case_			,							return_labels=snake_case_    )
											__lowercase			       = model(**snake_case_    ).loss
											loss.backward()






					@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''    )
					def A   (					self    ) ->      List[Any]:







								'''simple docstring'''

								pass






					@slow
					def A   (					self    ) ->      str:







								'''simple docstring'''

								for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase			       = SegformerModel.from_pretrained(snake_case_    )
											self.assertIsNotNone(snake_case_    )




def 		lowercase_	(  ):


			'''simple docstring'''







			__lowercase			       = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
			return image





@require_torch
class 						lowerCamelCase_							(					unittest.TestCase					):



					'''simple docstring'''







					@slow
					def A   (					self    ) ->      Union[str, Any]:







								'''simple docstring'''

								__lowercase			       = SegformerImageProcessor(
								    image_scale=(5_1_2, 5_1_2)			,							keep_ratio=snake_case_			,							align=snake_case_			,							do_random_crop=snake_case_    )
								__lowercase			       = SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''    ).to(
								    snake_case_    )

								__lowercase			       = prepare_img()
								__lowercase			       = image_processor(images=snake_case_			,							return_tensors='''pt'''    )
								__lowercase			       = encoded_inputs.pixel_values.to(snake_case_    )

								with torch.no_grad():
											__lowercase			       = model(snake_case_    )

								__lowercase			       = torch.Size((1, model.config.num_labels, 1_2_8, 1_2_8)    )
								self.assertEqual(outputs.logits.shape			,							snake_case_    )

								__lowercase			       = torch.tensor(
								    [
								        [[-4.6_3_1_0, -5.5_2_3_2, -6.2_3_5_6], [-5.1_9_2_1, -6.1_4_4_4, -6.5_9_9_6], [-5.4_4_2_4, -6.2_7_9_0, -6.7_5_7_4]],
								        [[-1_2.1_3_9_1, -1_3.3_1_2_2, -1_3.9_5_5_4], [-1_2.8_7_3_2, -1_3.9_3_5_2, -1_4.3_5_6_3], [-1_2.9_4_3_8, -1_3.8_2_2_6, -1_4.2_5_1_3]],
								        [[-1_2.5_1_3_4, -1_3.4_6_8_6, -1_4.4_9_1_5], [-1_2.8_6_6_9, -1_4.4_3_4_3, -1_4.7_7_5_8], [-1_3.2_5_2_3, -1_4.5_8_1_9, -1_5.0_6_9_4]],
								    ]    ).to(snake_case_    )
								self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]			,							snake_case_			,							atol=1e-4    )    )






					@slow
					def A   (					self    ) ->      int:







								'''simple docstring'''

								__lowercase			       = SegformerImageProcessor(
								    image_scale=(5_1_2, 5_1_2)			,							keep_ratio=snake_case_			,							align=snake_case_			,							do_random_crop=snake_case_    )
								__lowercase			       = SegformerForSemanticSegmentation.from_pretrained(
								    '''nvidia/segformer-b1-finetuned-cityscapes-1024-1024'''    ).to(snake_case_    )

								__lowercase			       = prepare_img()
								__lowercase			       = image_processor(images=snake_case_			,							return_tensors='''pt'''    )
								__lowercase			       = encoded_inputs.pixel_values.to(snake_case_    )

								with torch.no_grad():
											__lowercase			       = model(snake_case_    )

								__lowercase			       = torch.Size((1, model.config.num_labels, 1_2_8, 1_2_8)    )
								self.assertEqual(outputs.logits.shape			,							snake_case_    )

								__lowercase			       = torch.tensor(
								    [
								        [[-1_3.5_7_4_8, -1_3.9_1_1_1, -1_2.6_5_0_0], [-1_4.3_5_0_0, -1_5.3_6_8_3, -1_4.2_3_2_8], [-1_4.7_5_3_2, -1_6.0_4_2_4, -1_5.6_0_8_7]],
								        [[-1_7.1_6_5_1, -1_5.8_7_2_5, -1_2.9_6_5_3], [-1_7.2_5_8_0, -1_7.3_7_1_8, -1_4.8_2_2_3], [-1_6.6_0_5_8, -1_6.8_7_8_3, -1_6.7_4_5_2]],
								        [[-3.6_4_5_6, -3.0_2_0_9, -1.4_2_0_3], [-3.0_7_9_7, -3.1_9_5_9, -2.0_0_0_0], [-1.8_7_5_7, -1.9_2_1_7, -1.6_9_9_7]],
								    ]    ).to(snake_case_    )
								self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]			,							snake_case_			,							atol=1e-1    )    )






					@slow
					def A   (					self    ) ->      int:







								'''simple docstring'''

								__lowercase			       = SegformerImageProcessor(
								    image_scale=(5_1_2, 5_1_2)			,							keep_ratio=snake_case_			,							align=snake_case_			,							do_random_crop=snake_case_    )
								__lowercase			       = SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''    ).to(
								    snake_case_    )

								__lowercase			       = prepare_img()
								__lowercase			       = image_processor(images=snake_case_			,							return_tensors='''pt'''    )
								__lowercase			       = encoded_inputs.pixel_values.to(snake_case_    )

								with torch.no_grad():
											__lowercase			       = model(snake_case_    )

								__lowercase			       = outputs.logits.detach().cpu()

								__lowercase			       = image_processor.post_process_semantic_segmentation(outputs=snake_case_			,							target_sizes=[(5_0_0, 3_0_0)]    )
								__lowercase			       = torch.Size((5_0_0, 3_0_0)    )
								self.assertEqual(segmentation[0].shape			,							snake_case_    )

								__lowercase			       = image_processor.post_process_semantic_segmentation(outputs=snake_case_    )
								__lowercase			       = torch.Size((1_2_8, 1_2_8)    )
								self.assertEqual(segmentation[0].shape			,							snake_case_    )


