




"""simple docstring"""




import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import (
    BitConfig,
    ViTHybridConfig,
    ViTHybridForImageClassification,
    ViTHybridImageProcessor,
    ViTHybridModel,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
A_							:			Any											= logging.get_logger(__name__)

def 	A       (     snake_case__		,				snake_case__=False    ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      []

			# fmt: off
			# stem:
			rename_keys.append(("""cls_token""", """vit.embeddings.cls_token""")    )
			rename_keys.append(("""pos_embed""", """vit.embeddings.position_embeddings""")    )

			rename_keys.append(("""patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight""")    )
			rename_keys.append(("""patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias""")    )

			# backbone
			rename_keys.append(("""patch_embed.backbone.stem.conv.weight""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight""")    )
			rename_keys.append(("""patch_embed.backbone.stem.norm.weight""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight""")    )
			rename_keys.append(("""patch_embed.backbone.stem.norm.bias""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias""")    )

			for stage_idx in range(len(config.backbone_config.depths    )    ):
						for layer_idx in range(config.backbone_config.depths[stage_idx]    ):
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight""")    )
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight""")    )
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias""")    )
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight""")    )
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight""")    )
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias""")    )
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight""")    )
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight""")    )
									rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias""")    )

						rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight""")    )
						rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight""")    )
						rename_keys.append((f"""patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias""", f"""vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias""")    )

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

			if base_model:
						# layernorm + pooler
						rename_keys.extend(
						    [
						        ("""norm.weight""", """layernorm.weight"""),
						        ("""norm.bias""", """layernorm.bias"""),
						        ("""pre_logits.fc.weight""", """pooler.dense.weight"""),
						        ("""pre_logits.fc.bias""", """pooler.dense.bias"""),
						    ]    )

						# if just the base model, we should remove "vit" from all keys that start with "vit"
						SCREAMING_SNAKE_CASE__								=      [(pair[0], pair[1][4:]) if pair[1].startswith("""vit"""    ) else pair for pair in rename_keys]
			else:
						# layernorm + classification head
						rename_keys.extend(
						    [
						        ("""norm.weight""", """vit.layernorm.weight"""),
						        ("""norm.bias""", """vit.layernorm.bias"""),
						        ("""head.weight""", """classifier.weight"""),
						        ("""head.bias""", """classifier.bias"""),
						    ]    )
			# fmt: on

			return rename_keys

def 	A       (     snake_case__		,				snake_case__		,				snake_case__=False    ):




			'''simple docstring'''


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

def 	A       (     snake_case__    ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      ["""head.weight""", """head.bias"""]
			for k in ignore_keys:
						state_dict.pop(snake_case__		,				snake_case__    )

def 	A       (     snake_case__		,				snake_case__		,				snake_case__    ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      dct.pop(snake_case__    )
			SCREAMING_SNAKE_CASE__								=      val

def 	A       (     ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      """http://images.cocodataset.org/val2017/000000039769.jpg"""
			SCREAMING_SNAKE_CASE__								=      Image.open(requests.get(snake_case__		,				stream=snake_case__    ).raw    )
			return im

