"""simple docstring"""







import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import List

import timm
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
from torch import Tensor

from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
from transformers.utils import logging


logging.set_verbosity_info()
_a					:					Optional[int]=			logging.get_logger()

@dataclass
class 		UpperCamelCase      :
				UpperCAmelCase    :				nn.Module
				UpperCAmelCase    :				List[nn.Module]   =		field(default_factory=lowercase						)
				UpperCAmelCase    :				list   =		field(default_factory=lowercase						)



				def  _lowercase					(self    :				str     ,  _A    :				Optional[Any]     ,  _A    :				Tensor     ,  _A    :				Tensor)   ->     Any:
					__snake_case      :							str						=			len(list(m.modules())) == 1 or isinstance(_A     ,  nn.Convad) or isinstance(_A     ,  nn.BatchNormad)
					if has_not_submodules:
						self.traced.append(_A)



				def __call__(self    :				Dict     ,  _A    :				Tensor)   ->     Optional[Any]:
					for m in self.module.modules():
						self.handles.append(m.register_forward_hook(self._forward_hook))
					self.module(_A)
					[x.remove() for x in self.handles]
					return self






				@property
				def  _lowercase					(self    :				Union[str, Any])   ->     List[str]:
					# check the len of the state_dict keys to see if we have learnable params
					return list(filter(lambda _A: len(list(x.state_dict().keys())) > 0     ,  self.traced))







@dataclass
class 		UpperCamelCase      :
				UpperCAmelCase    :				nn.Module
				UpperCAmelCase    :				nn.Module
				UpperCAmelCase    :				int   =		0
				UpperCAmelCase    :				List   =		field(default_factory=lowercase						)
				UpperCAmelCase    :				List   =		field(default_factory=lowercase						)



				def __call__(self    :				List[str]     ,  _A    :				Tensor)   ->     List[Any]:
					__snake_case      :							Any						=			Tracker(self.dest)(_A).parametrized
					__snake_case      :							int						=			Tracker(self.src)(_A).parametrized

					__snake_case      :							List[Any]						=			list(filter(lambda _A: type(_A) not in self.src_skip     ,  _A))
					__snake_case      :							Any						=			list(filter(lambda _A: type(_A) not in self.dest_skip     ,  _A))

					if len(_A) != len(_A):
						raise Exception(
						    f"Numbers of operations are different. Source module has {len(_A)} operations while"
						    f" destination module has {len(_A)}.")

					for dest_m, src_m in zip(_A     ,  _A):
						dest_m.load_state_dict(src_m.state_dict())
						if self.verbose == 1:
							print(f"Transfered from={src_m} to={dest_m}")







def   __UpperCAmelCase    (   UpperCAmelCase_   :    str      ,							UpperCAmelCase_   :    ResNetConfig      ,							UpperCAmelCase_   :    Path      ,							UpperCAmelCase_   :    bool = True  )							->      List[str]:

	'''simple docstring'''





	print(F"Converting {name}..."  )
	with torch.no_grad():
		__snake_case      :							Dict						=			timm.create_model(UpperCAmelCase_      ,							pretrained=UpperCAmelCase_  ).eval()
		__snake_case      :							List[Any]						=			ResNetForImageClassification(UpperCAmelCase_  ).eval()
		__snake_case      :							int						=			ModuleTransfer(src=UpperCAmelCase_      ,							dest=UpperCAmelCase_  )
		__snake_case      :							Optional[Any]						=			torch.randn((1, 3, 2_24, 2_24)  )
		module_transfer(UpperCAmelCase_  )

	assert torch.allclose(from_model(UpperCAmelCase_  )      ,							our_model(UpperCAmelCase_  ).logits  ), "The model logits don't match the original one."

	__snake_case      :							str						=			F"resnet{'-'.join(name.split('resnet'  )  )}"
	print(UpperCAmelCase_  )

	if push_to_hub:
		our_model.push_to_hub(
		    repo_path_or_name=save_directory / checkpoint_name      ,							commit_message='Add model'      ,							use_temp_dir=UpperCAmelCase_      ,							)

		# we can use the convnext one
		__snake_case      :							int						=			AutoImageProcessor.from_pretrained('facebook/convnext-base-224-22k-1k'  )
		image_processor.push_to_hub(
		    repo_path_or_name=save_directory / checkpoint_name      ,							commit_message='Add image processor'      ,							use_temp_dir=UpperCAmelCase_      ,							)

		print(F"Pushed {checkpoint_name}"  )
