

"""simple docstring"""



import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
     MODEL_MAPPING,
     LevitForImageClassification,
     LevitForImageClassificationWithTeacher,
     LevitModel,
 )
 from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import LevitImageProcessor



class 					a						(       _lowerCamelCase				):



    """simple docstring"""



    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         A__										=  self.config_class(**self.inputs_dict       )
         self.parent.assertTrue(hasattr(UpperCamelCase    ,						"""hidden_sizes"""       )       )
         self.parent.assertTrue(hasattr(UpperCamelCase    ,						"""num_attention_heads"""       )       )



class 					a						:



    """simple docstring"""



    def __init__(     self: int    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: Any=13    ,						UpperCamelCase: Union[str, Any]=64    ,						UpperCamelCase: str=3    ,						UpperCamelCase: str=3    ,						UpperCamelCase: List[str]=2    ,						UpperCamelCase: List[Any]=1    ,						UpperCamelCase: Tuple=16    ,						UpperCamelCase: Dict=[1_28, 2_56, 3_84]    ,						UpperCamelCase: Optional[Any]=[4, 6, 8]    ,						UpperCamelCase: Any=[2, 3, 4]    ,						UpperCamelCase: Union[str, Any]=[16, 16, 16]    ,						UpperCamelCase: Any=0    ,						UpperCamelCase: List[str]=[2, 2, 2]    ,						UpperCamelCase: Optional[Any]=[2, 2, 2]    ,						UpperCamelCase: int=0.02    ,						UpperCamelCase: Any=True    ,						UpperCamelCase: List[Any]=True    ,						UpperCamelCase: Tuple=2    ,						):






         """simple docstring"""


         A__										=  parent
         A__										=  batch_size
         A__										=  image_size
         A__										=  num_channels
         A__										=  kernel_size
         A__										=  stride
         A__										=  padding
         A__										=  hidden_sizes
         A__										=  num_attention_heads
         A__										=  depths
         A__										=  key_dim
         A__										=  drop_path_rate
         A__										=  patch_size
         A__										=  attention_ratio
         A__										=  mlp_ratio
         A__										=  initializer_range
         A__										=  [
             ["""Subsample""", key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
             ["""Subsample""", key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
         ]
         A__										=  is_training
         A__										=  use_labels
         A__										=  num_labels
         A__										=  initializer_range

    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         A__										=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

         A__										=  self.get_config()
         return config, pixel_values, labels

    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


         return LevitConfig(
             image_size=self.image_size    ,						num_channels=self.num_channels    ,						kernel_size=self.kernel_size    ,						stride=self.stride    ,						padding=self.padding    ,						patch_size=self.patch_size    ,						hidden_sizes=self.hidden_sizes    ,						num_attention_heads=self.num_attention_heads    ,						depths=self.depths    ,						key_dim=self.key_dim    ,						drop_path_rate=self.drop_path_rate    ,						mlp_ratio=self.mlp_ratio    ,						attention_ratio=self.attention_ratio    ,						initializer_range=self.initializer_range    ,						down_ops=self.down_ops    ,						)

    def 				UpperCamelCase	(     self: List[str]    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: List[Any]    ,						UpperCamelCase: str       ):






         """simple docstring"""


         A__										=  LevitModel(config=UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()
         A__										=  model(UpperCamelCase       )
         A__										=  (self.image_size, self.image_size)
         A__			,				A__										=  image_size[0], image_size[1]
         for _ in range(4       ):
              A__										=  floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1       )
              A__										=  floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1       )
         self.parent.assertEqual(
             result.last_hidden_state.shape    ,						(self.batch_size, ceil(height / 4       ) * ceil(width / 4       ), self.hidden_sizes[-1])    ,						)

    def 				UpperCamelCase	(     self: Dict    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: str    ,						UpperCamelCase: Any       ):






         """simple docstring"""


         A__										=  self.num_labels
         A__										=  LevitForImageClassification(UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()
         A__										=  model(UpperCamelCase    ,						labels=UpperCamelCase       )
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.num_labels)       )





    def 				UpperCamelCase	(     self: int       ):






         """simple docstring"""


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