@torch.no_grad()
def 	A       (     snake_case__		,				snake_case__		,				snake_case__=False    ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      BitConfig(
			    global_padding="""same"""		,				layer_type="""bottleneck"""		,				depths=(3, 4, 9)		,				out_features=["""stage3"""]		,				embedding_dynamic_padding=snake_case__		,				)
			SCREAMING_SNAKE_CASE__								=      ViTHybridConfig(backbone_config=snake_case__		,				image_size=3_84		,				num_labels=10_00    )
			SCREAMING_SNAKE_CASE__								=      False

			# load original model from timm
			SCREAMING_SNAKE_CASE__								=      timm.create_model(snake_case__		,				pretrained=snake_case__    )
			timm_model.eval()

			# load state_dict of original model, remove and rename some keys
			SCREAMING_SNAKE_CASE__								=      timm_model.state_dict()
			if base_model:
						remove_classification_head_(snake_case__    )
			SCREAMING_SNAKE_CASE__								=      create_rename_keys(snake_case__		,				snake_case__    )
			for src, dest in rename_keys:
						rename_key(snake_case__		,				snake_case__		,				snake_case__    )
			read_in_q_k_v(snake_case__		,				snake_case__		,				snake_case__    )

			SCREAMING_SNAKE_CASE__								=      """huggingface/label-files"""
			SCREAMING_SNAKE_CASE__								=      """imagenet-1k-id2label.json"""
			SCREAMING_SNAKE_CASE__								=      json.load(open(hf_hub_download(snake_case__		,				snake_case__		,				repo_type="""dataset"""    )		,				"""r"""    )    )
			SCREAMING_SNAKE_CASE__								=      {int(snake_case__    ): v for k, v in idalabel.items()}
			SCREAMING_SNAKE_CASE__								=      idalabel
			SCREAMING_SNAKE_CASE__								=      {v: k for k, v in idalabel.items()}

			# load HuggingFace model
			if vit_name[-5:] == "in21k":
						SCREAMING_SNAKE_CASE__								=      ViTHybridModel(snake_case__    ).eval()
			else:
						SCREAMING_SNAKE_CASE__								=      ViTHybridForImageClassification(snake_case__    ).eval()
			model.load_state_dict(snake_case__    )

			# create image processor
			SCREAMING_SNAKE_CASE__								=      create_transform(**resolve_data_config({}		,				model=snake_case__    )    )
			SCREAMING_SNAKE_CASE__								=      transform.transforms

			SCREAMING_SNAKE_CASE__								=      {
			    """bilinear""": PILImageResampling.BILINEAR,
			    """bicubic""": PILImageResampling.BICUBIC,
			    """nearest""": PILImageResampling.NEAREST,
			}

			SCREAMING_SNAKE_CASE__								=      ViTHybridImageProcessor(
			    do_resize=snake_case__		,				size={"""shortest_edge""": timm_transforms[0].size}		,				resample=pillow_resamplings[timm_transforms[0].interpolation.value]		,				do_center_crop=snake_case__		,				crop_size={"""height""": timm_transforms[1].size[0], """width""": timm_transforms[1].size[1]}		,				do_normalize=snake_case__		,				image_mean=timm_transforms[-1].mean.tolist()		,				image_std=timm_transforms[-1].std.tolist()		,				)

			SCREAMING_SNAKE_CASE__								=      prepare_img()
			SCREAMING_SNAKE_CASE__								=      transform(snake_case__    ).unsqueeze(0    )
			SCREAMING_SNAKE_CASE__								=      processor(snake_case__		,				return_tensors="""pt"""    ).pixel_values

			# verify pixel values
			assert torch.allclose(snake_case__		,				snake_case__    )

			# verify logits
			with torch.no_grad():
						SCREAMING_SNAKE_CASE__								=      model(snake_case__    )
						SCREAMING_SNAKE_CASE__								=      outputs.logits

			print("""Predicted class:"""		,				logits.argmax(-1    ).item()    )
			if base_model:
						SCREAMING_SNAKE_CASE__								=      timm_model.forward_features(snake_case__    )
						assert timm_pooled_output.shape == outputs.pooler_output.shape
						assert torch.allclose(snake_case__		,				outputs.pooler_output		,				atol=1e-3    )
			else:
						SCREAMING_SNAKE_CASE__								=      timm_model(snake_case__    )
						assert timm_logits.shape == outputs.logits.shape
						assert torch.allclose(snake_case__		,				outputs.logits		,				atol=1e-3    )
			print("""Looks ok!"""    )

			if pytorch_dump_folder_path is not None:
						Path(snake_case__    ).mkdir(exist_ok=snake_case__    )
						print(f"""Saving model {vit_name} to {pytorch_dump_folder_path}"""    )
						model.save_pretrained(snake_case__    )
						print(f"""Saving processor to {pytorch_dump_folder_path}"""    )
						processor.save_pretrained(snake_case__    )

			if push_to_hub:
						print(f"""Pushing model and processor to the hub {vit_name}"""    )
						model.push_to_hub(f"""ybelkada/{vit_name}"""    )
						processor.push_to_hub(f"""ybelkada/{vit_name}"""    )


if __name__ == "__main__":
						A_							:			Dict											= argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    "--vit_name",
						    default="vit_base_r50_s16_384",
						    type=str,
						    help="Name of the hybrid ViT timm model you'd like to convert.",
						)
						parser.add_argument(
						    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
						)
						parser.add_argument(
						    "--push_to_hub", action="store_true", help="Whether to upload the model to the HuggingFace hub."
						)

						A_							:			str											= parser.parse_args()
						convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)





