





import numpy

# List of input, output pairs
UpperCAmelCase_      							=     (
    ((5, 2, 3), 15),
    ((6, 5, 9), 25),
    ((11, 12, 13), 41),
    ((1, 1, 1), 8),
    ((11, 12, 13), 41),
)
UpperCAmelCase_      							=     (((515, 22, 13), 555), ((61, 35, 49), 150))
UpperCAmelCase_      							=     [2, 4, 1, 5]
UpperCAmelCase_      							=     len(train_data)
UpperCAmelCase_      							=     0.0_09





def 						lowerCamelCase__     (     UpperCamelCase__			:       List[Any]       ,    UpperCamelCase__			:       str="train"						)			-> Union[str, Any]:



					'''simple docstring'''




					return calculate_hypothesis_value(UpperCamelCase__       ,    UpperCamelCase__						) - output(
					    UpperCamelCase__       ,    UpperCamelCase__						)





def 						lowerCamelCase__     (     UpperCamelCase__			:       List[Any]						)			-> Optional[int]:



					'''simple docstring'''




					_snake_case									=				0
					for i in range(len(UpperCamelCase__						) - 1						):
										hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
					hyp_val += parameter_vector[0]
					return hyp_val





def 						lowerCamelCase__     (     UpperCamelCase__			:       int       ,    UpperCamelCase__			:       Tuple						)			-> Tuple:



					'''simple docstring'''




					if data_set == "train":
										return train_data[example_no][1]
					elif data_set == "test":
										return test_data[example_no][1]
					return None





def 						lowerCamelCase__     (     UpperCamelCase__			:       Any       ,    UpperCamelCase__			:       List[str]						)			-> Dict:



					'''simple docstring'''




					if data_set == "train":
										return _hypothesis_value(train_data[example_no][0]						)
					elif data_set == "test":
										return _hypothesis_value(test_data[example_no][0]						)
					return None





def 						lowerCamelCase__     (     UpperCamelCase__			:       Any       ,    UpperCamelCase__			:       Union[str, Any]=m						)			-> Optional[int]:



					'''simple docstring'''




					_snake_case									=				0
					for i in range(UpperCamelCase__						):
										if index == -1:
															summation_value += _error(UpperCamelCase__						)
										else:
															summation_value += _error(UpperCamelCase__						) * train_data[i][0][index]
					return summation_value





def 						lowerCamelCase__     (     UpperCamelCase__			:       List[str]						)			-> Tuple:



					'''simple docstring'''




					_snake_case									=				summation_of_cost_derivative(UpperCamelCase__       ,    UpperCamelCase__						) / m
					return cost_derivative_value





def 						lowerCamelCase__     (     )			-> str:



					'''simple docstring'''




					global parameter_vector
					# Tune these values to set a tolerance value for predicted output
					_snake_case									=				0.00_0002
					_snake_case									=				0
					_snake_case									=				0
					while True:
										j += 1
										_snake_case									=				[0, 0, 0, 0]
										for i in range(0       ,    len(UpperCamelCase__						)						):
															_snake_case									=				get_cost_derivative(i - 1						)
															_snake_case									=				(
															    parameter_vector[i] - LEARNING_RATE * cost_derivative
															)
										if numpy.allclose(
										    UpperCamelCase__       ,    UpperCamelCase__       ,    atol=UpperCamelCase__       ,    rtol=UpperCamelCase__       ,    ):
															break
										_snake_case									=				temp_parameter_vector
					print(('Number of iterations:', j)						)





def 						lowerCamelCase__     (     )			-> str:



					'''simple docstring'''




					for i in range(len(UpperCamelCase__						)						):
										print(('Actual output value:', output(UpperCamelCase__       ,    'test'						))						)
										print(('Hypothesis output:', calculate_hypothesis_value(UpperCamelCase__       ,    'test'						))						)


if __name__ == "__main__":
					run_gradient_descent()
					print("""\nTesting gradient descent for a linear hypothesis function.\n""")
					test_gradient_descent()










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				,						lowerCAmelCase_				,						lowerCAmelCase_=13				,						lowerCAmelCase_=32				,						lowerCAmelCase_=2				,						lowerCAmelCase_=3				,						lowerCAmelCase_=16				,						lowerCAmelCase_=[1, 2, 1]				,						lowerCAmelCase_=[2, 2, 4]				,						lowerCAmelCase_=2				,						lowerCAmelCase_=2.0				,						lowerCAmelCase_=True				,						lowerCAmelCase_=0.0				,						lowerCAmelCase_=0.0				,						lowerCAmelCase_=0.1				,						lowerCAmelCase_="gelu"				,						lowerCAmelCase_=False				,						lowerCAmelCase_=True				,						lowerCAmelCase_=0.02				,						lowerCAmelCase_=1E-5				,						lowerCAmelCase_=True				,						lowerCAmelCase_=None				,						lowerCAmelCase_=True				,						lowerCAmelCase_=10				,						lowerCAmelCase_=8				,						)		->							Tuple:
										_snake_case									=				parent
										_snake_case									=				batch_size
										_snake_case									=				image_size
										_snake_case									=				patch_size
										_snake_case									=				num_channels
										_snake_case									=				embed_dim
										_snake_case									=				depths
										_snake_case									=				num_heads
										_snake_case									=				window_size
										_snake_case									=				mlp_ratio
										_snake_case									=				qkv_bias
										_snake_case									=				hidden_dropout_prob
										_snake_case									=				attention_probs_dropout_prob
										_snake_case									=				drop_path_rate
										_snake_case									=				hidden_act
										_snake_case									=				use_absolute_embeddings
										_snake_case									=				patch_norm
										_snake_case									=				layer_norm_eps
										_snake_case									=				initializer_range
										_snake_case									=				is_training
										_snake_case									=				scope
										_snake_case									=				use_labels
										_snake_case									=				type_sequence_label_size
										_snake_case									=				encoder_stride




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

										_snake_case									=				self.get_config()

										return config, pixel_values, labels




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

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

										# test greyscale images
										_snake_case									=				1
										_snake_case									=				SwinvaForMaskedImageModeling(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()

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




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Optional[int]:
										_snake_case									=				self.type_sequence_label_size
										_snake_case									=				SwinvaForImageClassification(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_snake_case									=				model(lowerCAmelCase_				,						labels=lowerCAmelCase_  )
										self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.type_sequence_label_size)  )






					def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
										_snake_case									=				self.prepare_config_and_inputs()
										_snake_case							,     _snake_case							,     _snake_case									=				config_and_inputs
										_snake_case									=				{'pixel_values': pixel_values}
										return config, inputs_dict





