






'''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     a_						:

  def __init__(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE=13      ,		_SCREAMING_SNAKE_CASE=30      ,		_SCREAMING_SNAKE_CASE=2      ,		_SCREAMING_SNAKE_CASE=3      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=32      ,		_SCREAMING_SNAKE_CASE=5      ,		_SCREAMING_SNAKE_CASE=4      ,		_SCREAMING_SNAKE_CASE=37      ,		_SCREAMING_SNAKE_CASE="gelu"      ,		_SCREAMING_SNAKE_CASE=0.1      ,		_SCREAMING_SNAKE_CASE=0.1      ,		_SCREAMING_SNAKE_CASE=10      ,		_SCREAMING_SNAKE_CASE=0.0_2      ,		_SCREAMING_SNAKE_CASE=3      ,		_SCREAMING_SNAKE_CASE=None      ,		_SCREAMING_SNAKE_CASE=2      ,		)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = parent
        UpperCamelCase      = batch_size
        UpperCamelCase      = image_size
        UpperCamelCase      = patch_size
        UpperCamelCase      = num_channels
        UpperCamelCase      = is_training
        UpperCamelCase      = use_labels
        UpperCamelCase      = hidden_size
        UpperCamelCase      = num_hidden_layers
        UpperCamelCase      = num_attention_heads
        UpperCamelCase      = intermediate_size
        UpperCamelCase      = hidden_act
        UpperCamelCase      = hidden_dropout_prob
        UpperCamelCase      = attention_probs_dropout_prob
        UpperCamelCase      = type_sequence_label_size
        UpperCamelCase      = initializer_range
        UpperCamelCase      = scope
        UpperCamelCase      = encoder_stride

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

  def   A__						(				self				)  ->				Dict:



        """simple docstring"""






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

        UpperCamelCase      = None
        if self.use_labels:
              UpperCamelCase      = ids_tensor([self.batch_size]      ,		self.type_sequence_label_size				)

        UpperCamelCase      = self.get_config()

        return config, pixel_values, labels

  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        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=_SCREAMING_SNAKE_CASE      ,		initializer_range=self.initializer_range      ,		encoder_stride=self.encoder_stride      ,		)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Union[str, Any]:



        """simple docstring"""






        UpperCamelCase      = DeiTModel(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, self.seq_length, self.hidden_size)				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Any:



        """simple docstring"""






        UpperCamelCase      = DeiTForMaskedImageModeling(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(
            result.reconstruction.shape      ,		(self.batch_size, self.num_channels, self.image_size, self.image_size)				)

        # test greyscale images
        UpperCamelCase      = 1
        UpperCamelCase      = DeiTForMaskedImageModeling(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()

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

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Optional[int]:



        """simple docstring"""






        UpperCamelCase      = self.type_sequence_label_size
        UpperCamelCase      = DeiTForImageClassification(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		labels=_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.type_sequence_label_size)				)

        # test greyscale images
        UpperCamelCase      = 1
        UpperCamelCase      = DeiTForImageClassification(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()

        UpperCamelCase      = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		labels=_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.type_sequence_label_size)				)


  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






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






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

  lowercase							=				False
  lowercase							=				False
  lowercase							=				False

  def   A__						(				self				)  ->				Optional[int]:



        """simple docstring"""






        UpperCamelCase      = DeiTModelTester(self				)
        UpperCamelCase      = ConfigTester(self      ,		config_class=_SCREAMING_SNAKE_CASE      ,		has_text_modality=_SCREAMING_SNAKE_CASE      ,		hidden_size=37				)

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        self.config_tester.run_common_tests()

  @unittest.skip(reason="""DeiT does not use inputs_embeds"""				)
  def   A__						(				self				)  ->				int:



        """simple docstring"""






        pass

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

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

  def   A__						(				self				)  ->				Optional[int]:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

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

              UpperCamelCase      = ["""pixel_values"""]
              self.assertListEqual(arg_names[:1]      ,		_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				int:



        """simple docstring"""






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

  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






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

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE=False				)  ->				Tuple:



        """simple docstring"""






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

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

        return inputs_dict

  def   A__						(				self				)  ->				Any:



        """simple docstring"""






        if not self.model_tester.is_training:
              return

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

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

  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






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

        UpperCamelCase      = False
        UpperCamelCase      = True

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

  def   A__						(				self				)  ->				Optional[int]:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

        UpperCamelCase      = [
            {"""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(_SCREAMING_SNAKE_CASE				),
                      *get_values(_SCREAMING_SNAKE_CASE				),
                  ]
                  or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
              ):
                    continue

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

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

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

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

                          UpperCamelCase      = 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=_SCREAMING_SNAKE_CASE				) as warning_list:
                                UpperCamelCase      = model(**_SCREAMING_SNAKE_CASE				).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   A__						(				self				)  ->				Any:



        """simple docstring"""






        for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCamelCase      = DeiTModel.from_pretrained(_SCREAMING_SNAKE_CASE				)
              self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)







def    lowercase__			(				)->			Dict:
      UpperCamelCase      = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
      return image






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

  @cached_property
  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        return (
            DeiTImageProcessor.from_pretrained("""facebook/deit-base-distilled-patch16-224"""				)
            if is_vision_available()
            else None
        )

  @slow
  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        UpperCamelCase      = DeiTForImageClassificationWithTeacher.from_pretrained("""facebook/deit-base-distilled-patch16-224"""				).to(
            _SCREAMING_SNAKE_CASE				)

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

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

        # verify the logits
        UpperCamelCase      = torch.Size((1, 1000)				)
        self.assertEqual(outputs.logits.shape      ,		_SCREAMING_SNAKE_CASE				)

        UpperCamelCase      = torch.tensor([-1.0_2_6_6, 0.1_9_1_2, -1.2_8_6_1]				).to(_SCREAMING_SNAKE_CASE				)

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


  @slow
  @require_accelerate
  @require_torch_gpu
  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        UpperCamelCase      = DeiTModel.from_pretrained(
            """facebook/deit-base-distilled-patch16-224"""      ,		torch_dtype=torch.floataa      ,		device_map="""auto"""				)
        UpperCamelCase      = self.default_image_processor

        UpperCamelCase      = prepare_img()
        UpperCamelCase      = image_processor(images=_SCREAMING_SNAKE_CASE      ,		return_tensors="""pt"""				)
        UpperCamelCase      = inputs.pixel_values.to(_SCREAMING_SNAKE_CASE				)

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








'''simple docstring'''

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
     from PIL import Image






class     a_						(      lowerCamelCase    ):
  lowercase							=				"""Salesforce/blip-image-captioning-base"""
  lowercase							=				(
      """This is a tool that generates a description of an image. It takes an input named `image` which should be the """
      """image to caption, and returns a text that contains the description in English."""
  )
  lowercase							=				"""image_captioner"""
  lowercase							=				AutoModelForVisionaSeq

  lowercase							=				["""image"""]
  lowercase							=				["""text"""]

  def __init__(				self      ,		*_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE				)  ->				Any:



        """simple docstring"""






        requires_backends(self      ,		["""vision"""]				)
        super().__init__(*_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE				)  ->				str:



        """simple docstring"""






        return self.pre_processor(images=_SCREAMING_SNAKE_CASE      ,		return_tensors="""pt"""				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE				)  ->				str:



        """simple docstring"""






        return self.model.generate(**_SCREAMING_SNAKE_CASE				)


  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE				)  ->				Union[str, Any]:



        """simple docstring"""






        return self.pre_processor.batch_decode(_SCREAMING_SNAKE_CASE      ,		skip_special_tokens=_SCREAMING_SNAKE_CASE				)[0].strip()
