




"""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, PNDMScheduler, StableDiffusionInpaintPipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class      a__				(	__magic_name__							,    __magic_name__							,    __magic_name__							,    unittest.TestCase   ):
			lowercase_    =	StableDiffusionInpaintPipeline
			lowercase_    =	TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			lowercase_    =	TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			lowercase_    =	frozenset(
			    []   )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
			lowercase_    =	frozenset([]   )


			def       a_     (      self      :    Any):


						"""simple docstring"""




						torch.manual_seed(0)
						__UpperCAmelCase	: str		=					UNetaDConditionModel(
						    block_out_channels=(32, 64)      ,  layers_per_block=2      ,  sample_size=32      ,  in_channels=9      ,  out_channels=4      ,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")      ,  up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")      ,  cross_attention_dim=32      ,  attention_head_dim=(2, 4)      ,  use_linear_projection=UpperCamelCase_      ,  )
						__UpperCAmelCase	: List[Any]		=					PNDMScheduler(skip_prk_steps=UpperCamelCase_)
						torch.manual_seed(0)
						__UpperCAmelCase	: Tuple		=					AutoencoderKL(
						    block_out_channels=[32, 64]      ,  in_channels=3      ,  out_channels=3      ,  down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]      ,  up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]      ,  latent_channels=4      ,  sample_size=128      ,  )
						torch.manual_seed(0)
						__UpperCAmelCase	: Optional[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=1000      ,  hidden_act="gelu"      ,  projection_dim=512      ,  )
						__UpperCAmelCase	: Union[str, Any]		=					CLIPTextModel(UpperCamelCase_)
						__UpperCAmelCase	: Union[str, Any]		=					CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

						__UpperCAmelCase	: int		=					{
						    "unet": unet,
						    "scheduler": scheduler,
						    "vae": vae,
						    "text_encoder": text_encoder,
						    "tokenizer": tokenizer,
						    "safety_checker": None,
						    "feature_extractor": None,
						}
						return components


			def       a_     (      self      :    Optional[Any]      ,  UpperCamelCase_      :    int      ,  UpperCamelCase_      :    str=0):


						"""simple docstring"""




						__UpperCAmelCase	: List[str]		=					floats_tensor((1, 3, 32, 32)      ,  rng=random.Random(UpperCamelCase_)).to(UpperCamelCase_)
						__UpperCAmelCase	: int		=					image.cpu().permute(0      ,  2      ,  3      ,  1)[0]
						__UpperCAmelCase	: List[Any]		=					Image.fromarray(np.uinta(UpperCamelCase_)).convert("RGB").resize((64, 64))
						__UpperCAmelCase	: Dict		=					Image.fromarray(np.uinta(image + 4)).convert("RGB").resize((64, 64))
						if str(UpperCamelCase_).startswith("mps"):
									__UpperCAmelCase	: Union[str, Any]		=					torch.manual_seed(UpperCamelCase_)
						else:
									__UpperCAmelCase	: str		=					torch.Generator(device=UpperCamelCase_).manual_seed(UpperCamelCase_)
						__UpperCAmelCase	: str		=					{
						    "prompt": "A painting of a squirrel eating a burger",
						    "image": init_image,
						    "mask_image": mask_image,
						    "generator": generator,
						    "num_inference_steps": 2,
						    "guidance_scale": 6.0,
						    "output_type": "numpy",
						}
						return inputs


			def       a_     (      self      :    Any):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[Any]		=					"cpu"  # ensure determinism for the device-dependent torch.Generator
						__UpperCAmelCase	: List[str]		=					self.get_dummy_components()
						__UpperCAmelCase	: List[str]		=					StableDiffusionInpaintPipeline(**UpperCamelCase_)
						__UpperCAmelCase	: Optional[Any]		=					sd_pipe.to(UpperCamelCase_)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase_)

						__UpperCAmelCase	: List[str]		=					self.get_dummy_inputs(UpperCamelCase_)
						__UpperCAmelCase	: int		=					sd_pipe(**UpperCamelCase_).images
						__UpperCAmelCase	: Optional[Any]		=					image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)
						__UpperCAmelCase	: int		=					np.array([0.4727, 0.5735, 0.3941, 0.5446, 0.5926, 0.4394, 0.5062, 0.4654, 0.4476])

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


			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						super().test_inference_batch_single_identical(expected_max_diff=3e-3)






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


			def       a_     (      self      :    Optional[Any]):


						"""simple docstring"""




						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()


			def       a_     (      self      :    str):


						"""simple docstring"""




						__UpperCAmelCase	: int		=					load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
						    "/sd2-inpaint/init_image.png")
						__UpperCAmelCase	: str		=					load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png")
						__UpperCAmelCase	: Union[str, Any]		=					load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint"
						    "/yellow_cat_sitting_on_a_park_bench.npy")

						__UpperCAmelCase	: Dict		=					"stabilityai/stable-diffusion-2-inpainting"
						__UpperCAmelCase	: str		=					StableDiffusionInpaintPipeline.from_pretrained(UpperCamelCase_      ,  safety_checker=UpperCamelCase_)
						pipe.to(UpperCamelCase_)
						pipe.set_progress_bar_config(disable=UpperCamelCase_)
						pipe.enable_attention_slicing()

						__UpperCAmelCase	: int		=					"Face of a yellow cat, high resolution, sitting on a park bench"

						__UpperCAmelCase	: int		=					torch.manual_seed(0)
						__UpperCAmelCase	: str		=					pipe(
						    prompt=UpperCamelCase_      ,  image=UpperCamelCase_      ,  mask_image=UpperCamelCase_      ,  generator=UpperCamelCase_      ,  output_type="np"      ,  )
						__UpperCAmelCase	: str		=					output.images[0]

						assert image.shape == (512, 512, 3)
						assert np.abs(expected_image - image).max() < 9e-3


			def       a_     (      self      :    Dict):


						"""simple docstring"""




						__UpperCAmelCase	: Dict		=					load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
						    "/sd2-inpaint/init_image.png")
						__UpperCAmelCase	: Dict		=					load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png")
						__UpperCAmelCase	: Dict		=					load_numpy(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint"
						    "/yellow_cat_sitting_on_a_park_bench_fp16.npy")

						__UpperCAmelCase	: Union[str, Any]		=					"stabilityai/stable-diffusion-2-inpainting"
						__UpperCAmelCase	: Dict		=					StableDiffusionInpaintPipeline.from_pretrained(
						    UpperCamelCase_      ,  torch_dtype=torch.floataa      ,  safety_checker=UpperCamelCase_      ,  )
						pipe.to(UpperCamelCase_)
						pipe.set_progress_bar_config(disable=UpperCamelCase_)
						pipe.enable_attention_slicing()

						__UpperCAmelCase	: Optional[Any]		=					"Face of a yellow cat, high resolution, sitting on a park bench"

						__UpperCAmelCase	: List[Any]		=					torch.manual_seed(0)
						__UpperCAmelCase	: Any		=					pipe(
						    prompt=UpperCamelCase_      ,  image=UpperCamelCase_      ,  mask_image=UpperCamelCase_      ,  generator=UpperCamelCase_      ,  output_type="np"      ,  )
						__UpperCAmelCase	: Any		=					output.images[0]

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


			def       a_     (      self      :    str):


						"""simple docstring"""




						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()

						__UpperCAmelCase	: str		=					load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
						    "/sd2-inpaint/init_image.png")
						__UpperCAmelCase	: Optional[int]		=					load_image(
						    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png")

						__UpperCAmelCase	: Optional[Any]		=					"stabilityai/stable-diffusion-2-inpainting"
						__UpperCAmelCase	: Optional[int]		=					PNDMScheduler.from_pretrained(UpperCamelCase_      ,  subfolder="scheduler")
						__UpperCAmelCase	: Optional[Any]		=					StableDiffusionInpaintPipeline.from_pretrained(
						    UpperCamelCase_      ,  safety_checker=UpperCamelCase_      ,  scheduler=UpperCamelCase_      ,  torch_dtype=torch.floataa      ,  )
						pipe.to(UpperCamelCase_)
						pipe.set_progress_bar_config(disable=UpperCamelCase_)
						pipe.enable_attention_slicing(1)
						pipe.enable_sequential_cpu_offload()

						__UpperCAmelCase	: List[str]		=					"Face of a yellow cat, high resolution, sitting on a park bench"

						__UpperCAmelCase	: List[Any]		=					torch.manual_seed(0)
						__UpperCAmelCase	: Tuple		=					pipe(
						    prompt=UpperCamelCase_      ,  image=UpperCamelCase_      ,  mask_image=UpperCamelCase_      ,  generator=UpperCamelCase_      ,  num_inference_steps=2      ,  output_type="np"      ,  )

						__UpperCAmelCase	: Union[str, Any]		=					torch.cuda.max_memory_allocated()
						# make sure that less than 2.65 GB is allocated
						assert mem_bytes < 2.65 * 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      a__				(	__magic_name__   ):


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


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					self.config_class(**self.inputs_dict)
						self.parent.assertTrue(hasattr(UpperCamelCase_      ,  "hidden_sizes"))
						self.parent.assertTrue(hasattr(UpperCamelCase_      ,  "num_attention_heads"))
						self.parent.assertTrue(hasattr(UpperCamelCase_      ,  "num_encoder_blocks"))






class      a__				:


			def __init__(      self      :    List[str]      ,  UpperCamelCase_      :    Tuple      ,  UpperCamelCase_      :    List[str]=13      ,  UpperCamelCase_      :    str=64      ,  UpperCamelCase_      :    Optional[Any]=3      ,  UpperCamelCase_      :    List[str]=4      ,  UpperCamelCase_      :    int=[2, 2, 2, 2]      ,  UpperCamelCase_      :    int=[8, 4, 2, 1]      ,  UpperCamelCase_      :    int=[16, 32, 64, 128]      ,  UpperCamelCase_      :    Tuple=[1, 4, 8, 16]      ,  UpperCamelCase_      :    List[str]=[1, 2, 4, 8]      ,  UpperCamelCase_      :    str=True      ,  UpperCamelCase_      :    Any=True      ,  UpperCamelCase_      :    str="gelu"      ,  UpperCamelCase_      :    Optional[Any]=0.1      ,  UpperCamelCase_      :    int=0.1      ,  UpperCamelCase_      :    Tuple=0.02      ,  UpperCamelCase_      :    Dict=3      ,  UpperCamelCase_      :    Union[str, Any]=None      ,  ):


						"""simple docstring"""




						__UpperCAmelCase	: str		=					parent
						__UpperCAmelCase	: Dict		=					batch_size
						__UpperCAmelCase	: str		=					image_size
						__UpperCAmelCase	: str		=					num_channels
						__UpperCAmelCase	: Any		=					num_encoder_blocks
						__UpperCAmelCase	: List[Any]		=					sr_ratios
						__UpperCAmelCase	: Optional[int]		=					depths
						__UpperCAmelCase	: Union[str, Any]		=					hidden_sizes
						__UpperCAmelCase	: Union[str, Any]		=					downsampling_rates
						__UpperCAmelCase	: Union[str, Any]		=					num_attention_heads
						__UpperCAmelCase	: Any		=					is_training
						__UpperCAmelCase	: Optional[Any]		=					use_labels
						__UpperCAmelCase	: List[Any]		=					hidden_act
						__UpperCAmelCase	: str		=					hidden_dropout_prob
						__UpperCAmelCase	: str		=					attention_probs_dropout_prob
						__UpperCAmelCase	: Dict		=					initializer_range
						__UpperCAmelCase	: List[str]		=					num_labels
						__UpperCAmelCase	: Union[str, Any]		=					scope


			def       a_     (      self      :    int):


						"""simple docstring"""




						__UpperCAmelCase	: str		=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

						__UpperCAmelCase	: List[Any]		=					None
						if self.use_labels:
									__UpperCAmelCase	: int		=					ids_tensor([self.batch_size, self.image_size, self.image_size]      ,  self.num_labels)

						__UpperCAmelCase	: Optional[Any]		=					self.get_config()
						return config, pixel_values, labels


			def       a_     (      self      :    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      :    Dict      ,  UpperCamelCase_      :    Optional[Any]      ,  UpperCamelCase_      :    Dict      ,  UpperCamelCase_      :    Dict):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					SegformerModel(config=UpperCamelCase_)
						model.to(UpperCamelCase_)
						model.eval()
						__UpperCAmelCase	: List[Any]		=					model(UpperCamelCase_)
						__UpperCAmelCase	: Optional[int]		=					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      :    Optional[Any]      ,  UpperCamelCase_      :    List[str]      ,  UpperCamelCase_      :    Tuple      ,  UpperCamelCase_      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Tuple		=					self.num_labels
						__UpperCAmelCase	: Union[str, Any]		=					SegformerForSemanticSegmentation(UpperCamelCase_)
						model.to(UpperCamelCase_)
						model.eval()
						__UpperCAmelCase	: Tuple		=					model(UpperCamelCase_)
						self.parent.assertEqual(
						    result.logits.shape      ,  (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4))
						__UpperCAmelCase	: int		=					model(UpperCamelCase_      ,  labels=UpperCamelCase_)
						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      :    Dict      ,  UpperCamelCase_      :    Tuple      ,  UpperCamelCase_      :    Optional[Any]      ,  UpperCamelCase_      :    List[Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					1
						__UpperCAmelCase	: Dict		=					SegformerForSemanticSegmentation(config=UpperCamelCase_)
						model.to(UpperCamelCase_)
						model.eval()
						__UpperCAmelCase	: List[str]		=					torch.randint(0      ,  1      ,  (self.batch_size, self.image_size, self.image_size)).to(UpperCamelCase_)
						__UpperCAmelCase	: Dict		=					model(UpperCamelCase_      ,  labels=UpperCamelCase_)
						self.parent.assertGreater(result.loss      ,  0.0)


			def       a_     (      self      :    List[Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Union[str, Any]		=					self.prepare_config_and_inputs()
						__UpperCAmelCase	,     __UpperCAmelCase	,     __UpperCAmelCase	: Any		=					config_and_inputs
						__UpperCAmelCase	: Optional[Any]		=					{"pixel_values": pixel_values}
						return config, inputs_dict






@require_torch
class      a__				(	__magic_name__							,    __magic_name__							,    unittest.TestCase   ):
			lowercase_    =	(
			    (
			        SegformerModel,
			        SegformerForSemanticSegmentation,
			        SegformerForImageClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			lowercase_    =	(
			    {
			        "feature-extraction": SegformerModel,
			        "image-classification": SegformerForImageClassification,
			        "image-segmentation": SegformerForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			lowercase_    =	True
			lowercase_    =	False
			lowercase_    =	False
			lowercase_    =	False


			def       a_     (      self      :    Any):


						"""simple docstring"""




						__UpperCAmelCase	: Dict		=					SegformerModelTester(self)
						__UpperCAmelCase	: Any		=					SegformerConfigTester(self      ,  config_class=UpperCamelCase_)


			def       a_     (      self      :    Dict):


						"""simple docstring"""




						self.config_tester.run_common_tests()


			def       a_     (      self      :    List[str]):


						"""simple docstring"""




						__UpperCAmelCase	: Dict		=					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCamelCase_)


			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: List[str]		=					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_binary_image_segmentation(*UpperCamelCase_)


			def       a_     (      self      :    Optional[Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Union[str, Any]		=					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_segmentation(*UpperCamelCase_)


			@unittest.skip("SegFormer does not use inputs_embeds")
			def       a_     (      self      :    Dict):


						"""simple docstring"""




						pass


			@unittest.skip("SegFormer does not have get_input_embeddings method and get_output_embeddings methods")
			def       a_     (      self      :    Any):


						"""simple docstring"""




						pass


			def       a_     (      self      :    Dict):


						"""simple docstring"""




						__UpperCAmelCase	,     __UpperCAmelCase	: Union[str, Any]		=					self.model_tester.prepare_config_and_inputs_for_common()

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

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


			def       a_     (      self      :    Dict):


						"""simple docstring"""




						__UpperCAmelCase	,     __UpperCAmelCase	: int		=					self.model_tester.prepare_config_and_inputs_for_common()
						__UpperCAmelCase	: Any		=					True

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

									__UpperCAmelCase	: Optional[Any]		=					sum(self.model_tester.depths)
									self.assertEqual(len(UpperCamelCase_)      ,  UpperCamelCase_)

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

									self.assertEqual(len(UpperCamelCase_)      ,  UpperCamelCase_)

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

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

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

									__UpperCAmelCase	: str		=					outputs.attentions

									self.assertEqual(len(UpperCamelCase_)      ,  UpperCamelCase_)
									# verify the first attentions (first block, first layer)
									__UpperCAmelCase	: Union[str, Any]		=					(self.model_tester.image_size // 4) ** 2
									__UpperCAmelCase	: 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       a_     (      self      :    Union[str, Any]):


						"""simple docstring"""




						def check_hidden_states_output(UpperCamelCase_      :    List[str]      ,  UpperCamelCase_      :    str      ,  UpperCamelCase_      :    Union[str, Any]):
									__UpperCAmelCase	: Tuple		=					model_class(UpperCamelCase_)
									model.to(UpperCamelCase_)
									model.eval()

									with torch.no_grad():
												__UpperCAmelCase	: Tuple		=					model(**self._prepare_for_class(UpperCamelCase_      ,  UpperCamelCase_))

									__UpperCAmelCase	: int		=					outputs.hidden_states

									__UpperCAmelCase	: Any		=					self.model_tester.num_encoder_blocks
									self.assertEqual(len(UpperCamelCase_)      ,  UpperCamelCase_)

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

						__UpperCAmelCase	,     __UpperCAmelCase	: Optional[int]		=					self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									__UpperCAmelCase	: Any		=					True
									check_hidden_states_output(UpperCamelCase_      ,  UpperCamelCase_      ,  UpperCamelCase_)

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

									check_hidden_states_output(UpperCamelCase_      ,  UpperCamelCase_      ,  UpperCamelCase_)


			def       a_     (      self      :    Any):


						"""simple docstring"""




						if not self.model_tester.is_training:
									return

						__UpperCAmelCase	,     __UpperCAmelCase	: Dict		=					self.model_tester.prepare_config_and_inputs_for_common()
						__UpperCAmelCase	: Optional[Any]		=					True

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

									__UpperCAmelCase	: List[Any]		=					model_class(UpperCamelCase_)
									model.to(UpperCamelCase_)
									model.train()
									__UpperCAmelCase	: Optional[int]		=					self._prepare_for_class(UpperCamelCase_      ,  UpperCamelCase_      ,  return_labels=UpperCamelCase_)
									__UpperCAmelCase	: Tuple		=					model(**UpperCamelCase_).loss
									loss.backward()


			@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests.")
			def       a_     (      self      :    List[str]):


						"""simple docstring"""




						pass


			@slow
			def       a_     (      self      :    int):


						"""simple docstring"""




						for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__UpperCAmelCase	: Optional[Any]		=					SegformerModel.from_pretrained(UpperCamelCase_)
									self.assertIsNotNone(UpperCamelCase_)






def 					_UpperCamelCase    (			)			->			Dict:


			"""simple docstring"""
			__UpperCAmelCase	: List[str]		=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
			return image





@require_torch
class      a__				(	unittest.TestCase   ):


			@slow
			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					SegformerImageProcessor(
						    image_scale=(512, 512)      ,  keep_ratio=UpperCamelCase_      ,  align=UpperCamelCase_      ,  do_random_crop=UpperCamelCase_)
						__UpperCAmelCase	: List[str]		=					SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512").to(
						    UpperCamelCase_)

						__UpperCAmelCase	: Dict		=					prepare_img()
						__UpperCAmelCase	: List[Any]		=					image_processor(images=UpperCamelCase_      ,  return_tensors="pt")
						__UpperCAmelCase	: Optional[int]		=					encoded_inputs.pixel_values.to(UpperCamelCase_)

						with torch.no_grad():
									__UpperCAmelCase	: Tuple		=					model(UpperCamelCase_)

						__UpperCAmelCase	: Optional[int]		=					torch.Size((1, model.config.num_labels, 128, 128))
						self.assertEqual(outputs.logits.shape      ,  UpperCamelCase_)

						__UpperCAmelCase	: List[str]		=					torch.tensor(
						    [
						        [[-4.6310, -5.5232, -6.2356], [-5.1921, -6.1444, -6.5996], [-5.4424, -6.2790, -6.7574]],
						        [[-12.1391, -13.3122, -13.9554], [-12.8732, -13.9352, -14.3563], [-12.9438, -13.8226, -14.2513]],
						        [[-12.5134, -13.4686, -14.4915], [-12.8669, -14.4343, -14.7758], [-13.2523, -14.5819, -15.0694]],
						    ]).to(UpperCamelCase_)
						self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]      ,  UpperCamelCase_      ,  atol=1e-4))


			@slow
			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Any		=					SegformerImageProcessor(
						    image_scale=(512, 512)      ,  keep_ratio=UpperCamelCase_      ,  align=UpperCamelCase_      ,  do_random_crop=UpperCamelCase_)
						__UpperCAmelCase	: Dict		=					SegformerForSemanticSegmentation.from_pretrained(
						    "nvidia/segformer-b1-finetuned-cityscapes-1024-1024").to(UpperCamelCase_)

						__UpperCAmelCase	: Union[str, Any]		=					prepare_img()
						__UpperCAmelCase	: Optional[Any]		=					image_processor(images=UpperCamelCase_      ,  return_tensors="pt")
						__UpperCAmelCase	: int		=					encoded_inputs.pixel_values.to(UpperCamelCase_)

						with torch.no_grad():
									__UpperCAmelCase	: Tuple		=					model(UpperCamelCase_)

						__UpperCAmelCase	: str		=					torch.Size((1, model.config.num_labels, 128, 128))
						self.assertEqual(outputs.logits.shape      ,  UpperCamelCase_)

						__UpperCAmelCase	: Optional[int]		=					torch.tensor(
						    [
						        [[-13.5748, -13.9111, -12.6500], [-14.3500, -15.3683, -14.2328], [-14.7532, -16.0424, -15.6087]],
						        [[-17.1651, -15.8725, -12.9653], [-17.2580, -17.3718, -14.8223], [-16.6058, -16.8783, -16.7452]],
						        [[-3.6456, -3.0209, -1.4203], [-3.0797, -3.1959, -2.0000], [-1.8757, -1.9217, -1.6997]],
						    ]).to(UpperCamelCase_)
						self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]      ,  UpperCamelCase_      ,  atol=1e-1))


			@slow
			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					SegformerImageProcessor(
						    image_scale=(512, 512)      ,  keep_ratio=UpperCamelCase_      ,  align=UpperCamelCase_      ,  do_random_crop=UpperCamelCase_)
						__UpperCAmelCase	: Union[str, Any]		=					SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512").to(
						    UpperCamelCase_)

						__UpperCAmelCase	: Dict		=					prepare_img()
						__UpperCAmelCase	: Any		=					image_processor(images=UpperCamelCase_      ,  return_tensors="pt")
						__UpperCAmelCase	: List[str]		=					encoded_inputs.pixel_values.to(UpperCamelCase_)

						with torch.no_grad():
									__UpperCAmelCase	: Tuple		=					model(UpperCamelCase_)

						__UpperCAmelCase	: Any		=					outputs.logits.detach().cpu()

						__UpperCAmelCase	: Optional[int]		=					image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase_      ,  target_sizes=[(500, 300)])
						__UpperCAmelCase	: Tuple		=					torch.Size((500, 300))
						self.assertEqual(segmentation[0].shape      ,  UpperCamelCase_)

						__UpperCAmelCase	: List[Any]		=					image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase_)
						__UpperCAmelCase	: str		=					torch.Size((128, 128))
						self.assertEqual(segmentation[0].shape      ,  UpperCamelCase_)