"""simple docstring"""




import inspect
import unittest

from transformers import MobileNetVaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation, MobileNetVaModel
						from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import MobileNetVaImageProcessor





class    lowerCamelCase						(A__			):

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[str]       )   ->    Any:
						SCREAMING_SNAKE_CASE__								=      self.config_class(**self.inputs_dict       )
						self.parent.assertTrue(hasattr(__UpperCAmelCase    ,				"""tf_padding"""       )       )
						self.parent.assertTrue(hasattr(__UpperCAmelCase    ,				"""depth_multiplier"""       )       )





class    lowerCamelCase						:

			def __init__(					self				:						Any    ,				__UpperCAmelCase				:						Any    ,				__UpperCAmelCase				:						Any=1_3    ,				__UpperCAmelCase				:						Any=3    ,				__UpperCAmelCase				:						int=3_2    ,				__UpperCAmelCase				:						Tuple=0.25    ,				__UpperCAmelCase				:						Optional[int]=8    ,				__UpperCAmelCase				:						Any=8    ,				__UpperCAmelCase				:						str=6    ,				__UpperCAmelCase				:						Optional[int]=3_2    ,				__UpperCAmelCase				:						str=True    ,				__UpperCAmelCase				:						List[str]=True    ,				__UpperCAmelCase				:						Tuple=True    ,				__UpperCAmelCase				:						Any="relu6"    ,				__UpperCAmelCase				:						str=1_2_8_0    ,				__UpperCAmelCase				:						List[str]=0.1    ,				__UpperCAmelCase				:						Any=0.02    ,				__UpperCAmelCase				:						Any=True    ,				__UpperCAmelCase				:						Optional[int]=True    ,				__UpperCAmelCase				:						Dict=1_0    ,				__UpperCAmelCase				:						Optional[int]=None    ,				)   ->    Optional[Any]:
						SCREAMING_SNAKE_CASE__								=      parent
						SCREAMING_SNAKE_CASE__								=      batch_size
						SCREAMING_SNAKE_CASE__								=      num_channels
						SCREAMING_SNAKE_CASE__								=      image_size
						SCREAMING_SNAKE_CASE__								=      depth_multiplier
						SCREAMING_SNAKE_CASE__								=      depth_divisible_by
						SCREAMING_SNAKE_CASE__								=      min_depth
						SCREAMING_SNAKE_CASE__								=      expand_ratio
						SCREAMING_SNAKE_CASE__								=      tf_padding
						SCREAMING_SNAKE_CASE__								=      output_stride
						SCREAMING_SNAKE_CASE__								=      first_layer_is_expansion
						SCREAMING_SNAKE_CASE__								=      finegrained_output
						SCREAMING_SNAKE_CASE__								=      hidden_act
						SCREAMING_SNAKE_CASE__								=      last_hidden_size if finegrained_output else int(last_hidden_size * depth_multiplier       )
						SCREAMING_SNAKE_CASE__								=      classifier_dropout_prob
						SCREAMING_SNAKE_CASE__								=      use_labels
						SCREAMING_SNAKE_CASE__								=      is_training
						SCREAMING_SNAKE_CASE__								=      num_labels
						SCREAMING_SNAKE_CASE__								=      initializer_range
						SCREAMING_SNAKE_CASE__								=      scope

			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Tuple:
						SCREAMING_SNAKE_CASE__								=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

						SCREAMING_SNAKE_CASE__								=      self.get_config()

						return config, pixel_values, labels, pixel_labels

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    List[str]:
						return MobileNetVaConfig(
						    num_channels=self.num_channels    ,				image_size=self.image_size    ,				depth_multiplier=self.depth_multiplier    ,				depth_divisible_by=self.depth_divisible_by    ,				min_depth=self.min_depth    ,				expand_ratio=self.expand_ratio    ,				output_stride=self.output_stride    ,				first_layer_is_expansion=self.first_layer_is_expansion    ,				finegrained_output=self.finegrained_output    ,				hidden_act=self.hidden_act    ,				tf_padding=self.tf_padding    ,				classifier_dropout_prob=self.classifier_dropout_prob    ,				initializer_range=self.initializer_range    ,				)

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						List[Any]    ,				__UpperCAmelCase				:						Any    ,				__UpperCAmelCase				:						Tuple    ,				__UpperCAmelCase				:						Any       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      MobileNetVaModel(config=__UpperCAmelCase       )
						model.to(__UpperCAmelCase       )
						model.eval()
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase       )
						self.parent.assertEqual(
						    result.last_hidden_state.shape    ,				(
						        self.batch_size,
						        self.last_hidden_size,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )    ,				)
						self.parent.assertEqual(
						    result.pooler_output.shape    ,				(self.batch_size, self.last_hidden_size)    ,				)

			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]    ,				__UpperCAmelCase				:						Union[str, Any]    ,				__UpperCAmelCase				:						Union[str, Any]    ,				__UpperCAmelCase				:						Union[str, Any]    ,				__UpperCAmelCase				:						str       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      self.num_labels
						SCREAMING_SNAKE_CASE__								=      MobileNetVaForImageClassification(__UpperCAmelCase       )
						model.to(__UpperCAmelCase       )
						model.eval()
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase    ,				labels=__UpperCAmelCase       )
						self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.num_labels)       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple    ,				__UpperCAmelCase				:						str    ,				__UpperCAmelCase				:						Optional[Any]    ,				__UpperCAmelCase				:						int    ,				__UpperCAmelCase				:						Optional[int]       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      self.num_labels
						SCREAMING_SNAKE_CASE__								=      MobileNetVaForSemanticSegmentation(__UpperCAmelCase       )
						model.to(__UpperCAmelCase       )
						model.eval()
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase       )
						self.parent.assertEqual(
						    result.logits.shape    ,				(
						        self.batch_size,
						        self.num_labels,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )    ,				)
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase    ,				labels=__UpperCAmelCase       )
						self.parent.assertEqual(
						    result.logits.shape    ,				(
						        self.batch_size,
						        self.num_labels,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )    ,				)





			def 					SCREAMING_SNAKE_CASE				(					self				:						str       )   ->    Tuple:
						SCREAMING_SNAKE_CASE__								=      self.prepare_config_and_inputs()
						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      config_and_inputs
						SCREAMING_SNAKE_CASE__								=      {"""pixel_values""": pixel_values}
						return config, inputs_dict





