
"""simple docstring"""



from collections.abc import Generator
from math import sin
def 					_UpperCAmelCase      ( __lowerCamelCase   :       List[Any]		)     ->					List[str]:





  if len(UpperCamelCase__		) != 32:
    raise ValueError('''Input must be of length 32'''		)

  _snake_case					     =       b''''''
  for i in [3, 2, 1, 0]:
    little_endian += string_aa[8 * i : 8 * i + 8]
  return little_endian
def 					_UpperCAmelCase      ( __lowerCamelCase   :       Optional[int]		)     ->					List[str]:





  if i < 0:
    raise ValueError('''Input must be non-negative'''		)

  _snake_case					     =       format(UpperCamelCase__ ,					'''08x'''		)[-8:]
  _snake_case					     =       b''''''
  for i in [3, 2, 1, 0]:
    little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('''utf-8'''		)
  return little_endian_hex
def 					_UpperCAmelCase      ( __lowerCamelCase   :       List[str]		)     ->					Optional[Any]:
  _snake_case					     =       b''''''
  for char in message:
    bit_string += format(UpperCamelCase__ ,					'''08b'''		).encode('''utf-8'''		)
  _snake_case					     =       format(len(UpperCamelCase__		) ,					'''064b'''		).encode('''utf-8'''		)

  # Pad bit_string to a multiple of 512 chars
  bit_string += b"1"
  while len(UpperCamelCase__		) % 5_12 != 4_48:
    bit_string += b"0"
  bit_string += to_little_endian(start_len[32:]		) + to_little_endian(start_len[:32]		)

  return bit_string
def 					_UpperCAmelCase      ( __lowerCamelCase   :       Dict		)     ->					Optional[Any]:





  if len(UpperCamelCase__		) % 5_12 != 0:
    raise ValueError('''Input must have length that\'s a multiple of 512'''		)

  for pos in range(0 ,					len(UpperCamelCase__		) ,					5_12		):
    _snake_case					     =       bit_string[pos : pos + 5_12]
    _snake_case					     =       []
    for i in range(0 ,					5_12 ,					32		):
      block_words.append(int(to_little_endian(block[i : i + 32]		) ,					2		)		)
    yield block_words
def 					_UpperCAmelCase      ( __lowerCamelCase   :       Tuple		)     ->					Dict:





  if i < 0:
    raise ValueError('''Input must be non-negative'''		)

  _snake_case					     =       format(UpperCamelCase__ ,					'''032b'''		)
  _snake_case					     =       ''''''
  for c in i_str:
    new_str += "1" if c == "0" else "0"
  return int(UpperCamelCase__ ,					2		)
def 					_UpperCAmelCase      ( __lowerCamelCase   :       Optional[int] ,					__lowerCamelCase   :       Any		)     ->					Any:
  return (a + b) % 2**32
def 					_UpperCAmelCase      ( __lowerCamelCase   :       str ,					__lowerCamelCase   :       Tuple		)     ->					Any:





  if i < 0:
    raise ValueError('''Input must be non-negative'''		)
  if shift < 0:
    raise ValueError('''Shift must be non-negative'''		)
  return ((i << shift) ^ (i >> (32 - shift))) % 2**32
def 					_UpperCAmelCase      ( __lowerCamelCase   :       int		)     ->					Optional[Any]:
  _snake_case					     =       preprocess(UpperCamelCase__		)

  _snake_case					     =       [int(2**32 * abs(sin(i + 1		)		)		) for i in range(64		)]

  # Starting states
  _snake_case					     =       0X67_45_23_01
  _snake_case					     =       0Xef_cd_ab_89
  _snake_case					     =       0X98_ba_dc_fe
  _snake_case					     =       0X10_32_54_76

  _snake_case					     =       [
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
  ]

  # Process bit string in chunks, each with 16 32-char words
  for block_words in get_block_words(UpperCamelCase__		):
    _snake_case					     =       aa
    _snake_case					     =       ba
    _snake_case					     =       ca
    _snake_case					     =       da

    # Hash current chunk
    for i in range(64		):
      if i <= 15:
        # f = (b & c) | (not_32(b) & d)     # Alternate definition for f
        _snake_case					     =       d ^ (b & (c ^ d))
        _snake_case					     =       i
      elif i <= 31:
        # f = (d & b) | (not_32(d) & c)     # Alternate definition for f
        _snake_case					     =       c ^ (d & (b ^ c))
        _snake_case					     =       (5 * i + 1) % 16
      elif i <= 47:
        _snake_case					     =       b ^ c ^ d
        _snake_case					     =       (3 * i + 5) % 16
      else:
        _snake_case					     =       c ^ (b | not_aa(UpperCamelCase__		))
        _snake_case					     =       (7 * i) % 16
      _snake_case					     =       (f + a + added_consts[i] + block_words[g]) % 2**32
      _snake_case					     =       d
      _snake_case					     =       c
      _snake_case					     =       b
      _snake_case					     =       sum_aa(UpperCamelCase__ ,					left_rotate_aa(UpperCamelCase__ ,					shift_amounts[i]		)		)

    # Add hashed chunk to running total
    _snake_case					     =       sum_aa(UpperCamelCase__ ,					UpperCamelCase__		)
    _snake_case					     =       sum_aa(UpperCamelCase__ ,					UpperCamelCase__		)
    _snake_case					     =       sum_aa(UpperCamelCase__ ,					UpperCamelCase__		)
    _snake_case					     =       sum_aa(UpperCamelCase__ ,					UpperCamelCase__		)

  _snake_case					     =       reformat_hex(UpperCamelCase__		) + reformat_hex(UpperCamelCase__		) + reformat_hex(UpperCamelCase__		) + reformat_hex(UpperCamelCase__		)
  return digest


