



import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
	import torch

	from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin


class 	__snake_case   :
		def __init__(							self    ,a_    ,a_=None    ,a_=None    ,a_=None    ,a_="resnet50"    ,a_=3    ,a_=32    ,a_=3    ,a_=True    ,a_=True    ,):







						"""simple docstring"""
						lowerCAmelCase__		  =  parent
						lowerCAmelCase__		  =  out_indices if out_indices is not None else [4]
						lowerCAmelCase__		  =  stage_names
						lowerCAmelCase__		  =  out_features
						lowerCAmelCase__		  =  backbone
						lowerCAmelCase__		  =  batch_size
						lowerCAmelCase__		  =  image_size
						lowerCAmelCase__		  =  num_channels
						lowerCAmelCase__		  =  use_pretrained_backbone
						lowerCAmelCase__		  =  is_training
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__		  =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)
						lowerCAmelCase__		  =  self.get_config()

						return config, pixel_values
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return TimmBackboneConfig(
						    image_size=self.image_size    ,num_channels=self.num_channels    ,out_features=self.out_features    ,out_indices=self.out_indices    ,stage_names=self.stage_names    ,use_pretrained_backbone=self.use_pretrained_backbone    ,backbone=self.backbone    ,)
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_    ,a_						):







						"""simple docstring"""
						lowerCAmelCase__		  =  TimmBackbone(config=a_						)
						model.to(a_						)
						model.eval()
						with torch.no_grad():
										lowerCAmelCase__		  =  model(a_						)
						self.parent.assertEqual(
						    result.feature_map[-1].shape    ,(self.batch_size, model.channels[-1], 14, 14)    ,)



		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__		  =  self.prepare_config_and_inputs()
						lowerCAmelCase__  ,   lowerCAmelCase__		  =  config_and_inputs
						lowerCAmelCase__		  =  {'pixel_values': pixel_values}
						return config, inputs_dict