@require_torch
class    lowerCamelCase						(A__			,A__			,unittest.TestCase			):
			lowerCamelCase__   :		str							=							(
			    (MobileNetVaModel, MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation)
			    if is_torch_available()
			    else ()
			)
			lowerCamelCase__   :		str							=							(
			    {
			        'feature-extraction': MobileNetVaModel,
			        'image-classification': MobileNetVaForImageClassification,
			        'image-segmentation': MobileNetVaForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			lowerCamelCase__   :		Optional[int]							=							False
			lowerCamelCase__   :		Dict							=							False
			lowerCamelCase__   :		List[Any]							=							False
			lowerCamelCase__   :		Union[str, Any]							=							False

			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    List[str]:
						SCREAMING_SNAKE_CASE__								=      MobileNetVaModelTester(self       )
						SCREAMING_SNAKE_CASE__								=      MobileNetVaConfigTester(self    ,				config_class=__UpperCAmelCase    ,				has_text_modality=__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						str       )   ->    int:
						self.config_tester.run_common_tests()

			@unittest.skip(reason="""MobileNetV2 does not use inputs_embeds"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Union[str, Any]:
						pass

			@unittest.skip(reason="""MobileNetV2 does not support input and output embeddings"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    List[str]:
						pass

			@unittest.skip(reason="""MobileNetV2 does not output attentions"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Optional[int]:
						pass

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[str]       )   ->    str:
						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs_for_common()

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

									SCREAMING_SNAKE_CASE__								=      ["""pixel_values"""]
									self.assertListEqual(arg_names[:1]    ,				__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    Union[str, Any]:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]       )   ->    List[str]:
						def check_hidden_states_output(__UpperCAmelCase				:						Tuple    ,				__UpperCAmelCase				:						Optional[int]    ,				__UpperCAmelCase				:						Optional[int]       ):
									SCREAMING_SNAKE_CASE__								=      model_class(__UpperCAmelCase       )
									model.to(__UpperCAmelCase       )
									model.eval()

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

									SCREAMING_SNAKE_CASE__								=      outputs.hidden_states

									SCREAMING_SNAKE_CASE__								=      1_6
									self.assertEqual(len(__UpperCAmelCase       )    ,				__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs_for_common()

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

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

									check_hidden_states_output(__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple       )   ->    Optional[int]:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						str       )   ->    int:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCAmelCase       )





			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]       )   ->    Dict:
						for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE__								=      MobileNetVaModel.from_pretrained(__UpperCAmelCase       )
									self.assertIsNotNone(__UpperCAmelCase       )

def 	A       (     ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
			return image





@require_torch
@require_vision
class    lowerCamelCase						(unittest.TestCase			):

			@cached_property
			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    str:
						return (
						    MobileNetVaImageProcessor.from_pretrained("""google/mobilenet_v2_1.0_224"""       ) if is_vision_available() else None
						)

			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    int:
						SCREAMING_SNAKE_CASE__								=      MobileNetVaForImageClassification.from_pretrained("""google/mobilenet_v2_1.0_224"""       ).to(__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      self.default_image_processor
						SCREAMING_SNAKE_CASE__								=      prepare_img()
						SCREAMING_SNAKE_CASE__								=      image_processor(images=__UpperCAmelCase    ,				return_tensors="""pt"""       ).to(__UpperCAmelCase       )

						# forward pass
						with torch.no_grad():
									SCREAMING_SNAKE_CASE__								=      model(**__UpperCAmelCase       )

						# verify the logits
						SCREAMING_SNAKE_CASE__								=      torch.Size((1, 1_0_0_1)       )
						self.assertEqual(outputs.logits.shape    ,				__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      torch.tensor([0.2_445, -1.1_993, 0.1_905]       ).to(__UpperCAmelCase       )

						self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,				__UpperCAmelCase    ,				atol=1e-4       )       )





			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    int:
						SCREAMING_SNAKE_CASE__								=      MobileNetVaForSemanticSegmentation.from_pretrained("""google/deeplabv3_mobilenet_v2_1.0_513"""       )
						SCREAMING_SNAKE_CASE__								=      model.to(__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      MobileNetVaImageProcessor.from_pretrained("""google/deeplabv3_mobilenet_v2_1.0_513"""       )

						SCREAMING_SNAKE_CASE__								=      prepare_img()
						SCREAMING_SNAKE_CASE__								=      image_processor(images=__UpperCAmelCase    ,				return_tensors="""pt"""       ).to(__UpperCAmelCase       )

						# forward pass
						with torch.no_grad():
									SCREAMING_SNAKE_CASE__								=      model(**__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      outputs.logits

						# verify the logits
						SCREAMING_SNAKE_CASE__								=      torch.Size((1, 2_1, 6_5, 6_5)       )
						self.assertEqual(logits.shape    ,				__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      torch.tensor(
						    [
						        [[17.5_790, 17.7_581, 18.3_355], [18.3_257, 18.4_230, 18.8_973], [18.6_169, 18.8_650, 19.2_187]],
						        [[-2.1_595, -2.0_977, -2.3_741], [-2.4_226, -2.3_028, -2.6_835], [-2.7_819, -2.5_991, -2.7_706]],
						        [[4.2_058, 4.8_317, 4.7_638], [4.4_136, 5.0_361, 4.9_383], [4.5_028, 4.9_644, 4.8_734]],
						    ]    ,				device=__UpperCAmelCase    ,				)

						self.assertTrue(torch.allclose(logits[0, :3, :3, :3]    ,				__UpperCAmelCase    ,				atol=1e-4       )       )


