






'''simple docstring'''



import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


__UpperCamelCase      :       str      			=      get_logger(__name__)


__UpperCamelCase      :       List[str]      			=      Path(__file__).parent / """model_card_template.md"""
__UpperCamelCase      :       int      			=      uuida().hex
__UpperCamelCase      :       int      			=      os.getenv("""HF_HUB_OFFLINE""", """""").upper() in ENV_VARS_TRUE_VALUES
__UpperCamelCase      :       str      			=      os.getenv("""DISABLE_TELEMETRY""", """""").upper() in ENV_VARS_TRUE_VALUES
__UpperCamelCase      :       Optional[Any]      			=      HUGGINGFACE_CO_RESOLVE_ENDPOINT + """/api/telemetry/"""



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Union[Dict, str, None] = None    )  ->			Tuple:

   """simple docstring"""
   __a				     =    f"""diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}"""
   if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
      return ua + "; telemetry/off"
   if is_torch_available():
      ua += f"""; torch/{_torch_version}"""
   if is_flax_available():
      ua += f"""; jax/{_jax_version}"""
      ua += f"""; flax/{_flax_version}"""
   if is_onnx_available():
      ua += f"""; onnxruntime/{_onnxruntime_version}"""
   # CI will set this value to True
   if os.environ.get('DIFFUSERS_IS_CI',					''    ).upper() in ENV_VARS_TRUE_VALUES:
      ua += "; is_ci/true"
   if isinstance(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    ):
      ua += "; " + "; ".join(f"""{k}/{v}""" for k, v in user_agent.items()    )
   elif isinstance(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    ):
      ua += "; " + user_agent
   return ua



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	str,					SCREAMING_SNAKE_CASE__:	Optional[str] = None,					SCREAMING_SNAKE_CASE__:	Optional[str] = None    )  ->			Any:

   """simple docstring"""





   if token is None:
      __a				     =    HfFolder.get_token()
   if organization is None:
      __a				     =    whoami(SCREAMING_SNAKE_CASE__    )["""name"""]
      return f"""{username}/{model_id}"""
   else:
      return f"""{organization}/{model_id}"""



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	List[str],					SCREAMING_SNAKE_CASE__:	str    )  ->			str:

   """simple docstring"""





   if not is_jinja_available():
      raise ValueError(
          'Modelcard rendering is based on Jinja templates.'
          ' Please make sure to have `jinja` installed before using `create_model_card`.'
          ' To install it, please run `pip install Jinja2`.'    )

   if hasattr(SCREAMING_SNAKE_CASE__,					'local_rank'    ) and args.local_rank not in [-1, 0]:
      return

   __a				     =    args.hub_token if hasattr(SCREAMING_SNAKE_CASE__,					'hub_token'    ) else None
   __a				     =    get_full_repo_name(SCREAMING_SNAKE_CASE__,					token=SCREAMING_SNAKE_CASE__    )

   __a				     =    ModelCard.from_template(
       card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
           language='en',					license='apache-2.0',					library_name='diffusers',					tags=[],					datasets=args.dataset_name,					metrics=[],					),					template_path=SCREAMING_SNAKE_CASE__,					model_name=SCREAMING_SNAKE_CASE__,					repo_name=SCREAMING_SNAKE_CASE__,					dataset_name=args.dataset_name if hasattr(SCREAMING_SNAKE_CASE__,					'dataset_name'    ) else None,					learning_rate=args.learning_rate,					train_batch_size=args.train_batch_size,					eval_batch_size=args.eval_batch_size,					gradient_accumulation_steps=(
           args.gradient_accumulation_steps if hasattr(SCREAMING_SNAKE_CASE__,					'gradient_accumulation_steps'    ) else None
       ),					adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE__,					'adam_beta1'    ) else None,					adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE__,					'adam_beta2'    ) else None,					adam_weight_decay=args.adam_weight_decay if hasattr(SCREAMING_SNAKE_CASE__,					'adam_weight_decay'    ) else None,					adam_epsilon=args.adam_epsilon if hasattr(SCREAMING_SNAKE_CASE__,					'adam_epsilon'    ) else None,					lr_scheduler=args.lr_scheduler if hasattr(SCREAMING_SNAKE_CASE__,					'lr_scheduler'    ) else None,					lr_warmup_steps=args.lr_warmup_steps if hasattr(SCREAMING_SNAKE_CASE__,					'lr_warmup_steps'    ) else None,					ema_inv_gamma=args.ema_inv_gamma if hasattr(SCREAMING_SNAKE_CASE__,					'ema_inv_gamma'    ) else None,					ema_power=args.ema_power if hasattr(SCREAMING_SNAKE_CASE__,					'ema_power'    ) else None,					ema_max_decay=args.ema_max_decay if hasattr(SCREAMING_SNAKE_CASE__,					'ema_max_decay'    ) else None,					mixed_precision=args.mixed_precision,					)

   __a				     =    os.path.join(args.output_dir,					'README.md'    )
   model_card.save(SCREAMING_SNAKE_CASE__    )



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Optional[str],					SCREAMING_SNAKE_CASE__:	Optional[str] = None    )  ->			Any:

   """simple docstring"""





   if resolved_file is None or commit_hash is not None:
      return commit_hash
   __a				     =    str(Path(SCREAMING_SNAKE_CASE__    ).as_posix()    )
   __a				     =    re.search(r'snapshots/([^/]+)/',					SCREAMING_SNAKE_CASE__    )
   if search is None:
      return None
   __a				     =    search.groups()[0]
   return commit_hash if REGEX_COMMIT_HASH.match(SCREAMING_SNAKE_CASE__    ) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