def   __UpperCAmelCase    (   UpperCAmelCase_   :    Path      ,							UpperCAmelCase_   :    str = None      ,							UpperCAmelCase_   :    bool = True  )							->      Union[str, Any]:

	'''simple docstring'''





	__snake_case      :							str						=			'imagenet-1k-id2label.json'
	__snake_case      :							Optional[Any]						=			10_00
	__snake_case      :							Any						=			(1, num_labels)

	__snake_case      :							List[Any]						=			'huggingface/label-files'
	__snake_case      :							Dict						=			num_labels
	__snake_case      :							Any						=			json.load(open(hf_hub_download(UpperCAmelCase_      ,							UpperCAmelCase_      ,							repo_type='dataset'  )      ,							'r'  )  )
	__snake_case      :							Any						=			{int(UpperCAmelCase_  ): v for k, v in idalabel.items()}

	__snake_case      :							Optional[Any]						=			idalabel
	__snake_case      :							Optional[Any]						=			{v: k for k, v in idalabel.items()}

	__snake_case      :							Optional[int]						=			partial(UpperCAmelCase_      ,							num_labels=UpperCAmelCase_      ,							idalabel=UpperCAmelCase_      ,							labelaid=UpperCAmelCase_  )

	__snake_case      :							str						=			{
	    'resnet18': ImageNetPreTrainedConfig(
	        depths=[2, 2, 2, 2]      ,							hidden_sizes=[64, 1_28, 2_56, 5_12]      ,							layer_type='basic'  ),
	    'resnet26': ImageNetPreTrainedConfig(
	        depths=[2, 2, 2, 2]      ,							hidden_sizes=[2_56, 5_12, 10_24, 20_48]      ,							layer_type='bottleneck'  ),
	    'resnet34': ImageNetPreTrainedConfig(
	        depths=[3, 4, 6, 3]      ,							hidden_sizes=[64, 1_28, 2_56, 5_12]      ,							layer_type='basic'  ),
	    'resnet50': ImageNetPreTrainedConfig(
	        depths=[3, 4, 6, 3]      ,							hidden_sizes=[2_56, 5_12, 10_24, 20_48]      ,							layer_type='bottleneck'  ),
	    'resnet101': ImageNetPreTrainedConfig(
	        depths=[3, 4, 23, 3]      ,							hidden_sizes=[2_56, 5_12, 10_24, 20_48]      ,							layer_type='bottleneck'  ),
	    'resnet152': ImageNetPreTrainedConfig(
	        depths=[3, 8, 36, 3]      ,							hidden_sizes=[2_56, 5_12, 10_24, 20_48]      ,							layer_type='bottleneck'  ),
	}

	if model_name:
		convert_weight_and_push(UpperCAmelCase_      ,							names_to_config[model_name]      ,							UpperCAmelCase_      ,							UpperCAmelCase_  )
	else:
		for model_name, config in names_to_config.items():
			convert_weight_and_push(UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_  )
	return config, expected_shape


if __name__ == "__main__":
	_a					:					Optional[Any]=			argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    "--model_name",
	    default=None,
	    type=str,
	    help=(
	        "The name of the model you wish to convert, it must be one of the supported resnet* architecture,"
	        " currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted."
	    ),
	)
	parser.add_argument(
	    "--pytorch_dump_folder_path",
	    default=None,
	    type=Path,
	    required=True,
	    help="Path to the output PyTorch model directory.",
	)
	parser.add_argument(
	    "--push_to_hub",
	    default=True,
	    type=bool,
	    required=False,
	    help="If True, push model and image processor to the hub.",
	)

	_a					:					Union[str, Any]=			parser.parse_args()
	_a					:					Path=			args.pytorch_dump_folder_path
	pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
	convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)






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





