

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       ,							_a       ,							_a=1_3       ,							_a=3_2       ,							_a=2       ,							_a=3       ,							_a=1_6       ,							_a=[1, 2, 1]       ,							_a=[2, 2, 4]       ,							_a=2       ,							_a=2.0       ,							_a=True       ,							_a=0.0       ,							_a=0.0       ,							_a=0.1       ,							_a="gelu"       ,							_a=False       ,							_a=True       ,							_a=0.02       ,							_a=1e-5       ,							_a=True       ,							_a=None       ,							_a=True       ,							_a=1_0       ,							_a=8       ,							)    ->    int:
												_a	:    List[Any]         =		parent
												_a	:    Any         =		batch_size
												_a	:    Union[str, Any]         =		image_size
												_a	:    Tuple         =		patch_size
												_a	:    Any         =		num_channels
												_a	:    int         =		embed_dim
												_a	:    int         =		depths
												_a	:    str         =		num_heads
												_a	:    Dict         =		window_size
												_a	:    Optional[Any]         =		mlp_ratio
												_a	:    Optional[int]         =		qkv_bias
												_a	:    int         =		hidden_dropout_prob
												_a	:    Any         =		attention_probs_dropout_prob
												_a	:    int         =		drop_path_rate
												_a	:    int         =		hidden_act
												_a	:    Union[str, Any]         =		use_absolute_embeddings
												_a	:    List[str]         =		patch_norm
												_a	:    Any         =		layer_norm_eps
												_a	:    Optional[int]         =		initializer_range
												_a	:    Dict         =		is_training
												_a	:    List[Any]         =		scope
												_a	:    List[Any]         =		use_labels
												_a	:    Tuple         =		type_sequence_label_size
												_a	:    Union[str, Any]         =		encoder_stride


							def 				__lowercase				(			self       )    ->    Optional[Any]:
												_a	:    Tuple         =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

												_a	:    Union[str, Any]         =		None
												if self.use_labels:
																	_a	:    Tuple         =		ids_tensor([self.batch_size]       ,							self.type_sequence_label_size       )

												_a	:    int         =		self.get_config()

												return config, pixel_values, labels


							def 				__lowercase				(			self       )    ->    Union[str, Any]:
												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 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       )    ->    Tuple:
												_a	:    Tuple         =		SwinvaModel(config=_a       )
												model.to(_a       )
												model.eval()
												_a	:    Optional[Any]         =		model(_a       )

												_a	:    List[str]         =		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths       ) - 1))
												_a	:    List[str]         =		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 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       )    ->    str:
												_a	:    str         =		SwinvaForMaskedImageModeling(config=_a       )
												model.to(_a       )
												model.eval()
												_a	:    Tuple         =		model(_a       )
												self.parent.assertEqual(
												    result.logits.shape       ,							(self.batch_size, self.num_channels, self.image_size, self.image_size)       )

												# test greyscale images
												_a	:    Any         =		1
												_a	:    Optional[Any]         =		SwinvaForMaskedImageModeling(_a       )
												model.to(_a       )
												model.eval()

												_a	:    List[Any]         =		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
												_a	:    int         =		model(_a       )
												self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, 1, self.image_size, self.image_size)       )


							def 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       )    ->    Union[str, Any]:
												_a	:    Optional[int]         =		self.type_sequence_label_size
												_a	:    Any         =		SwinvaForImageClassification(_a       )
												model.to(_a       )
												model.eval()
												_a	:    Dict         =		model(_a       ,							labels=_a       )
												self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.type_sequence_label_size)       )




							def 				__lowercase				(			self       )    ->    List[Any]:
												_a	:    int         =		self.prepare_config_and_inputs()
												_a      ,					_a      ,					_a	:    Optional[Any]         =		config_and_inputs
												_a	:    Tuple         =		{'''pixel_values''': pixel_values}
												return config, inputs_dict



