


import unittest

from transformers import is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
 from PIL import Image
else:






 class 	__lowercase					:





       @staticmethod
       def 							_lowercase					(		*__lowerCamelCase    :       Optional[Any]       ,							**__lowerCamelCase    :       Tuple							)     -> Optional[Any]:






          """simple docstring"""







          pass






@is_pipeline_test
@require_vision
class 	__lowercase					(	unittest.TestCase	):





      @require_torch
      def 							_lowercase					(		self    :       List[Any]							)     -> Dict:






         """simple docstring"""







         UpperCAmelCase      					=  pipeline(
             model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""       ,							)
         UpperCAmelCase      					=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
         UpperCAmelCase      					=  image_classifier(__lowerCamelCase       ,							candidate_labels=["""a""", """b""", """c"""]							)

         # The floating scores are so close, we enter floating error approximation and the order is not guaranteed across
         # python and torch versions.
         self.assertIn(
             nested_simplify(__lowerCamelCase							)       ,							[
                 [{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """b"""}, {"""score""": 0.333, """label""": """c"""}],
                 [{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """c"""}, {"""score""": 0.333, """label""": """b"""}],
             ]       ,							)

         UpperCAmelCase      					=  image_classifier([image] * 5       ,							candidate_labels=["""A""", """B""", """C"""]       ,							batch_size=2							)
         self.assertEqual(
             nested_simplify(__lowerCamelCase							)       ,							[
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
             ]       ,							)





      @require_tf
      def 							_lowercase					(		self    :       List[str]							)     -> Optional[int]:






         """simple docstring"""







         UpperCAmelCase      					=  pipeline(
             model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""       ,							framework="""tf"""							)
         UpperCAmelCase      					=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
         UpperCAmelCase      					=  image_classifier(__lowerCamelCase       ,							candidate_labels=["""a""", """b""", """c"""]							)

         self.assertEqual(
             nested_simplify(__lowerCamelCase							)       ,							[{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """b"""}, {"""score""": 0.333, """label""": """c"""}]       ,							)

         UpperCAmelCase      					=  image_classifier([image] * 5       ,							candidate_labels=["""A""", """B""", """C"""]       ,							batch_size=2							)
         self.assertEqual(
             nested_simplify(__lowerCamelCase							)       ,							[
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
                 [
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                     {"""score""": 0.333, """label""": ANY(__lowerCamelCase							)},
                 ],
             ]       ,							)





      @slow
      @require_torch
      def 							_lowercase					(		self    :       str							)     -> Dict:






         """simple docstring"""







         UpperCAmelCase      					=  pipeline(
             task="""zero-shot-image-classification"""       ,							model="""openai/clip-vit-base-patch32"""       ,							)
         # This is an image of 2 cats with remotes and no planes
         UpperCAmelCase      					=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
         UpperCAmelCase      					=  image_classifier(__lowerCamelCase       ,							candidate_labels=["""cat""", """plane""", """remote"""]							)

         self.assertEqual(
             nested_simplify(__lowerCamelCase							)       ,							[
                 {"""score""": 0.511, """label""": """remote"""},
                 {"""score""": 0.485, """label""": """cat"""},
                 {"""score""": 0.004, """label""": """plane"""},
             ]       ,							)

         UpperCAmelCase      					=  image_classifier([image] * 5       ,							candidate_labels=["""cat""", """plane""", """remote"""]       ,							batch_size=2							)
         self.assertEqual(
             nested_simplify(__lowerCamelCase							)       ,							[
                 [
                     {"""score""": 0.511, """label""": """remote"""},
                     {"""score""": 0.485, """label""": """cat"""},
                     {"""score""": 0.004, """label""": """plane"""},
                 ],
             ]
             * 5       ,							)





      @slow
      @require_tf
      def 							_lowercase					(		self    :       int							)     -> Any:






         """simple docstring"""







         UpperCAmelCase      					=  pipeline(
             task="""zero-shot-image-classification"""       ,							model="""openai/clip-vit-base-patch32"""       ,							framework="""tf"""							)
         # This is an image of 2 cats with remotes and no planes
         UpperCAmelCase      					=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
         UpperCAmelCase      					=  image_classifier(__lowerCamelCase       ,							candidate_labels=["""cat""", """plane""", """remote"""]							)
         self.assertEqual(
             nested_simplify(__lowerCamelCase							)       ,							[
                 {"""score""": 0.511, """label""": """remote"""},
                 {"""score""": 0.485, """label""": """cat"""},
                 {"""score""": 0.004, """label""": """plane"""},
             ]       ,							)

         UpperCAmelCase      					=  image_classifier([image] * 5       ,							candidate_labels=["""cat""", """plane""", """remote"""]       ,							batch_size=2							)
         self.assertEqual(
             nested_simplify(__lowerCamelCase							)       ,							[
                 [
                     {"""score""": 0.511, """label""": """remote"""},
                     {"""score""": 0.485, """label""": """cat"""},
                     {"""score""": 0.004, """label""": """plane"""},
                 ],
             ]
             * 5       ,							)