if __name__ == "__main__":
 import doctest

 doctest.testmod()




"""simple docstring"""




import inspect
import unittest

from huggingface_hub import hf_hub_download

from transformers import ConvNextConfig, UperNetConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import 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 transformers import UperNetForSemanticSegmentation
				from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor
class 			UpperCamelCase__:





						def __init__(				self						,__UpperCAmelCase						,__UpperCAmelCase=13						,__UpperCAmelCase=32						,__UpperCAmelCase=3						,__UpperCAmelCase=4						,__UpperCAmelCase=[10, 20, 30, 40]						,__UpperCAmelCase=[2, 2, 3, 2]						,__UpperCAmelCase=True						,__UpperCAmelCase=True						,__UpperCAmelCase=37						,__UpperCAmelCase="gelu"						,__UpperCAmelCase=10						,__UpperCAmelCase=0.0_2						,__UpperCAmelCase=["stage2", "stage3", "stage4"]						,__UpperCAmelCase=3						,__UpperCAmelCase=None						,)    -> Optional[int]:
													A__		   =							parent
													A__		   =							batch_size
													A__		   =							image_size
													A__		   =							num_channels
													A__		   =							num_stages
													A__		   =							hidden_sizes
													A__		   =							depths
													A__		   =							is_training
													A__		   =							use_labels
													A__		   =							intermediate_size
													A__		   =							hidden_act
													A__		   =							type_sequence_label_size
													A__		   =							initializer_range
													A__		   =							out_features
													A__		   =							num_labels
													A__		   =							scope
													A__		   =							num_stages





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

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

													A__		   =							self.get_config()

													return config, pixel_values, labels





						def  snake_case__		(				self   )    -> str:
													return ConvNextConfig(
													    num_channels=self.num_channels						,num_stages=self.num_stages						,hidden_sizes=self.hidden_sizes						,depths=self.depths						,is_training=self.is_training						,intermediate_size=self.intermediate_size						,hidden_act=self.hidden_act						,out_features=self.out_features						,)





						def  snake_case__		(				self   )    -> Tuple:
													return UperNetConfig(
													    backbone_config=self.get_backbone_config()						,hidden_size=5_12						,pool_scales=[1, 2, 3, 6]						,use_auxiliary_head=__UpperCAmelCase						,auxiliary_loss_weight=0.4						,auxiliary_in_channels=40						,auxiliary_channels=2_56						,auxiliary_num_convs=1						,auxiliary_concat_input=__UpperCAmelCase						,loss_ignore_index=2_55						,num_labels=self.num_labels						,)





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )    -> Dict:
													A__		   =							UperNetForSemanticSegmentation(config=__UpperCAmelCase   )
													model.to(__UpperCAmelCase   )
													model.eval()
													A__		   =							model(__UpperCAmelCase   )
													self.parent.assertEqual(
													    result.logits.shape						,(self.batch_size, self.num_labels, self.image_size, self.image_size)   )





						def  snake_case__		(				self   )    -> str:
													A__		   =							self.prepare_config_and_inputs()
													(
													    (
													    A__
													)   ,     (
													    A__
													)   ,     (
													    A__
													)   ,     
													)		   =							config_and_inputs
													A__		   =							{'pixel_values': pixel_values}
													return config, inputs_dict