@require_torch
@require_timm
class 	__snake_case   ( SCREAMING_SNAKE_CASE							, SCREAMING_SNAKE_CASE							, SCREAMING_SNAKE_CASE							, unittest.TestCase ):
		SCREAMING_SNAKE_CASE__								=	(TimmBackbone,) if is_torch_available() else ()
		SCREAMING_SNAKE_CASE__								=	{'feature-extraction': TimmBackbone} if is_torch_available() else {}
		SCREAMING_SNAKE_CASE__								=	False
		SCREAMING_SNAKE_CASE__								=	False
		SCREAMING_SNAKE_CASE__								=	False
		SCREAMING_SNAKE_CASE__								=	False
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__		  =  TimmBackboneModelTester(self						)
						lowerCAmelCase__		  =  ConfigTester(self    ,config_class=a_    ,has_text_modality=a_						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						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 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__		  =  'resnet18'
						lowerCAmelCase__		  =  'microsoft/resnet-18'

						lowerCAmelCase__		  =  AutoBackbone.from_pretrained(a_    ,use_timm_backbone=a_						)
						lowerCAmelCase__		  =  AutoBackbone.from_pretrained(a_						)

						self.assertEqual(len(timm_model.out_features						)    ,len(transformers_model.out_features						)						)
						self.assertEqual(len(timm_model.stage_names						)    ,len(transformers_model.stage_names						)						)
						self.assertEqual(timm_model.channels    ,transformers_model.channels						)
						# Out indices are set to the last layer by default. For timm models, we don't know
						# the number of layers in advance, so we set it to (-1,), whereas for transformers
						# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
						self.assertEqual(timm_model.out_indices    ,(-1,)						)
						self.assertEqual(transformers_model.out_indices    ,[len(timm_model.stage_names						) - 1]						)

						lowerCAmelCase__		  =  AutoBackbone.from_pretrained(a_    ,use_timm_backbone=a_    ,out_indices=[1, 2, 3]						)
						lowerCAmelCase__		  =  AutoBackbone.from_pretrained(a_    ,out_indices=[1, 2, 3]						)

						self.assertEqual(timm_model.out_indices    ,transformers_model.out_indices						)
						self.assertEqual(len(timm_model.out_features						)    ,len(transformers_model.out_features						)						)
						self.assertEqual(timm_model.channels    ,transformers_model.channels						)
		@unittest.skip('TimmBackbone doesn\'t support feed forward chunking'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('TimmBackbone initialization is managed on the timm side'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('model weights aren\'t tied in TimmBackbone.'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('model weights aren\'t tied in TimmBackbone.'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('TimmBackbone doesn\'t support output_attentions.'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('Safetensors is not supported by timm.'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						pass
		def 						SCREAMING_SNAKE_CASE_					(							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(a_						)
										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]    ,a_						)
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__  ,   lowerCAmelCase__		  =  self.model_tester.prepare_config_and_inputs_for_common()
						lowerCAmelCase__		  =  True
						lowerCAmelCase__		  =  self.has_attentions

						# no need to test all models as different heads yield the same functionality
						lowerCAmelCase__		  =  self.all_model_classes[0]
						lowerCAmelCase__		  =  model_class(a_						)
						model.to(a_						)

						lowerCAmelCase__		  =  self._prepare_for_class(a_    ,a_						)
						lowerCAmelCase__		  =  model(**a_						)
						lowerCAmelCase__		  =  outputs[0][-1]

						# Encoder-/Decoder-only models
						lowerCAmelCase__		  =  outputs.hidden_states[0]
						hidden_states.retain_grad()

						if self.has_attentions:
										lowerCAmelCase__		  =  outputs.attentions[0]
										attentions.retain_grad()

						output.flatten()[0].backward(retain_graph=a_						)

						self.assertIsNotNone(hidden_states.grad						)

						if self.has_attentions:
										self.assertIsNotNone(attentions.grad						)



		def 						SCREAMING_SNAKE_CASE_					(							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(a_						)
										model.to(a_						)
										model.eval()
										lowerCAmelCase__		  =  model(**a_						)

										self.assertEqual(len(result.feature_maps						)    ,len(config.out_indices						)						)
										self.assertEqual(len(model.channels						)    ,len(config.out_indices						)						)

										# Check output of last stage is taken if out_features=None, out_indices=None
										lowerCAmelCase__		  =  copy.deepcopy(a_						)
										lowerCAmelCase__		  =  None
										lowerCAmelCase__		  =  model_class(a_						)
										model.to(a_						)
										model.eval()
										lowerCAmelCase__		  =  model(**a_						)

										self.assertEqual(len(result.feature_maps						)    ,1						)
										self.assertEqual(len(model.channels						)    ,1						)

										# Check backbone can be initialized with fresh weights
										lowerCAmelCase__		  =  copy.deepcopy(a_						)
										lowerCAmelCase__		  =  False
										lowerCAmelCase__		  =  model_class(a_						)
										model.to(a_						)
										model.eval()
										lowerCAmelCase__		  =  model(**a_						)





import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


_lowerCAmelCase	:   Any    =   False


class 	__snake_case   ( unittest.TestCase ):
		pass



@nightly
@require_torch_gpu
class 	__snake_case   ( unittest.TestCase ):
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__		  =  VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion'    ,torch_dtype=torch.floataa						)
						pipe.to(a_						)
						pipe.set_progress_bar_config(disable=a_						)

						lowerCAmelCase__		  =  load_image(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'						)

						lowerCAmelCase__		  =  torch.manual_seed(0						)
						lowerCAmelCase__		  =  pipe.dual_guided(
						    prompt='first prompt'    ,image=a_    ,text_to_image_strength=0.75    ,generator=a_    ,guidance_scale=7.5    ,num_inference_steps=2    ,output_type='numpy'    ,).images

						with tempfile.TemporaryDirectory() as tmpdirname:
										pipe.save_pretrained(a_						)
										lowerCAmelCase__		  =  VersatileDiffusionPipeline.from_pretrained(a_    ,torch_dtype=torch.floataa						)
						pipe.to(a_						)
						pipe.set_progress_bar_config(disable=a_						)

						lowerCAmelCase__		  =  generator.manual_seed(0						)
						lowerCAmelCase__		  =  pipe.dual_guided(
						    prompt='first prompt'    ,image=a_    ,text_to_image_strength=0.75    ,generator=a_    ,guidance_scale=7.5    ,num_inference_steps=2    ,output_type='numpy'    ,).images

						assert np.abs(image - new_image						).sum() < 1e-5, "Models don't have the same forward pass"



		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__		  =  VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion'    ,torch_dtype=torch.floataa						)
						pipe.to(a_						)
						pipe.set_progress_bar_config(disable=a_						)

						lowerCAmelCase__		  =  'cyberpunk 2077'
						lowerCAmelCase__		  =  load_image(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'						)
						lowerCAmelCase__		  =  torch.manual_seed(0						)
						lowerCAmelCase__		  =  pipe.dual_guided(
						    prompt=a_    ,image=a_    ,text_to_image_strength=0.75    ,generator=a_    ,guidance_scale=7.5    ,num_inference_steps=50    ,output_type='numpy'    ,).images

						lowerCAmelCase__		  =  image[0, 253:256, 253:256, -1]

						assert image.shape == (1, 512, 512, 3)
						lowerCAmelCase__		  =  np.array([0.1448, 0.1619, 0.1741, 0.1086, 0.1147, 0.1128, 0.1199, 0.1165, 0.1001]						)

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

						lowerCAmelCase__		  =  'A painting of a squirrel eating a burger '
						lowerCAmelCase__		  =  torch.manual_seed(0						)
						lowerCAmelCase__		  =  pipe.text_to_image(
						    prompt=a_    ,generator=a_    ,guidance_scale=7.5    ,num_inference_steps=50    ,output_type='numpy'						).images

						lowerCAmelCase__		  =  image[0, 253:256, 253:256, -1]

						assert image.shape == (1, 512, 512, 3)
						lowerCAmelCase__		  =  np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778]						)

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

						lowerCAmelCase__		  =  pipe.image_variation(a_    ,generator=a_    ,output_type='numpy'						).images

						lowerCAmelCase__		  =  image[0, 253:256, 253:256, -1]

						assert image.shape == (1, 512, 512, 3)
						lowerCAmelCase__		  =  np.array([0.3076, 0.3123, 0.3284, 0.3782, 0.3770, 0.3894, 0.4297, 0.4331, 0.4456]						)

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