
'''simple docstring'''
import inspect
import unittest
import warnings

from transformers import DeiTConfig
from transformers.models.auto import get_values
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 (
      MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      MODEL_MAPPING,
      DeiTForImageClassification,
      DeiTForImageClassificationWithTeacher,
      DeiTForMaskedImageModeling,
      DeiTModel,
  )
  from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import DeiTImageProcessor






class    UpperCAmelCase_				:





 def __init__(    self ,       lowercase_ ,       lowercase_=13 ,       lowercase_=30 ,       lowercase_=2 ,       lowercase_=3 ,       lowercase_=True ,       lowercase_=True ,       lowercase_=32 ,       lowercase_=5 ,       lowercase_=4 ,       lowercase_=37 ,       lowercase_="gelu" ,       lowercase_=0.1 ,       lowercase_=0.1 ,       lowercase_=10 ,       lowercase_=0.02 ,       lowercase_=3 ,       lowercase_=None ,       lowercase_=2 ,       ):
     snake_case_ :    Union[str, Any]     			=						parent
     snake_case_ :    Optional[int]     			=						batch_size
     snake_case_ :    Dict     			=						image_size
     snake_case_ :    Tuple     			=						patch_size
     snake_case_ :    Union[str, Any]     			=						num_channels
     snake_case_ :    int     			=						is_training
     snake_case_ :    Tuple     			=						use_labels
     snake_case_ :    int     			=						hidden_size
     snake_case_ :    str     			=						num_hidden_layers
     snake_case_ :    List[str]     			=						num_attention_heads
     snake_case_ :    Dict     			=						intermediate_size
     snake_case_ :    Any     			=						hidden_act
     snake_case_ :    Optional[int]     			=						hidden_dropout_prob
     snake_case_ :    str     			=						attention_probs_dropout_prob
     snake_case_ :    str     			=						type_sequence_label_size
     snake_case_ :    Optional[Any]     			=						initializer_range
     snake_case_ :    Any     			=						scope
     snake_case_ :    str     			=						encoder_stride

     # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
     snake_case_ :    Optional[Any]     			=						(image_size // patch_size) ** 2
     snake_case_ :    Union[str, Any]     			=						num_patches + 2





 def        snake_case__		(    self):
     snake_case_ :    List[Any]     			=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

     snake_case_ :    Optional[int]     			=						None
     if self.use_labels:
         snake_case_ :    str     			=						ids_tensor([self.batch_size] ,       self.type_sequence_label_size)

     snake_case_ :    Tuple     			=						self.get_config()

     return config, pixel_values, labels





 def        snake_case__		(    self):
     return DeiTConfig(
         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=lowercase_ ,       initializer_range=self.initializer_range ,       encoder_stride=self.encoder_stride ,       )





 def        snake_case__		(    self ,       lowercase_ ,       lowercase_ ,       lowercase_):
     snake_case_ :    Tuple     			=						DeiTModel(config=lowercase_)
     model.to(lowercase_)
     model.eval()
     snake_case_ :    Optional[Any]     			=						model(lowercase_)
     self.parent.assertEqual(result.last_hidden_state.shape ,       (self.batch_size, self.seq_length, self.hidden_size))





 def        snake_case__		(    self ,       lowercase_ ,       lowercase_ ,       lowercase_):
     snake_case_ :    Union[str, Any]     			=						DeiTForMaskedImageModeling(config=lowercase_)
     model.to(lowercase_)
     model.eval()
     snake_case_ :    Union[str, Any]     			=						model(lowercase_)
     self.parent.assertEqual(
         result.reconstruction.shape ,       (self.batch_size, self.num_channels, self.image_size, self.image_size))

     # test greyscale images
     snake_case_ :    Optional[int]     			=						1
     snake_case_ :    Any     			=						DeiTForMaskedImageModeling(lowercase_)
     model.to(lowercase_)
     model.eval()

     snake_case_ :    str     			=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
     snake_case_ :    List[str]     			=						model(lowercase_)
     self.parent.assertEqual(result.reconstruction.shape ,       (self.batch_size, 1, self.image_size, self.image_size))





 def        snake_case__		(    self ,       lowercase_ ,       lowercase_ ,       lowercase_):
     snake_case_ :    Any     			=						self.type_sequence_label_size
     snake_case_ :    str     			=						DeiTForImageClassification(lowercase_)
     model.to(lowercase_)
     model.eval()
     snake_case_ :    Optional[Any]     			=						model(lowercase_ ,       labels=lowercase_)
     self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size))

     # test greyscale images
     snake_case_ :    int     			=						1
     snake_case_ :    str     			=						DeiTForImageClassification(lowercase_)
     model.to(lowercase_)
     model.eval()

     snake_case_ :    Optional[int]     			=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
     snake_case_ :    Optional[Any]     			=						model(lowercase_ ,       labels=lowercase_)
     self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size))





 def        snake_case__		(    self):
     snake_case_ :    Dict     			=						self.prepare_config_and_inputs()
     (
         snake_case_ 
     ) :    Any     			=						config_and_inputs
     snake_case_ :    Any     			=						{"pixel_values": pixel_values}
     return config, inputs_dict






