




import collections
import inspect
import unittest

from transformers import SwinvaConfig
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_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 SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
		from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	List[str]       ,     a       :	Any       ,     a       :	Dict=13       ,     a       :	Optional[Any]=32       ,     a       :	Union[str, Any]=2       ,     a       :	Optional[int]=3       ,     a       :	List[Any]=16       ,     a       :	List[Any]=[1, 2, 1]       ,     a       :	List[Any]=[2, 2, 4]       ,     a       :	Any=2       ,     a       :	Optional[Any]=2.0       ,     a       :	Optional[Any]=True       ,     a       :	Union[str, Any]=0.0       ,     a       :	int=0.0       ,     a       :	Dict=0.1       ,     a       :	str="gelu"       ,     a       :	int=False       ,     a       :	Any=True       ,     a       :	int=0.02       ,     a       :	Optional[int]=1E-5       ,     a       :	List[str]=True       ,     a       :	List[str]=None       ,     a       :	Tuple=True       ,     a       :	Tuple=10       ,     a       :	Tuple=8       ,     )			->					Dict:
										SCREAMING_SNAKE_CASE           =					parent
										SCREAMING_SNAKE_CASE           =					batch_size
										SCREAMING_SNAKE_CASE           =					image_size
										SCREAMING_SNAKE_CASE           =					patch_size
										SCREAMING_SNAKE_CASE           =					num_channels
										SCREAMING_SNAKE_CASE           =					embed_dim
										SCREAMING_SNAKE_CASE           =					depths
										SCREAMING_SNAKE_CASE           =					num_heads
										SCREAMING_SNAKE_CASE           =					window_size
										SCREAMING_SNAKE_CASE           =					mlp_ratio
										SCREAMING_SNAKE_CASE           =					qkv_bias
										SCREAMING_SNAKE_CASE           =					hidden_dropout_prob
										SCREAMING_SNAKE_CASE           =					attention_probs_dropout_prob
										SCREAMING_SNAKE_CASE           =					drop_path_rate
										SCREAMING_SNAKE_CASE           =					hidden_act
										SCREAMING_SNAKE_CASE           =					use_absolute_embeddings
										SCREAMING_SNAKE_CASE           =					patch_norm
										SCREAMING_SNAKE_CASE           =					layer_norm_eps
										SCREAMING_SNAKE_CASE           =					initializer_range
										SCREAMING_SNAKE_CASE           =					is_training
										SCREAMING_SNAKE_CASE           =					scope
										SCREAMING_SNAKE_CASE           =					use_labels
										SCREAMING_SNAKE_CASE           =					type_sequence_label_size
										SCREAMING_SNAKE_CASE           =					encoder_stride





							def    _UpperCAmelCase     (					self       :	List[Any]			)			->					Any:
										SCREAMING_SNAKE_CASE           =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

										SCREAMING_SNAKE_CASE           =					self.get_config()

										return config, pixel_values, labels





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					List[str]:
										return SwinvaConfig(
										    image_size=self.image_size       ,     patch_size=self.patch_size       ,     num_channels=self.num_channels       ,     embed_dim=self.embed_dim       ,     depths=self.depths       ,     num_heads=self.num_heads       ,     window_size=self.window_size       ,     mlp_ratio=self.mlp_ratio       ,     qkv_bias=self.qkv_bias       ,     hidden_dropout_prob=self.hidden_dropout_prob       ,     attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,     drop_path_rate=self.drop_path_rate       ,     hidden_act=self.hidden_act       ,     use_absolute_embeddings=self.use_absolute_embeddings       ,     path_norm=self.patch_norm       ,     layer_norm_eps=self.layer_norm_eps       ,     initializer_range=self.initializer_range       ,     encoder_stride=self.encoder_stride       ,     )





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Union[str, Any]       ,     a       :	Union[str, Any]       ,     a       :	Dict			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					SwinvaModel(config=__a			)
										model.to(__a			)
										model.eval()
										SCREAMING_SNAKE_CASE           =					model(__a			)

										SCREAMING_SNAKE_CASE           =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
										SCREAMING_SNAKE_CASE           =					int(config.embed_dim * 2 ** (len(config.depths			) - 1)			)

										self.parent.assertEqual(result.last_hidden_state.shape       ,     (self.batch_size, expected_seq_len, expected_dim)			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Dict       ,     a       :	Union[str, Any]       ,     a       :	Union[str, Any]			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					SwinvaForMaskedImageModeling(config=__a			)
										model.to(__a			)
										model.eval()
										SCREAMING_SNAKE_CASE           =					model(__a			)
										self.parent.assertEqual(
										    result.logits.shape       ,     (self.batch_size, self.num_channels, self.image_size, self.image_size)			)

										# test greyscale images
										SCREAMING_SNAKE_CASE           =					1
										SCREAMING_SNAKE_CASE           =					SwinvaForMaskedImageModeling(__a			)
										model.to(__a			)
										model.eval()

										SCREAMING_SNAKE_CASE           =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
										SCREAMING_SNAKE_CASE           =					model(__a			)
										self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, 1, self.image_size, self.image_size)			)





							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Union[str, Any]       ,     a       :	Optional[int]       ,     a       :	str			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					self.type_sequence_label_size
										SCREAMING_SNAKE_CASE           =					SwinvaForImageClassification(__a			)
										model.to(__a			)
										model.eval()
										SCREAMING_SNAKE_CASE           =					model(__a       ,     labels=__a			)
										self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)			)







							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					int:
										SCREAMING_SNAKE_CASE           =					self.prepare_config_and_inputs()
										SCREAMING_SNAKE_CASE           =					config_and_inputs
										SCREAMING_SNAKE_CASE           =					{"pixel_values": pixel_values}
										return config, inputs_dict





