
"""simple docstring"""





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:



		def __init__( self    ,		__a    ,		__a=13    ,		__a=32    ,		__a=2    ,		__a=3    ,		__a=16    ,		__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=10    ,		__a=8    ,		)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  parent
							_UpperCamelCase										=  batch_size
							_UpperCamelCase										=  image_size
							_UpperCamelCase										=  patch_size
							_UpperCamelCase										=  num_channels
							_UpperCamelCase										=  embed_dim
							_UpperCamelCase										=  depths
							_UpperCamelCase										=  num_heads
							_UpperCamelCase										=  window_size
							_UpperCamelCase										=  mlp_ratio
							_UpperCamelCase										=  qkv_bias
							_UpperCamelCase										=  hidden_dropout_prob
							_UpperCamelCase										=  attention_probs_dropout_prob
							_UpperCamelCase										=  drop_path_rate
							_UpperCamelCase										=  hidden_act
							_UpperCamelCase										=  use_absolute_embeddings
							_UpperCamelCase										=  patch_norm
							_UpperCamelCase										=  layer_norm_eps
							_UpperCamelCase										=  initializer_range
							_UpperCamelCase										=  is_training
							_UpperCamelCase										=  scope
							_UpperCamelCase										=  use_labels
							_UpperCamelCase										=  type_sequence_label_size
							_UpperCamelCase										=  encoder_stride



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

							_UpperCamelCase										=  self.get_config()

							return config, pixel_values, labels



		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							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    ,		__a    ,		__a    ,		__a)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  SwinvaModel(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(__a)

							_UpperCamelCase										=  ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
							_UpperCamelCase										=  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    ,		__a    ,		__a    ,		__a)	->	List[str]:






							'''simple docstring'''
							_UpperCamelCase										=  SwinvaForMaskedImageModeling(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(__a)
							self.parent.assertEqual(
							    result.logits.shape    ,		(self.batch_size, self.num_channels, self.image_size, self.image_size))

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

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



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a)	->	Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  self.type_sequence_label_size
							_UpperCamelCase										=  SwinvaForImageClassification(__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase										=  model(__a    ,		labels=__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.type_sequence_label_size))




		def 						UpperCAmelCase							( self)	->	int:






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






