"""simple docstring"""







import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()

class 		UpperCamelCase      (   unittest.TestCase						):



				def  _lowercase					(self    :				Optional[int])   ->     Optional[Any]:
					# clean up the VRAM after each test
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()



				@property
				def  _lowercase					(self    :				Optional[int])   ->     Dict:
					__snake_case      :							Any						=			1
					__snake_case      :							List[str]						=			3
					__snake_case      :							Optional[int]						=			(32, 32)

					__snake_case      :							Any						=			floats_tensor((batch_size, num_channels) + sizes     ,  rng=random.Random(0)).to(_A)
					return image



				@property
				def  _lowercase					(self    :				List[Any])   ->     List[Any]:
					torch.manual_seed(0)
					__snake_case      :							Dict						=			UNetaDConditionModel(
					    block_out_channels=(32, 32, 64)     ,  layers_per_block=2     ,  sample_size=32     ,  in_channels=7     ,  out_channels=4     ,  down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D')     ,  up_block_types=('CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'UpBlock2D')     ,  cross_attention_dim=32     ,  attention_head_dim=8     ,  use_linear_projection=_A     ,  only_cross_attention=(True, True, False)     ,  num_class_embeds=1_00     ,  )
					return model



				@property
				def  _lowercase					(self    :				Dict)   ->     Tuple:
					torch.manual_seed(0)
					__snake_case      :							str						=			AutoencoderKL(
					    block_out_channels=[32, 32, 64]     ,  in_channels=3     ,  out_channels=3     ,  down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D']     ,  up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']     ,  latent_channels=4     ,  )
					return model



				@property
				def  _lowercase					(self    :				Optional[Any])   ->     Dict:
					torch.manual_seed(0)
					__snake_case      :							int						=			CLIPTextConfig(
					    bos_token_id=0     ,  eos_token_id=2     ,  hidden_size=32     ,  intermediate_size=37     ,  layer_norm_eps=1E-05     ,  num_attention_heads=4     ,  num_hidden_layers=5     ,  pad_token_id=1     ,  vocab_size=10_00     ,  hidden_act='gelu'     ,  projection_dim=5_12     ,  )
					return CLIPTextModel(_A)



				def  _lowercase					(self    :				List[str])   ->     Dict:
					__snake_case      :							Union[str, Any]						=			'cpu'  # ensure determinism for the device-dependent torch.Generator
					__snake_case      :							Union[str, Any]						=			self.dummy_cond_unet_upscale
					__snake_case      :							Tuple						=			DDPMScheduler()
					__snake_case      :							Union[str, Any]						=			DDIMScheduler(prediction_type='v_prediction')
					__snake_case      :							int						=			self.dummy_vae
					__snake_case      :							Tuple						=			self.dummy_text_encoder
					__snake_case      :							int						=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

					__snake_case      :							str						=			self.dummy_image.cpu().permute(0     ,  2     ,  3     ,  1)[0]
					__snake_case      :							int						=			Image.fromarray(np.uinta(_A)).convert('RGB').resize((64, 64))

					# make sure here that pndm scheduler skips prk
					__snake_case      :							Dict						=			StableDiffusionUpscalePipeline(
					    unet=_A     ,  low_res_scheduler=_A     ,  scheduler=_A     ,  vae=_A     ,  text_encoder=_A     ,  tokenizer=_A     ,  max_noise_level=3_50     ,  )
					__snake_case      :							Dict						=			sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

					__snake_case      :							Union[str, Any]						=			'A painting of a squirrel eating a burger'
					__snake_case      :							str						=			torch.Generator(device=_A).manual_seed(0)
					__snake_case      :							List[str]						=			sd_pipe(
					    [prompt]     ,  image=_A     ,  generator=_A     ,  guidance_scale=6.0     ,  noise_level=20     ,  num_inference_steps=2     ,  output_type='np'     ,  )

					__snake_case      :							List[Any]						=			output.images

					__snake_case      :							Optional[Any]						=			torch.Generator(device=_A).manual_seed(0)
					__snake_case      :							Optional[Any]						=			sd_pipe(
					    [prompt]     ,  image=_A     ,  generator=_A     ,  guidance_scale=6.0     ,  noise_level=20     ,  num_inference_steps=2     ,  output_type='np'     ,  return_dict=_A     ,  )[0]

					__snake_case      :							int						=			image[0, -3:, -3:, -1]
					__snake_case      :							Tuple						=			image_from_tuple[0, -3:, -3:, -1]

					__snake_case      :							Dict						=			low_res_image.size[0] * 4
					assert image.shape == (1, expected_height_width, expected_height_width, 3)
					__snake_case      :							Any						=			np.array([0.3_113, 0.3_910, 0.4_272, 0.4_859, 0.5_061, 0.4_652, 0.5_362, 0.5_715, 0.5_661])

					assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
					assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2



				def  _lowercase					(self    :				Any)   ->     Any:
					__snake_case      :							int						=			'cpu'  # ensure determinism for the device-dependent torch.Generator
					__snake_case      :							Optional[Any]						=			self.dummy_cond_unet_upscale
					__snake_case      :							Tuple						=			DDPMScheduler()
					__snake_case      :							str						=			DDIMScheduler(prediction_type='v_prediction')
					__snake_case      :							Optional[int]						=			self.dummy_vae
					__snake_case      :							List[Any]						=			self.dummy_text_encoder
					__snake_case      :							Any						=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

					__snake_case      :							List[Any]						=			self.dummy_image.cpu().permute(0     ,  2     ,  3     ,  1)[0]
					__snake_case      :							str						=			Image.fromarray(np.uinta(_A)).convert('RGB').resize((64, 64))

					# make sure here that pndm scheduler skips prk
					__snake_case      :							int						=			StableDiffusionUpscalePipeline(
					    unet=_A     ,  low_res_scheduler=_A     ,  scheduler=_A     ,  vae=_A     ,  text_encoder=_A     ,  tokenizer=_A     ,  max_noise_level=3_50     ,  )
					__snake_case      :							int						=			sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

					__snake_case      :							Union[str, Any]						=			'A painting of a squirrel eating a burger'
					__snake_case      :							Union[str, Any]						=			sd_pipe(
					    2 * [prompt]     ,  image=2 * [low_res_image]     ,  guidance_scale=6.0     ,  noise_level=20     ,  num_inference_steps=2     ,  output_type='np'     ,  )
					__snake_case      :							Dict						=			output.images
					assert image.shape[0] == 2

					__snake_case      :							List[Any]						=			torch.Generator(device=_A).manual_seed(0)
					__snake_case      :							List[Any]						=			sd_pipe(
					    [prompt]     ,  image=_A     ,  generator=_A     ,  num_images_per_prompt=2     ,  guidance_scale=6.0     ,  noise_level=20     ,  num_inference_steps=2     ,  output_type='np'     ,  )
					__snake_case      :							int						=			output.images
					assert image.shape[0] == 2






				@unittest.skipIf(torch_device != 'cuda'     ,  'This test requires a GPU')
				def  _lowercase					(self    :				int)   ->     int:
					__snake_case      :							Tuple						=			self.dummy_cond_unet_upscale
					__snake_case      :							List[Any]						=			DDPMScheduler()
					__snake_case      :							Tuple						=			DDIMScheduler(prediction_type='v_prediction')
					__snake_case      :							Dict						=			self.dummy_vae
					__snake_case      :							Union[str, Any]						=			self.dummy_text_encoder
					__snake_case      :							List[Any]						=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

					__snake_case      :							Dict						=			self.dummy_image.cpu().permute(0     ,  2     ,  3     ,  1)[0]
					__snake_case      :							Any						=			Image.fromarray(np.uinta(_A)).convert('RGB').resize((64, 64))

					# put models in fp16, except vae as it overflows in fp16
					__snake_case      :							List[Any]						=			unet.half()
					__snake_case      :							List[str]						=			text_encoder.half()

					# make sure here that pndm scheduler skips prk
					__snake_case      :							Dict						=			StableDiffusionUpscalePipeline(
					    unet=_A     ,  low_res_scheduler=_A     ,  scheduler=_A     ,  vae=_A     ,  text_encoder=_A     ,  tokenizer=_A     ,  max_noise_level=3_50     ,  )
					__snake_case      :							Optional[Any]						=			sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

					__snake_case      :							Dict						=			'A painting of a squirrel eating a burger'
					__snake_case      :							int						=			torch.manual_seed(0)
					__snake_case      :							str						=			sd_pipe(
					    [prompt]     ,  image=_A     ,  generator=_A     ,  num_inference_steps=2     ,  output_type='np'     ,  ).images

					__snake_case      :							Optional[Any]						=			low_res_image.size[0] * 4
					assert image.shape == (1, expected_height_width, expected_height_width, 3)