@require_torch
class 			UpperCAmelCase_      (   _UpperCamelCase		,      _UpperCamelCase		,      unittest.TestCase       ):




							'''simple docstring'''



							a__						  =     (
							    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
							)
							a__						  =     (
							    {"feature-extraction": SwinvaModel, "image-classification": SwinvaForImageClassification}
							    if is_torch_available()
							    else {}
							)

							a__						  =     False
							a__						  =     False
							a__						  =     False
							a__						  =     False





							def    _UpperCAmelCase     (					self       :	Tuple			)			->					int:
										SCREAMING_SNAKE_CASE           =					SwinvaModelTester(self			)
										SCREAMING_SNAKE_CASE           =					ConfigTester(self       ,     config_class=__a       ,     embed_dim=37			)





							def    _UpperCAmelCase     (					self       :	Dict			)			->					Tuple:
										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       :	Tuple			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__a			)





							@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""			)
							def    _UpperCAmelCase     (					self       :	Tuple			)			->					List[str]:
										pass





							@unittest.skip(reason="""Swinv2 does not use inputs_embeds"""			)
							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					Any:
										pass





							def    _UpperCAmelCase     (					self       :	Tuple			)			->					Any:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

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





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

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

													SCREAMING_SNAKE_CASE           =					["pixel_values"]
													self.assertListEqual(arg_names[:1]       ,     __a			)





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					str:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE           =					True

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					True
													SCREAMING_SNAKE_CASE           =					False
													SCREAMING_SNAKE_CASE           =					True
													SCREAMING_SNAKE_CASE           =					model_class(__a			)
													model.to(__a			)
													model.eval()
													with torch.no_grad():
																SCREAMING_SNAKE_CASE           =					model(**self._prepare_for_class(__a       ,     __a			)			)
													SCREAMING_SNAKE_CASE           =					outputs.attentions
													SCREAMING_SNAKE_CASE           =					len(self.model_tester.depths			)
													self.assertEqual(len(__a			)       ,     __a			)

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													SCREAMING_SNAKE_CASE           =					True
													SCREAMING_SNAKE_CASE           =					config.window_size**2
													SCREAMING_SNAKE_CASE           =					model_class(__a			)
													model.to(__a			)
													model.eval()
													with torch.no_grad():
																SCREAMING_SNAKE_CASE           =					model(**self._prepare_for_class(__a       ,     __a			)			)
													SCREAMING_SNAKE_CASE           =					outputs.attentions
													self.assertEqual(len(__a			)       ,     __a			)

													self.assertListEqual(
													    list(attentions[0].shape[-3:]			)       ,     [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,     )
													SCREAMING_SNAKE_CASE           =					len(__a			)

													# Check attention is always last and order is fine
													SCREAMING_SNAKE_CASE           =					True
													SCREAMING_SNAKE_CASE           =					True
													SCREAMING_SNAKE_CASE           =					model_class(__a			)
													model.to(__a			)
													model.eval()
													with torch.no_grad():
																SCREAMING_SNAKE_CASE           =					model(**self._prepare_for_class(__a       ,     __a			)			)

													if hasattr(self.model_tester       ,     """num_hidden_states_types"""			):
																SCREAMING_SNAKE_CASE           =					self.model_tester.num_hidden_states_types
													else:
																# also another +1 for reshaped_hidden_states
																SCREAMING_SNAKE_CASE           =					2
													self.assertEqual(out_len + added_hidden_states       ,     len(__a			)			)

													SCREAMING_SNAKE_CASE           =					outputs.attentions

													self.assertEqual(len(__a			)       ,     __a			)

													self.assertListEqual(
													    list(self_attentions[0].shape[-3:]			)       ,     [self.model_tester.num_heads[0], window_size_squared, window_size_squared]       ,     )





							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	str       ,     a       :	List[str]       ,     a       :	int       ,     a       :	str			)			->					int:
										SCREAMING_SNAKE_CASE           =					model_class(__a			)
										model.to(__a			)
										model.eval()

										with torch.no_grad():
													SCREAMING_SNAKE_CASE           =					model(**self._prepare_for_class(__a       ,     __a			)			)

										SCREAMING_SNAKE_CASE           =					outputs.hidden_states

										SCREAMING_SNAKE_CASE           =					getattr(
										    self.model_tester       ,     """expected_num_hidden_layers"""       ,     len(self.model_tester.depths			) + 1			)
										self.assertEqual(len(__a			)       ,     __a			)

										# Swinv2 has a different seq_length
										SCREAMING_SNAKE_CASE           =					(
										    config.patch_size
										    if isinstance(config.patch_size       ,     collections.abc.Iterable			)
										    else (config.patch_size, config.patch_size)
										)

										SCREAMING_SNAKE_CASE           =					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

										self.assertListEqual(
										    list(hidden_states[0].shape[-2:]			)       ,     [num_patches, self.model_tester.embed_dim]       ,     )

										SCREAMING_SNAKE_CASE           =					outputs.reshaped_hidden_states
										self.assertEqual(len(__a			)       ,     __a			)

										SCREAMING_SNAKE_CASE           =					reshaped_hidden_states[0].shape
										SCREAMING_SNAKE_CASE           =					(
										    reshaped_hidden_states[0].view(__a       ,     __a       ,     height * width			).permute(0       ,     2       ,     1			)
										)
										self.assertListEqual(
										    list(reshaped_hidden_states.shape[-2:]			)       ,     [num_patches, self.model_tester.embed_dim]       ,     )





							def    _UpperCAmelCase     (					self       :	Tuple			)			->					str:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

										SCREAMING_SNAKE_CASE           =					(
										    self.model_tester.image_size
										    if isinstance(self.model_tester.image_size       ,     collections.abc.Iterable			)
										    else (self.model_tester.image_size, self.model_tester.image_size)
										)

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					True
													self.check_hidden_states_output(__a       ,     __a       ,     __a       ,     __a			)

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

													self.check_hidden_states_output(__a       ,     __a       ,     __a       ,     __a			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE           =					3

										SCREAMING_SNAKE_CASE           =					(
										    self.model_tester.image_size
										    if isinstance(self.model_tester.image_size       ,     collections.abc.Iterable			)
										    else (self.model_tester.image_size, self.model_tester.image_size)
										)
										SCREAMING_SNAKE_CASE           =					(
										    config.patch_size
										    if isinstance(config.patch_size       ,     collections.abc.Iterable			)
										    else (config.patch_size, config.patch_size)
										)

										SCREAMING_SNAKE_CASE           =					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
										SCREAMING_SNAKE_CASE           =					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					True
													self.check_hidden_states_output(__a       ,     __a       ,     __a       ,     (padded_height, padded_width)			)

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													SCREAMING_SNAKE_CASE           =					True
													self.check_hidden_states_output(__a       ,     __a       ,     __a       ,     (padded_height, padded_width)			)





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*__a			)





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*__a			)





							@slow
							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					Dict:
										for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													SCREAMING_SNAKE_CASE           =					SwinvaModel.from_pretrained(__a			)
													self.assertIsNotNone(__a			)







							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					List[str]:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

										SCREAMING_SNAKE_CASE           =					_config_zero_init(__a			)
										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					model_class(config=__a			)
													for name, param in model.named_parameters():
																if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
																			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"""       ,     )





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




							'''simple docstring'''



							@cached_property
							def    _UpperCAmelCase     (					self       :	Tuple			)			->					int:
										return (
										    AutoImageProcessor.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""			)
										    if is_vision_available()
										    else None
										)







							@slow
							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					SwinvaForImageClassification.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""			).to(
										    __a			)
										SCREAMING_SNAKE_CASE           =					self.default_image_processor

										SCREAMING_SNAKE_CASE           =					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
										SCREAMING_SNAKE_CASE           =					image_processor(images=__a       ,     return_tensors="""pt"""			).to(__a			)

										# forward pass
										with torch.no_grad():
													SCREAMING_SNAKE_CASE           =					model(**__a			)

										# verify the logits
										SCREAMING_SNAKE_CASE           =					torch.Size((1, 1_000)			)
										self.assertEqual(outputs.logits.shape       ,     __a			)
										SCREAMING_SNAKE_CASE           =					torch.tensor([-0.3947, -0.4306, 0.0026]			).to(__a			)
										self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,     __a       ,     atol=1E-4			)			)






import argparse

from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_controlnet_from_original_ckpt


if __name__ == "__main__":
		__A						:							Tuple							=  argparse.ArgumentParser()

		parser.add_argument(
		    """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
		)
		parser.add_argument(
		    """--original_config_file""",
		    type=str,
		    required=True,
		    help="""The YAML config file corresponding to the original architecture.""",
		)
		parser.add_argument(
		    """--num_in_channels""",
		    default=None,
		    type=int,
		    help="""The number of input channels. If `None` number of input channels will be automatically inferred.""",
		)
		parser.add_argument(
		    """--image_size""",
		    default=5_1_2,
		    type=int,
		    help=(
		        """The image size that the model was trained on. Use 512 for Stable Diffusion v1.X and Stable Siffusion v2"""
		        """ Base. Use 768 for Stable Diffusion v2."""
		    ),
		)
		parser.add_argument(
		    """--extract_ema""",
		    action="""store_true""",
		    help=(
		        """Only relevant for checkpoints that have both EMA and non-EMA weights. Whether to extract the EMA weights"""
		        """ or not. Defaults to `False`. Add `--extract_ema` to extract the EMA weights. EMA weights usually yield"""
		        """ higher quality images for inference. Non-EMA weights are usually better to continue fine-tuning."""
		    ),
		)
		parser.add_argument(
		    """--upcast_attention""",
		    action="""store_true""",
		    help=(
		        """Whether the attention computation should always be upcasted. This is necessary when running stable"""
		        """ diffusion 2.1."""
		    ),
		)
		parser.add_argument(
		    """--from_safetensors""",
		    action="""store_true""",
		    help="""If `--checkpoint_path` is in `safetensors` format, load checkpoint with safetensors instead of PyTorch.""",
		)
		parser.add_argument(
		    """--to_safetensors""",
		    action="""store_true""",
		    help="""Whether to store pipeline in safetensors format or not.""",
		)
		parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
		parser.add_argument("""--device""", type=str, help="""Device to use (e.g. cpu, cuda:0, cuda:1, etc.)""")
		def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
					'''simple docstring'''
					if string == "True":
								return True
					elif string == "False":
								return False
					else:
								raise ValueError(f"""could not parse string as bool {string}"""   )

		parser.add_argument(
		    """--use_linear_projection""", help="""Override for use linear projection""", required=False, type=parse_bool
		)

		parser.add_argument("""--cross_attention_dim""", help="""Override for cross attention_dim""", required=False, type=int)

		__A						:							Union[str, Any]							=  parser.parse_args()

		__A						:							Any							=  download_controlnet_from_original_ckpt(
		    checkpoint_path=args.checkpoint_path,
		    original_config_file=args.original_config_file,
		    image_size=args.image_size,
		    extract_ema=args.extract_ema,
		    num_in_channels=args.num_in_channels,
		    upcast_attention=args.upcast_attention,
		    from_safetensors=args.from_safetensors,
		    device=args.device,
		    use_linear_projection=args.use_linear_projection,
		    cross_attention_dim=args.cross_attention_dim,
		)




		controlnet.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)






