




"""simple docstring"""





import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    BertTokenizer,
    ViltConfig,
    ViltForImageAndTextRetrieval,
    ViltForImagesAndTextClassification,
    ViltForMaskedLM,
    ViltForQuestionAnswering,
    ViltImageProcessor,
    ViltProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
A   =       logging.get_logger(__name__)

def 					_UpperCamelCase    (			UpperCamelCase				,       UpperCamelCase=False				,       UpperCamelCase=False				,       UpperCamelCase=False							)			->			int:


			"""simple docstring"""
			__UpperCAmelCase	: Tuple		=					[]
			for i in range(config.num_hidden_layers							):
						# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
						rename_keys.append((f"transformer.blocks.{i}.norm1.weight", f"vilt.encoder.layer.{i}.layernorm_before.weight")							)
						rename_keys.append((f"transformer.blocks.{i}.norm1.bias", f"vilt.encoder.layer.{i}.layernorm_before.bias")							)
						rename_keys.append(
						    (f"transformer.blocks.{i}.attn.proj.weight", f"vilt.encoder.layer.{i}.attention.output.dense.weight")							)
						rename_keys.append(
						    (f"transformer.blocks.{i}.attn.proj.bias", f"vilt.encoder.layer.{i}.attention.output.dense.bias")							)
						rename_keys.append((f"transformer.blocks.{i}.norm2.weight", f"vilt.encoder.layer.{i}.layernorm_after.weight")							)
						rename_keys.append((f"transformer.blocks.{i}.norm2.bias", f"vilt.encoder.layer.{i}.layernorm_after.bias")							)
						rename_keys.append(
						    (f"transformer.blocks.{i}.mlp.fc1.weight", f"vilt.encoder.layer.{i}.intermediate.dense.weight")							)
						rename_keys.append((f"transformer.blocks.{i}.mlp.fc1.bias", f"vilt.encoder.layer.{i}.intermediate.dense.bias")							)
						rename_keys.append((f"transformer.blocks.{i}.mlp.fc2.weight", f"vilt.encoder.layer.{i}.output.dense.weight")							)
						rename_keys.append((f"transformer.blocks.{i}.mlp.fc2.bias", f"vilt.encoder.layer.{i}.output.dense.bias")							)

			# embeddings
			rename_keys.extend(
			    [
			        # text embeddings
			        ("text_embeddings.word_embeddings.weight", "vilt.embeddings.text_embeddings.word_embeddings.weight"),
			        (
			            "text_embeddings.position_embeddings.weight",
			            "vilt.embeddings.text_embeddings.position_embeddings.weight",
			        ),
			        ("text_embeddings.position_ids", "vilt.embeddings.text_embeddings.position_ids"),
			        (
			            "text_embeddings.token_type_embeddings.weight",
			            "vilt.embeddings.text_embeddings.token_type_embeddings.weight",
			        ),
			        ("text_embeddings.LayerNorm.weight", "vilt.embeddings.text_embeddings.LayerNorm.weight"),
			        ("text_embeddings.LayerNorm.bias", "vilt.embeddings.text_embeddings.LayerNorm.bias"),
			        # patch embeddings
			        ("transformer.cls_token", "vilt.embeddings.cls_token"),
			        ("transformer.patch_embed.proj.weight", "vilt.embeddings.patch_embeddings.projection.weight"),
			        ("transformer.patch_embed.proj.bias", "vilt.embeddings.patch_embeddings.projection.bias"),
			        ("transformer.pos_embed", "vilt.embeddings.position_embeddings"),
			        # token type embeddings
			        ("token_type_embeddings.weight", "vilt.embeddings.token_type_embeddings.weight"),
			    ]							)

			# final layernorm + pooler
			rename_keys.extend(
			    [
			        ("transformer.norm.weight", "vilt.layernorm.weight"),
			        ("transformer.norm.bias", "vilt.layernorm.bias"),
			        ("pooler.dense.weight", "vilt.pooler.dense.weight"),
			        ("pooler.dense.bias", "vilt.pooler.dense.bias"),
			    ]							)

			# classifier head(s)
			if vqa_model:
						# classification head
						rename_keys.extend(
						    [
						        ("vqa_classifier.0.weight", "classifier.0.weight"),
						        ("vqa_classifier.0.bias", "classifier.0.bias"),
						        ("vqa_classifier.1.weight", "classifier.1.weight"),
						        ("vqa_classifier.1.bias", "classifier.1.bias"),
						        ("vqa_classifier.3.weight", "classifier.3.weight"),
						        ("vqa_classifier.3.bias", "classifier.3.bias"),
						    ]							)
			elif nlvr_model:
						# classification head
						rename_keys.extend(
						    [
						        ("nlvr2_classifier.0.weight", "classifier.0.weight"),
						        ("nlvr2_classifier.0.bias", "classifier.0.bias"),
						        ("nlvr2_classifier.1.weight", "classifier.1.weight"),
						        ("nlvr2_classifier.1.bias", "classifier.1.bias"),
						        ("nlvr2_classifier.3.weight", "classifier.3.weight"),
						        ("nlvr2_classifier.3.bias", "classifier.3.bias"),
						    ]							)
			else:
						pass

			return rename_keys