@require_torch
class    UpperCAmelCase_				(	snake_case__    ,						snake_case__    ,						unittest.TestCase					):
 UpperCAmelCase_		    =						(
     (
         DeiTModel,
         DeiTForImageClassification,
         DeiTForImageClassificationWithTeacher,
         DeiTForMaskedImageModeling,
     )
     if is_torch_available()
     else ()
 )
 UpperCAmelCase_		    =						(
     {
         """feature-extraction""": DeiTModel,
         """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
     }
     if is_torch_available()
     else {}
 )

 UpperCAmelCase_		    =						False
 UpperCAmelCase_		    =						False
 UpperCAmelCase_		    =						False





 def        snake_case__		(    self):
     snake_case_ :    Tuple     			=						DeiTModelTester(self)
     snake_case_ :    Optional[int]     			=						ConfigTester(self ,       config_class=lowercase_ ,       has_text_modality=lowercase_ ,       hidden_size=37)





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





 @unittest.skip(reason="DeiT does not use inputs_embeds")
 def        snake_case__		(    self):
     pass





 def        snake_case__		(    self):
     snake_case_ :    Union[str, Any]     			=						self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         snake_case_ :    int     			=						model_class(lowercase_)
         self.assertIsInstance(model.get_input_embeddings() ,       (nn.Module))
         snake_case_ :    Optional[Any]     			=						model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(lowercase_ ,       nn.Linear))





 def        snake_case__		(    self):
     snake_case_ :    Tuple     			=						self.model_tester.prepare_config_and_inputs_for_common()

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

         snake_case_ :    Tuple     			=						["pixel_values"]
         self.assertListEqual(arg_names[:1] ,       lowercase_)





 def        snake_case__		(    self):
     snake_case_ :    List[Any]     			=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_)





 def        snake_case__		(    self):
     snake_case_ :    List[Any]     			=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_image_modeling(*lowercase_)





 def        snake_case__		(    self):
     snake_case_ :    List[Any]     			=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*lowercase_)





 def        snake_case__		(    self ,       lowercase_ ,       lowercase_ ,       lowercase_=False):
     snake_case_ :    List[Any]     			=						super()._prepare_for_class(lowercase_ ,       lowercase_ ,       return_labels=lowercase_)

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

     return inputs_dict





 def        snake_case__		(    self):
     if not self.model_tester.is_training:
         return

     snake_case_ :    Tuple     			=						self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_ :    List[Any]     			=						True

     for model_class in self.all_model_classes:
         # DeiTForImageClassificationWithTeacher supports inference-only
         if (
             model_class in get_values(lowercase_)
             or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
         ):
             continue
         snake_case_ :    Tuple     			=						model_class(lowercase_)
         model.to(lowercase_)
         model.train()
         snake_case_ :    List[Any]     			=						self._prepare_for_class(lowercase_ ,       lowercase_ ,       return_labels=lowercase_)
         snake_case_ :    Optional[int]     			=						model(**lowercase_).loss
         loss.backward()





 def        snake_case__		(    self):
     snake_case_ :    str     			=						self.model_tester.prepare_config_and_inputs_for_common()
     if not self.model_tester.is_training:
         return

     snake_case_ :    List[Any]     			=						False
     snake_case_ :    List[Any]     			=						True

     for model_class in self.all_model_classes:
         if model_class in get_values(lowercase_) or not model_class.supports_gradient_checkpointing:
             continue
         # DeiTForImageClassificationWithTeacher supports inference-only
         if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
             continue
         snake_case_ :    int     			=						model_class(lowercase_)
         model.gradient_checkpointing_enable()
         model.to(lowercase_)
         model.train()
         snake_case_ :    int     			=						self._prepare_for_class(lowercase_ ,       lowercase_ ,       return_labels=lowercase_)
         snake_case_ :    Union[str, Any]     			=						model(**lowercase_).loss
         loss.backward()





 def        snake_case__		(    self):
     snake_case_ :    List[str]     			=						self.model_tester.prepare_config_and_inputs_for_common()

     snake_case_ :    Optional[int]     			=						[
         {"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_),
                 *get_values(lowercase_),
             ]
             or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
         ):
             continue

         for problem_type in problem_types:
             with self.subTest(msg=F'Testing {model_class} with {problem_type["title"]}'):
                 snake_case_ :    Optional[int]     			=						problem_type["title"]
                 snake_case_ :    List[Any]     			=						problem_type["num_labels"]

                 snake_case_ :    List[Any]     			=						model_class(lowercase_)
                 model.to(lowercase_)
                 model.train()

                 snake_case_ :    Dict     			=						self._prepare_for_class(lowercase_ ,       lowercase_ ,       return_labels=lowercase_)

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

                 snake_case_ :    List[str]     			=						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:
                     snake_case_ :    Union[str, Any]     			=						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):
     for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         snake_case_ :    Optional[int]     			=						DeiTModel.from_pretrained(lowercase_)
         self.assertIsNotNone(lowercase_)


def 						UpperCamelCase_     (	):
    """simple docstring"""






    snake_case_ :    Dict     			=						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 (
         DeiTImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
         if is_vision_available()
         else None
     )





 @slow
 def        snake_case__		(    self):
     snake_case_ :    int     			=						DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224").to(
         lowercase_)

     snake_case_ :    Dict     			=						self.default_image_processor
     snake_case_ :    Optional[Any]     			=						prepare_img()
     snake_case_ :    Optional[Any]     			=						image_processor(images=lowercase_ ,       return_tensors="pt").to(lowercase_)

     # forward pass
     with torch.no_grad():
         snake_case_ :    Any     			=						model(**lowercase_)

     # verify the logits
     snake_case_ :    int     			=						torch.Size((1, 10_00))
     self.assertEqual(outputs.logits.shape ,       lowercase_)

     snake_case_ :    Optional[int]     			=						torch.tensor([-1.0_266, 0.1_912, -1.2_861]).to(lowercase_)

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





 @slow
 @require_accelerate
 @require_torch_gpu
 def        snake_case__		(    self):
     snake_case_ :    Any     			=						DeiTModel.from_pretrained(
         "facebook/deit-base-distilled-patch16-224" ,       torch_dtype=torch.floataa ,       device_map="auto")
     snake_case_ :    List[str]     			=						self.default_image_processor

     snake_case_ :    Dict     			=						prepare_img()
     snake_case_ :    List[Any]     			=						image_processor(images=lowercase_ ,       return_tensors="pt")
     snake_case_ :    List[Any]     			=						inputs.pixel_values.to(lowercase_)

     # forward pass to make sure inference works in fp16
     with torch.no_grad():
         snake_case_ :    Optional[Any]     			=						model(lowercase_)






'''simple docstring'''
from __future__ import annotations

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    List[Any]     			=						0.00
    snake_case_ :    int     			=						0
    for resistor in resistors:
        if resistor <= 0:
            snake_case_ :    Dict     			=						f'Resistor at index {index} has a negative or zero value!'
            raise ValueError(__SCREAMING_SNAKE_CASE       )
        first_sum += 1 / float(__SCREAMING_SNAKE_CASE       )
        index += 1
    return 1 / first_sum

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    snake_case_ :    Union[str, Any]     			=						0.00
    snake_case_ :    List[Any]     			=						0
    for resistor in resistors:
        sum_r += resistor
        if resistor < 0:
            snake_case_ :    str     			=						f'Resistor at index {index} has a negative value!'
            raise ValueError(__SCREAMING_SNAKE_CASE       )
        index += 1
    return sum_r


if __name__ == "__main__":
  import doctest

  doctest.testmod()




