



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 				__snake_case						(     UpperCamelCase_						):




							def    UpperCAmelCase__			(       self     :       List[Any]):
									lowerCAmelCase_			:     str									= self.config_class(**self.inputs_dict)
									self.parent.assertTrue(hasattr(A_				,				'''tf_padding'''))
									self.parent.assertTrue(hasattr(A_				,				'''depth_multiplier'''))





class 				__snake_case						:




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




							def    UpperCAmelCase__			(       self     :       List[str]):
									lowerCAmelCase_			:     Optional[Any]									= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

									lowerCAmelCase_			:     List[str]									= self.get_config()

									return config, pixel_values, labels, pixel_labels




							def    UpperCAmelCase__			(       self     :       Dict):
									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    UpperCAmelCase__			(       self     :       Any				,				A_     :       Any				,				A_     :       List[Any]				,				A_     :       List[str]				,				A_     :       Tuple):
									lowerCAmelCase_			:     int									= MobileNetVaModel(config=A_)
									model.to(A_)
									model.eval()
									lowerCAmelCase_			:     str									= model(A_)
									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    UpperCAmelCase__			(       self     :       Optional[Any]				,				A_     :       Tuple				,				A_     :       List[Any]				,				A_     :       Optional[int]				,				A_     :       Optional[Any]):
									lowerCAmelCase_			:     Any									= self.num_labels
									lowerCAmelCase_			:     List[str]									= MobileNetVaForImageClassification(A_)
									model.to(A_)
									model.eval()
									lowerCAmelCase_			:     Optional[int]									= model(A_				,				labels=A_)
									self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_labels))




							def    UpperCAmelCase__			(       self     :       Optional[Any]				,				A_     :       Union[str, Any]				,				A_     :       int				,				A_     :       Tuple				,				A_     :       Optional[int]):
									lowerCAmelCase_			:     Any									= self.num_labels
									lowerCAmelCase_			:     Optional[int]									= MobileNetVaForSemanticSegmentation(A_)
									model.to(A_)
									model.eval()
									lowerCAmelCase_			:     str									= model(A_)
									self.parent.assertEqual(
									    result.logits.shape				,				(
									        self.batch_size,
									        self.num_labels,
									        self.image_size // self.output_stride,
									        self.image_size // self.output_stride,
									    )				,				)
									lowerCAmelCase_			:     Union[str, Any]									= model(A_				,				labels=A_)
									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    UpperCAmelCase__			(       self     :       int):
									lowerCAmelCase_			:     Tuple									= self.prepare_config_and_inputs()
									lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_			:     Optional[Any]									= config_and_inputs
									lowerCAmelCase_			:     Dict									= {'''pixel_values''': pixel_values}
									return config, inputs_dict