@require_torch
class 					a						(       _lowerCamelCase,	_lowerCamelCase,	unittest.TestCase				):



    """simple docstring"""



    UpperCAmelCase						 =					(
        (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
        if is_torch_available()
        else ()
    )
    UpperCAmelCase						 =					(
        {
            "feature-extraction": LevitModel,
            "image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
        }
        if is_torch_available()
        else {}
    )

    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False

    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         A__										=  LevitModelTester(self       )
         A__										=  ConfigTester(self    ,						config_class=UpperCamelCase    ,						has_text_modality=UpperCamelCase    ,						hidden_size=37       )

    def 				UpperCamelCase	(     self: List[Any]       ):






         """simple docstring"""


         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()

    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         return

    @unittest.skip(reason="""Levit does not use inputs_embeds"""       )
    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


         pass

    @unittest.skip(reason="""Levit does not support input and output embeddings"""       )
    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         pass

    @unittest.skip(reason="""Levit does not output attentions"""       )
    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         pass

    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
              A__										=  model_class(UpperCamelCase       )
              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]    ,						UpperCamelCase       )

    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


         def check_hidden_states_output(UpperCamelCase: Dict    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Tuple       ):
              A__										=  model_class(UpperCamelCase       )
              model.to(UpperCamelCase       )
              model.eval()

              with torch.no_grad():
                   A__										=  model(**self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )

              A__										=  outputs.hidden_states

              A__										=  len(self.model_tester.depths       ) + 1
              self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

              A__										=  (self.model_tester.image_size, self.model_tester.image_size)
              A__			,				A__										=  image_size[0], image_size[1]
              for _ in range(4       ):
                   A__										=  floor(
                       (
                           (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                           / self.model_tester.stride
                       )
                       + 1       )
                   A__										=  floor(
                       (
                           (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                           / self.model_tester.stride
                       )
                       + 1       )
              # verify the first hidden states (first block)
              self.assertListEqual(
                  list(hidden_states[0].shape[-2:]       )    ,						[
                      height * width,
                      self.model_tester.hidden_sizes[0],
                  ]    ,						)

         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(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase       )

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

              check_hidden_states_output(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase       )

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






         """simple docstring"""


         pass

    def 				UpperCamelCase	(     self: int    ,						UpperCamelCase: Optional[int]    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: str=False       ):






         """simple docstring"""


         A__										=  super()._prepare_for_class(UpperCamelCase    ,						UpperCamelCase    ,						return_labels=UpperCamelCase       )

         if return_labels:
              if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                   del inputs_dict["labels"]

         return inputs_dict

    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         if not self.model_tester.is_training:
              return

         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()
         A__										=  True

         for model_class in self.all_model_classes:
              # LevitForImageClassificationWithTeacher supports inference-only
              if (
                  model_class in get_values(UpperCamelCase       )
                  or model_class.__name__ == "LevitForImageClassificationWithTeacher"
              ):
                   continue
              A__										=  model_class(UpperCamelCase       )
              model.to(UpperCamelCase       )
              model.train()
              A__										=  self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase    ,						return_labels=UpperCamelCase       )
              A__										=  model(**UpperCamelCase       ).loss
              loss.backward()

    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()
         if not self.model_tester.is_training:
              return

         A__										=  False
         A__										=  True

         for model_class in self.all_model_classes:
              if model_class in get_values(UpperCamelCase       ) or not model_class.supports_gradient_checkpointing:
                   continue
              # LevitForImageClassificationWithTeacher supports inference-only
              if model_class.__name__ == "LevitForImageClassificationWithTeacher":
                   continue
              A__										=  model_class(UpperCamelCase       )
              model.gradient_checkpointing_enable()
              model.to(UpperCamelCase       )
              model.train()
              A__										=  self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase    ,						return_labels=UpperCamelCase       )
              A__										=  model(**UpperCamelCase       ).loss
              loss.backward()

    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()

         A__										=  [
             {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
             {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
             {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
         ]

         for model_class in self.all_model_classes:
              if (
                  model_class
                  not in [
                      *get_values(UpperCamelCase       ),
                  ]
                  or model_class.__name__ == "LevitForImageClassificationWithTeacher"
              ):
                   continue

              for problem_type in problem_types:
                   with self.subTest(msg=f"""Testing {model_class} with {problem_type['title']}"""       ):
                        A__										=  problem_type["""title"""]
                        A__										=  problem_type["""num_labels"""]

                        A__										=  model_class(UpperCamelCase       )
                        model.to(UpperCamelCase       )
                        model.train()

                        A__										=  self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase    ,						return_labels=UpperCamelCase       )

                        if problem_type["num_labels"] > 1:
                             A__										=  inputs["""labels"""].unsqueeze(1       ).repeat(1    ,						problem_type["""num_labels"""]       )

                        A__										=  inputs["""labels"""].to(problem_type["""dtype"""]       )

                        # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
                        # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
                        # they have the same size." which is a symptom something in wrong for the regression problem.
                        # See https://github.com/huggingface/transformers/issues/11780
                        with warnings.catch_warnings(record=UpperCamelCase       ) as warning_list:
                             A__										=  model(**UpperCamelCase       ).loss
                        for w in warning_list:
                             if "Using a target size that is different to the input size" in str(w.message       ):
                                  raise ValueError(
                                      f"""Something is going wrong in the regression problem: intercepted {w.message}"""       )

                        loss.backward()





    @slow
    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              A__										=  LevitModel.from_pretrained(UpperCamelCase       )
              self.assertIsNotNone(UpperCamelCase       )





def  _snake_case     (    ):
     A__										=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
     return image



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



    """simple docstring"""



    @cached_property
    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )





    @slow
    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


         A__										=  LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       ).to(
             UpperCamelCase       )

         A__										=  self.default_image_processor
         A__										=  prepare_img()
         A__										=  image_processor(images=UpperCamelCase    ,						return_tensors="""pt"""       ).to(UpperCamelCase       )

         # forward pass
         with torch.no_grad():
              A__										=  model(**UpperCamelCase       )

         # verify the logits
         A__										=  torch.Size((1, 10_00)       )
         self.assertEqual(outputs.logits.shape    ,						UpperCamelCase       )

         A__										=  torch.tensor([1.0_448, -0.3_745, -1.8_317]       ).to(UpperCamelCase       )

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









