

"""simple docstring"""

import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
_UpperCamelCase		     =    sys.version_info >= (3, 1_0)



def       SCREAMING_SNAKE_CASE							( lowercase__=None					,					lowercase__=None   )			->						List[Any]:
 return field(default_factory=lambda: default					,					metadata=lowercase__   )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      int
       __UpperCamelCase					:      float
       __UpperCamelCase					:      str
       __UpperCamelCase					:      bool






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      int    =						42
       __UpperCamelCase					:      str    =						field(default='toto'       ,	metadata={'help': 'help message'}       )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      bool    =						False
       __UpperCamelCase					:      bool    =						True
       __UpperCamelCase					:      Optional[bool]    =						None






class 			__a					(						__magic_name__       ):





       """simple docstring"""


       __UpperCamelCase					:      List[str]    =						'titi'
       __UpperCamelCase					:      Tuple    =						'toto'






class 			__a					(						__magic_name__       ):





       """simple docstring"""


       __UpperCamelCase					:      Tuple    =						'titi'
       __UpperCamelCase					:      List[Any]    =						'toto'
       __UpperCamelCase					:      List[str]    =						42






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      BasicEnum    =						"toto"






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[int] 			=				BasicEnum(self.foo   )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      MixedTypeEnum    =						"toto"






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				List[str] 			=				MixedTypeEnum(self.foo   )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      Optional[int]    =						None
       __UpperCamelCase					:      Optional[float]    =						field(default=__magic_name__       ,	metadata={'help': 'help message'}       )
       __UpperCamelCase					:      Optional[str]    =						None
       __UpperCamelCase					:      Optional[List[str]]    =						list_field(default=[]       )
       __UpperCamelCase					:      Optional[List[int]]    =						list_field(default=[]       )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      List[int]    =						list_field(default=[]       )
       __UpperCamelCase					:      List[int]    =						list_field(default=[1, 2, 3]       )
       __UpperCamelCase					:      List[str]    =						list_field(default=['Hallo', 'Bonjour', 'Hello']       )
       __UpperCamelCase					:      List[float]    =						list_field(default=[0.1, 0.2, 0.3]       )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      List[int]    =						field()
       __UpperCamelCase					:      str    =						field()
       __UpperCamelCase					:      BasicEnum    =						field()






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[Any] 			=				BasicEnum(self.required_enum   )






@dataclass
class 			__a					:





       """simple docstring"""


       __UpperCamelCase					:      int
       __UpperCamelCase					:      "BasicEnum"    =						field()
       __UpperCamelCase					:      "Optional[bool]"    =						None
       __UpperCamelCase					:      "str"    =						field(default='toto'       ,	metadata={'help': 'help message'}       )
       __UpperCamelCase					:      "List[str]"    =						list_field(default=['Hallo', 'Bonjour', 'Hello']       )


if is_python_no_less_than_3_10:






    @dataclass
    class 			__a					:





           """simple docstring"""


           __UpperCamelCase					:      bool    =						False
           __UpperCamelCase					:      bool    =						True
           __UpperCamelCase					:      bool | None    =						None






    @dataclass
    class 			__a					:





           """simple docstring"""


           __UpperCamelCase					:      int | None    =						None
           __UpperCamelCase					:      float | None    =						field(default=__magic_name__       ,	metadata={'help': 'help message'}       )
           __UpperCamelCase					:      str | None    =						None
           __UpperCamelCase					:      list[str] | None    =						list_field(default=[]       )
           __UpperCamelCase					:      list[int] | None    =						list_field(default=[]       )