@require_torch
class 				__snake_case						(     UpperCamelCase_						,UpperCamelCase_						,unittest.TestCase						):
							_a			      = (
							    (MobileNetVaModel, MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)
							_a			      = (
							    {
							        '''feature-extraction''': MobileNetVaModel,
							        '''image-classification''': MobileNetVaForImageClassification,
							        '''image-segmentation''': MobileNetVaForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							_a			      = False
							_a			      = False
							_a			      = False
							_a			      = False




							def    UpperCAmelCase__			(       self     :       Optional[Any]):
									lowerCAmelCase_			:     List[Any]									= MobileNetVaModelTester(self)
									lowerCAmelCase_			:     int									= MobileNetVaConfigTester(self				,				config_class=A_				,				has_text_modality=A_)




							def    UpperCAmelCase__			(       self     :       Any):
									self.config_tester.run_common_tests()




							@unittest.skip(reason='''MobileNetV2 does not use inputs_embeds''')
							def    UpperCAmelCase__			(       self     :       List[Any]):
									pass




							@unittest.skip(reason='''MobileNetV2 does not support input and output embeddings''')
							def    UpperCAmelCase__			(       self     :       int):
									pass




							@unittest.skip(reason='''MobileNetV2 does not output attentions''')
							def    UpperCAmelCase__			(       self     :       List[str]):
									pass




							def    UpperCAmelCase__			(       self     :       int):
									lowerCAmelCase_					,  lowerCAmelCase_			:     str									= self.model_tester.prepare_config_and_inputs_for_common()

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

											lowerCAmelCase_			:     str									= ['''pixel_values''']
											self.assertListEqual(arg_names[:1]				,				A_)




							def    UpperCAmelCase__			(       self     :       int):
									lowerCAmelCase_			:     Tuple									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*A_)




							def    UpperCAmelCase__			(       self     :       int):
									def check_hidden_states_output(A_     :       List[str]				,				A_     :       int				,				A_     :       Any):
											lowerCAmelCase_			:     Tuple									= model_class(A_)
											model.to(A_)
											model.eval()

											with torch.no_grad():
													lowerCAmelCase_			:     Any									= model(**self._prepare_for_class(A_				,				A_))

											lowerCAmelCase_			:     str									= outputs.hidden_states

											lowerCAmelCase_			:     List[Any]									= 1_6
											self.assertEqual(len(A_)				,				A_)

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

									for model_class in self.all_model_classes:
											lowerCAmelCase_			:     Optional[int]									= True
											check_hidden_states_output(A_				,				A_				,				A_)

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

											check_hidden_states_output(A_				,				A_				,				A_)




							def    UpperCAmelCase__			(       self     :       str):
									lowerCAmelCase_			:     Optional[Any]									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*A_)




							def    UpperCAmelCase__			(       self     :       Union[str, Any]):
									lowerCAmelCase_			:     Union[str, Any]									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_semantic_segmentation(*A_)







							@slow
							def    UpperCAmelCase__			(       self     :       List[str]):
									for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											lowerCAmelCase_			:     List[Any]									= MobileNetVaModel.from_pretrained(A_)
											self.assertIsNotNone(A_)





def 			UpperCamelCase(  ):
		lowerCAmelCase_			:     List[str]									= Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
		return image





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




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




							@slow
							def    UpperCAmelCase__			(       self     :       Dict):
									lowerCAmelCase_			:     List[str]									= MobileNetVaForImageClassification.from_pretrained('''google/mobilenet_v2_1.0_224''').to(A_)

									lowerCAmelCase_			:     List[str]									= self.default_image_processor
									lowerCAmelCase_			:     List[str]									= prepare_img()
									lowerCAmelCase_			:     List[str]									= image_processor(images=A_				,				return_tensors='''pt''').to(A_)

									# forward pass
									with torch.no_grad():
											lowerCAmelCase_			:     int									= model(**A_)

									# verify the logits
									lowerCAmelCase_			:     Tuple									= torch.Size((1, 1_0_0_1))
									self.assertEqual(outputs.logits.shape				,				A_)

									lowerCAmelCase_			:     str									= torch.tensor([0.2445, -1.1993, 0.1905]).to(A_)

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







							@slow
							def    UpperCAmelCase__			(       self     :       Union[str, Any]):
									lowerCAmelCase_			:     str									= MobileNetVaForSemanticSegmentation.from_pretrained('''google/deeplabv3_mobilenet_v2_1.0_513''')
									lowerCAmelCase_			:     int									= model.to(A_)

									lowerCAmelCase_			:     Optional[Any]									= MobileNetVaImageProcessor.from_pretrained('''google/deeplabv3_mobilenet_v2_1.0_513''')

									lowerCAmelCase_			:     int									= prepare_img()
									lowerCAmelCase_			:     Tuple									= image_processor(images=A_				,				return_tensors='''pt''').to(A_)

									# forward pass
									with torch.no_grad():
											lowerCAmelCase_			:     str									= model(**A_)
									lowerCAmelCase_			:     Optional[int]									= outputs.logits

									# verify the logits
									lowerCAmelCase_			:     Dict									= torch.Size((1, 2_1, 6_5, 6_5))
									self.assertEqual(logits.shape				,				A_)

									lowerCAmelCase_			:     Optional[Any]									= torch.tensor(
									    [
									        [[17.5790, 17.7581, 18.3355], [18.3257, 18.4230, 18.8973], [18.6169, 18.8650, 19.2187]],
									        [[-2.1595, -2.0977, -2.3741], [-2.4226, -2.3028, -2.6835], [-2.7819, -2.5991, -2.7706]],
									        [[4.2058, 4.8317, 4.7638], [4.4136, 5.0361, 4.9383], [4.5028, 4.9644, 4.8734]],
									    ]				,				device=A_				,				)

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










# Lint as: python3
import os
import re
import urllib.parse
from pathlib import Path
from typing import Callable, List, Optional, Union
from zipfile import ZipFile

from ..utils.file_utils import cached_path, hf_github_url
from ..utils.logging import get_logger
from ..utils.version import Version


A__  :  Tuple								=					get_logger(__name__)



class 				__snake_case						:
							_a			      = '''dummy_data'''
							_a			      = '''datasets'''
							_a			      = False




							def __init__(       self     :       Optional[Any]				,				A_     :       str				,				A_     :       str				,				A_     :       Union[Version, str]				,				A_     :       Optional[str] = None				,				A_     :       bool = False				,				A_     :       bool = True				,				A_     :       Optional[List[Callable]] = None				,				):
									lowerCAmelCase_			:     List[Any]									= 0
									lowerCAmelCase_			:     Any									= dataset_name
									lowerCAmelCase_			:     Union[str, Any]									= cache_dir
									lowerCAmelCase_			:     List[Any]									= use_local_dummy_data
									lowerCAmelCase_			:     Optional[Any]									= config
									# download_callbacks take a single url as input
									lowerCAmelCase_			:     List[Callable]									= download_callbacks or []
									# if False, it doesn't load existing files and it returns the paths of the dummy files relative
									# to the dummy_data zip file root
									lowerCAmelCase_			:     Tuple									= load_existing_dummy_data

									# TODO(PVP, QL) might need to make this more general
									lowerCAmelCase_			:     int									= str(A_)
									# to be downloaded
									lowerCAmelCase_			:     Dict									= None
									lowerCAmelCase_			:     Optional[int]									= None




							@property
							def    UpperCAmelCase__			(       self     :       List[str]):
									if self._dummy_file is None:
											lowerCAmelCase_			:     int									= self.download_dummy_data()
									return self._dummy_file




							@property
							def    UpperCAmelCase__			(       self     :       str):
									if self.config is not None:
											# structure is dummy / config_name / version_name
											return os.path.join('''dummy'''				,				self.config.name				,				self.version_name)
									# structure is dummy / version_name
									return os.path.join('''dummy'''				,				self.version_name)




							@property
							def    UpperCAmelCase__			(       self     :       str):
									return os.path.join(self.dummy_data_folder				,				'''dummy_data.zip''')




							def    UpperCAmelCase__			(       self     :       Any):
									lowerCAmelCase_			:     Any									= (
									    self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
									)

									lowerCAmelCase_			:     Union[str, Any]									= cached_path(
									    A_				,				cache_dir=self.cache_dir				,				extract_compressed_file=A_				,				force_extract=A_)

									return os.path.join(A_				,				self.dummy_file_name)




							@property
							def    UpperCAmelCase__			(       self     :       List[str]):
									return os.path.join(self.datasets_scripts_dir				,				self.dataset_name				,				self.dummy_zip_file)




							@property
							def    UpperCAmelCase__			(       self     :       Optional[int]):
									if self._bucket_url is None:
											lowerCAmelCase_			:     str									= hf_github_url(self.dataset_name				,				self.dummy_zip_file.replace(os.sep				,				'''/'''))
									return self._bucket_url




							@property
							def    UpperCAmelCase__			(       self     :       List[Any]):
									# return full path if its a dir
									if os.path.isdir(self.dummy_file):
											return self.dummy_file
									# else cut off path to file -> example `xsum`.
									return "/".join(self.dummy_file.replace(os.sep				,				'''/''').split('''/''')[:-1])




							def    UpperCAmelCase__			(       self     :       Union[str, Any]				,				A_     :       Dict				,				*A_     :       List[Any]):
									if self.load_existing_dummy_data:
											# dummy data is downloaded and tested
											lowerCAmelCase_			:     Union[str, Any]									= self.dummy_file
									else:
											# dummy data cannot be downloaded and only the path to dummy file is returned
											lowerCAmelCase_			:     Optional[int]									= self.dummy_file_name

									# special case when data_url is a dict
									if isinstance(A_				,				A_):
											return self.create_dummy_data_dict(A_				,				A_)
									elif isinstance(A_				,				(list, tuple)):
											return self.create_dummy_data_list(A_				,				A_)
									else:
											return self.create_dummy_data_single(A_				,				A_)




							def    UpperCAmelCase__			(       self     :       Optional[int]				,				A_     :       Tuple				,				*A_     :       int):
									return self.download_and_extract(A_)




							def    UpperCAmelCase__			(       self     :       Tuple				,				A_     :       List[str]				,				A_     :       Optional[Any]):
									return self.download_and_extract(A_)




							def    UpperCAmelCase__			(       self     :       int				,				A_     :       Optional[int]				,				*A_     :       str				,				**A_     :       List[Any]):
									return path




							def    UpperCAmelCase__			(       self     :       Tuple):
									return {}




							def    UpperCAmelCase__			(       self     :       Optional[Any]				,				A_     :       Union[str, Any]				,				A_     :       List[Any]):
									lowerCAmelCase_			:     Union[str, Any]									= {}
									for key, single_urls in data_url.items():
											for download_callback in self.download_callbacks:
													if isinstance(A_				,				A_):
															for single_url in single_urls:
																	download_callback(A_)
													else:
															lowerCAmelCase_			:     Any									= single_urls
															download_callback(A_)
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
											if isinstance(A_				,				A_):
													lowerCAmelCase_			:     Any									= [os.path.join(A_				,				urllib.parse.quote_plus(Path(A_).name)) for x in single_urls]
											else:
													lowerCAmelCase_			:     Optional[int]									= single_urls
													lowerCAmelCase_			:     List[str]									= os.path.join(A_				,				urllib.parse.quote_plus(Path(A_).name))
											lowerCAmelCase_			:     Dict									= value

									# make sure that values are unique
									if all(isinstance(A_				,				A_) for i in dummy_data_dict.values()) and len(set(dummy_data_dict.values())) < len(
									    dummy_data_dict.values()):
											# append key to value to make its name unique
											lowerCAmelCase_			:     Tuple									= {key: value + key for key, value in dummy_data_dict.items()}

									return dummy_data_dict




							def    UpperCAmelCase__			(       self     :       Dict				,				A_     :       List[str]				,				A_     :       str):
									lowerCAmelCase_			:     Optional[Any]									= []
									# trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
									lowerCAmelCase_			:     str									= all(bool(re.findall('''[0-9]{3,}-of-[0-9]{3,}'''				,				A_)) for url in data_url)
									lowerCAmelCase_			:     Optional[Any]									= all(
									    url.startswith('''https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed''') for url in data_url)
									if data_url and (is_tf_records or is_pubmed_records):
											lowerCAmelCase_			:     Any									= [data_url[0]] * len(A_)
									for single_url in data_url:
											for download_callback in self.download_callbacks:
													download_callback(A_)
											# we force the name of each key to be the last file / folder name of the url path
											# if the url has arguments, we need to encode them with urllib.parse.quote_plus
											lowerCAmelCase_			:     int									= os.path.join(A_				,				urllib.parse.quote_plus(single_url.split('''/''')[-1]))
											dummy_data_list.append(A_)
									return dummy_data_list




							def    UpperCAmelCase__			(       self     :       List[str]				,				A_     :       Optional[Any]				,				A_     :       Tuple):
									for download_callback in self.download_callbacks:
											download_callback(A_)
									# we force the name of each key to be the last file / folder name of the url path
									# if the url has arguments, we need to encode them with urllib.parse.quote_plus
									lowerCAmelCase_			:     Tuple									= os.path.join(A_				,				urllib.parse.quote_plus(data_url.split('''/''')[-1]))
									if os.path.exists(A_) or not self.load_existing_dummy_data:
											return value
									else:
											# Backward compatibility, maybe deprecate at one point.
											# For many datasets with single url calls to dl_manager.download_and_extract,
											# the dummy_data.zip file is actually the zipped downloaded file
											# while now we expected the dummy_data.zip file to be a directory containing
											# the downloaded file.
											return path_to_dummy_data




							def    UpperCAmelCase__			(       self     :       int):
									pass




							def    UpperCAmelCase__			(       self     :       Optional[int]):
									pass




							def    UpperCAmelCase__			(       self     :       List[str]				,				A_     :       str):
									def _iter_archive_members(A_     :       Any):
											# this preserves the order of the members inside the ZIP archive
											lowerCAmelCase_			:     Optional[int]									= Path(self.dummy_file).parent
											lowerCAmelCase_			:     Optional[int]									= path.relative_to(A_)
											with ZipFile(self.local_path_to_dummy_data) as zip_file:
													lowerCAmelCase_			:     Tuple									= zip_file.namelist()
											for member in members:
													if member.startswith(relative_path.as_posix()):
															yield dummy_parent_path.joinpath(A_)

									lowerCAmelCase_			:     List[Any]									= Path(A_)
									lowerCAmelCase_			:     Optional[int]									= _iter_archive_members(A_) if self.use_local_dummy_data else path.rglob('''*''')
									for file_path in file_paths:
											if file_path.is_file() and not file_path.name.startswith(('''.''', '''__''')):
													yield file_path.relative_to(A_).as_posix(), file_path.open('''rb''')







							def    UpperCAmelCase__			(       self     :       Dict				,				A_     :       Any):
									if not isinstance(A_				,				A_):
											lowerCAmelCase_			:     Dict									= [paths]
									for path in paths:
											if os.path.isfile(A_):
													if os.path.basename(A_).startswith(('''.''', '''__''')):
															return
													yield path
											else:
													for dirpath, dirnames, filenames in os.walk(A_):
															if os.path.basename(A_).startswith(('''.''', '''__''')):
																	continue
															dirnames.sort()
															for filename in sorted(A_):
																	if filename.startswith(('''.''', '''__''')):
																			continue
																	yield os.path.join(A_				,				A_)





