



import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_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 torch import nn

   from transformers import ViTForImageClassification, ViTForMaskedImageModeling, ViTModel
   from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import ViTImageProcessor



class      _UpperCAmelCase      :




     def __init__(					self			,    a__			,    a__=1_3			,    a__=3_0			,    a__=2			,    a__=3			,    a__=True			,    a__=True			,    a__=3_2			,    a__=5			,    a__=4			,    a__=3_7			,    a__="gelu"			,    a__=0.1			,    a__=0.1			,    a__=1_0			,    a__=0.0_2			,    a__=None			,    a__=2			,    ):
         A__					=       parent
         A__					=       batch_size
         A__					=       image_size
         A__					=       patch_size
         A__					=       num_channels
         A__					=       is_training
         A__					=       use_labels
         A__					=       hidden_size
         A__					=       num_hidden_layers
         A__					=       num_attention_heads
         A__					=       intermediate_size
         A__					=       hidden_act
         A__					=       hidden_dropout_prob
         A__					=       attention_probs_dropout_prob
         A__					=       type_sequence_label_size
         A__					=       initializer_range
         A__					=       scope
         A__					=       encoder_stride

         # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
         A__					=       (image_size // patch_size) ** 2
         A__					=       num_patches + 1




     def 		snake_case_		(					self):
         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.type_sequence_label_size)

         A__					=       self.get_config()

         return config, pixel_values, labels




     def 		snake_case_		(					self):
         return ViTConfig(
             image_size=self.image_size			,    patch_size=self.patch_size			,    num_channels=self.num_channels			,    hidden_size=self.hidden_size			,    num_hidden_layers=self.num_hidden_layers			,    num_attention_heads=self.num_attention_heads			,    intermediate_size=self.intermediate_size			,    hidden_act=self.hidden_act			,    hidden_dropout_prob=self.hidden_dropout_prob			,    attention_probs_dropout_prob=self.attention_probs_dropout_prob			,    is_decoder=a__			,    initializer_range=self.initializer_range			,    encoder_stride=self.encoder_stride			,    )




     def 		snake_case_		(					self			,    a__			,    a__			,    a__):
         A__					=       ViTModel(config=a__)
         model.to(a__)
         model.eval()
         A__					=       model(a__)
         self.parent.assertEqual(result.last_hidden_state.shape			,    (self.batch_size, self.seq_length, self.hidden_size))




     def 		snake_case_		(					self			,    a__			,    a__			,    a__):
         A__					=       ViTForMaskedImageModeling(config=a__)
         model.to(a__)
         model.eval()
         A__					=       model(a__)
         self.parent.assertEqual(
             result.reconstruction.shape			,    (self.batch_size, self.num_channels, self.image_size, self.image_size))

         # test greyscale images
         A__					=       1
         A__					=       ViTForMaskedImageModeling(a__)
         model.to(a__)
         model.eval()

         A__					=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
         A__					=       model(a__)
         self.parent.assertEqual(result.reconstruction.shape			,    (self.batch_size, 1, self.image_size, self.image_size))




     def 		snake_case_		(					self			,    a__			,    a__			,    a__):
         A__					=       self.type_sequence_label_size
         A__					=       ViTForImageClassification(a__)
         model.to(a__)
         model.eval()
         A__					=       model(a__			,    labels=a__)
         self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.type_sequence_label_size))

         # test greyscale images
         A__					=       1
         A__					=       ViTForImageClassification(a__)
         model.to(a__)
         model.eval()

         A__					=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
         A__					=       model(a__)
         self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.type_sequence_label_size))




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







@require_torch
class      _UpperCAmelCase      (							A__      ,   A__      ,   unittest.TestCase  ):
     UpperCamelCase__		     =					(
         (
             ViTModel,
             ViTForImageClassification,
             ViTForMaskedImageModeling,
         )
         if is_torch_available()
         else ()
     )
     UpperCamelCase__		     =					(
         {'''feature-extraction''': ViTModel, '''image-classification''': ViTForImageClassification}
         if is_torch_available()
         else {}
     )
     UpperCamelCase__		     =					True

     UpperCamelCase__		     =					False
     UpperCamelCase__		     =					False
     UpperCamelCase__		     =					False




     def 		snake_case_		(					self):
         A__					=       ViTModelTester(self)
         A__					=       ConfigTester(self			,    config_class=a__			,    has_text_modality=a__			,    hidden_size=3_7)




     def 		snake_case_		(					self):
         self.config_tester.run_common_tests()




     @unittest.skip(reason='''ViT does not use inputs_embeds''')
     def 		snake_case_		(					self):
         pass




     def 		snake_case_		(					self):
         A__			,						A__					=       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             A__					=       model_class(a__)
             self.assertIsInstance(model.get_input_embeddings()			,    (nn.Module))
             A__					=       model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(a__			,    nn.Linear))




     def 		snake_case_		(					self):
         A__			,						A__					=       self.model_tester.prepare_config_and_inputs_for_common()

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




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a__)




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*a__)




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*a__)




     @slow
     def 		snake_case_		(					self):
         for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             A__					=       ViTModel.from_pretrained(a__)
             self.assertIsNotNone(a__)







