




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





				'''simple docstring'''



				def __init__( self       , UpperCAmelCase_       , UpperCAmelCase_=3       , UpperCAmelCase_=32       , UpperCAmelCase_=3       , UpperCAmelCase_=10       , UpperCAmelCase_=[8, 16, 32, 64]       , UpperCAmelCase_=[1, 1, 2, 1]       , UpperCAmelCase_=True       , UpperCAmelCase_=True       , UpperCAmelCase_="relu"       , UpperCAmelCase_=3       , UpperCAmelCase_=None       , UpperCAmelCase_=["stage2", "stage3", "stage4"]       , UpperCAmelCase_=[2, 3, 4]       , UpperCAmelCase_=1       , ):
											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(UpperCAmelCase_						)
											lowerCAmelCase   =		out_features
											lowerCAmelCase   =		out_indices
											lowerCAmelCase   =		num_groups



				def       __snake_case		( self						):
											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       __snake_case		( self						):
											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       __snake_case		( self       , UpperCAmelCase_       , UpperCAmelCase_       , UpperCAmelCase_						):
											lowerCAmelCase   =		BitModel(config=UpperCAmelCase_						)
											model.to(UpperCAmelCase_						)
											model.eval()
											lowerCAmelCase   =		model(UpperCAmelCase_						)
											self.parent.assertEqual(
											    result.last_hidden_state.shape       , (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)       , )



				def       __snake_case		( self       , UpperCAmelCase_       , UpperCAmelCase_       , UpperCAmelCase_						):
											lowerCAmelCase   =		self.num_labels
											lowerCAmelCase   =		BitForImageClassification(UpperCAmelCase_						)
											model.to(UpperCAmelCase_						)
											model.eval()
											lowerCAmelCase   =		model(UpperCAmelCase_       , labels=UpperCAmelCase_						)
											self.parent.assertEqual(result.logits.shape       , (self.batch_size, self.num_labels)						)



				def       __snake_case		( self       , UpperCAmelCase_       , UpperCAmelCase_       , UpperCAmelCase_						):
											lowerCAmelCase   =		BitBackbone(config=UpperCAmelCase_						)
											model.to(UpperCAmelCase_						)
											model.eval()
											lowerCAmelCase   =		model(UpperCAmelCase_						)

											# 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=UpperCAmelCase_						)
											model.to(UpperCAmelCase_						)
											model.eval()
											lowerCAmelCase   =		model(UpperCAmelCase_						)

											# 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       __snake_case		( self						):
											lowerCAmelCase   =		self.prepare_config_and_inputs()
											lowerCAmelCase   ,     lowerCAmelCase   ,     lowerCAmelCase   =		config_and_inputs
											lowerCAmelCase   =		{'''pixel_values''': pixel_values}
											return config, inputs_dict




@require_torch
class 							__UpperCamelCase			( __UpperCAmelCase     ,					__UpperCAmelCase     ,					unittest.TestCase  ):





				'''simple docstring'''



				__a							: int										=(BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
				__a							: Any										=(
				    {"""feature-extraction""": BitModel, """image-classification""": BitForImageClassification}
				    if is_torch_available()
				    else {}
				)

				__a							: Tuple										=False
				__a							: List[str]										=False
				__a							: Dict										=False
				__a							: Tuple										=False
				__a							: int										=False



				def       __snake_case		( self						):
											lowerCAmelCase   =		BitModelTester(self						)
											lowerCAmelCase   =		ConfigTester(self       , config_class=UpperCAmelCase_       , has_text_modality=UpperCAmelCase_						)



				def       __snake_case		( self						):
											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       __snake_case		( self						):
											return



				@unittest.skip(reason='''Bit does not output attentions'''						)
				def       __snake_case		( self						):
											pass



				@unittest.skip(reason='''Bit does not use inputs_embeds'''						)
				def       __snake_case		( self						):
											pass



				@unittest.skip(reason='''Bit does not support input and output embeddings'''						)
				def       __snake_case		( self						):
											pass



				def       __snake_case		( self						):
											lowerCAmelCase   ,     lowerCAmelCase   =		self.model_tester.prepare_config_and_inputs_for_common()

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



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*UpperCAmelCase_						)



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_backbone(*UpperCAmelCase_						)



				def       __snake_case		( self						):
											lowerCAmelCase   ,     lowerCAmelCase   =		self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		lowerCAmelCase   =		model_class(config=UpperCAmelCase_						)
																		for name, module in model.named_modules():
																									if isinstance(UpperCAmelCase_       , (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       __snake_case		( self						):
											def check_hidden_states_output(UpperCAmelCase_       , UpperCAmelCase_       , UpperCAmelCase_						):
																		lowerCAmelCase   =		model_class(UpperCAmelCase_						)
																		model.to(UpperCAmelCase_						)
																		model.eval()

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

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

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

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

																									check_hidden_states_output(UpperCAmelCase_       , UpperCAmelCase_       , UpperCAmelCase_						)



				@unittest.skip(reason='''Bit does not use feedforward chunking'''						)
				def       __snake_case		( self						):
											pass



				def       __snake_case		( self						):
											lowerCAmelCase   =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase_						)






				@slow
				def       __snake_case		( self						):
											for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase   =		BitModel.from_pretrained(UpperCAmelCase_						)
																		self.assertIsNotNone(UpperCAmelCase_						)




def       UpperCAmelCase       (     ):
							lowerCAmelCase   =		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
							return image


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





				'''simple docstring'''



				@cached_property
				def       __snake_case		( self						):
											return (
											    BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						) if is_vision_available() else None
											)






				@slow
				def       __snake_case		( self						):
											lowerCAmelCase   =		BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(UpperCAmelCase_						)

											lowerCAmelCase   =		self.default_image_processor
											lowerCAmelCase   =		prepare_img()
											lowerCAmelCase   =		image_processor(images=UpperCAmelCase_       , return_tensors='''pt'''						).to(UpperCAmelCase_						)

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

											# verify the logits
											lowerCAmelCase   =		torch.Size((1, 10_00)						)
											self.assertEqual(outputs.logits.shape       , UpperCAmelCase_						)

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

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




@require_torch
class 							__UpperCamelCase			( __UpperCAmelCase     ,					unittest.TestCase  ):





				'''simple docstring'''



				__a							: Optional[int]										=(BitBackbone,) if is_torch_available() else ()
				__a							: Dict										=BitConfig

				__a							: Tuple										=False



				def       __snake_case		( self						):
											lowerCAmelCase   =		BitModelTester(self						)









import torch

from diffusers import StableDiffusionPipeline


UpperCAmelCase_						="""path-to-your-trained-model"""
UpperCAmelCase_						=StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.floataa).to("""cuda""")

UpperCAmelCase_						="""A photo of sks dog in a bucket"""
UpperCAmelCase_						=pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0]

image.save("""dog-bucket.png""")



