





import inspect
import unittest

from transformers import ViTHybridConfig
from transformers.testing_utils import require_accelerate, 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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel
    from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image





class  A__    :




   """simple docstring"""



   def __init__(					self					,  lowercase					,  lowercase=13					,  lowercase=64					,  lowercase=2					,  lowercase=3					,  lowercase=True					,  lowercase=True					,  lowercase=32					,  lowercase=5					,  lowercase=4					,  lowercase=37					,  lowercase="gelu"					,  lowercase=0.1					,  lowercase=0.1					,  lowercase=10					,  lowercase=0.02					,  lowercase=[1, 16, 4, 4]					,  lowercase=None					,  )			->						List[Any]:







          '''simple docstring'''

          a__						:	Optional[int] =				parent
          a__						:	Optional[int] =				batch_size
          a__						:	Any =				image_size
          a__						:	Optional[Any] =				patch_size
          a__						:	Optional[Any] =				num_channels
          a__						:	int =				is_training
          a__						:	List[str] =				use_labels
          a__						:	List[str] =				hidden_size
          a__						:	Tuple =				num_hidden_layers
          a__						:	Optional[Any] =				num_attention_heads
          a__						:	Union[str, Any] =				intermediate_size
          a__						:	Optional[int] =				hidden_act
          a__						:	Optional[Any] =				hidden_dropout_prob
          a__						:	Any =				attention_probs_dropout_prob
          a__						:	Any =				type_sequence_label_size
          a__						:	Tuple =				initializer_range
          a__						:	Tuple =				scope
          a__						:	int =				backbone_featmap_shape

          # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
          # the number of patches is based on the feature map of the backbone, which by default uses an output stride
          # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size
          a__						:	Any =				(self.image_size // 32) ** 2
          a__						:	List[Any] =				num_patches + 1

   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          a__						:	List[str] =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

          a__						:	List[str] =				self.get_config()

          return config, pixel_values, labels

   def 							__lowercase		(					self)			->						Dict:







          '''simple docstring'''

          a__						:	List[str] =				{
              'global_padding': 'same',
              'layer_type': 'bottleneck',
              'depths': [3, 4, 9],
              'out_features': ['stage1', 'stage2', 'stage3'],
              'embedding_dynamic_padding': True,
              'hidden_sizes': [4, 8, 16, 32],
              'num_groups': 2,
          }

          return ViTHybridConfig(
              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=lowercase					,  initializer_range=self.initializer_range					,  backbone_featmap_shape=self.backbone_featmap_shape					,  backbone_config=lowercase					,  )

   def 							__lowercase		(					self					,  lowercase					,  lowercase					,  lowercase)			->						List[str]:







          '''simple docstring'''

          a__						:	List[str] =				ViTHybridModel(config=lowercase)
          model.to(lowercase)
          model.eval()
          a__						:	Union[str, Any] =				model(lowercase)
          self.parent.assertEqual(result.last_hidden_state.shape					,  (self.batch_size, self.seq_length, self.hidden_size))

   def 							__lowercase		(					self					,  lowercase					,  lowercase					,  lowercase)			->						Union[str, Any]:







          '''simple docstring'''

          a__						:	Dict =				self.type_sequence_label_size
          a__						:	Union[str, Any] =				ViTHybridForImageClassification(lowercase)
          model.to(lowercase)
          model.eval()
          a__						:	Tuple =				model(lowercase					,  labels=lowercase)
          self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.type_sequence_label_size))

   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          a__						:	List[str] =				self.prepare_config_and_inputs()
          a__ ,							a__ ,							a__						:	Union[str, Any] =				config_and_inputs
          a__						:	str =				{'pixel_values': pixel_values}
          return config, inputs_dict





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




   """simple docstring"""



   __A   :				Optional[Any]         =  (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
   __A   :				List[str]         =  (
       {'''feature-extraction''': ViTHybridModel, '''image-classification''': ViTHybridForImageClassification}
       if is_torch_available()
       else {}
   )
   __A   :				Any         =  False
   __A   :				Optional[int]         =  False
   __A   :				Optional[Any]         =  False

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







          '''simple docstring'''

          a__						:	Any =				ViTHybridModelTester(self)
          a__						:	Any =				ConfigTester(self					,  config_class=lowercase					,  has_text_modality=lowercase					,  hidden_size=37)

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







          '''simple docstring'''

          self.config_tester.run_common_tests()

   @unittest.skip(reason='ViT does not use inputs_embeds')
   def 							__lowercase		(					self)			->						Dict:







          '''simple docstring'''

          pass

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







          '''simple docstring'''

          a__ ,							a__						:	List[str] =				self.model_tester.prepare_config_and_inputs_for_common()

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

   def 							__lowercase		(					self)			->						int:







          '''simple docstring'''

          a__ ,							a__						:	str =				self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 a__						:	Union[str, Any] =				model_class(lowercase)
                 a__						:	Union[str, Any] =				inspect.signature(model.forward)
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 a__						:	Optional[Any] =				[*signature.parameters.keys()]

                 a__						:	Dict =				['pixel_values']
                 self.assertListEqual(arg_names[:1]					,  lowercase)

   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          a__						:	List[Any] =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase)

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







          '''simple docstring'''

          a__						:	Any =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowercase)

   def 							__lowercase		(					self)			->						Dict:







          '''simple docstring'''

          a__ ,							a__						:	Tuple =				self.model_tester.prepare_config_and_inputs_for_common()

          a__						:	Tuple =				_config_zero_init(lowercase)
          for model_class in self.all_model_classes:
                 a__						:	List[Any] =				model_class(config=lowercase)
                 # Skip the check for the backbone
                 for name, module in model.named_modules():
                        if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
                               a__						:	Dict =				[F'{name}.{key}' for key in module.state_dict().keys()]
                               break

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

   @slow
   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 a__						:	Optional[Any] =				ViTHybridModel.from_pretrained(lowercase)
                 self.assertIsNotNone(lowercase)