__UpperCamelCase      :       int      			=      os.path.expanduser(
    os.getenv("""HF_HOME""", os.path.join(os.getenv("""XDG_CACHE_HOME""", """~/.cache"""), """huggingface"""))
)
__UpperCamelCase      :       Optional[Any]      			=      os.path.join(hf_cache_home, """diffusers""")



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Optional[str] = None,					SCREAMING_SNAKE_CASE__:	Optional[str] = None    )  ->			str:

   """simple docstring"""





   if new_cache_dir is None:
      __a				     =    DIFFUSERS_CACHE
   if old_cache_dir is None:
      __a				     =    old_diffusers_cache

   __a				     =    Path(SCREAMING_SNAKE_CASE__    ).expanduser()
   __a				     =    Path(SCREAMING_SNAKE_CASE__    ).expanduser()
   for old_blob_path in old_cache_dir.glob('**/blobs/*'    ):
      if old_blob_path.is_file() and not old_blob_path.is_symlink():
         __a				     =    new_cache_dir / old_blob_path.relative_to(SCREAMING_SNAKE_CASE__    )
         new_blob_path.parent.mkdir(parents=SCREAMING_SNAKE_CASE__,					exist_ok=SCREAMING_SNAKE_CASE__    )
         os.replace(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )
         try:
            os.symlink(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )
         except OSError:
            logger.warning(
                'Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded.'    )
   # At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


__UpperCamelCase      :       List[str]      			=      os.path.join(DIFFUSERS_CACHE, """version_diffusers_cache.txt""")
if not os.path.isfile(cache_version_file):
 __UpperCamelCase      :       Tuple      			=      0
else:
 with open(cache_version_file) as f:
  try:
   __UpperCamelCase      :       Dict      			=      int(f.read())
  except ValueError:
   __UpperCamelCase      :       str      			=      0

if cache_version < 1:
 __UpperCamelCase      :       Optional[int]      			=      os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
 if old_cache_is_not_empty:
  logger.warning(
      """The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your """
      """existing cached models. This is a one-time operation, you can interrupt it or run it """
      """later by calling `diffusers.utils.hub_utils.move_cache()`."""
  )
  try:
   move_cache()
  except Exception as e:
   __UpperCamelCase      :       Any      			=      """\n""".join(traceback.format_tb(e.__traceback__))
   logger.error(
       f"""There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease """
       """file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole """
       """message and we will do our best to help."""
   )