@require_torch
class 				UpperCAmelCase_		(			__lowercase				,       __lowercase				,       unittest.TestCase   ):
							"""simple docstring"""







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

							UpperCAmelCase__       :						Optional[Any]	    =    False
							UpperCAmelCase__       :						Tuple	    =    False
							UpperCAmelCase__       :						Any	    =    False
							UpperCAmelCase__       :						Dict	    =    False


							def 				__lowercase				(			self       )    ->    Union[str, Any]:
												_a	:    Tuple         =		SwinvaModelTester(self       )
												_a	:    Any         =		ConfigTester(self       ,							config_class=_a       ,							embed_dim=3_7       )


							def 				__lowercase				(			self       )    ->    Dict:
												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 				__lowercase				(			self       )    ->    str:
												_a	:    Tuple         =		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 				__lowercase				(			self       )    ->    Tuple:
												pass


							@unittest.skip(reason='''Swinv2 does not use inputs_embeds'''       )
							def 				__lowercase				(			self       )    ->    str:
												pass


							def 				__lowercase				(			self       )    ->    Tuple:
												_a      ,					_a	:    Optional[int]         =		self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	_a	:    int         =		model_class(_a       )
																	self.assertIsInstance(model.get_input_embeddings()       ,							(nn.Module)       )
																	_a	:    Optional[int]         =		model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(_a       ,							nn.Linear       )       )


							def 				__lowercase				(			self       )    ->    str:
												_a      ,					_a	:    Tuple         =		self.model_tester.prepare_config_and_inputs_for_common()

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

																	_a	:    Union[str, Any]         =		['''pixel_values''']
																	self.assertListEqual(arg_names[:1]       ,							_a       )


							def 				__lowercase				(			self       )    ->    Tuple:
												_a      ,					_a	:    List[str]         =		self.model_tester.prepare_config_and_inputs_for_common()
												_a	:    Dict         =		True

												for model_class in self.all_model_classes:
																	_a	:    Optional[int]         =		True
																	_a	:    Any         =		False
																	_a	:    Optional[Any]         =		True
																	_a	:    Dict         =		model_class(_a       )
																	model.to(_a       )
																	model.eval()
																	with torch.no_grad():
																						_a	:    Optional[int]         =		model(**self._prepare_for_class(_a       ,							_a       )       )
																	_a	:    Dict         =		outputs.attentions
																	_a	:    Any         =		len(self.model_tester.depths       )
																	self.assertEqual(len(_a       )       ,							_a       )

																	# check that output_attentions also work using config
																	del inputs_dict["output_attentions"]
																	_a	:    Union[str, Any]         =		True
																	_a	:    Optional[int]         =		config.window_size**2
																	_a	:    Optional[int]         =		model_class(_a       )
																	model.to(_a       )
																	model.eval()
																	with torch.no_grad():
																						_a	:    List[str]         =		model(**self._prepare_for_class(_a       ,							_a       )       )
																	_a	:    List[str]         =		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]       ,							)
																	_a	:    Optional[int]         =		len(_a       )

																	# Check attention is always last and order is fine
																	_a	:    Optional[int]         =		True
																	_a	:    str         =		True
																	_a	:    List[str]         =		model_class(_a       )
																	model.to(_a       )
																	model.eval()
																	with torch.no_grad():
																						_a	:    Dict         =		model(**self._prepare_for_class(_a       ,							_a       )       )

																	if hasattr(self.model_tester       ,							'''num_hidden_states_types'''       ):
																						_a	:    Optional[int]         =		self.model_tester.num_hidden_states_types
																	else:
																						# also another +1 for reshaped_hidden_states
																						_a	:    Dict         =		2
																	self.assertEqual(out_len + added_hidden_states       ,							len(_a       )       )

																	_a	:    List[Any]         =		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 				__lowercase				(			self       ,							_a       ,							_a       ,							_a       ,							_a       )    ->    Any:
												_a	:    Union[str, Any]         =		model_class(_a       )
												model.to(_a       )
												model.eval()

												with torch.no_grad():
																	_a	:    str         =		model(**self._prepare_for_class(_a       ,							_a       )       )

												_a	:    Tuple         =		outputs.hidden_states

												_a	:    int         =		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
												_a	:    Tuple         =		(
												    config.patch_size
												    if isinstance(config.patch_size       ,							collections.abc.Iterable       )
												    else (config.patch_size, config.patch_size)
												)

												_a	:    List[Any]         =		(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]       ,							)

												_a	:    Optional[int]         =		outputs.reshaped_hidden_states
												self.assertEqual(len(_a       )       ,							_a       )

												_a      ,					_a      ,					_a      ,					_a	:    List[Any]         =		reshaped_hidden_states[0].shape
												_a	:    Tuple         =		(
												    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 				__lowercase				(			self       )    ->    str:
												_a      ,					_a	:    List[str]         =		self.model_tester.prepare_config_and_inputs_for_common()

												_a	:    Optional[int]         =		(
												    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:
																	_a	:    Optional[Any]         =		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"]
																	_a	:    Dict         =		True

																	self.check_hidden_states_output(_a       ,							_a       ,							_a       ,							_a       )


							def 				__lowercase				(			self       )    ->    str:
												_a      ,					_a	:    List[str]         =		self.model_tester.prepare_config_and_inputs_for_common()
												_a	:    Optional[int]         =		3

												_a	:    List[Any]         =		(
												    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)
												)
												_a	:    str         =		(
												    config.patch_size
												    if isinstance(config.patch_size       ,							collections.abc.Iterable       )
												    else (config.patch_size, config.patch_size)
												)

												_a	:    Dict         =		image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
												_a	:    str         =		image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

												for model_class in self.all_model_classes:
																	_a	:    Optional[int]         =		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"]
																	_a	:    Tuple         =		True
																	self.check_hidden_states_output(_a       ,							_a       ,							_a       ,							(padded_height, padded_width)       )


							def 				__lowercase				(			self       )    ->    List[str]:
												_a	:    Optional[Any]         =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_image_modeling(*_a       )


							def 				__lowercase				(			self       )    ->    Union[str, Any]:
												_a	:    List[str]         =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*_a       )


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




							def 				__lowercase				(			self       )    ->    int:
												_a      ,					_a	:    Optional[Any]         =		self.model_tester.prepare_config_and_inputs_for_common()

												_a	:    List[str]         =		_config_zero_init(_a       )
												for model_class in self.all_model_classes:
																	_a	:    Tuple         =		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 				__lowercase				(			self       )    ->    List[Any]:
												return (
												    AutoImageProcessor.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''       )
												    if is_vision_available()
												    else None
												)




							@slow
							def 				__lowercase				(			self       )    ->    Tuple:
												_a	:    List[str]         =		SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''       ).to(
												    _a       )
												_a	:    List[Any]         =		self.default_image_processor

												_a	:    List[str]         =		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
												_a	:    Optional[int]         =		image_processor(images=_a       ,							return_tensors='''pt'''       ).to(_a       )

												# forward pass
												with torch.no_grad():
																	_a	:    List[str]         =		model(**_a       )

												# verify the logits
												_a	:    List[Any]         =		torch.Size((1, 1_0_0_0)       )
												self.assertEqual(outputs.logits.shape       ,							_a       )
												_a	:    Optional[Any]         =		torch.tensor([-0.3947, -0.4306, 0.0026]       ).to(_a       )
												self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,							_a       ,							atol=1e-4       )       )