def A_	(		)  ->		int:
       a__						:	Dict =				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
       return image





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




   """simple docstring"""



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







          '''simple docstring'''

          return (
              ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0])
              if is_vision_available()
              else None
          )

   @slow
   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          a__						:	List[str] =				ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
              lowercase)

          a__						:	List[str] =				self.default_image_processor
          a__						:	List[Any] =				prepare_img()
          a__						:	Any =				image_processor(images=lowercase					,  return_tensors='pt').to(lowercase)

          # forward pass
          with torch.no_grad():
                 a__						:	Optional[Any] =				model(**lowercase)

          # verify the logits
          a__						:	Optional[Any] =				torch.Size((1, 1000))
          self.assertEqual(outputs.logits.shape					,  lowercase)

          a__						:	Any =				torch.tensor([-1.90_90, -0.49_93, -0.23_89]).to(lowercase)

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

   @slow
   @require_accelerate
   def 							__lowercase		(					self)			->						Optional[int]:







          '''simple docstring'''

          a__						:	List[str] =				ViTHybridImageProcessor.from_pretrained('google/vit-hybrid-base-bit-384')
          a__						:	Union[str, Any] =				ViTHybridForImageClassification.from_pretrained('google/vit-hybrid-base-bit-384'					,  device_map='auto')

          a__						:	Any =				prepare_img()

          a__						:	str =				image_processor(images=lowercase					,  return_tensors='pt')
          a__						:	List[Any] =				model(**lowercase)
          a__						:	int =				outputs.logits
          # model predicts one of the 1000 ImageNet classes
          a__						:	List[str] =				logits.argmax(-1).item()

          self.assertTrue(model.config.idalabel[predicted_class_idx]					,  'tabby, tabby cat')









import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference





class  A__    (							__UpperCAmelCase ,  unittest.TestCase	):




   """simple docstring"""



   __A   :				Optional[int]         =  ShapEImgaImgPipeline
   __A   :				Tuple         =  ['''image''']
   __A   :				Any         =  ['''image''']
   __A   :				Optional[Any]         =  [
       '''num_images_per_prompt''',
       '''num_inference_steps''',
       '''generator''',
       '''latents''',
       '''guidance_scale''',
       '''frame_size''',
       '''output_type''',
       '''return_dict''',
   ]
   __A   :				Dict         =  False

   @property
   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          return 32

   @property
   def 							__lowercase		(					self)			->						Optional[int]:







          '''simple docstring'''

          return 32

   @property
   def 							__lowercase		(					self)			->						Optional[Any]:







          '''simple docstring'''

          return self.time_input_dim * 4

   @property
   def 							__lowercase		(					self)			->						Union[str, Any]:







          '''simple docstring'''

          return 8

   @property
   def 							__lowercase		(					self)			->						Union[str, Any]:







          '''simple docstring'''

          torch.manual_seed(0)
          a__						:	Any =				CLIPVisionConfig(
              hidden_size=self.text_embedder_hidden_size					,  image_size=64					,  projection_dim=self.text_embedder_hidden_size					,  intermediate_size=37					,  num_attention_heads=4					,  num_channels=3					,  num_hidden_layers=5					,  patch_size=1					,  )

          a__						:	Dict =				CLIPVisionModel(lowercase)
          return model

   @property
   def 							__lowercase		(					self)			->						List[Any]:







          '''simple docstring'''

          a__						:	str =				CLIPImageProcessor(
              crop_size=224					,  do_center_crop=lowercase					,  do_normalize=lowercase					,  do_resize=lowercase					,  image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]					,  image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]					,  resample=3					,  size=224					,  )

          return image_processor

   @property
   def 							__lowercase		(					self)			->						str:







          '''simple docstring'''

          torch.manual_seed(0)

          a__						:	str =				{
              'num_attention_heads': 2,
              'attention_head_dim': 16,
              'embedding_dim': self.time_input_dim,
              'num_embeddings': 32,
              'embedding_proj_dim': self.text_embedder_hidden_size,
              'time_embed_dim': self.time_embed_dim,
              'num_layers': 1,
              'clip_embed_dim': self.time_input_dim * 2,
              'additional_embeddings': 0,
              'time_embed_act_fn': 'gelu',
              'norm_in_type': 'layer',
              'embedding_proj_norm_type': 'layer',
              'encoder_hid_proj_type': None,
              'added_emb_type': None,
          }

          a__						:	Any =				PriorTransformer(**lowercase)
          return model

   @property
   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          torch.manual_seed(0)

          a__						:	List[Any] =				{
              'param_shapes': (
                  (self.renderer_dim, 93),
                  (self.renderer_dim, 8),
                  (self.renderer_dim, 8),
                  (self.renderer_dim, 8),
              ),
              'd_latent': self.time_input_dim,
              'd_hidden': self.renderer_dim,
              'n_output': 12,
              'background': (
                  0.1,
                  0.1,
                  0.1,
              ),
          }
          a__						:	List[str] =				ShapERenderer(**lowercase)
          return model

   def 							__lowercase		(					self)			->						str:







          '''simple docstring'''

          a__						:	Dict =				self.dummy_prior
          a__						:	List[str] =				self.dummy_image_encoder
          a__						:	int =				self.dummy_image_processor
          a__						:	str =				self.dummy_renderer

          a__						:	Optional[int] =				HeunDiscreteScheduler(
              beta_schedule='exp'					,  num_train_timesteps=1024					,  prediction_type='sample'					,  use_karras_sigmas=lowercase					,  clip_sample=lowercase					,  clip_sample_range=1.0					,  )
          a__						:	List[Any] =				{
              'prior': prior,
              'image_encoder': image_encoder,
              'image_processor': image_processor,
              'renderer': renderer,
              'scheduler': scheduler,
          }

          return components

   def 							__lowercase		(					self					,  lowercase					,  lowercase=0)			->						List[str]:







          '''simple docstring'''

          a__						:	List[str] =				floats_tensor((1, 3, 64, 64)					,  rng=random.Random(lowercase)).to(lowercase)

          if str(lowercase).startswith('mps'):
                 a__						:	List[str] =				torch.manual_seed(lowercase)
          else:
                 a__						:	str =				torch.Generator(device=lowercase).manual_seed(lowercase)
          a__						:	Tuple =				{
              'image': input_image,
              'generator': generator,
              'num_inference_steps': 1,
              'frame_size': 32,
              'output_type': 'np',
          }
          return inputs

   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          a__						:	int =				'cpu'

          a__						:	List[str] =				self.get_dummy_components()

          a__						:	Dict =				self.pipeline_class(**lowercase)
          a__						:	Optional[int] =				pipe.to(lowercase)

          pipe.set_progress_bar_config(disable=lowercase)

          a__						:	Tuple =				pipe(**self.get_dummy_inputs(lowercase))
          a__						:	Any =				output.images[0]
          a__						:	Any =				image[0, -3:, -3:, -1]

          assert image.shape == (20, 32, 32, 3)

          a__						:	List[str] =				np.array(
              [
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
              ])

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2

   def 							__lowercase		(					self)			->						Any:







          '''simple docstring'''

          self._test_inference_batch_consistent(batch_sizes=[1, 2])

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







          '''simple docstring'''

          a__						:	str =				torch_device == 'cpu'
          a__						:	Tuple =				True
          self._test_inference_batch_single_identical(
              batch_size=2					,  test_max_difference=lowercase					,  relax_max_difference=lowercase					,  )

   def 							__lowercase		(					self)			->						Tuple:







          '''simple docstring'''

          a__						:	List[str] =				self.get_dummy_components()
          a__						:	str =				self.pipeline_class(**lowercase)
          a__						:	List[str] =				pipe.to(lowercase)
          pipe.set_progress_bar_config(disable=lowercase)

          a__						:	Optional[Any] =				1
          a__						:	List[str] =				2

          a__						:	Optional[Any] =				self.get_dummy_inputs(lowercase)

          for key in inputs.keys():
                 if key in self.batch_params:
                        a__						:	Any =				batch_size * [inputs[key]]

          a__						:	int =				pipe(**lowercase					,  num_images_per_prompt=lowercase)[0]

          assert images.shape[0] == batch_size * num_images_per_prompt





@slow
@require_torch_gpu
class  A__    (							unittest.TestCase	):




   """simple docstring"""



   def 							__lowercase		(					self)			->						Dict:







          '''simple docstring'''

          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()

   def 							__lowercase		(					self)			->						Dict:







          '''simple docstring'''

          a__						:	str =				load_image(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/corgi.png')
          a__						:	str =				load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
              '/shap_e/test_shap_e_img2img_out.npy')
          a__						:	List[str] =				ShapEImgaImgPipeline.from_pretrained('openai/shap-e-img2img')
          a__						:	Tuple =				pipe.to(lowercase)
          pipe.set_progress_bar_config(disable=lowercase)

          a__						:	List[Any] =				torch.Generator(device=lowercase).manual_seed(0)

          a__						:	Optional[int] =				pipe(
              lowercase					,  generator=lowercase					,  guidance_scale=3.0					,  num_inference_steps=64					,  frame_size=64					,  output_type='np'					,  ).images[0]

          assert images.shape == (20, 64, 64, 3)

          assert_mean_pixel_difference(lowercase					,  lowercase)


