





import inspect
import unittest

from transformers import BitConfig
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_backbone_common import BackboneTesterMixin
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 BitBackbone, BitForImageClassification, BitImageProcessor, BitModel
    from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

class     snake_case_		:






 '''simple docstring'''





 def __init__(  self,		A_,		A_=3,		A_=32,		A_=3,		A_=10,		A_=[8, 16, 32, 64],		A_=[1, 1, 2, 1],		A_=True,		A_=True,		A_="relu",		A_=3,		A_=None,		A_=["stage2", "stage3", "stage4"],		A_=[2, 3, 4],		A_=1,		)	->       str:
    UpperCAmelCase__						=parent
    UpperCAmelCase__						=batch_size
    UpperCAmelCase__						=image_size
    UpperCAmelCase__						=num_channels
    UpperCAmelCase__						=embeddings_size
    UpperCAmelCase__						=hidden_sizes
    UpperCAmelCase__						=depths
    UpperCAmelCase__						=is_training
    UpperCAmelCase__						=use_labels
    UpperCAmelCase__						=hidden_act
    UpperCAmelCase__						=num_labels
    UpperCAmelCase__						=scope
    UpperCAmelCase__						=len(A_		)
    UpperCAmelCase__						=out_features
    UpperCAmelCase__						=out_indices
    UpperCAmelCase__						=num_groups

 def  __UpperCAmelCase						(  self		)	->       Optional[int]:
    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  __UpperCAmelCase						(  self		)	->       List[str]:
    return BitConfig(
        num_channels=self.num_channels,		embeddings_size=self.embeddings_size,		hidden_sizes=self.hidden_sizes,		depths=self.depths,		hidden_act=self.hidden_act,		num_labels=self.num_labels,		out_features=self.out_features,		out_indices=self.out_indices,		num_groups=self.num_groups,		)

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_		)	->       Any:
    UpperCAmelCase__						=BitModel(config=A_		)
    model.to(A_		)
    model.eval()
    UpperCAmelCase__						=model(A_		)
    self.parent.assertEqual(
        result.last_hidden_state.shape,		(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32),		)

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_		)	->       str:
    UpperCAmelCase__						=self.num_labels
    UpperCAmelCase__						=BitForImageClassification(A_		)
    model.to(A_		)
    model.eval()
    UpperCAmelCase__						=model(A_,		labels=A_		)
    self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.num_labels)		)

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_		)	->       int:
    UpperCAmelCase__						=BitBackbone(config=A_		)
    model.to(A_		)
    model.eval()
    UpperCAmelCase__						=model(A_		)

    # verify feature maps
    self.parent.assertEqual(len(result.feature_maps		),		len(config.out_features		)		)
    self.parent.assertListEqual(list(result.feature_maps[0].shape		),		[self.batch_size, self.hidden_sizes[1], 4, 4]		)

    # verify channels
    self.parent.assertEqual(len(model.channels		),		len(config.out_features		)		)
    self.parent.assertListEqual(model.channels,		config.hidden_sizes[1:]		)

    # verify backbone works with out_features=None
    UpperCAmelCase__						=None
    UpperCAmelCase__						=BitBackbone(config=A_		)
    model.to(A_		)
    model.eval()
    UpperCAmelCase__						=model(A_		)

    # verify feature maps
    self.parent.assertEqual(len(result.feature_maps		),		1		)
    self.parent.assertListEqual(list(result.feature_maps[0].shape		),		[self.batch_size, self.hidden_sizes[-1], 1, 1]		)

    # verify channels
    self.parent.assertEqual(len(model.channels		),		1		)
    self.parent.assertListEqual(model.channels,		[config.hidden_sizes[-1]]		)






 def  __UpperCAmelCase						(  self		)	->       List[str]:
    UpperCAmelCase__						=self.prepare_config_and_inputs()
    UpperCAmelCase__			,							UpperCAmelCase__			,							UpperCAmelCase__						=config_and_inputs
    UpperCAmelCase__						={"pixel_values": pixel_values}
    return config, inputs_dict

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






 '''simple docstring'''





 __UpperCamelCase       =      (BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
 __UpperCamelCase       =      (
     {'feature-extraction': BitModel, 'image-classification': BitForImageClassification}
     if is_torch_available()
     else {}
 )

 __UpperCamelCase       =      False
 __UpperCamelCase       =      False
 __UpperCamelCase       =      False
 __UpperCamelCase       =      False
 __UpperCamelCase       =      False

 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    UpperCAmelCase__						=BitModelTester(self		)
    UpperCAmelCase__						=ConfigTester(self,		config_class=A_,		has_text_modality=A_		)

 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    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  __UpperCAmelCase						(  self		)	->       Dict:
    return

 @unittest.skip(reason="Bit does not output attentions"		)
 def  __UpperCAmelCase						(  self		)	->       str:
    pass

 @unittest.skip(reason="Bit does not use inputs_embeds"		)
 def  __UpperCAmelCase						(  self		)	->       Any:
    pass

 @unittest.skip(reason="Bit does not support input and output embeddings"		)
 def  __UpperCAmelCase						(  self		)	->       Optional[Any]:
    pass

 def  __UpperCAmelCase						(  self		)	->       List[str]:
    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()

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

 def  __UpperCAmelCase						(  self		)	->       List[str]:
    UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*A_		)

 def  __UpperCAmelCase						(  self		)	->       Optional[int]:
    UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_backbone(*A_		)

 def  __UpperCAmelCase						(  self		)	->       Tuple:
    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       UpperCAmelCase__						=model_class(config=A_		)
       for name, module in model.named_modules():
          if isinstance(A_,		(nn.BatchNormad, nn.GroupNorm)		):
             self.assertTrue(
                 torch.all(module.weight == 1		),		msg=f"""Parameter {name} of model {model_class} seems not properly initialized""",		)
             self.assertTrue(
                 torch.all(module.bias == 0		),		msg=f"""Parameter {name} of model {model_class} seems not properly initialized""",		)

 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    def check_hidden_states_output(A_,		A_,		A_		):
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()

       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)

       UpperCAmelCase__						=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

       UpperCAmelCase__						=self.model_tester.num_stages
       self.assertEqual(len(A_		),		expected_num_stages + 1		)

       # Bit's feature maps are of shape (batch_size, num_channels, height, width)
       self.assertListEqual(
           list(hidden_states[0].shape[-2:]		),		[self.model_tester.image_size // 4, self.model_tester.image_size // 4],		)

    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()
    UpperCAmelCase__						=["preactivation", "bottleneck"]
    for model_class in self.all_model_classes:
       for layer_type in layers_type:
          UpperCAmelCase__						=layer_type
          UpperCAmelCase__						=True
          check_hidden_states_output(A_,		A_,		A_		)

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

          check_hidden_states_output(A_,		A_,		A_		)

 @unittest.skip(reason="Bit does not use feedforward chunking"		)
 def  __UpperCAmelCase						(  self		)	->       Dict:
    pass

 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*A_		)






 @slow
 def  __UpperCAmelCase						(  self		)	->       int:
    for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCAmelCase__						=BitModel.from_pretrained(A_		)
       self.assertIsNotNone(A_		)






def 				_UpperCAmelCase			(    ):




   '''simple docstring'''

   UpperCAmelCase__						=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     )
   return image

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






 '''simple docstring'''





 @cached_property
 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    return (
        BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		) if is_vision_available() else None
    )






 @slow
 def  __UpperCAmelCase						(  self		)	->       Any:
    UpperCAmelCase__						=BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(A_		)

    UpperCAmelCase__						=self.default_image_processor
    UpperCAmelCase__						=prepare_img()
    UpperCAmelCase__						=image_processor(images=A_,		return_tensors="pt"		).to(A_		)

    # forward pass
    with torch.no_grad():
       UpperCAmelCase__						=model(**A_		)

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

    UpperCAmelCase__						=torch.tensor([[-0.65_26, -0.52_63, -1.43_98]]		).to(A_		)

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

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






 '''simple docstring'''





 __UpperCamelCase       =      (BitBackbone,) if is_torch_available() else ()
 __UpperCamelCase       =      BitConfig

 __UpperCamelCase       =      False

 def  __UpperCAmelCase						(  self		)	->       Optional[int]:
    UpperCAmelCase__						=BitModelTester(self		)










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


UpperCamelCase_												=	{
    'configuration_owlvit': [
        'OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'OwlViTConfig',
        'OwlViTOnnxConfig',
        'OwlViTTextConfig',
        'OwlViTVisionConfig',
    ],
    'processing_owlvit': ['OwlViTProcessor'],
}


try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase_												=	['OwlViTFeatureExtractor']
    UpperCamelCase_												=	['OwlViTImageProcessor']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase_												=	[
        'OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
        'OwlViTModel',
        'OwlViTPreTrainedModel',
        'OwlViTTextModel',
        'OwlViTVisionModel',
        'OwlViTForObjectDetection',
    ]

if TYPE_CHECKING:
    from .configuration_owlvit import (
        OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP,
        OwlViTConfig,
        OwlViTOnnxConfig,
        OwlViTTextConfig,
        OwlViTVisionConfig,
    )
    from .processing_owlvit import OwlViTProcessor

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_owlvit import OwlViTFeatureExtractor
        from .image_processing_owlvit import OwlViTImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_owlvit import (
            OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
            OwlViTForObjectDetection,
            OwlViTModel,
            OwlViTPreTrainedModel,
            OwlViTTextModel,
            OwlViTVisionModel,
        )

else:
    import sys

    UpperCamelCase_												=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