@slow
@require_torch_gpu
class 		UpperCamelCase      (   unittest.TestCase						):



				def  _lowercase					(self    :				Tuple)   ->     Any:
					# clean up the VRAM after each test
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()



				def  _lowercase					(self    :				Optional[Any])   ->     Tuple:
					__snake_case      :							Dict						=			load_image(
					    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
					    '/sd2-upscale/low_res_cat.png')
					__snake_case      :							Optional[int]						=			load_numpy(
					    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
					    '/upsampled_cat.npy')

					__snake_case      :							Optional[int]						=			'stabilityai/stable-diffusion-x4-upscaler'
					__snake_case      :							List[str]						=			StableDiffusionUpscalePipeline.from_pretrained(_A)
					pipe.to(_A)
					pipe.set_progress_bar_config(disable=_A)
					pipe.enable_attention_slicing()

					__snake_case      :							List[str]						=			'a cat sitting on a park bench'

					__snake_case      :							int						=			torch.manual_seed(0)
					__snake_case      :							List[str]						=			pipe(
					    prompt=_A     ,  image=_A     ,  generator=_A     ,  output_type='np'     ,  )
					__snake_case      :							Optional[int]						=			output.images[0]

					assert image.shape == (5_12, 5_12, 3)
					assert np.abs(expected_image - image).max() < 1E-3



				def  _lowercase					(self    :				Optional[int])   ->     str:
					__snake_case      :							List[str]						=			load_image(
					    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
					    '/sd2-upscale/low_res_cat.png')
					__snake_case      :							Optional[int]						=			load_numpy(
					    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
					    '/upsampled_cat_fp16.npy')

					__snake_case      :							str						=			'stabilityai/stable-diffusion-x4-upscaler'
					__snake_case      :							int						=			StableDiffusionUpscalePipeline.from_pretrained(
					    _A     ,  torch_dtype=torch.floataa     ,  )
					pipe.to(_A)
					pipe.set_progress_bar_config(disable=_A)
					pipe.enable_attention_slicing()

					__snake_case      :							Union[str, Any]						=			'a cat sitting on a park bench'

					__snake_case      :							Dict						=			torch.manual_seed(0)
					__snake_case      :							Tuple						=			pipe(
					    prompt=_A     ,  image=_A     ,  generator=_A     ,  output_type='np'     ,  )
					__snake_case      :							int						=			output.images[0]

					assert image.shape == (5_12, 5_12, 3)
					assert np.abs(expected_image - image).max() < 5E-1






				def  _lowercase					(self    :				List[str])   ->     int:
					torch.cuda.empty_cache()
					torch.cuda.reset_max_memory_allocated()
					torch.cuda.reset_peak_memory_stats()

					__snake_case      :							List[str]						=			load_image(
					    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
					    '/sd2-upscale/low_res_cat.png')

					__snake_case      :							List[Any]						=			'stabilityai/stable-diffusion-x4-upscaler'
					__snake_case      :							Tuple						=			StableDiffusionUpscalePipeline.from_pretrained(
					    _A     ,  torch_dtype=torch.floataa     ,  )
					pipe.to(_A)
					pipe.set_progress_bar_config(disable=_A)
					pipe.enable_attention_slicing(1)
					pipe.enable_sequential_cpu_offload()

					__snake_case      :							Tuple						=			'a cat sitting on a park bench'

					__snake_case      :							Optional[Any]						=			torch.manual_seed(0)
					__snake_case      :							Optional[Any]						=			pipe(
					    prompt=_A     ,  image=_A     ,  generator=_A     ,  num_inference_steps=5     ,  output_type='np'     ,  )

					__snake_case      :							Dict						=			torch.cuda.max_memory_allocated()
					# make sure that less than 2.9 GB is allocated
					assert mem_bytes < 2.9 * 10**9






