'''simple docstring'''




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 							a__:


			'''simple docstring'''






			def __init__(  self			,       __lowerCAmelCase			,       __lowerCAmelCase=3			,       __lowerCAmelCase=32			,       __lowerCAmelCase=3			,       __lowerCAmelCase=10			,       __lowerCAmelCase=[8, 16, 32, 64]			,       __lowerCAmelCase=[1, 1, 2, 1]			,       __lowerCAmelCase=True			,       __lowerCAmelCase=True			,       __lowerCAmelCase="relu"			,       __lowerCAmelCase=3			,       __lowerCAmelCase=None			,       __lowerCAmelCase=["stage2", "stage3", "stage4"]			,       __lowerCAmelCase=[2, 3, 4]			,       __lowerCAmelCase=1			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    parent
					lowerCAmelCase     =    batch_size
					lowerCAmelCase     =    image_size
					lowerCAmelCase     =    num_channels
					lowerCAmelCase     =    embeddings_size
					lowerCAmelCase     =    hidden_sizes
					lowerCAmelCase     =    depths
					lowerCAmelCase     =    is_training
					lowerCAmelCase     =    use_labels
					lowerCAmelCase     =    hidden_act
					lowerCAmelCase     =    num_labels
					lowerCAmelCase     =    scope
					lowerCAmelCase     =    len(__lowerCAmelCase)
					lowerCAmelCase     =    out_features
					lowerCAmelCase     =    out_indices
					lowerCAmelCase     =    num_groups



			def 				a_			(  self):




					"""simple docstring"""


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

					lowerCAmelCase     =    None
					if self.use_labels:
							lowerCAmelCase     =    ids_tensor([self.batch_size]			,       self.num_labels)

					lowerCAmelCase     =    self.get_config()

					return config, pixel_values, labels



			def 				a_			(  self):




					"""simple docstring"""


					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 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase     =    BitModel(config=__lowerCAmelCase)
					model.to(__lowerCAmelCase)
					model.eval()
					lowerCAmelCase     =    model(__lowerCAmelCase)
					self.parent.assertEqual(
					    result.last_hidden_state.shape			,       (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)			,       )



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase     =    self.num_labels
					lowerCAmelCase     =    BitForImageClassification(__lowerCAmelCase)
					model.to(__lowerCAmelCase)
					model.eval()
					lowerCAmelCase     =    model(__lowerCAmelCase			,       labels=__lowerCAmelCase)
					self.parent.assertEqual(result.logits.shape			,       (self.batch_size, self.num_labels))



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase     =    BitBackbone(config=__lowerCAmelCase)
					model.to(__lowerCAmelCase)
					model.eval()
					lowerCAmelCase     =    model(__lowerCAmelCase)

					# 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
					lowerCAmelCase     =    None
					lowerCAmelCase     =    BitBackbone(config=__lowerCAmelCase)
					model.to(__lowerCAmelCase)
					model.eval()
					lowerCAmelCase     =    model(__lowerCAmelCase)

					# 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 				a_			(  self):




					"""simple docstring"""


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







@require_torch
class 							a__(   lowerCAmelCase__					,		lowerCAmelCase__					,		unittest.TestCase      ):


			'''simple docstring'''






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

			UpperCAmelCase_     :	Any						=			False
			UpperCAmelCase_     :	int						=			False
			UpperCAmelCase_     :	int						=			False
			UpperCAmelCase_     :	Union[str, Any]						=			False
			UpperCAmelCase_     :	int						=			False



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    BitModelTester(self)
					lowerCAmelCase     =    ConfigTester(self			,       config_class=__lowerCAmelCase			,       has_text_modality=__lowerCAmelCase)



			def 				a_			(  self):




					"""simple docstring"""


					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 				a_			(  self):




					"""simple docstring"""


					return



			@unittest.skip(reason="""Bit does not output attentions""")
			def 				a_			(  self):




					"""simple docstring"""


					pass



			@unittest.skip(reason="""Bit does not use inputs_embeds""")
			def 				a_			(  self):




					"""simple docstring"""


					pass



			@unittest.skip(reason="""Bit does not support input and output embeddings""")
			def 				a_			(  self):




					"""simple docstring"""


					pass



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase   ,	lowerCAmelCase     =    self.model_tester.prepare_config_and_inputs_for_common()

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

							lowerCAmelCase     =    ["""pixel_values"""]
							self.assertListEqual(arg_names[:1]			,       __lowerCAmelCase)



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__lowerCAmelCase)



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*__lowerCAmelCase)



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase   ,	lowerCAmelCase     =    self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
							lowerCAmelCase     =    model_class(config=__lowerCAmelCase)
							for name, module in model.named_modules():
									if isinstance(__lowerCAmelCase			,       (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 				a_			(  self):




					"""simple docstring"""


					def check_hidden_states_output(__lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):
							lowerCAmelCase     =    model_class(__lowerCAmelCase)
							model.to(__lowerCAmelCase)
							model.eval()

							with torch.no_grad():
									lowerCAmelCase     =    model(**self._prepare_for_class(__lowerCAmelCase			,       __lowerCAmelCase))

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

							lowerCAmelCase     =    self.model_tester.num_stages
							self.assertEqual(len(__lowerCAmelCase)			,       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]			,       )

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

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

									check_hidden_states_output(__lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase)



			@unittest.skip(reason="""Bit does not use feedforward chunking""")
			def 				a_			(  self):




					"""simple docstring"""


					pass



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase)







			@slow
			def 				a_			(  self):




					"""simple docstring"""


					for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							lowerCAmelCase     =    BitModel.from_pretrained(__lowerCAmelCase)
							self.assertIsNotNone(__lowerCAmelCase)







