


'''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 						_lowerCamelCase					(    snake_case_				):




 '''simple docstring'''


 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Dict       =			self.config_class(**self.inputs_dict						)
  self.parent.assertTrue(hasattr(__lowercase      ,      'hidden_sizes'						)						)
  self.parent.assertTrue(hasattr(__lowercase      ,      'num_attention_heads'						)						)


class 						_lowerCamelCase					:




 '''simple docstring'''


 def __init__(      self      ,      __lowercase      ,      __lowercase=13      ,      __lowercase=64      ,      __lowercase=3      ,      __lowercase=3      ,      __lowercase=2      ,      __lowercase=1      ,      __lowercase=16      ,      __lowercase=[128, 256, 384]      ,      __lowercase=[4, 6, 8]      ,      __lowercase=[2, 3, 4]      ,      __lowercase=[16, 16, 16]      ,      __lowercase=0      ,      __lowercase=[2, 2, 2]      ,      __lowercase=[2, 2, 2]      ,      __lowercase=0.0_2      ,      __lowercase=True      ,      __lowercase=True      ,      __lowercase=2      ,      ):

  """simple docstring"""







  __A  :		Union[str, Any]       =			parent
  __A  :		Dict       =			batch_size
  __A  :		List[str]       =			image_size
  __A  :		Tuple       =			num_channels
  __A  :		str       =			kernel_size
  __A  :		List[Any]       =			stride
  __A  :		Tuple       =			padding
  __A  :		str       =			hidden_sizes
  __A  :		Union[str, Any]       =			num_attention_heads
  __A  :		List[str]       =			depths
  __A  :		Tuple       =			key_dim
  __A  :		List[Any]       =			drop_path_rate
  __A  :		int       =			patch_size
  __A  :		Any       =			attention_ratio
  __A  :		Optional[Any]       =			mlp_ratio
  __A  :		Dict       =			initializer_range
  __A  :		Union[str, Any]       =			[
      ['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  :		Optional[int]       =			is_training
  __A  :		Optional[Any]       =			use_labels
  __A  :		Tuple       =			num_labels
  __A  :		Union[str, Any]       =			initializer_range


 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Dict       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

  __A  :		str       =			None
  if self.use_labels:
   __A  :		int       =			ids_tensor([self.batch_size]      ,      self.num_labels						)

  __A  :		int       =			self.get_config()
  return config, pixel_values, labels


 def  snake_case__   (      self						):

  """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  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase						):

  """simple docstring"""







  __A  :		str       =			LevitModel(config=__lowercase						)
  model.to(__lowercase						)
  model.eval()
  __A  :		Optional[int]       =			model(__lowercase						)
  __A  :		List[str]       =			(self.image_size, self.image_size)
  __A     ,__A  :		Dict       =			image_size[0], image_size[1]
  for _ in range(4						):
   __A  :		Any       =			floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
   __A  :		Dict       =			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  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase						):

  """simple docstring"""







  __A  :		str       =			self.num_labels
  __A  :		Dict       =			LevitForImageClassification(__lowercase						)
  model.to(__lowercase						)
  model.eval()
  __A  :		Optional[int]       =			model(__lowercase      ,      labels=__lowercase						)
  self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.num_labels)						)







 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Optional[Any]       =			self.prepare_config_and_inputs()
  __A     ,__A     ,__A  :		List[str]       =			config_and_inputs
  __A  :		Tuple       =			{'pixel_values': pixel_values}
  return config, inputs_dict


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




 '''simple docstring'''
 __lowercase				:		List[Any]    							=						(
     (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
     if is_torch_available()
     else ()
 )
 __lowercase				:		Any    							=						(
     {
         '''feature-extraction''': LevitModel,
         '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
     }
     if is_torch_available()
     else {}
 )

 __lowercase				:		str    							=						False
 __lowercase				:		Optional[Any]    							=						False
 __lowercase				:		Tuple    							=						False
 __lowercase				:		Any    							=						False
 __lowercase				:		Dict    							=						False


 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Tuple       =			LevitModelTester(self						)
  __A  :		str       =			ConfigTester(self      ,      config_class=__lowercase      ,      has_text_modality=__lowercase      ,      hidden_size=37						)


 def  snake_case__   (      self						):

  """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  snake_case__   (      self						):

  """simple docstring"""







  return


 @unittest.skip(reason='Levit does not use inputs_embeds'						)
 def  snake_case__   (      self						):

  """simple docstring"""







  pass


 @unittest.skip(reason='Levit does not support input and output embeddings'						)
 def  snake_case__   (      self						):

  """simple docstring"""







  pass


 @unittest.skip(reason='Levit does not output attentions'						)
 def  snake_case__   (      self						):

  """simple docstring"""







  pass


 def  snake_case__   (      self						):

  """simple docstring"""







  __A     ,__A  :		Optional[int]       =			self.model_tester.prepare_config_and_inputs_for_common()

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

   __A  :		str       =			['pixel_values']
   self.assertListEqual(arg_names[:1]      ,      __lowercase						)


 def  snake_case__   (      self						):

  """simple docstring"""







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

   with torch.no_grad():
    __A  :		Any       =			model(**self._prepare_for_class(__lowercase      ,      __lowercase						)						)

   __A  :		Any       =			outputs.hidden_states

   __A  :		Optional[Any]       =			len(self.model_tester.depths						) + 1
   self.assertEqual(len(__lowercase						)      ,      __lowercase						)

   __A  :		Union[str, Any]       =			(self.model_tester.image_size, self.model_tester.image_size)
   __A     ,__A  :		Union[str, Any]       =			image_size[0], image_size[1]
   for _ in range(4						):
    __A  :		List[Any]       =			floor(
        (
            (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
            / self.model_tester.stride
        )
        + 1						)
    __A  :		List[Any]       =			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  :		Any       =			self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   __A  :		Optional[Any]       =			True
   check_hidden_states_output(__lowercase      ,      __lowercase      ,      __lowercase						)

   # check that output_hidden_states also work using config
   del inputs_dict["output_hidden_states"]
   __A  :		Optional[Any]       =			True

   check_hidden_states_output(__lowercase      ,      __lowercase      ,      __lowercase						)


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

  """simple docstring"""







  pass


 def  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase=False						):

  """simple docstring"""







  __A  :		Optional[int]       =			super()._prepare_for_class(__lowercase      ,      __lowercase      ,      return_labels=__lowercase						)

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

  return inputs_dict


 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		List[str]       =			self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*__lowercase						)


 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		List[Any]       =			self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_image_classification(*__lowercase						)


 def  snake_case__   (      self						):

  """simple docstring"""







  if not self.model_tester.is_training:
   return

  __A     ,__A  :		Optional[int]       =			self.model_tester.prepare_config_and_inputs_for_common()
  __A  :		List[Any]       =			True

  for model_class in self.all_model_classes:
   # LevitForImageClassificationWithTeacher supports inference-only
   if (
       model_class in get_values(__lowercase						)
       or model_class.__name__ == "LevitForImageClassificationWithTeacher"
   ):
    continue
   __A  :		List[str]       =			model_class(__lowercase						)
   model.to(__lowercase						)
   model.train()
   __A  :		Union[str, Any]       =			self._prepare_for_class(__lowercase      ,      __lowercase      ,      return_labels=__lowercase						)
   __A  :		List[str]       =			model(**__lowercase						).loss
   loss.backward()


 def  snake_case__   (      self						):

  """simple docstring"""







  __A     ,__A  :		List[str]       =			self.model_tester.prepare_config_and_inputs_for_common()
  if not self.model_tester.is_training:
   return

  __A  :		Optional[Any]       =			False
  __A  :		Tuple       =			True

  for model_class in self.all_model_classes:
   if model_class in get_values(__lowercase						) or not model_class.supports_gradient_checkpointing:
    continue
   # LevitForImageClassificationWithTeacher supports inference-only
   if model_class.__name__ == "LevitForImageClassificationWithTeacher":
    continue
   __A  :		List[str]       =			model_class(__lowercase						)
   model.gradient_checkpointing_enable()
   model.to(__lowercase						)
   model.train()
   __A  :		Optional[Any]       =			self._prepare_for_class(__lowercase      ,      __lowercase      ,      return_labels=__lowercase						)
   __A  :		Optional[Any]       =			model(**__lowercase						).loss
   loss.backward()


 def  snake_case__   (      self						):

  """simple docstring"""







  __A     ,__A  :		List[Any]       =			self.model_tester.prepare_config_and_inputs_for_common()

  __A  :		Union[str, Any]       =			[
      {'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(__lowercase						),
       ]
       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  :		Dict       =			problem_type['title']
     __A  :		List[str]       =			problem_type['num_labels']

     __A  :		int       =			model_class(__lowercase						)
     model.to(__lowercase						)
     model.train()

     __A  :		Tuple       =			self._prepare_for_class(__lowercase      ,      __lowercase      ,      return_labels=__lowercase						)

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

     __A  :		Union[str, Any]       =			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=__lowercase						) as warning_list:
      __A  :		int       =			model(**__lowercase						).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  snake_case__   (      self						):

  """simple docstring"""







  for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
   __A  :		Dict       =			LevitModel.from_pretrained(__lowercase						)
   self.assertIsNotNone(__lowercase						)


def 			_lowercase       (				):
 __A  :		Optional[Any]       =			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
 return image


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




 '''simple docstring'''


 @cached_property
 def  snake_case__   (      self						):

  """simple docstring"""







  return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)







 @slow
 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Tuple       =			LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
      __lowercase						)

  __A  :		Union[str, Any]       =			self.default_image_processor
  __A  :		List[Any]       =			prepare_img()
  __A  :		List[str]       =			image_processor(images=__lowercase      ,      return_tensors='pt'						).to(__lowercase						)

  # forward pass
  with torch.no_grad():
   __A  :		Any       =			model(**__lowercase						)

  # verify the logits
  __A  :		List[str]       =			torch.Size((1, 1_000)						)
  self.assertEqual(outputs.logits.shape      ,      __lowercase						)

  __A  :		Tuple       =			torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]						).to(__lowercase						)

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










'''simple docstring'''
from collections import defaultdict
from math import ceil, sqrt


def 			_lowercase       (				UpperCamelCase__       :					int = 1000000,				UpperCamelCase__       :					int = 10			):
 __A  :		defaultdict       =			defaultdict(UpperCamelCase__			)

 for outer_width in range(3,				(t_limit // 4) + 2			):
  if outer_width * outer_width > t_limit:
   __A  :		Optional[int]       =			max(
       ceil(sqrt(outer_width * outer_width - t_limit			)			),				1			)
  else:
   __A  :		Optional[Any]       =			1

  hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

  for hole_width in range(UpperCamelCase__,				outer_width - 1,				2			):
   count[outer_width * outer_width - hole_width * hole_width] += 1

 return sum(1 for n in count.values() if 1 <= n <= 10			)


if __name__ == "__main__":
 print(f'''{solution() = }''')