import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
from transformers.testing_utils import (
    require_torch,
    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 SwiftFormerForImageClassification, SwiftFormerModel
 from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import ViTImageProcessor






class 	__lowercase					:





      def __init__(		self    :       Optional[Any]       ,							__lowerCamelCase    :       Any       ,							__lowerCamelCase    :       int=1_3       ,							__lowerCamelCase    :       List[str]=3       ,							__lowerCamelCase    :       List[str]=True       ,							__lowerCamelCase    :       Any=True       ,							__lowerCamelCase    :       Optional[int]=0.1       ,							__lowerCamelCase    :       Optional[Any]=0.1       ,							__lowerCamelCase    :       Tuple=2_2_4       ,							__lowerCamelCase    :       int=1_0_0_0       ,							__lowerCamelCase    :       int=[3, 3, 6, 4]       ,							__lowerCamelCase    :       Dict=[4_8, 5_6, 1_1_2, 2_2_0]       ,							)     -> Union[str, Any]:






         """simple docstring"""







         UpperCAmelCase      					=  parent
         UpperCAmelCase      					=  batch_size
         UpperCAmelCase      					=  num_channels
         UpperCAmelCase      					=  is_training
         UpperCAmelCase      					=  use_labels
         UpperCAmelCase      					=  hidden_dropout_prob
         UpperCAmelCase      					=  attention_probs_dropout_prob
         UpperCAmelCase      					=  num_labels
         UpperCAmelCase      					=  image_size
         UpperCAmelCase      					=  layer_depths
         UpperCAmelCase      					=  embed_dims





      def 							_lowercase					(		self    :       List[str]							)     -> Optional[Any]:






         """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.num_labels							)

         UpperCAmelCase      					=  self.get_config()

         return config, pixel_values, labels





      def 							_lowercase					(		self    :       Optional[Any]							)     -> str:






         """simple docstring"""







         return SwiftFormerConfig(
             depths=self.layer_depths       ,							embed_dims=self.embed_dims       ,							mlp_ratio=4       ,							downsamples=[True, True, True, True]       ,							hidden_act="""gelu"""       ,							num_labels=self.num_labels       ,							down_patch_size=3       ,							down_stride=2       ,							down_pad=1       ,							drop_rate=0.0       ,							drop_path_rate=0.0       ,							use_layer_scale=__lowerCamelCase       ,							layer_scale_init_value=1e-5       ,							)





      def 							_lowercase					(		self    :       Tuple       ,							__lowerCamelCase    :       int       ,							__lowerCamelCase    :       List[str]       ,							__lowerCamelCase    :       Optional[int]							)     -> str:






         """simple docstring"""







         UpperCAmelCase      					=  SwiftFormerModel(config=__lowerCamelCase							)
         model.to(__lowerCamelCase							)
         model.eval()
         UpperCAmelCase      					=  model(__lowerCamelCase							)
         self.parent.assertEqual(result.last_hidden_state.shape       ,							(self.batch_size, self.embed_dims[-1], 7, 7)							)





      def 							_lowercase					(		self    :       List[str]       ,							__lowerCamelCase    :       int       ,							__lowerCamelCase    :       List[str]       ,							__lowerCamelCase    :       Any							)     -> Dict:






         """simple docstring"""







         UpperCAmelCase      					=  self.num_labels
         UpperCAmelCase      					=  SwiftFormerForImageClassification(__lowerCamelCase							)
         model.to(__lowerCamelCase							)
         model.eval()
         UpperCAmelCase      					=  model(__lowerCamelCase       ,							labels=__lowerCamelCase							)
         self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.num_labels)							)

         UpperCAmelCase      					=  SwiftFormerForImageClassification(__lowerCamelCase							)
         model.to(__lowerCamelCase							)
         model.eval()

         UpperCAmelCase      					=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)
         UpperCAmelCase      					=  model(__lowerCamelCase							)
         self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.num_labels)							)





      def 							_lowercase					(		self    :       Tuple							)     -> Optional[Any]:






         """simple docstring"""







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






@require_torch
class 	__lowercase					(	__snake_case			,       __snake_case			,       unittest.TestCase	):
      UpperCamelCase										=							(SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
      UpperCamelCase										=							(
          {'''feature-extraction''': SwiftFormerModel, '''image-classification''': SwiftFormerForImageClassification}
          if is_torch_available()
          else {}
      )

      UpperCamelCase										=							False
      UpperCamelCase										=							False
      UpperCamelCase										=							False
      UpperCamelCase										=							False
      UpperCamelCase										=							False





      def 							_lowercase					(		self    :       str							)     -> Tuple:






         """simple docstring"""







         UpperCAmelCase      					=  SwiftFormerModelTester(self							)
         UpperCAmelCase      					=  ConfigTester(
             self       ,							config_class=__lowerCamelCase       ,							has_text_modality=__lowerCamelCase       ,							hidden_size=3_7       ,							num_attention_heads=1_2       ,							num_hidden_layers=1_2       ,							)





      def 							_lowercase					(		self    :       Dict							)     -> Union[str, Any]:






         """simple docstring"""







         self.config_tester.run_common_tests()





      @unittest.skip(reason="""SwiftFormer does not use inputs_embeds"""							)
      def 							_lowercase					(		self    :       Optional[int]							)     -> List[str]:






         """simple docstring"""







         pass





      def 							_lowercase					(		self    :       str							)     -> str:






         """simple docstring"""







         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase      					=  model_class(__lowerCamelCase							)
            UpperCAmelCase      					=  model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(__lowerCamelCase       ,							nn.Linear							)							)





      def 							_lowercase					(		self    :       Union[str, Any]							)     -> List[Any]:






         """simple docstring"""







         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

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





      def 							_lowercase					(		self    :       List[str]							)     -> Dict:






         """simple docstring"""







         UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCamelCase							)





      def 							_lowercase					(		self    :       Optional[Any]							)     -> List[Any]:






         """simple docstring"""







         UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase							)





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






         """simple docstring"""







         for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase      					=  SwiftFormerModel.from_pretrained(__lowerCamelCase							)
            self.assertIsNotNone(__lowerCamelCase							)





      @unittest.skip(reason="""SwiftFormer does not output attentions"""							)
      def 							_lowercase					(		self    :       List[str]							)     -> Union[str, Any]:






         """simple docstring"""







         pass





      def 							_lowercase					(		self    :       Dict							)     -> List[Any]:






         """simple docstring"""







         def check_hidden_states_output(__lowerCamelCase    :       List[str]       ,							__lowerCamelCase    :       Dict       ,							__lowerCamelCase    :       Optional[Any]							):
            UpperCAmelCase      					=  model_class(__lowerCamelCase							)
            model.to(__lowerCamelCase							)
            model.eval()

            with torch.no_grad():
               UpperCAmelCase      					=  model(**self._prepare_for_class(__lowerCamelCase       ,							__lowerCamelCase							)							)

            UpperCAmelCase      					=  outputs.hidden_states

            UpperCAmelCase      					=  8
            self.assertEqual(len(__lowerCamelCase							)       ,							__lowerCamelCase							)  # TODO

            # SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
            # with the width and height being successively divided by 2, after every 2 blocks
            for i in range(len(__lowerCamelCase							)							):
               self.assertEqual(
                   hidden_states[i].shape       ,							torch.Size(
                       [
                           self.model_tester.batch_size,
                           self.model_tester.embed_dims[i // 2],
                           (self.model_tester.image_size // 4) // 2 ** (i // 2),
                           (self.model_tester.image_size // 4) // 2 ** (i // 2),
                       ]							)       ,							)

         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase      					=  True
            check_hidden_states_output(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)

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

            check_hidden_states_output(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)





      def 							_lowercase					(		self    :       Dict							)     -> Union[str, Any]:






         """simple docstring"""







         def _config_zero_init(__lowerCamelCase    :       Any							):
            UpperCAmelCase      					=  copy.deepcopy(__lowerCamelCase							)
            for key in configs_no_init.__dict__.keys():
               if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
                  setattr(__lowerCamelCase       ,							__lowerCamelCase       ,							1e-1_0							)
               if isinstance(getattr(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)       ,							__lowerCamelCase							):
                  UpperCAmelCase      					=  _config_zero_init(getattr(__lowerCamelCase       ,							__lowerCamelCase							)							)
                  setattr(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)
            return configs_no_init

         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase      					=  _config_zero_init(__lowerCamelCase							)
         for model_class in self.all_model_classes:
            UpperCAmelCase      					=  model_class(config=__lowerCamelCase							)
            for name, param in model.named_parameters():
               if param.requires_grad:
                  self.assertIn(
                      ((param.data.mean() * 1e9) / 1e9).round().item()       ,							[0.0, 1.0]       ,							msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""       ,							)





      @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""							)
      def 							_lowercase					(		self    :       Optional[int]							)     -> List[str]:






         """simple docstring"""







         pass

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







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





      @cached_property
      def 							_lowercase					(		self    :       Optional[int]							)     -> int:






         """simple docstring"""







         return ViTImageProcessor.from_pretrained("""MBZUAI/swiftformer-xs"""							) if is_vision_available() else None





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






         """simple docstring"""







         UpperCAmelCase      					=  SwiftFormerForImageClassification.from_pretrained("""MBZUAI/swiftformer-xs"""							).to(__lowerCamelCase							)

         UpperCAmelCase      					=  self.default_image_processor
         UpperCAmelCase      					=  prepare_img()
         UpperCAmelCase      					=  image_processor(images=__lowerCamelCase       ,							return_tensors="""pt"""							).to(__lowerCamelCase							)

         # forward pass
         with torch.no_grad():
            UpperCAmelCase      					=  model(**__lowerCamelCase							)

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

         UpperCAmelCase      					=  torch.tensor([[-2.1_7_0_3e0_0, 2.1_1_0_7e0_0, -2.0_8_1_1e0_0]]							).to(__lowerCamelCase							)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,							__lowerCamelCase       ,							atol=1e-4							)							)