def 							snake_case__				(     )       ->      int:

		'''simple docstring'''


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






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


			'''simple docstring'''






			@cached_property
			def 				a_			(  self):




					"""simple docstring"""


					return (
					    BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]) if is_vision_available() else None
					)







			@slow
			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(__lowerCAmelCase)

					lowerCAmelCase     =    self.default_image_processor
					lowerCAmelCase     =    prepare_img()
					lowerCAmelCase     =    image_processor(images=__lowerCAmelCase			,       return_tensors="""pt""").to(__lowerCAmelCase)

					# forward pass
					with torch.no_grad():
							lowerCAmelCase     =    model(**__lowerCAmelCase)

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

					lowerCAmelCase     =    torch.tensor([[-0.6526, -0.5263, -1.4398]]).to(__lowerCAmelCase)

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







@require_torch
class 							a__(   lowerCAmelCase__					,		unittest.TestCase      ):


			'''simple docstring'''






			UpperCAmelCase_     :	List[Any]						=			(BitBackbone,) if is_torch_available() else ()
			UpperCAmelCase_     :	Union[str, Any]						=			BitConfig

			UpperCAmelCase_     :	Optional[Any]						=			False



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    BitModelTester(self)





'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowercase        =    {
    '''configuration_chinese_clip''': [
        '''CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''ChineseCLIPConfig''',
        '''ChineseCLIPOnnxConfig''',
        '''ChineseCLIPTextConfig''',
        '''ChineseCLIPVisionConfig''',
    ],
    '''processing_chinese_clip''': ['''ChineseCLIPProcessor'''],
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase        =    ['''ChineseCLIPFeatureExtractor''']
						__lowercase        =    ['''ChineseCLIPImageProcessor''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase        =    [
						    '''CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''ChineseCLIPModel''',
						    '''ChineseCLIPPreTrainedModel''',
						    '''ChineseCLIPTextModel''',
						    '''ChineseCLIPVisionModel''',
						]

if TYPE_CHECKING:
						from .configuration_chinese_clip import (
						    CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    ChineseCLIPConfig,
						    ChineseCLIPOnnxConfig,
						    ChineseCLIPTextConfig,
						    ChineseCLIPVisionConfig,
						)
						from .processing_chinese_clip import ChineseCLIPProcessor

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_chinese_clip import ChineseCLIPFeatureExtractor, ChineseCLIPImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_chinese_clip import (
												    CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
												    ChineseCLIPModel,
												    ChineseCLIPPreTrainedModel,
												    ChineseCLIPTextModel,
												    ChineseCLIPVisionModel,
												)

else:
						import sys

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