"""simple docstring"""



def  _snake_case     (    UpperCAmelCase_  :					int			):
     A__										=  generate_pascal_triangle(UpperCAmelCase_			)
     for row_idx in range(UpperCAmelCase_			):
          # Print left spaces
          for _ in range(num_rows - row_idx - 1			):
               print(end=""" """			)
          # Print row values
          for col_idx in range(row_idx + 1			):
               if col_idx != row_idx:
                    print(triangle[row_idx][col_idx]					,   end=""" """			)
               else:
                    print(triangle[row_idx][col_idx]					,   end=""""""			)
          print()





def  _snake_case     (    UpperCAmelCase_  :					int			):

     if not isinstance(UpperCAmelCase_					,   UpperCAmelCase_			):
          raise TypeError("""The input value of 'num_rows' should be 'int'"""			)

     if num_rows == 0:
          return []
     elif num_rows < 0:
          raise ValueError(
              """The input value of 'num_rows' should be greater than or equal to 0"""			)

     A__										=  []
     for current_row_idx in range(UpperCAmelCase_			):
          A__										=  populate_current_row(UpperCAmelCase_					,   UpperCAmelCase_			)
          triangle.append(UpperCAmelCase_			)
     return triangle





def  _snake_case     (    UpperCAmelCase_  :					list[list[int]]					,   UpperCAmelCase_  :					int			):
     A__										=  [-1] * (current_row_idx + 1)
     # first and last elements of current row are equal to 1
     A__			,				A__										=  1, 1
     for current_col_idx in range(1					,   UpperCAmelCase_			):
          calculate_current_element(
              UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_			)
     return current_row





def  _snake_case     (    UpperCAmelCase_  :					list[list[int]]					,   UpperCAmelCase_  :					list[int]					,   UpperCAmelCase_  :					int					,   UpperCAmelCase_  :					int					,   ):
     A__										=  triangle[current_row_idx - 1][current_col_idx - 1]
     A__										=  triangle[current_row_idx - 1][current_col_idx]
     A__										=  above_to_left_elt + above_to_right_elt





def  _snake_case     (    UpperCAmelCase_  :					int			):

     if not isinstance(UpperCAmelCase_					,   UpperCAmelCase_			):
          raise TypeError("""The input value of 'num_rows' should be 'int'"""			)

     if num_rows == 0:
          return []
     elif num_rows < 0:
          raise ValueError(
              """The input value of 'num_rows' should be greater than or equal to 0"""			)

     A__										=  [[1]]

     for row_index in range(1					,   UpperCAmelCase_			):
          A__										=  [0] + result[-1] + [0]
          A__										=  row_index + 1
          # Calculate the number of distinct elements in a row
          A__										=  sum(divmod(UpperCAmelCase_					,   2			)			)
          A__										=  [
              temp_row[i - 1] + temp_row[i] for i in range(1					,   distinct_elements + 1			)
          ]
          A__										=  row_first_half[: (row_index + 1) // 2]
          row_second_half.reverse()
          A__										=  row_first_half + row_second_half
          result.append(UpperCAmelCase_			)

     return result





def  _snake_case     (    ):
     from collections.abc import Callable
     from timeit import timeit

     def benchmark_a_function(UpperCAmelCase_  :					Callable					,   UpperCAmelCase_  :					int			) -> None:
          A__										=  F"""{func.__name__}({value})"""
          A__										=  timeit(F"""__main__.{call}"""					,   setup="""import __main__"""			)
          # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
          print(F"""{call:38} -- {timing:.4f} seconds"""			)

     for value in range(15			):  # (1, 7, 14):
          for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
               benchmark_a_function(UpperCAmelCase_					,   UpperCAmelCase_			)
          print()


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 benchmark()