class 			__a					(						unittest.TestCase       ):





       """simple docstring"""


       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case			,					snake_case   ):





        """simple docstring"""

        self.assertEqual(len(a._actions   )			,					len(b._actions   )   )
        for x, y in zip(a._actions			,					b._actions   ):
         lowerCAmelCase__   :				Union[str, Any] 			=				{k: v for k, v in vars(snake_case   ).items() if k != "container"}
         lowerCAmelCase__   :				Union[str, Any] 			=				{k: v for k, v in vars(snake_case   ).items() if k != "container"}

         # Choices with mixed type have custom function as "type"
         # So we need to compare results directly for equality
         if xx.get("choices"			,					snake_case   ) and yy.get("choices"			,					snake_case   ):
          for expected_choice in yy["choices"] + xx["choices"]:
           self.assertEqual(xx["type"](snake_case   )			,					yy["type"](snake_case   )   )
          del xx["type"], yy["type"]

         self.assertEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Optional[int] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument("--bar"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument("--baz"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument("--flag"			,					type=snake_case			,					default=snake_case			,					const=snake_case			,					nargs="?"   )
        self.argparsersEqual(snake_case			,					snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				["--foo", "1", "--baz", "quux", "--bar", "0.5"]
        ((lowerCAmelCase__)			,						)   :				Dict 			=				parser.parse_args_into_dataclasses(snake_case			,					look_for_args_file=snake_case   )
        self.assertFalse(example.flag   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Tuple 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Optional[int] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo"			,					default=42			,					type=snake_case   )
        expected.add_argument("--baz"			,					default="toto"			,					type=snake_case			,					help="help message"   )
        self.argparsersEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[Any] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo"			,					type=snake_case			,					default=snake_case			,					const=snake_case			,					nargs="?"   )
        expected.add_argument("--baz"			,					type=snake_case			,					default=snake_case			,					const=snake_case			,					nargs="?"   )
        # A boolean no_* argument always has to come after its "default: True" regular counter-part
        # and its default must be set to False
        expected.add_argument("--no_baz"			,					action="store_false"			,					default=snake_case			,					dest="baz"   )
        expected.add_argument("--opt"			,					type=snake_case			,					default=snake_case   )

        lowerCAmelCase__   :				Optional[Any] 			=				[WithDefaultBoolExample]
        if is_python_no_less_than_3_10:
         dataclass_types.append(snake_case   )

        for dataclass_type in dataclass_types:
         lowerCAmelCase__   :				Optional[Any] 			=				HfArgumentParser(snake_case   )
         self.argparsersEqual(snake_case			,					snake_case   )

         lowerCAmelCase__   :				Union[str, Any] 			=				parser.parse_args([]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )

         lowerCAmelCase__   :				List[str] 			=				parser.parse_args(["--foo", "--no_baz"]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )

         lowerCAmelCase__   :				Optional[Any] 			=				parser.parse_args(["--foo", "--baz"]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )

         lowerCAmelCase__   :				List[Any] 			=				parser.parse_args(["--foo", "True", "--baz", "True", "--opt", "True"]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )

         lowerCAmelCase__   :				Optional[int] 			=				parser.parse_args(["--foo", "False", "--baz", "False", "--opt", "False"]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					baz=snake_case			,					opt=snake_case   )   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Tuple 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Optional[Any] 			=				argparse.ArgumentParser()
        expected.add_argument(
            "--foo"			,					default="toto"			,					choices=["titi", "toto", 42]			,					type=make_choice_type_function(["titi", "toto", 42]   )			,					)
        self.argparsersEqual(snake_case			,					snake_case   )

        lowerCAmelCase__   :				Union[str, Any] 			=				parser.parse_args([]   )
        self.assertEqual(args.foo			,					"toto"   )
        lowerCAmelCase__   :				List[str] 			=				parser.parse_args_into_dataclasses([]   )[0]
        self.assertEqual(enum_ex.foo			,					MixedTypeEnum.toto   )

        lowerCAmelCase__   :				List[Any] 			=				parser.parse_args(["--foo", "titi"]   )
        self.assertEqual(args.foo			,					"titi"   )
        lowerCAmelCase__   :				Any 			=				parser.parse_args_into_dataclasses(["--foo", "titi"]   )[0]
        self.assertEqual(enum_ex.foo			,					MixedTypeEnum.titi   )

        lowerCAmelCase__   :				Tuple 			=				parser.parse_args(["--foo", "42"]   )
        self.assertEqual(args.foo			,					42   )
        lowerCAmelCase__   :				Tuple 			=				parser.parse_args_into_dataclasses(["--foo", "42"]   )[0]
        self.assertEqual(enum_ex.foo			,					MixedTypeEnum.fourtytwo   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        @dataclass
        class 			__a					:





               """simple docstring"""


               __UpperCamelCase					:      Literal["titi", "toto", 42]    =						"toto"




        lowerCAmelCase__   :				Dict 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Dict 			=				argparse.ArgumentParser()
        expected.add_argument(
            "--foo"			,					default="toto"			,					choices=("titi", "toto", 42)			,					type=make_choice_type_function(["titi", "toto", 42]   )			,					)
        self.argparsersEqual(snake_case			,					snake_case   )

        lowerCAmelCase__   :				int 			=				parser.parse_args([]   )
        self.assertEqual(args.foo			,					"toto"   )

        lowerCAmelCase__   :				Optional[int] 			=				parser.parse_args(["--foo", "titi"]   )
        self.assertEqual(args.foo			,					"titi"   )

        lowerCAmelCase__   :				int 			=				parser.parse_args(["--foo", "42"]   )
        self.assertEqual(args.foo			,					42   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				str 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Union[str, Any] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo_int"			,					nargs="+"			,					default=[]			,					type=snake_case   )
        expected.add_argument("--bar_int"			,					nargs="+"			,					default=[1, 2, 3]			,					type=snake_case   )
        expected.add_argument("--foo_str"			,					nargs="+"			,					default=["Hallo", "Bonjour", "Hello"]			,					type=snake_case   )
        expected.add_argument("--foo_float"			,					nargs="+"			,					default=[0.1, 0.2, 0.3]			,					type=snake_case   )

        self.argparsersEqual(snake_case			,					snake_case   )

        lowerCAmelCase__   :				Tuple 			=				parser.parse_args([]   )
        self.assertEqual(
            snake_case			,					Namespace(foo_int=[]			,					bar_int=[1, 2, 3]			,					foo_str=["Hallo", "Bonjour", "Hello"]			,					foo_float=[0.1, 0.2, 0.3]   )			,					)

        lowerCAmelCase__   :				List[Any] 			=				parser.parse_args("--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7".split()   )
        self.assertEqual(snake_case			,					Namespace(foo_int=[1]			,					bar_int=[2, 3]			,					foo_str=["a", "b", "c"]			,					foo_float=[0.1, 0.7]   )   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Dict 			=				argparse.ArgumentParser()
        expected.add_argument("--foo"			,					default=snake_case			,					type=snake_case   )
        expected.add_argument("--bar"			,					default=snake_case			,					type=snake_case			,					help="help message"   )
        expected.add_argument("--baz"			,					default=snake_case			,					type=snake_case   )
        expected.add_argument("--ces"			,					nargs="+"			,					default=[]			,					type=snake_case   )
        expected.add_argument("--des"			,					nargs="+"			,					default=[]			,					type=snake_case   )

        lowerCAmelCase__   :				Optional[Any] 			=				[OptionalExample]
        if is_python_no_less_than_3_10:
         dataclass_types.append(snake_case   )

        for dataclass_type in dataclass_types:
         lowerCAmelCase__   :				Tuple 			=				HfArgumentParser(snake_case   )

         self.argparsersEqual(snake_case			,					snake_case   )

         lowerCAmelCase__   :				Any 			=				parser.parse_args([]   )
         self.assertEqual(snake_case			,					Namespace(foo=snake_case			,					bar=snake_case			,					baz=snake_case			,					ces=[]			,					des=[]   )   )

         lowerCAmelCase__   :				List[str] 			=				parser.parse_args("--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3".split()   )
         self.assertEqual(snake_case			,					Namespace(foo=12			,					bar=3.14			,					baz="42"			,					ces=["a", "b", "c"]			,					des=[1, 2, 3]   )   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[Any] 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				argparse.ArgumentParser()
        expected.add_argument("--required_list"			,					nargs="+"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument("--required_str"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument(
            "--required_enum"			,					type=make_choice_type_function(["titi", "toto"]   )			,					choices=["titi", "toto"]			,					required=snake_case			,					)
        self.argparsersEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Dict 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Optional[Any] 			=				argparse.ArgumentParser()
        expected.add_argument("--foo"			,					type=snake_case			,					required=snake_case   )
        expected.add_argument(
            "--required_enum"			,					type=make_choice_type_function(["titi", "toto"]   )			,					choices=["titi", "toto"]			,					required=snake_case			,					)
        expected.add_argument("--opt"			,					type=snake_case			,					default=snake_case   )
        expected.add_argument("--baz"			,					default="toto"			,					type=snake_case			,					help="help message"   )
        expected.add_argument("--foo_str"			,					nargs="+"			,					default=["Hallo", "Bonjour", "Hello"]			,					type=snake_case   )
        self.argparsersEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Any 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				{
            "foo": 12,
            "bar": 3.14,
            "baz": "42",
            "flag": True,
        }

        lowerCAmelCase__   :				Tuple 			=				parser.parse_dict(snake_case   )[0]
        lowerCAmelCase__   :				Any 			=				BasicExample(**snake_case   )
        self.assertEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				{
            "foo": 12,
            "bar": 3.14,
            "baz": "42",
            "flag": True,
            "extra": 42,
        }

        self.assertRaises(snake_case			,					parser.parse_dict			,					snake_case			,					allow_extra_keys=snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				Optional[Any] 			=				{
            "foo": 12,
            "bar": 3.14,
            "baz": "42",
            "flag": True,
        }
        with tempfile.TemporaryDirectory() as tmp_dir:
         lowerCAmelCase__   :				int 			=				os.path.join(snake_case			,					"temp_json"   )
         os.mkdir(snake_case   )
         with open(temp_local_path + ".json"			,					"w+"   ) as f:
          json.dump(snake_case			,					snake_case   )
         lowerCAmelCase__   :				Any 			=				parser.parse_yaml_file(Path(temp_local_path + ".json"   )   )[0]

        lowerCAmelCase__   :				str 			=				BasicExample(**snake_case   )
        self.assertEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				str 			=				HfArgumentParser(snake_case   )

        lowerCAmelCase__   :				int 			=				{
            "foo": 12,
            "bar": 3.14,
            "baz": "42",
            "flag": True,
        }
        with tempfile.TemporaryDirectory() as tmp_dir:
         lowerCAmelCase__   :				Optional[Any] 			=				os.path.join(snake_case			,					"temp_yaml"   )
         os.mkdir(snake_case   )
         with open(temp_local_path + ".yaml"			,					"w+"   ) as f:
          yaml.dump(snake_case			,					snake_case   )
         lowerCAmelCase__   :				Dict 			=				parser.parse_yaml_file(Path(temp_local_path + ".yaml"   )   )[0]
        lowerCAmelCase__   :				int 			=				BasicExample(**snake_case   )
        self.assertEqual(snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Union[str, Any] 			=				HfArgumentParser(snake_case   )
        self.assertIsNotNone(snake_case   )









"""simple docstring"""

import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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 MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
    from transformers.models.mobilevitva.modeling_mobilevitva import (
        MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
        make_divisible,
    )


if is_vision_available():
    from PIL import Image

    from transformers import MobileViTImageProcessor






class 			__a					(						__magic_name__       ):





       """simple docstring"""


       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Any 			=				self.config_class(**self.inputs_dict   )
        self.parent.assertTrue(hasattr(snake_case			,					"width_multiplier"   )   )






class 			__a					:





       """simple docstring"""


       def __init__(   self			,					snake_case			,					snake_case=13			,					snake_case=64			,					snake_case=2			,					snake_case=3			,					snake_case="swish"			,					snake_case=3			,					snake_case=32			,					snake_case=0.1			,					snake_case=0.02			,					snake_case=True			,					snake_case=True			,					snake_case=10			,					snake_case=None			,					snake_case=0.25			,					snake_case=0.0			,					snake_case=0.0			,					):





        """simple docstring"""

        lowerCAmelCase__   :				List[Any] 			=				parent
        lowerCAmelCase__   :				Optional[Any] 			=				batch_size
        lowerCAmelCase__   :				Optional[Any] 			=				image_size
        lowerCAmelCase__   :				Tuple 			=				patch_size
        lowerCAmelCase__   :				Any 			=				num_channels
        lowerCAmelCase__   :				Tuple 			=				make_divisible(512 * width_multiplier			,					divisor=8   )
        lowerCAmelCase__   :				str 			=				hidden_act
        lowerCAmelCase__   :				Union[str, Any] 			=				conv_kernel_size
        lowerCAmelCase__   :				List[str] 			=				output_stride
        lowerCAmelCase__   :				List[Any] 			=				classifier_dropout_prob
        lowerCAmelCase__   :				List[Any] 			=				use_labels
        lowerCAmelCase__   :				Tuple 			=				is_training
        lowerCAmelCase__   :				Optional[int] 			=				num_labels
        lowerCAmelCase__   :				int 			=				initializer_range
        lowerCAmelCase__   :				str 			=				scope
        lowerCAmelCase__   :				Optional[Any] 			=				width_multiplier
        lowerCAmelCase__   :				Union[str, Any] 			=				ffn_dropout
        lowerCAmelCase__   :				Tuple 			=				attn_dropout






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				str 			=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

        lowerCAmelCase__   :				Optional[Any] 			=				None
        lowerCAmelCase__   :				List[str] 			=				None
        if self.use_labels:
         lowerCAmelCase__   :				Dict 			=				ids_tensor([self.batch_size]			,					self.num_labels   )
         lowerCAmelCase__   :				Dict 			=				ids_tensor([self.batch_size, self.image_size, self.image_size]			,					self.num_labels   )

        lowerCAmelCase__   :				int 			=				self.get_config()

        return config, pixel_values, labels, pixel_labels






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        return MobileViTVaConfig(
            image_size=self.image_size			,					patch_size=self.patch_size			,					num_channels=self.num_channels			,					hidden_act=self.hidden_act			,					conv_kernel_size=self.conv_kernel_size			,					output_stride=self.output_stride			,					classifier_dropout_prob=self.classifier_dropout_prob			,					initializer_range=self.initializer_range			,					width_multiplier=self.width_multiplier			,					ffn_dropout=self.ffn_dropout_prob			,					attn_dropout=self.attn_dropout_prob			,					)






       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case			,					snake_case			,					snake_case			,					snake_case   ):





        """simple docstring"""

        lowerCAmelCase__   :				Any 			=				MobileViTVaModel(config=snake_case   )
        model.to(snake_case   )
        model.eval()
        lowerCAmelCase__   :				int 			=				model(snake_case   )
        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,
            )			,					)






       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case			,					snake_case			,					snake_case			,					snake_case   ):





        """simple docstring"""

        lowerCAmelCase__   :				Any 			=				self.num_labels
        lowerCAmelCase__   :				Any 			=				MobileViTVaForImageClassification(snake_case   )
        model.to(snake_case   )
        model.eval()
        lowerCAmelCase__   :				int 			=				model(snake_case			,					labels=snake_case   )
        self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.num_labels)   )






       def 			SCREAMING_SNAKE_CASE_	(   self			,					snake_case			,					snake_case			,					snake_case			,					snake_case   ):





        """simple docstring"""

        lowerCAmelCase__   :				List[Any] 			=				self.num_labels
        lowerCAmelCase__   :				Optional[int] 			=				MobileViTVaForSemanticSegmentation(snake_case   )
        model.to(snake_case   )
        model.eval()
        lowerCAmelCase__   :				Any 			=				model(snake_case   )
        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__   :				Tuple 			=				model(snake_case			,					labels=snake_case   )
        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   ):





        """simple docstring"""

        lowerCAmelCase__   :				int 			=				self.prepare_config_and_inputs()
        lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__   :				Any 			=				config_and_inputs
        lowerCAmelCase__   :				int 			=				{"pixel_values": pixel_values}
        return config, inputs_dict






@require_torch
class 			__a					(						__magic_name__       ,	__magic_name__       ,	unittest.TestCase       ):





       """simple docstring"""


       __UpperCamelCase					:      List[Any]    =						(
           (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
           if is_torch_available()
           else ()
       )

       __UpperCamelCase					:      List[Any]    =						(
           {
               'feature-extraction': MobileViTVaModel,
               'image-classification': MobileViTVaForImageClassification,
               'image-segmentation': MobileViTVaForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       __UpperCamelCase					:      str    =						False
       __UpperCamelCase					:      int    =						False
       __UpperCamelCase					:      Tuple    =						False
       __UpperCamelCase					:      List[str]    =						False






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Tuple 			=				MobileViTVaModelTester(self   )
        lowerCAmelCase__   :				List[str] 			=				MobileViTVaConfigTester(self			,					config_class=snake_case			,					has_text_modality=snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        self.config_tester.run_common_tests()






       @unittest.skip(reason="MobileViTV2 does not use inputs_embeds"   )
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        pass






       @unittest.skip(reason="MobileViTV2 does not support input and output embeddings"   )
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        pass






       @unittest.skip(reason="MobileViTV2 does not output attentions"   )
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        pass






       @require_torch_multi_gpu
       @unittest.skip(reason="Got `CUDA error: misaligned address` for tests after this one being run."   )
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        pass






       @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."   )
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        pass






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__			,						lowerCAmelCase__   :				Tuple 			=				self.model_tester.prepare_config_and_inputs_for_common()

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

         lowerCAmelCase__   :				Dict 			=				["pixel_values"]
         self.assertListEqual(arg_names[:1]			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				str 			=				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        def check_hidden_states_output(snake_case			,					snake_case			,					snake_case   ):
         lowerCAmelCase__   :				List[str] 			=				model_class(snake_case   )
         model.to(snake_case   )
         model.eval()

         with torch.no_grad():
          lowerCAmelCase__   :				Optional[int] 			=				model(**self._prepare_for_class(snake_case			,					snake_case   )   )

         lowerCAmelCase__   :				str 			=				outputs.hidden_states

         lowerCAmelCase__   :				List[Any] 			=				5
         self.assertEqual(len(snake_case   )			,					snake_case   )

         # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
         # with the width and height being successively divided by 2.
         lowerCAmelCase__   :				str 			=				2
         for i in range(len(snake_case   )   ):
          self.assertListEqual(
              list(hidden_states[i].shape[-2:]   )			,					[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]			,					)
          divisor *= 2

         self.assertEqual(self.model_tester.output_stride			,					divisor // 2   )

        lowerCAmelCase__			,						lowerCAmelCase__   :				Tuple 			=				self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         lowerCAmelCase__   :				int 			=				True
         check_hidden_states_output(snake_case			,					snake_case			,					snake_case   )

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

         check_hidden_states_output(snake_case			,					snake_case			,					snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				str 			=				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*snake_case   )






       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				str 			=				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_semantic_segmentation(*snake_case   )






       @slow
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCAmelCase__   :				Dict 			=				MobileViTVaModel.from_pretrained(snake_case   )
         self.assertIsNotNone(snake_case   )




def       SCREAMING_SNAKE_CASE							( )			->						Optional[int]:
 lowerCAmelCase__   :				Optional[Any] 			=				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
 return image






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





       """simple docstring"""


       @cached_property
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        return (
            MobileViTImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"   )
            if is_vision_available()
            else None
        )






       @slow
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Dict 			=				MobileViTVaForImageClassification.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"   ).to(
            snake_case   )

        lowerCAmelCase__   :				Union[str, Any] 			=				self.default_image_processor
        lowerCAmelCase__   :				Union[str, Any] 			=				prepare_img()
        lowerCAmelCase__   :				List[str] 			=				image_processor(images=snake_case			,					return_tensors="pt"   ).to(snake_case   )

        # forward pass
        with torch.no_grad():
         lowerCAmelCase__   :				str 			=				model(**snake_case   )

        # verify the logits
        lowerCAmelCase__   :				int 			=				torch.Size((1, 1_000)   )
        self.assertEqual(outputs.logits.shape			,					snake_case   )

        lowerCAmelCase__   :				Optional[int] 			=				torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01]   ).to(snake_case   )

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






       @slow
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				List[str] 			=				MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"   )
        lowerCAmelCase__   :				Tuple 			=				model.to(snake_case   )

        lowerCAmelCase__   :				Optional[Any] 			=				MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"   )

        lowerCAmelCase__   :				Union[str, Any] 			=				prepare_img()
        lowerCAmelCase__   :				str 			=				image_processor(images=snake_case			,					return_tensors="pt"   ).to(snake_case   )

        # forward pass
        with torch.no_grad():
         lowerCAmelCase__   :				Any 			=				model(**snake_case   )
        lowerCAmelCase__   :				List[str] 			=				outputs.logits

        # verify the logits
        lowerCAmelCase__   :				Tuple 			=				torch.Size((1, 21, 32, 32)   )
        self.assertEqual(logits.shape			,					snake_case   )

        lowerCAmelCase__   :				Dict 			=				torch.tensor(
            [
                [[7.0_863, 7.1_525, 6.8_201], [6.6_931, 6.8_770, 6.8_933], [6.2_978, 7.0_366, 6.9_636]],
                [[-3.7_134, -3.6_712, -3.6_675], [-3.5_825, -3.3_549, -3.4_777], [-3.3_435, -3.3_979, -3.2_857]],
                [[-2.9_329, -2.8_003, -2.7_369], [-3.0_564, -2.4_780, -2.0_207], [-2.6_889, -1.9_298, -1.7_640]],
            ]			,					device=snake_case			,					)

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






       @slow
       def 			SCREAMING_SNAKE_CASE_	(   self   ):





        """simple docstring"""

        lowerCAmelCase__   :				Optional[int] 			=				MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"   )
        lowerCAmelCase__   :				List[Any] 			=				model.to(snake_case   )

        lowerCAmelCase__   :				str 			=				MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"   )

        lowerCAmelCase__   :				Optional[int] 			=				prepare_img()
        lowerCAmelCase__   :				List[Any] 			=				image_processor(images=snake_case			,					return_tensors="pt"   ).to(snake_case   )

        # forward pass
        with torch.no_grad():
         lowerCAmelCase__   :				Union[str, Any] 			=				model(**snake_case   )

        lowerCAmelCase__   :				List[Any] 			=				outputs.logits.detach().cpu()

        lowerCAmelCase__   :				Optional[int] 			=				image_processor.post_process_semantic_segmentation(outputs=snake_case			,					target_sizes=[(50, 60)]   )
        lowerCAmelCase__   :				Union[str, Any] 			=				torch.Size((50, 60)   )
        self.assertEqual(segmentation[0].shape			,					snake_case   )

        lowerCAmelCase__   :				Any 			=				image_processor.post_process_semantic_segmentation(outputs=snake_case   )
        lowerCAmelCase__   :				Optional[int] 			=				torch.Size((32, 32)   )
        self.assertEqual(segmentation[0].shape			,					snake_case   )