import operator as op


a__				=		'''scaler.pt'''
a__				=		'''pytorch_model'''
a__				=		'''random_states'''
a__				=		'''optimizer'''
a__				=		'''scheduler'''
a__				=		'''pytorch_model.bin'''
a__				=		'''pytorch_model.bin.index.json'''
a__				=		'''model.safetensors'''
a__				=		'''model.safetensors.index.json'''
a__				=		'''1.10.2'''
a__				=		'''py38'''
a__				=		'''4.17.0'''
a__				=		['''ml.p3.16xlarge''', '''ml.p3dn.24xlarge''', '''ml.p4dn.24xlarge''']
a__				=		['''FULL_SHARD''', '''SHARD_GRAD_OP''', '''NO_SHARD''', '''HYBRID_SHARD''', '''HYBRID_SHARD_ZERO2''']
a__				=		['''TRANSFORMER_BASED_WRAP''', '''SIZE_BASED_WRAP''', '''NO_WRAP''']
a__				=		['''BACKWARD_PRE''', '''BACKWARD_POST''', '''NO_PREFETCH''']
a__				=		['''FULL_STATE_DICT''', '''LOCAL_STATE_DICT''', '''SHARDED_STATE_DICT''']
a__				=		'''2.0.1'''
a__				=		['''pdsh''', '''standard''', '''openmpi''', '''mvapich''']
a__				=		['''default''', '''reduce-overhead''', '''max-autotune''']

a__				=		{'''>''': op.gt, '''>=''': op.ge, '''==''': op.eq, '''!=''': op.ne, '''<=''': op.le, '''<''': op.lt}

# These are the args for `torch.distributed.launch` for pytorch < 1.9
a__				=		[
    '''nnodes''',
    '''nproc_per_node''',
    '''rdzv_backend''',
    '''rdzv_endpoint''',
    '''rdzv_id''',
    '''rdzv_conf''',
    '''standalone''',
    '''max_restarts''',
    '''monitor_interval''',
    '''start_method''',
    '''role''',
    '''module''',
    '''m''',
    '''no_python''',
    '''run_path''',
    '''log_dir''',
    '''r''',
    '''redirects''',
    '''t''',
    '''tee''',
    '''node_rank''',
    '''master_addr''',
    '''master_port''',
]

a__				=		['''DEEPSPEED''', '''MULTI_GPU''', '''FSDP''', '''MEGATRON_LM''']
a__				=		['''DEEPSPEED''', '''MULTI_XPU''', '''FSDP''']