@require_torch
class 			UpperCamelCase_		(  _lowerCamelCase							,  _lowerCamelCase							,  unittest.TestCase					):
					lowerCAmelCase_							=	(
					    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
					)
					lowerCAmelCase_							=	(
					    {'''feature-extraction''': SwinvaModel, '''image-classification''': SwinvaForImageClassification}
					    if is_torch_available()
					    else {}
					)

					lowerCAmelCase_							=	False
					lowerCAmelCase_							=	False
					lowerCAmelCase_							=	False
					lowerCAmelCase_							=	False




					def 	lowerCAmelCase			(		self  )		->							Any:
										_snake_case									=				SwinvaModelTester(self  )
										_snake_case									=				ConfigTester(self				,						config_class=lowerCAmelCase_				,						embed_dim=37  )




					def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
										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 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase_  )




					@unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'  )
					def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
										pass




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




					def 	lowerCAmelCase			(		self  )		->							Dict:
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

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




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

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

															_snake_case									=				['pixel_values']
															self.assertListEqual(arg_names[:1]				,						lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Dict:
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case									=				True

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

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

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

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

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

															_snake_case									=				outputs.attentions

															self.assertEqual(len(lowerCAmelCase_  )				,						lowerCAmelCase_  )

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




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Any:
										_snake_case									=				model_class(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()

										with torch.no_grad():
															_snake_case									=				model(**self._prepare_for_class(lowerCAmelCase_				,						lowerCAmelCase_  )  )

										_snake_case									=				outputs.hidden_states

										_snake_case									=				getattr(
										    self.model_tester				,						'expected_num_hidden_layers'				,						len(self.model_tester.depths  ) + 1  )
										self.assertEqual(len(lowerCAmelCase_  )				,						lowerCAmelCase_  )

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

										_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]				,						)

										_snake_case									=				outputs.reshaped_hidden_states
										self.assertEqual(len(lowerCAmelCase_  )				,						lowerCAmelCase_  )

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




					def 	lowerCAmelCase			(		self  )		->							Tuple:
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

										_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:
															_snake_case									=				True
															self.check_hidden_states_output(lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )

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

															self.check_hidden_states_output(lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Tuple:
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case									=				3

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

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

										for model_class in self.all_model_classes:
															_snake_case									=				True
															self.check_hidden_states_output(lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_				,						(padded_height, padded_width)  )

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




					def 	lowerCAmelCase			(		self  )		->							Tuple:
										_snake_case									=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Dict:
										_snake_case									=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_  )




					@slow
					def 	lowerCAmelCase			(		self  )		->							int:
										for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case									=				SwinvaModel.from_pretrained(lowerCAmelCase_  )
															self.assertIsNotNone(lowerCAmelCase_  )






					def 	lowerCAmelCase			(		self  )		->							str:
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

										_snake_case									=				_config_zero_init(lowerCAmelCase_  )
										for model_class in self.all_model_classes:
															_snake_case									=				model_class(config=lowerCAmelCase_  )
															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 	lowerCAmelCase			(		self  )		->							Dict:
										return (
										    AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'  )
										    if is_vision_available()
										    else None
										)






					@slow
					def 	lowerCAmelCase			(		self  )		->							List[str]:
										_snake_case									=				SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'  ).to(
										    lowerCAmelCase_  )
										_snake_case									=				self.default_image_processor

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

										# forward pass
										with torch.no_grad():
															_snake_case									=				model(**lowerCAmelCase_  )

										# verify the logits
										_snake_case									=				torch.Size((1, 1000)  )
										self.assertEqual(outputs.logits.shape				,						lowerCAmelCase_  )
										_snake_case									=				torch.tensor([-0.39_47, -0.43_06, 0.00_26]  ).to(lowerCAmelCase_  )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]				,						lowerCAmelCase_				,						atol=1E-4  )  )