if cache_version < 1:
 try:
  os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
  with open(cache_version_file, """w""") as f:
   f.write("""1""")
 except Exception:
  logger.warning(
      f"""There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure """
      """the directory exists and can be written to."""
  )



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	str,					SCREAMING_SNAKE_CASE__:	Optional[str] = None    )  ->			Union[str, Any]:

   """simple docstring"""





   if variant is not None:
      __a				     =    weights_name.split('.'    )
      __a				     =    splits[:-1] + [variant] + splits[-1:]
      __a				     =    """.""".join(SCREAMING_SNAKE_CASE__    )

   return weights_name



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Union[str, Any],					*,
    SCREAMING_SNAKE_CASE__:	Any,					SCREAMING_SNAKE_CASE__:	Tuple,					SCREAMING_SNAKE_CASE__:	List[Any],					SCREAMING_SNAKE_CASE__:	List[str],					SCREAMING_SNAKE_CASE__:	int,					SCREAMING_SNAKE_CASE__:	str,					SCREAMING_SNAKE_CASE__:	int,					SCREAMING_SNAKE_CASE__:	Tuple,					SCREAMING_SNAKE_CASE__:	str,					SCREAMING_SNAKE_CASE__:	str,					SCREAMING_SNAKE_CASE__:	int=None,					)  ->			Optional[int]:

   """simple docstring"""
   __a				     =    str(SCREAMING_SNAKE_CASE__    )
   if os.path.isfile(SCREAMING_SNAKE_CASE__    ):
      return pretrained_model_name_or_path
   elif os.path.isdir(SCREAMING_SNAKE_CASE__    ):
      if os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )    ):
         # Load from a PyTorch checkpoint
         __a				     =    os.path.join(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )
         return model_file
      elif subfolder is not None and os.path.isfile(
          os.path.join(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )    ):
         __a				     =    os.path.join(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )
         return model_file
      else:
         raise EnvironmentError(
             f"""Error no file named {weights_name} found in directory {pretrained_model_name_or_path}."""    )
   else:
      # 1. First check if deprecated way of loading from branches is used
      if (
          revision in DEPRECATED_REVISION_ARGS
          and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
          and version.parse(version.parse(SCREAMING_SNAKE_CASE__    ).base_version    ) >= version.parse('0.20.0'    )
      ):
         try:
            __a				     =    hf_hub_download(
                SCREAMING_SNAKE_CASE__,					filename=_add_variant(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    ),					cache_dir=SCREAMING_SNAKE_CASE__,					force_download=SCREAMING_SNAKE_CASE__,					proxies=SCREAMING_SNAKE_CASE__,					resume_download=SCREAMING_SNAKE_CASE__,					local_files_only=SCREAMING_SNAKE_CASE__,					use_auth_token=SCREAMING_SNAKE_CASE__,					user_agent=SCREAMING_SNAKE_CASE__,					subfolder=SCREAMING_SNAKE_CASE__,					revision=revision or commit_hash,					)
            warnings.warn(
                f"""Loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'` is deprecated. Loading instead from `revision=\'main\'` with `variant={revision}`. Loading model variants via `revision=\'{revision}\'` will be removed in diffusers v1. Please use `variant=\'{revision}\'` instead.""",					SCREAMING_SNAKE_CASE__,					)
            return model_file
         except:  # noqa: E722
            warnings.warn(
                f"""You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant=\'{revision}\'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )} file in the \'main\' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title \'{pretrained_model_name_or_path} is missing {_add_variant(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )}\' so that the correct variant file can be added.""",					SCREAMING_SNAKE_CASE__,					)
      try:
         # 2. Load model file as usual
         __a				     =    hf_hub_download(
             SCREAMING_SNAKE_CASE__,					filename=SCREAMING_SNAKE_CASE__,					cache_dir=SCREAMING_SNAKE_CASE__,					force_download=SCREAMING_SNAKE_CASE__,					proxies=SCREAMING_SNAKE_CASE__,					resume_download=SCREAMING_SNAKE_CASE__,					local_files_only=SCREAMING_SNAKE_CASE__,					use_auth_token=SCREAMING_SNAKE_CASE__,					user_agent=SCREAMING_SNAKE_CASE__,					subfolder=SCREAMING_SNAKE_CASE__,					revision=revision or commit_hash,					)
         return model_file

      except RepositoryNotFoundError:
         raise EnvironmentError(
             f"""{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier """
             'listed on \'https://huggingface.co/models\'\nIf this is a private repository, make sure to pass a '
             'token having permission to this repo with `use_auth_token` or log in with `huggingface-cli '
             'login`.'    )
      except RevisionNotFoundError:
         raise EnvironmentError(
             f"""{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for """
             'this model name. Check the model page at '
             f"""\'https://huggingface.co/{pretrained_model_name_or_path}\' for available revisions."""    )
      except EntryNotFoundError:
         raise EnvironmentError(
             f"""{pretrained_model_name_or_path} does not appear to have a file named {weights_name}."""    )
      except HTTPError as err:
         raise EnvironmentError(
             f"""There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}"""    )
      except ValueError:
         raise EnvironmentError(
             f"""We couldn\'t connect to \'{HUGGINGFACE_CO_RESOLVE_ENDPOINT}\' to load this model, couldn\'t find it"""
             f""" in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a"""
             f""" directory containing a file named {weights_name} or"""
             ' \nCheckout your internet connection or see how to run the library in'
             ' offline mode at \'https://huggingface.co/docs/diffusers/installation#offline-mode\'.'    )
      except EnvironmentError:
         raise EnvironmentError(
             f"""Can\'t load the model for \'{pretrained_model_name_or_path}\'. If you were trying to load it from """
             '\'https://huggingface.co/models\', make sure you don\'t have a local directory with the same name. '
             f"""Otherwise, make sure \'{pretrained_model_name_or_path}\' is the correct path to a directory """
             f"""containing a file named {weights_name}"""    )