@require_torch
class    _UpperCAmelCase(   a_				,					a_				,					unittest.TestCase     ):
		lowercase__      =				(
		    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
		)
		lowercase__      =				(
		    {"feature-extraction": SwinvaModel, "image-classification": SwinvaForImageClassification}
		    if is_torch_available()
		    else {}
		)

		lowercase__      =				False
		lowercase__      =				False
		lowercase__      =				False
		lowercase__      =				False



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






							'''simple docstring'''
							_UpperCamelCase										=  SwinvaModelTester(self)
							_UpperCamelCase										=  ConfigTester(self    ,		config_class=__a    ,		embed_dim=37)



		def 						UpperCAmelCase							( self)	->	int:






							'''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 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  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)	->	Any:






							'''simple docstring'''
							pass



		@unittest.skip(reason='''Swinv2 does not use inputs_embeds''')
		def 						UpperCAmelCase							( self)	->	Union[str, Any]:






							'''simple docstring'''
							pass



		def 						UpperCAmelCase							( self)	->	List[str]:






							'''simple docstring'''
							_UpperCamelCase			,  _UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()

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



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






							'''simple docstring'''
							_UpperCamelCase			,  _UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()

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

												_UpperCamelCase										=  ['''pixel_values''']
												self.assertListEqual(arg_names[:1]    ,		__a)



		def 						UpperCAmelCase							( self)	->	Optional[int]:






							'''simple docstring'''
							_UpperCamelCase			,  _UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()
							_UpperCamelCase										=  True

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

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

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

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

												_UpperCamelCase										=  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    ,		__a    ,		__a    ,		__a    ,		__a)	->	str:






							'''simple docstring'''
							_UpperCamelCase										=  model_class(__a)
							model.to(__a)
							model.eval()

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

							_UpperCamelCase										=  outputs.hidden_states

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

							_UpperCamelCase										=  (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]    ,		)

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

							_UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase										=  reshaped_hidden_states[0].shape
							_UpperCamelCase										=  (
							    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)	->	int:






							'''simple docstring'''
							_UpperCamelCase			,  _UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()

							_UpperCamelCase										=  (
							    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:
												_UpperCamelCase										=  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"]
												_UpperCamelCase										=  True

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



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






							'''simple docstring'''
							_UpperCamelCase			,  _UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()
							_UpperCamelCase										=  3

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

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

							for model_class in self.all_model_classes:
												_UpperCamelCase										=  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"]
												_UpperCamelCase										=  True
												self.check_hidden_states_output(__a    ,		__a    ,		__a    ,		(padded_height, padded_width))



		def 						UpperCAmelCase							( self)	->	List[str]:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*__a)



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






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__a)



		@slow
		def 						UpperCAmelCase							( self)	->	Optional[Any]:






							'''simple docstring'''







							for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase										=  SwinvaModel.from_pretrained(__a)
												self.assertIsNotNone(__a)




		def 						UpperCAmelCase							( self)	->	List[str]:






							'''simple docstring'''
							_UpperCamelCase			,  _UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()

							_UpperCamelCase										=  _config_zero_init(__a)
							for model_class in self.all_model_classes:
												_UpperCamelCase										=  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     ):



		@cached_property
		def 						UpperCAmelCase							( self)	->	Union[str, Any]:






							'''simple docstring'''
							return (
							    AutoImageProcessor.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256''')
							    if is_vision_available()
							    else None
							)




		@slow
		def 						UpperCAmelCase							( self)	->	Dict:






							'''simple docstring'''
							_UpperCamelCase										=  SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256''').to(
							    __a)
							_UpperCamelCase										=  self.default_image_processor

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

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

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








"""simple docstring"""





from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase



def 				lowerCamelCase__		(      __snake_case     )							->		None:


					"""simple docstring"""





					_UpperCamelCase			,  _UpperCamelCase										=  analyze_text(__snake_case     )
					_UpperCamelCase										=  list(''' ''' + ascii_lowercase     )
					# what is our total sum of probabilities.
					_UpperCamelCase										=  sum(single_char_strings.values()     )

					# one length string
					_UpperCamelCase										=  0
					# for each alpha we go in our dict and if it is in it we calculate entropy
					for ch in my_alphas:
										if ch in single_char_strings:
															_UpperCamelCase										=  single_char_strings[ch]
															_UpperCamelCase										=  my_str / all_sum
															my_fir_sum += prob * math.loga(__snake_case     )  # entropy formula.

    # print entropy
					print(F'''{round(-1 * my_fir_sum     ):.1f}'''     )

					# two len string
					_UpperCamelCase										=  sum(two_char_strings.values()     )
					_UpperCamelCase										=  0
					# for each alpha (two in size) calculate entropy.
					for cha in my_alphas:
										for cha in my_alphas:
															_UpperCamelCase										=  cha + cha
															if sequence in two_char_strings:
																				_UpperCamelCase										=  two_char_strings[sequence]
																				_UpperCamelCase										=  int(__snake_case     ) / all_sum
																				my_sec_sum += prob * math.loga(__snake_case     )

    # print second entropy
					print(F'''{round(-1 * my_sec_sum     ):.1f}'''     )

					# print the difference between them
					print(F'''{round((-1 * my_sec_sum) - (-1 * my_fir_sum)     ):.1f}'''     )



def 				lowerCamelCase__		(      __snake_case     )							->		tuple[dict, dict]:


					"""simple docstring"""





					_UpperCamelCase										=  Counter()  # type: ignore
					_UpperCamelCase										=  Counter()  # type: ignore
					single_char_strings[text[-1]] += 1

					# first case when we have space at start.
					two_char_strings[" " + text[0]] += 1
					for i in range(0,					len(__snake_case     ) - 1     ):
										single_char_strings[text[i]] += 1
										two_char_strings[text[i : i + 2]] += 1
					return single_char_strings, two_char_strings



def 				lowerCamelCase__		(      )							->		Dict:


					"""simple docstring"""





					import doctest

					doctest.testmod()
					# text = (
					#     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
					#     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
					#     "jointure saw horrible. He private he on be imagine suppose. Fertile "
					#     "beloved evident through no service elderly is. Blind there if every no so "
					#     "at. Own neglected you preferred way sincerity delivered his attempted. To "
					#     "of message cottage windows do besides against uncivil.  Delightful "
					#     "unreserved impossible few estimating men favourable see entreaties. She "
					#     "propriety immediate was improving. He or entrance humoured likewise "
					#     "moderate. Much nor game son say feel. Fat make met can must form into "
					#     "gate. Me we offending prevailed discovery. "
					# )

					# calculate_prob(text)


if __name__ == "__main__":
				main()