def 		lowerCAmelCase__     (       )->	Any:
    A__					=       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
    return image



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




     @cached_property
     def 		snake_case_		(					self):
         return ViTImageProcessor.from_pretrained('''google/vit-base-patch16-224''') if is_vision_available() else None




     @slow
     def 		snake_case_		(					self):
         A__					=       ViTForImageClassification.from_pretrained('''google/vit-base-patch16-224''').to(a__)

         A__					=       self.default_image_processor
         A__					=       prepare_img()
         A__					=       image_processor(images=a__			,    return_tensors='''pt''').to(a__)

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

         # verify the logits
         A__					=       torch.Size((1, 1_0_0_0))
         self.assertEqual(outputs.logits.shape			,    a__)

         A__					=       torch.tensor([-0.2_7_4_4, 0.8_2_1_5, -0.0_8_3_6]).to(a__)

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




     @slow
     def 		snake_case_		(					self):
         # ViT models have an `interpolate_pos_encoding` argument in their forward method,
         # allowing to interpolate the pre-trained position embeddings in order to use
         # the model on higher resolutions. The DINO model by Facebook AI leverages this
         # to visualize self-attention on higher resolution images.
         A__					=       ViTModel.from_pretrained('''facebook/dino-vits8''').to(a__)

         A__					=       ViTImageProcessor.from_pretrained('''facebook/dino-vits8'''			,    size=4_8_0)
         A__					=       prepare_img()
         A__					=       image_processor(images=a__			,    return_tensors='''pt''')
         A__					=       inputs.pixel_values.to(a__)

         # forward pass
         with torch.no_grad():
             A__					=       model(a__			,    interpolate_pos_encoding=a__)

         # verify the logits
         A__					=       torch.Size((1, 3_6_0_1, 3_8_4))
         self.assertEqual(outputs.last_hidden_state.shape			,    a__)

         A__					=       torch.tensor(
             [[4.2_3_4_0, 4.3_9_0_6, -6.6_6_9_2], [4.5_4_6_3, 1.8_9_2_8, -6.7_2_5_7], [4.4_4_2_9, 0.8_4_9_6, -5.8_5_8_5]]).to(a__)

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




     @slow
     @require_accelerate
     @require_torch_gpu
     def 		snake_case_		(					self):
         A__					=       ViTModel.from_pretrained('''facebook/dino-vits8'''			,    torch_dtype=torch.floataa			,    device_map='''auto''')
         A__					=       self.default_image_processor

         A__					=       prepare_img()
         A__					=       image_processor(images=a__			,    return_tensors='''pt''')
         A__					=       inputs.pixel_values.to(a__)

         # forward pass to make sure inference works in fp16
         with torch.no_grad():
             A__					=       model(a__)





_lowercase    	=		[0, 2, 4, 6, 8]
_lowercase    	=		[1, 3, 5, 7, 9]



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int			,							UpperCamelCase_					:							int			,							UpperCamelCase_					:							list[int]			,							UpperCamelCase_					:							int						)->	int:
    if remaining_length == 0:
        if digits[0] == 0 or digits[-1] == 0:
            return 0

        for i in range(length // 2 - 1			,							-1			,							-1						):
            remainder += digits[i] + digits[length - i - 1]

            if remainder % 2 == 0:
                return 0

            remainder //= 1_0

        return 1

    if remaining_length == 1:
        if remainder % 2 == 0:
            return 0

        A__					=       0
        for digit in range(1_0						):
            A__					=       digit
            result += reversible_numbers(
                0			,							(remainder + 2 * digit) // 1_0			,							UpperCamelCase_			,							UpperCamelCase_						)
        return result

    A__					=       0
    for digita in range(1_0						):
        A__					=       digita

        if (remainder + digita) % 2 == 0:
            A__					=       ODD_DIGITS
        else:
            A__					=       EVEN_DIGITS

        for digita in other_parity_digits:
            A__					=       digita
            result += reversible_numbers(
                remaining_length - 2			,							(remainder + digita + digita) // 1_0			,							UpperCamelCase_			,							UpperCamelCase_			,							)
    return result



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int = 9						)->	int:
    A__					=       0
    for length in range(1			,							max_power + 1						):
        result += reversible_numbers(UpperCamelCase_			,							0			,							[0] * length			,							UpperCamelCase_						)
    return result


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