'''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 							__SCREAMING_SNAKE_CASE       (							_lowerCAmelCase     ):




      def  __UpperCamelCase							(  self      )							->int:



         '''simple docstring'''
         __a				     =    self.config_class(**self.inputs_dict      )
         self.parent.assertTrue(hasattr(lowerCamelCase ,   'tf_padding'      )      )
         self.parent.assertTrue(hasattr(lowerCamelCase ,   'depth_multiplier'      )      )







class 							__SCREAMING_SNAKE_CASE       :




      def __init__(  self ,   lowerCamelCase ,   lowerCamelCase=13 ,   lowerCamelCase=3 ,   lowerCamelCase=32 ,   lowerCamelCase=0.25 ,   lowerCamelCase=8 ,   lowerCamelCase=8 ,   lowerCamelCase=6 ,   lowerCamelCase=32 ,   lowerCamelCase=True ,   lowerCamelCase=True ,   lowerCamelCase=True ,   lowerCamelCase="relu6" ,   lowerCamelCase=1280 ,   lowerCamelCase=0.1 ,   lowerCamelCase=0.02 ,   lowerCamelCase=True ,   lowerCamelCase=True ,   lowerCamelCase=10 ,   lowerCamelCase=None ,   )							->Optional[int]:



         '''simple docstring'''
         __a				     =    parent
         __a				     =    batch_size
         __a				     =    num_channels
         __a				     =    image_size
         __a				     =    depth_multiplier
         __a				     =    depth_divisible_by
         __a				     =    min_depth
         __a				     =    expand_ratio
         __a				     =    tf_padding
         __a				     =    output_stride
         __a				     =    first_layer_is_expansion
         __a				     =    finegrained_output
         __a				     =    hidden_act
         __a				     =    last_hidden_size if finegrained_output else int(last_hidden_size * depth_multiplier      )
         __a				     =    classifier_dropout_prob
         __a				     =    use_labels
         __a				     =    is_training
         __a				     =    num_labels
         __a				     =    initializer_range
         __a				     =    scope




      def  __UpperCamelCase							(  self      )							->Optional[Any]:



         '''simple docstring'''
         __a				     =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

         __a				     =    self.get_config()

         return config, pixel_values, labels, pixel_labels




      def  __UpperCamelCase							(  self      )							->Dict:



         '''simple docstring'''
         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 ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )							->Tuple:



         '''simple docstring'''
         __a				     =    MobileNetVaModel(config=lowerCamelCase      )
         model.to(lowerCamelCase      )
         model.eval()
         __a				     =    model(lowerCamelCase      )
         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 ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )							->Dict:



         '''simple docstring'''
         __a				     =    self.num_labels
         __a				     =    MobileNetVaForImageClassification(lowerCamelCase      )
         model.to(lowerCamelCase      )
         model.eval()
         __a				     =    model(lowerCamelCase ,   labels=lowerCamelCase      )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.num_labels)      )




      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )							->Optional[int]:



         '''simple docstring'''
         __a				     =    self.num_labels
         __a				     =    MobileNetVaForSemanticSegmentation(lowerCamelCase      )
         model.to(lowerCamelCase      )
         model.eval()
         __a				     =    model(lowerCamelCase      )
         self.parent.assertEqual(
             result.logits.shape ,   (
                 self.batch_size,
                 self.num_labels,
                 self.image_size // self.output_stride,
                 self.image_size // self.output_stride,
             ) ,   )
         __a				     =    model(lowerCamelCase ,   labels=lowerCamelCase      )
         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      )							->Any:



         '''simple docstring'''
         __a				     =    self.prepare_config_and_inputs()
         __a     ,			__a     ,			__a     ,			__a				     =    config_and_inputs
         __a				     =    {'pixel_values': pixel_values}
         return config, inputs_dict







@require_torch
class 							__SCREAMING_SNAKE_CASE       (							_lowerCAmelCase      ,      _lowerCAmelCase      ,      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      )							->List[Any]:



         '''simple docstring'''
         __a				     =    MobileNetVaModelTester(self      )
         __a				     =    MobileNetVaConfigTester(self ,   config_class=lowerCamelCase ,   has_text_modality=lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->str:



         '''simple docstring'''
         self.config_tester.run_common_tests()




      @unittest.skip(reason='MobileNetV2 does not use inputs_embeds'      )
      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         pass




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



         '''simple docstring'''
         pass




      @unittest.skip(reason='MobileNetV2 does not output attentions'      )
      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         pass




      def  __UpperCamelCase							(  self      )							->str:



         '''simple docstring'''
         __a     ,			__a				     =    self.model_tester.prepare_config_and_inputs_for_common()

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

            __a				     =    ['pixel_values']
            self.assertListEqual(arg_names[:1] ,   lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->Optional[Any]:



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->Dict:



         '''simple docstring'''
         def check_hidden_states_output(lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      ):
            __a				     =    model_class(lowerCamelCase      )
            model.to(lowerCamelCase      )
            model.eval()

            with torch.no_grad():
               __a				     =    model(**self._prepare_for_class(lowerCamelCase ,   lowerCamelCase      )      )

            __a				     =    outputs.hidden_states

            __a				     =    16
            self.assertEqual(len(lowerCamelCase      ) ,   lowerCamelCase      )

         __a     ,			__a				     =    self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            __a				     =    True
            check_hidden_states_output(lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )

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

            check_hidden_states_output(lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->Union[str, Any]:



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*lowerCamelCase      )




      def  __UpperCamelCase							(  self      )							->List[str]:



         '''simple docstring'''
         __a				     =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase      )






      @slow
      def  __UpperCamelCase							(  self      )							->Optional[Any]:



         '''simple docstring'''
         for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __a				     =    MobileNetVaModel.from_pretrained(lowerCamelCase      )
            self.assertIsNotNone(lowerCamelCase      )







def    __UpperCAmelCase	(				)  ->			Union[str, Any]:

   """simple docstring"""
   __a				     =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
   return image



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




      @cached_property
      def  __UpperCamelCase							(  self      )							->Optional[Any]:



         '''simple docstring'''
         return (
             MobileNetVaImageProcessor.from_pretrained('google/mobilenet_v2_1.0_224'      ) if is_vision_available() else None
         )




      @slow
      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         __a				     =    MobileNetVaForImageClassification.from_pretrained('google/mobilenet_v2_1.0_224'      ).to(lowerCamelCase      )

         __a				     =    self.default_image_processor
         __a				     =    prepare_img()
         __a				     =    image_processor(images=lowerCamelCase ,   return_tensors='pt'      ).to(lowerCamelCase      )

         # forward pass
         with torch.no_grad():
            __a				     =    model(**lowerCamelCase      )

         # verify the logits
         __a				     =    torch.Size((1, 1001)      )
         self.assertEqual(outputs.logits.shape ,   lowerCamelCase      )

         __a				     =    torch.tensor([0.2445, -1.1993, 0.1905]      ).to(lowerCamelCase      )

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






      @slow
      def  __UpperCamelCase							(  self      )							->int:



         '''simple docstring'''
         __a				     =    MobileNetVaForSemanticSegmentation.from_pretrained('google/deeplabv3_mobilenet_v2_1.0_513'      )
         __a				     =    model.to(lowerCamelCase      )

         __a				     =    MobileNetVaImageProcessor.from_pretrained('google/deeplabv3_mobilenet_v2_1.0_513'      )

         __a				     =    prepare_img()
         __a				     =    image_processor(images=lowerCamelCase ,   return_tensors='pt'      ).to(lowerCamelCase      )

         # forward pass
         with torch.no_grad():
            __a				     =    model(**lowerCamelCase      )
         __a				     =    outputs.logits

         # verify the logits
         __a				     =    torch.Size((1, 21, 65, 65)      )
         self.assertEqual(logits.shape ,   lowerCamelCase      )

         __a				     =    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=lowerCamelCase ,   )

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