"""simple docstring"""







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 		UpperCamelCase      (   lowercase						):



				def  _lowercase					(self    :				Any)   ->     List[Any]:
					__snake_case      :							Any						=			self.config_class(**self.inputs_dict)
					self.parent.assertTrue(hasattr(_A     ,  'hidden_sizes'))
					self.parent.assertTrue(hasattr(_A     ,  'num_attention_heads'))
					self.parent.assertTrue(hasattr(_A     ,  'num_encoder_blocks'))







class 		UpperCamelCase      :



				def __init__(self    :				Optional[int]     ,  _A    :				Any     ,  _A    :				str=13     ,  _A    :				List[str]=64     ,  _A    :				List[Any]=3     ,  _A    :				Any=4     ,  _A    :				List[str]=[2, 2, 2, 2]     ,  _A    :				Tuple=[8, 4, 2, 1]     ,  _A    :				List[str]=[16, 32, 64, 1_28]     ,  _A    :				int=[1, 4, 8, 16]     ,  _A    :				List[str]=[1, 2, 4, 8]     ,  _A    :				Dict=True     ,  _A    :				Any=True     ,  _A    :				List[str]="gelu"     ,  _A    :				Optional[int]=0.1     ,  _A    :				Union[str, Any]=0.1     ,  _A    :				List[Any]=0.02     ,  _A    :				str=3     ,  _A    :				int=None     ,  )   ->     List[Any]:
					__snake_case      :							int						=			parent
					__snake_case      :							List[Any]						=			batch_size
					__snake_case      :							Optional[int]						=			image_size
					__snake_case      :							List[str]						=			num_channels
					__snake_case      :							Any						=			num_encoder_blocks
					__snake_case      :							Dict						=			sr_ratios
					__snake_case      :							Any						=			depths
					__snake_case      :							Tuple						=			hidden_sizes
					__snake_case      :							Tuple						=			downsampling_rates
					__snake_case      :							Union[str, Any]						=			num_attention_heads
					__snake_case      :							Optional[int]						=			is_training
					__snake_case      :							Any						=			use_labels
					__snake_case      :							List[Any]						=			hidden_act
					__snake_case      :							Union[str, Any]						=			hidden_dropout_prob
					__snake_case      :							Tuple						=			attention_probs_dropout_prob
					__snake_case      :							List[Any]						=			initializer_range
					__snake_case      :							Union[str, Any]						=			num_labels
					__snake_case      :							Dict						=			scope



				def  _lowercase					(self    :				List[Any])   ->     Tuple:
					__snake_case      :							Optional[Any]						=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

					__snake_case      :							str						=			None
					if self.use_labels:
						__snake_case      :							Optional[Any]						=			ids_tensor([self.batch_size, self.image_size, self.image_size]     ,  self.num_labels)

					__snake_case      :							Dict						=			self.get_config()
					return config, pixel_values, labels



				def  _lowercase					(self    :				Any)   ->     Optional[int]:
					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  _lowercase					(self    :				List[str]     ,  _A    :				Union[str, Any]     ,  _A    :				List[Any]     ,  _A    :				Union[str, Any])   ->     int:
					__snake_case      :							Union[str, Any]						=			SegformerModel(config=_A)
					model.to(_A)
					model.eval()
					__snake_case      :							str						=			model(_A)
					__snake_case      :							List[Any]						=			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  _lowercase					(self    :				Tuple     ,  _A    :				Dict     ,  _A    :				Any     ,  _A    :				int)   ->     str:
					__snake_case      :							Any						=			self.num_labels
					__snake_case      :							List[str]						=			SegformerForSemanticSegmentation(_A)
					model.to(_A)
					model.eval()
					__snake_case      :							Dict						=			model(_A)
					self.parent.assertEqual(
					    result.logits.shape     ,  (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4))
					__snake_case      :							Dict						=			model(_A     ,  labels=_A)
					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  _lowercase					(self    :				Optional[Any]     ,  _A    :				Dict     ,  _A    :				Optional[int]     ,  _A    :				str)   ->     List[Any]:
					__snake_case      :							List[Any]						=			1
					__snake_case      :							str						=			SegformerForSemanticSegmentation(config=_A)
					model.to(_A)
					model.eval()
					__snake_case      :							Any						=			torch.randint(0     ,  1     ,  (self.batch_size, self.image_size, self.image_size)).to(_A)
					__snake_case      :							Any						=			model(_A     ,  labels=_A)
					self.parent.assertGreater(result.loss     ,  0.0)






				def  _lowercase					(self    :				Any)   ->     Optional[int]:
					__snake_case      :							Optional[Any]						=			self.prepare_config_and_inputs()
					__snake_case		,    __snake_case		,    __snake_case      :							str						=			config_and_inputs
					__snake_case      :							List[str]						=			{'pixel_values': pixel_values}
					return config, inputs_dict