@require_torch
class 			UpperCamelCase__(	__A						,  __A						,  unittest.TestCase       ):
						lowerCAmelCase__     :  int  							=						(UperNetForSemanticSegmentation,) if is_torch_available() else ()
						lowerCAmelCase__     :  int  							=						{'image-segmentation': UperNetForSemanticSegmentation} if is_torch_available() else {}
						lowerCAmelCase__     :  Optional[int]  							=						False
						lowerCAmelCase__     :  List[Any]  							=						False
						lowerCAmelCase__     :  Tuple  							=						False
						lowerCAmelCase__     :  Optional[Any]  							=						False
						lowerCAmelCase__     :  Union[str, Any]  							=						False
						lowerCAmelCase__     :  Dict  							=						False





						def  snake_case__		(				self   )    -> Union[str, Any]:
													A__		   =							UperNetModelTester(self   )
													A__		   =							ConfigTester(self						,config_class=__UpperCAmelCase						,has_text_modality=__UpperCAmelCase						,hidden_size=37   )





						def  snake_case__		(				self   )    -> List[Any]:
													self.create_and_test_config_common_properties()
													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  snake_case__		(				self   )    -> int:
													return





						def  snake_case__		(				self   )    -> List[Any]:
													A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

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

																				A__		   =							['pixel_values']
																				self.assertListEqual(arg_names[:1]						,__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> Tuple:
													A__		   =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCAmelCase   )





						@unittest.skip(reason='UperNet does not use inputs_embeds'   )
						def  snake_case__		(				self   )    -> Optional[int]:
													pass





						@unittest.skip(reason='UperNet does not support input and output embeddings'   )
						def  snake_case__		(				self   )    -> Tuple:
													pass





						@unittest.skip(reason='UperNet does not have a base model'   )
						def  snake_case__		(				self   )    -> List[Any]:
													pass





						@unittest.skip(reason='UperNet does not have a base model'   )
						def  snake_case__		(				self   )    -> Dict:
													pass





						@require_torch_multi_gpu
						@unittest.skip(reason='UperNet has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'   )
						def  snake_case__		(				self   )    -> Any:
													pass





						@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'   )
						def  snake_case__		(				self   )    -> Dict:
													pass





						def  snake_case__		(				self   )    -> Optional[int]:
													def check_hidden_states_output(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   ):
																				A__		   =							model_class(__UpperCAmelCase   )
																				model.to(__UpperCAmelCase   )
																				model.eval()

																				with torch.no_grad():
																											A__		   =							model(**self._prepare_for_class(__UpperCAmelCase						,__UpperCAmelCase   )   )

																				A__		   =							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																				A__		   =							self.model_tester.num_stages
																				self.assertEqual(len(__UpperCAmelCase   )						,expected_num_stages + 1   )

																				# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
																				self.assertListEqual(
																				    list(hidden_states[0].shape[-2:]   )						,[self.model_tester.image_size // 4, self.model_tester.image_size // 4]						,)

													A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A__		   =							True
																				check_hidden_states_output(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )

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

																				check_hidden_states_output(__UpperCAmelCase						,__UpperCAmelCase						,__UpperCAmelCase   )





						def  snake_case__		(				self   )    -> Optional[Any]:
													A__   ,     A__		   =							self.model_tester.prepare_config_and_inputs_for_common()

													A__		   =							_config_zero_init(__UpperCAmelCase   )
													A__		   =							_config_zero_init(configs_no_init.backbone_config   )
													for model_class in self.all_model_classes:
																				A__		   =							model_class(config=__UpperCAmelCase   )
																				for name, param in model.named_parameters():
																											if 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'''						,)





						@unittest.skip(reason='UperNet does not have tied weights'   )
						def  snake_case__		(				self   )    -> str:
													pass





						@slow
						def  snake_case__		(				self   )    -> List[str]:
													for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__		   =							UperNetForSemanticSegmentation.from_pretrained(__UpperCAmelCase   )
																				self.assertIsNotNone(__UpperCAmelCase   )






def      UpperCAmelCase    (		):






							"""simple docstring"""





							A__		   =							hf_hub_download(
							    repo_id='hf-internal-testing/fixtures_ade20k'				,			repo_type='dataset'				,			filename='ADE_val_00000001.jpg' )
							A__		   =							Image.open(UpperCamelCase__ ).convert('RGB' )
							return image


@require_torch
@require_vision
@slow
class 			UpperCamelCase__(	unittest.TestCase       ):





						def  snake_case__		(				self   )    -> Dict:
													A__		   =							AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny'   )
													A__		   =							UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny'   ).to(__UpperCAmelCase   )

													A__		   =							prepare_img()
													A__		   =							processor(images=__UpperCAmelCase						,return_tensors='pt'   ).to(__UpperCAmelCase   )

													with torch.no_grad():
																				A__		   =							model(**__UpperCAmelCase   )

													A__		   =							torch.Size((1, model.config.num_labels, 5_12, 5_12)   )
													self.assertEqual(outputs.logits.shape						,__UpperCAmelCase   )

													A__		   =							torch.tensor(
													    [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]]   ).to(__UpperCAmelCase   )
													self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]						,__UpperCAmelCase						,atol=1e-4   )   )





						def  snake_case__		(				self   )    -> str:
													A__		   =							AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny'   )
													A__		   =							UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny'   ).to(__UpperCAmelCase   )

													A__		   =							prepare_img()
													A__		   =							processor(images=__UpperCAmelCase						,return_tensors='pt'   ).to(__UpperCAmelCase   )

													with torch.no_grad():
																				A__		   =							model(**__UpperCAmelCase   )

													A__		   =							torch.Size((1, model.config.num_labels, 5_12, 5_12)   )
													self.assertEqual(outputs.logits.shape						,__UpperCAmelCase   )

													A__		   =							torch.tensor(
													    [[-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.7_7_4_6, -8.7_7_4_6, -8.6_1_3_0]]   ).to(__UpperCAmelCase   )
													self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]						,__UpperCAmelCase						,atol=1e-4   )   )