def 					_UpperCamelCase    (			UpperCamelCase				,       UpperCamelCase							)			->			List[str]:


			"""simple docstring"""
			for i in range(config.num_hidden_layers							):
						__UpperCAmelCase	: Any		=					"vilt."
						# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
						__UpperCAmelCase	: int		=					state_dict.pop(f"transformer.blocks.{i}.attn.qkv.weight"							)
						__UpperCAmelCase	: Any		=					state_dict.pop(f"transformer.blocks.{i}.attn.qkv.bias"							)
						# next, add query, keys and values (in that order) to the state dict
						__UpperCAmelCase	: str		=					in_proj_weight[
						    : config.hidden_size, :
						]
						__UpperCAmelCase	: str		=					in_proj_bias[: config.hidden_size]
						__UpperCAmelCase	: List[Any]		=					in_proj_weight[
						    config.hidden_size : config.hidden_size * 2, :
						]
						__UpperCAmelCase	: str		=					in_proj_bias[
						    config.hidden_size : config.hidden_size * 2
						]
						__UpperCAmelCase	: str		=					in_proj_weight[
						    -config.hidden_size :, :
						]
						__UpperCAmelCase	: Any		=					in_proj_bias[-config.hidden_size :]

def 					_UpperCamelCase    (			UpperCamelCase							)			->			Optional[int]:


			"""simple docstring"""
			__UpperCAmelCase	: Any		=					["head.weight", "head.bias"]
			for k in ignore_keys:
						state_dict.pop(UpperCamelCase				,       UpperCamelCase							)

def 					_UpperCamelCase    (			UpperCamelCase				,       UpperCamelCase				,       UpperCamelCase							)			->			Tuple:


			"""simple docstring"""
			__UpperCAmelCase	: List[Any]		=					dct.pop(UpperCamelCase							)
			__UpperCAmelCase	: Optional[int]		=					val