@require_torch
class 		UpperCamelCase      (   lowercase				,     lowercase				,     unittest.TestCase						):
				UpperCAmelCase    :				List[str]   =		(
				    (
				        SegformerModel,
				        SegformerForSemanticSegmentation,
				        SegformerForImageClassification,
				    )
				    if is_torch_available()
				    else ()
				)
				UpperCAmelCase    :				Dict   =		(
				    {
				        """feature-extraction""": SegformerModel,
				        """image-classification""": SegformerForImageClassification,
				        """image-segmentation""": SegformerForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				UpperCAmelCase    :				Optional[int]   =		True
				UpperCAmelCase    :				Optional[int]   =		False
				UpperCAmelCase    :				List[Any]   =		False
				UpperCAmelCase    :				List[Any]   =		False



				def  _lowercase					(self    :				str)   ->     Union[str, Any]:
					__snake_case      :							Optional[int]						=			SegformerModelTester(self)
					__snake_case      :							Any						=			SegformerConfigTester(self     ,  config_class=_A)



				def  _lowercase					(self    :				List[str])   ->     Optional[int]:
					self.config_tester.run_common_tests()



				def  _lowercase					(self    :				List[Any])   ->     List[str]:
					__snake_case      :							int						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*_A)



				def  _lowercase					(self    :				Optional[int])   ->     str:
					__snake_case      :							List[Any]						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_binary_image_segmentation(*_A)



				def  _lowercase					(self    :				int)   ->     Union[str, Any]:
					__snake_case      :							Union[str, Any]						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_segmentation(*_A)



				@unittest.skip('SegFormer does not use inputs_embeds')
				def  _lowercase					(self    :				Union[str, Any])   ->     str:
					pass



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



				def  _lowercase					(self    :				List[str])   ->     Any:
					__snake_case		,    __snake_case      :							Dict						=			self.model_tester.prepare_config_and_inputs_for_common()

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

						__snake_case      :							Optional[int]						=			['pixel_values']
						self.assertListEqual(arg_names[:1]     ,  _A)



				def  _lowercase					(self    :				List[str])   ->     List[Any]:
					__snake_case		,    __snake_case      :							Union[str, Any]						=			self.model_tester.prepare_config_and_inputs_for_common()
					__snake_case      :							Optional[int]						=			True

					for model_class in self.all_model_classes:
						__snake_case      :							Union[str, Any]						=			True
						__snake_case      :							List[str]						=			False
						__snake_case      :							Tuple						=			True
						__snake_case      :							int						=			model_class(_A)
						model.to(_A)
						model.eval()
						with torch.no_grad():
							__snake_case      :							int						=			model(**self._prepare_for_class(_A     ,  _A))
						__snake_case      :							Union[str, Any]						=			outputs.attentions

						__snake_case      :							int						=			sum(self.model_tester.depths)
						self.assertEqual(len(_A)     ,  _A)

						# check that output_attentions also work using config
						del inputs_dict["output_attentions"]
						__snake_case      :							int						=			True
						__snake_case      :							Union[str, Any]						=			model_class(_A)
						model.to(_A)
						model.eval()
						with torch.no_grad():
							__snake_case      :							List[str]						=			model(**self._prepare_for_class(_A     ,  _A))
						__snake_case      :							Optional[int]						=			outputs.attentions

						self.assertEqual(len(_A)     ,  _A)

						# verify the first attentions (first block, first layer)
						__snake_case      :							Optional[int]						=			(self.model_tester.image_size // 4) ** 2
						__snake_case      :							Tuple						=			(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)
						__snake_case      :							int						=			(self.model_tester.image_size // 32) ** 2
						__snake_case      :							Any						=			(self.model_tester.image_size // (32 * 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]     ,  )
						__snake_case      :							int						=			len(_A)

						# Check attention is always last and order is fine
						__snake_case      :							Any						=			True
						__snake_case      :							Tuple						=			True
						__snake_case      :							Optional[Any]						=			model_class(_A)
						model.to(_A)
						model.eval()
						with torch.no_grad():
							__snake_case      :							Any						=			model(**self._prepare_for_class(_A     ,  _A))

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

						__snake_case      :							List[Any]						=			outputs.attentions

						self.assertEqual(len(_A)     ,  _A)
						# verify the first attentions (first block, first layer)
						__snake_case      :							Any						=			(self.model_tester.image_size // 4) ** 2
						__snake_case      :							List[Any]						=			(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  _lowercase					(self    :				str)   ->     List[str]:
					def check_hidden_states_output(_A    :				Union[str, Any]     ,  _A    :				List[str]     ,  _A    :				Tuple):
						__snake_case      :							Tuple						=			model_class(_A)
						model.to(_A)
						model.eval()

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

						__snake_case      :							List[str]						=			outputs.hidden_states

						__snake_case      :							Tuple						=			self.model_tester.num_encoder_blocks
						self.assertEqual(len(_A)     ,  _A)

						# 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,
						    ]     ,  )

					__snake_case		,    __snake_case      :							Optional[Any]						=			self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						__snake_case      :							List[str]						=			True
						check_hidden_states_output(_A     ,  _A     ,  _A)

						# check that output_hidden_states also work using config
						del inputs_dict["output_hidden_states"]
						__snake_case      :							Any						=			True

						check_hidden_states_output(_A     ,  _A     ,  _A)



				def  _lowercase					(self    :				Optional[int])   ->     int:
					if not self.model_tester.is_training:
						return

					__snake_case		,    __snake_case      :							Dict						=			self.model_tester.prepare_config_and_inputs_for_common()
					__snake_case      :							int						=			True

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

						__snake_case      :							Tuple						=			model_class(_A)
						model.to(_A)
						model.train()
						__snake_case      :							str						=			self._prepare_for_class(_A     ,  _A     ,  return_labels=_A)
						__snake_case      :							Dict						=			model(**_A).loss
						loss.backward()



				@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
				def  _lowercase					(self    :				Tuple)   ->     Dict:
					pass






				@slow
				def  _lowercase					(self    :				Any)   ->     List[str]:
					for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						__snake_case      :							List[Any]						=			SegformerModel.from_pretrained(_A)
						self.assertIsNotNone(_A)







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

	'''simple docstring'''





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

@require_torch
class 		UpperCamelCase      (   unittest.TestCase						):



				@slow
				def  _lowercase					(self    :				Union[str, Any])   ->     Any:
					# only resize + normalize
					__snake_case      :							List[str]						=			SegformerImageProcessor(
					    image_scale=(5_12, 5_12)     ,  keep_ratio=_A     ,  align=_A     ,  do_random_crop=_A)
					__snake_case      :							Tuple						=			SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512').to(
					    _A)

					__snake_case      :							Optional[Any]						=			prepare_img()
					__snake_case      :							Tuple						=			image_processor(images=_A     ,  return_tensors='pt')
					__snake_case      :							List[str]						=			encoded_inputs.pixel_values.to(_A)

					with torch.no_grad():
						__snake_case      :							Any						=			model(_A)

					__snake_case      :							Optional[int]						=			torch.Size((1, model.config.num_labels, 1_28, 1_28))
					self.assertEqual(outputs.logits.shape     ,  _A)

					__snake_case      :							Tuple						=			torch.tensor(
					    [
					        [[-4.6_310, -5.5_232, -6.2_356], [-5.1_921, -6.1_444, -6.5_996], [-5.4_424, -6.2_790, -6.7_574]],
					        [[-12.1_391, -13.3_122, -13.9_554], [-12.8_732, -13.9_352, -14.3_563], [-12.9_438, -13.8_226, -14.2_513]],
					        [[-12.5_134, -13.4_686, -14.4_915], [-12.8_669, -14.4_343, -14.7_758], [-13.2_523, -14.5_819, -15.0_694]],
					    ]).to(_A)
					self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]     ,  _A     ,  atol=1E-4))



				@slow
				def  _lowercase					(self    :				Any)   ->     Optional[int]:
					# only resize + normalize
					__snake_case      :							int						=			SegformerImageProcessor(
					    image_scale=(5_12, 5_12)     ,  keep_ratio=_A     ,  align=_A     ,  do_random_crop=_A)
					__snake_case      :							Tuple						=			SegformerForSemanticSegmentation.from_pretrained(
					    'nvidia/segformer-b1-finetuned-cityscapes-1024-1024').to(_A)

					__snake_case      :							str						=			prepare_img()
					__snake_case      :							Union[str, Any]						=			image_processor(images=_A     ,  return_tensors='pt')
					__snake_case      :							str						=			encoded_inputs.pixel_values.to(_A)

					with torch.no_grad():
						__snake_case      :							Any						=			model(_A)

					__snake_case      :							Any						=			torch.Size((1, model.config.num_labels, 1_28, 1_28))
					self.assertEqual(outputs.logits.shape     ,  _A)

					__snake_case      :							List[Any]						=			torch.tensor(
					    [
					        [[-13.5_748, -13.9_111, -12.6_500], [-14.3_500, -15.3_683, -14.2_328], [-14.7_532, -16.0_424, -15.6_087]],
					        [[-17.1_651, -15.8_725, -12.9_653], [-17.2_580, -17.3_718, -14.8_223], [-16.6_058, -16.8_783, -16.7_452]],
					        [[-3.6_456, -3.0_209, -1.4_203], [-3.0_797, -3.1_959, -2.0_000], [-1.8_757, -1.9_217, -1.6_997]],
					    ]).to(_A)
					self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]     ,  _A     ,  atol=1E-1))






				@slow
				def  _lowercase					(self    :				Optional[int])   ->     Union[str, Any]:
					# only resize + normalize
					__snake_case      :							List[Any]						=			SegformerImageProcessor(
					    image_scale=(5_12, 5_12)     ,  keep_ratio=_A     ,  align=_A     ,  do_random_crop=_A)
					__snake_case      :							Optional[Any]						=			SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512').to(
					    _A)

					__snake_case      :							Optional[Any]						=			prepare_img()
					__snake_case      :							Optional[Any]						=			image_processor(images=_A     ,  return_tensors='pt')
					__snake_case      :							Union[str, Any]						=			encoded_inputs.pixel_values.to(_A)

					with torch.no_grad():
						__snake_case      :							Any						=			model(_A)

					__snake_case      :							Optional[Any]						=			outputs.logits.detach().cpu()

					__snake_case      :							Any						=			image_processor.post_process_semantic_segmentation(outputs=_A     ,  target_sizes=[(5_00, 3_00)])
					__snake_case      :							Any						=			torch.Size((5_00, 3_00))
					self.assertEqual(segmentation[0].shape     ,  _A)

					__snake_case      :							Any						=			image_processor.post_process_semantic_segmentation(outputs=_A)
					__snake_case      :							str						=			torch.Size((1_28, 1_28))
					self.assertEqual(segmentation[0].shape     ,  _A)