@torch.no_grad()
def 					_UpperCamelCase    (			UpperCamelCase				,       UpperCamelCase							)			->			List[Any]:


			"""simple docstring"""
			__UpperCAmelCase	: int		=					ViltConfig(image_size=384				,       patch_size=32				,       tie_word_embeddings=UpperCamelCase							)
			__UpperCAmelCase	: Tuple		=					False
			__UpperCAmelCase	: int		=					False
			__UpperCAmelCase	: Union[str, Any]		=					False
			__UpperCAmelCase	: List[str]		=					False
			if "vqa" in checkpoint_url:
						__UpperCAmelCase	: Optional[int]		=					True
						__UpperCAmelCase	: List[Any]		=					3129
						__UpperCAmelCase	: Tuple		=					"huggingface/label-files"
						__UpperCAmelCase	: Optional[Any]		=					"vqa2-id2label.json"
						__UpperCAmelCase	: str		=					json.load(open(hf_hub_download(UpperCamelCase				,       UpperCamelCase				,       repo_type="dataset"							)				,       "r"							)							)
						__UpperCAmelCase	: Tuple		=					{int(UpperCamelCase							): v for k, v in idalabel.items()}
						__UpperCAmelCase	: Union[str, Any]		=					idalabel
						__UpperCAmelCase	: Any		=					{v: k for k, v in idalabel.items()}
						__UpperCAmelCase	: Dict		=					ViltForQuestionAnswering(UpperCamelCase							)
			elif "nlvr" in checkpoint_url:
						__UpperCAmelCase	: Optional[int]		=					True
						__UpperCAmelCase	: List[str]		=					2
						__UpperCAmelCase	: Optional[Any]		=					{0: "False", 1: "True"}
						__UpperCAmelCase	: int		=					{v: k for k, v in config.idalabel.items()}
						__UpperCAmelCase	: Tuple		=					3
						__UpperCAmelCase	: Optional[Any]		=					ViltForImagesAndTextClassification(UpperCamelCase							)
			elif "irtr" in checkpoint_url:
						__UpperCAmelCase	: List[Any]		=					True
						__UpperCAmelCase	: List[Any]		=					ViltForImageAndTextRetrieval(UpperCamelCase							)
			elif "mlm_itm" in checkpoint_url:
						__UpperCAmelCase	: List[Any]		=					True
						__UpperCAmelCase	: Optional[Any]		=					ViltForMaskedLM(UpperCamelCase							)
			else:
						raise ValueError("Unknown model type"							)

			# load state_dict of original model, remove and rename some keys
			__UpperCAmelCase	: Optional[int]		=					torch.hub.load_state_dict_from_url(UpperCamelCase				,       map_location="cpu"							)["state_dict"]
			__UpperCAmelCase	: List[Any]		=					create_rename_keys(UpperCamelCase				,       UpperCamelCase				,       UpperCamelCase				,       UpperCamelCase							)
			for src, dest in rename_keys:
						rename_key(UpperCamelCase				,       UpperCamelCase				,       UpperCamelCase							)
			read_in_q_k_v(UpperCamelCase				,       UpperCamelCase							)
			if mlm_model or irtr_model:
						__UpperCAmelCase	: List[str]		=					["itm_score.fc.weight", "itm_score.fc.bias"]
						for k in ignore_keys:
									state_dict.pop(UpperCamelCase				,       UpperCamelCase							)

    # load state dict into HuggingFace model
			model.eval()
			if mlm_model:
						__UpperCAmelCase	,     __UpperCAmelCase	: Optional[Any]		=					model.load_state_dict(UpperCamelCase				,       strict=UpperCamelCase							)
						assert missing_keys == ["mlm_score.decoder.bias"]
			else:
						model.load_state_dict(UpperCamelCase							)

			# Define processor
			__UpperCAmelCase	: Optional[Any]		=					ViltImageProcessor(size=384							)
			__UpperCAmelCase	: Optional[Any]		=					BertTokenizer.from_pretrained("bert-base-uncased"							)
			__UpperCAmelCase	: Any		=					ViltProcessor(UpperCamelCase				,       UpperCamelCase							)

			# Forward pass on example inputs (image + text)
			if nlvr_model:
						__UpperCAmelCase	: Dict		=					Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg"				,       stream=UpperCamelCase							).raw							)
						__UpperCAmelCase	: List[Any]		=					Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg"				,       stream=UpperCamelCase							).raw							)
						__UpperCAmelCase	: List[str]		=					(
						    "The left image contains twice the number of dogs as the right image, and at least two dogs in total are"
						    " standing."
						)
						__UpperCAmelCase	: int		=					processor(UpperCamelCase				,       UpperCamelCase				,       return_tensors="pt"							)
						__UpperCAmelCase	: Tuple		=					processor(UpperCamelCase				,       UpperCamelCase				,       return_tensors="pt"							)
						__UpperCAmelCase	: Optional[Any]		=					model(
						    input_ids=encoding_a.input_ids				,       pixel_values=encoding_a.pixel_values				,       pixel_values_a=encoding_a.pixel_values				,       )
			else:
						__UpperCAmelCase	: Tuple		=					Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg"				,       stream=UpperCamelCase							).raw							)
						if mlm_model:
									__UpperCAmelCase	: Union[str, Any]		=					"a bunch of [MASK] laying on a [MASK]."
						else:
									__UpperCAmelCase	: List[Any]		=					"How many cats are there?"
						__UpperCAmelCase	: List[Any]		=					processor(UpperCamelCase				,       UpperCamelCase				,       return_tensors="pt"							)
						__UpperCAmelCase	: int		=					model(**UpperCamelCase							)

			# Verify outputs
			if mlm_model:
						__UpperCAmelCase	: List[Any]		=					torch.Size([1, 11, 3_0522]							)
						__UpperCAmelCase	: List[str]		=					torch.tensor([-12.5061, -12.5123, -12.5174]							)
						assert outputs.logits.shape == expected_shape
						assert torch.allclose(outputs.logits[0, 0, :3]				,       UpperCamelCase				,       atol=1e-4							)

						# verify masked token prediction equals "cats"
						__UpperCAmelCase	: Optional[int]		=					outputs.logits[0, 4, :].argmax(-1							).item()
						assert tokenizer.decode([predicted_id]							) == "cats"
			elif vqa_model:
						__UpperCAmelCase	: List[str]		=					torch.Size([1, 3129]							)
						__UpperCAmelCase	: Union[str, Any]		=					torch.tensor([-15.9495, -18.1472, -10.3041]							)
						assert torch.allclose(outputs.logits[0, :3]				,       UpperCamelCase				,       atol=1e-4							)
						assert outputs.logits.shape == expected_shape
						assert torch.allclose(outputs.logits[0, 0, :3]				,       UpperCamelCase				,       atol=1e-4							)

						# verify vqa prediction equals "2"
						__UpperCAmelCase	: List[str]		=					outputs.logits.argmax(-1							).item()
						assert model.config.idalabel[predicted_idx] == "2"
			elif nlvr_model:
						__UpperCAmelCase	: Optional[int]		=					torch.Size([1, 2]							)
						__UpperCAmelCase	: Optional[int]		=					torch.tensor([-2.8721, 2.1291]							)
						assert torch.allclose(outputs.logits[0, :3]				,       UpperCamelCase				,       atol=1e-4							)
						assert outputs.logits.shape == expected_shape

			Path(UpperCamelCase							).mkdir(exist_ok=UpperCamelCase							)
			print(f"Saving model and processor to {pytorch_dump_folder_path}"							)
			model.save_pretrained(UpperCamelCase							)
			processor.save_pretrained(UpperCamelCase							)


if __name__ == "__main__":
					A   =       argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    """--checkpoint_url""",
					    default="""https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt""",
					    type=str,
					    help="""URL of the checkpoint you'd like to convert.""",
					)
					parser.add_argument(
					    """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
					)

					A   =       parser.parse_args()
					convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)








"""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_)


