





'''simple docstring'''

import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      MODEL_MAPPING,
      SegformerForImageClassification,
      SegformerForSemanticSegmentation,
      SegformerModel,
  )
  from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import SegformerImageProcessor






class    UpperCAmelCase	(       lowercase_				):
 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							List[str]:
     A__				=			self.config_class(**self.inputs_dict							)
     self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_						,       "hidden_sizes"							)							)
     self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_						,       "num_attention_heads"							)							)
     self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_						,       "num_encoder_blocks"							)							)






class    UpperCAmelCase	:
 def __init__(				self      :List[str]						,       lowercase_      :Tuple						,       lowercase_      :Any=13						,       lowercase_      :Dict=64						,       lowercase_      :Union[str, Any]=3						,       lowercase_      :List[str]=4						,       lowercase_      :Tuple=[2, 2, 2, 2]						,       lowercase_      :Tuple=[8, 4, 2, 1]						,       lowercase_      :Optional[Any]=[16, 32, 64, 1_28]						,       lowercase_      :Tuple=[1, 4, 8, 16]						,       lowercase_      :List[str]=[1, 2, 4, 8]						,       lowercase_      :Union[str, Any]=True						,       lowercase_      :Tuple=True						,       lowercase_      :Optional[int]="gelu"						,       lowercase_      :List[Any]=0.1						,       lowercase_      :List[Any]=0.1						,       lowercase_      :str=0.0_2						,       lowercase_      :Union[str, Any]=3						,       lowercase_      :Union[str, Any]=None						,       )->							int:
     A__				=			parent
     A__				=			batch_size
     A__				=			image_size
     A__				=			num_channels
     A__				=			num_encoder_blocks
     A__				=			sr_ratios
     A__				=			depths
     A__				=			hidden_sizes
     A__				=			downsampling_rates
     A__				=			num_attention_heads
     A__				=			is_training
     A__				=			use_labels
     A__				=			hidden_act
     A__				=			hidden_dropout_prob
     A__				=			attention_probs_dropout_prob
     A__				=			initializer_range
     A__				=			num_labels
     A__				=			scope
 def      UpperCAmelCase_							(				self      :Union[str, Any]							)->							Optional[int]:
     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.image_size, self.image_size]						,       self.num_labels							)

     A__				=			self.get_config()
     return config, pixel_values, labels
 def      UpperCAmelCase_							(				self      :List[str]							)->							List[str]:
     return SegformerConfig(
         image_size=self.image_size						,       num_channels=self.num_channels						,       num_encoder_blocks=self.num_encoder_blocks						,       depths=self.depths						,       hidden_sizes=self.hidden_sizes						,       num_attention_heads=self.num_attention_heads						,       hidden_act=self.hidden_act						,       hidden_dropout_prob=self.hidden_dropout_prob						,       attention_probs_dropout_prob=self.attention_probs_dropout_prob						,       initializer_range=self.initializer_range						,       )
 def      UpperCAmelCase_							(				self      :Optional[Any]						,       lowercase_      :Dict						,       lowercase_      :Dict						,       lowercase_      :Dict							)->							Any:
     A__				=			SegformerModel(config=SCREAMING_SNAKE_CASE_							)
     model.to(SCREAMING_SNAKE_CASE_							)
     model.eval()
     A__				=			model(SCREAMING_SNAKE_CASE_							)
     A__				=			self.image_size // (self.downsampling_rates[-1] * 2)
     self.parent.assertEqual(
         result.last_hidden_state.shape						,       (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)							)
 def      UpperCAmelCase_							(				self      :Optional[Any]						,       lowercase_      :Union[str, Any]						,       lowercase_      :List[Any]						,       lowercase_      :Dict							)->							Optional[int]:
     A__				=			self.num_labels
     A__				=			SegformerForSemanticSegmentation(SCREAMING_SNAKE_CASE_							)
     model.to(SCREAMING_SNAKE_CASE_							)
     model.eval()
     A__				=			model(SCREAMING_SNAKE_CASE_							)
     self.parent.assertEqual(
         result.logits.shape						,       (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)							)
     A__				=			model(SCREAMING_SNAKE_CASE_						,       labels=SCREAMING_SNAKE_CASE_							)
     self.parent.assertEqual(
         result.logits.shape						,       (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)							)
     self.parent.assertGreater(result.loss						,       0.0							)
 def      UpperCAmelCase_							(				self      :Union[str, Any]						,       lowercase_      :List[Any]						,       lowercase_      :Any						,       lowercase_      :Union[str, Any]							)->							Tuple:
     A__				=			1
     A__				=			SegformerForSemanticSegmentation(config=SCREAMING_SNAKE_CASE_							)
     model.to(SCREAMING_SNAKE_CASE_							)
     model.eval()
     A__				=			torch.randint(0						,       1						,       (self.batch_size, self.image_size, self.image_size)							).to(SCREAMING_SNAKE_CASE_							)
     A__				=			model(SCREAMING_SNAKE_CASE_						,       labels=SCREAMING_SNAKE_CASE_							)
     self.parent.assertGreater(result.loss						,       0.0							)



 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							Any:
     A__				=			self.prepare_config_and_inputs()
     A__				=			config_and_inputs
     A__				=			{'pixel_values': pixel_values}
     return config, inputs_dict






@require_torch
class    UpperCAmelCase	(       lowercase_			,       lowercase_			,       unittest.TestCase				):
 __lowercase   		=				(
     (
         SegformerModel,
         SegformerForSemanticSegmentation,
         SegformerForImageClassification,
     )
     if is_torch_available()
     else ()
 )
 __lowercase   		=				(
     {
         """feature-extraction""": SegformerModel,
         """image-classification""": SegformerForImageClassification,
         """image-segmentation""": SegformerForSemanticSegmentation,
     }
     if is_torch_available()
     else {}
 )

 __lowercase   		=				True
 __lowercase   		=				False
 __lowercase   		=				False
 __lowercase   		=				False
 def      UpperCAmelCase_							(				self      :int							)->							Any:
     A__				=			SegformerModelTester(self							)
     A__				=			SegformerConfigTester(self						,       config_class=SCREAMING_SNAKE_CASE_							)
 def      UpperCAmelCase_							(				self      :Tuple							)->							Dict:
     self.config_tester.run_common_tests()
 def      UpperCAmelCase_							(				self      :Dict							)->							Optional[int]:
     A__				=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_							)
 def      UpperCAmelCase_							(				self      :str							)->							Union[str, Any]:
     A__				=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_binary_image_segmentation(*SCREAMING_SNAKE_CASE_							)
 def      UpperCAmelCase_							(				self      :Any							)->							int:
     A__				=			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_segmentation(*SCREAMING_SNAKE_CASE_							)
 @unittest.skip("SegFormer does not use inputs_embeds"							)
 def      UpperCAmelCase_							(				self      :Optional[int]							)->							List[Any]:
     pass
 @unittest.skip("SegFormer does not have get_input_embeddings method and get_output_embeddings methods"							)
 def      UpperCAmelCase_							(				self      :List[str]							)->							Union[str, Any]:
     pass
 def      UpperCAmelCase_							(				self      :Optional[int]							)->							int:
     A__				=			self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         A__				=			model_class(SCREAMING_SNAKE_CASE_							)
         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]						,       SCREAMING_SNAKE_CASE_							)
 def      UpperCAmelCase_							(				self      :Tuple							)->							Union[str, Any]:
     A__				=			self.model_tester.prepare_config_and_inputs_for_common()
     A__				=			True

     for model_class in self.all_model_classes:
         A__				=			True
         A__				=			False
         A__				=			True
         A__				=			model_class(SCREAMING_SNAKE_CASE_							)
         model.to(SCREAMING_SNAKE_CASE_							)
         model.eval()
         with torch.no_grad():
             A__				=			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_						,       SCREAMING_SNAKE_CASE_							)							)
         A__				=			outputs.attentions

         A__				=			sum(self.model_tester.depths							)
         self.assertEqual(len(SCREAMING_SNAKE_CASE_							)						,       SCREAMING_SNAKE_CASE_							)

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

         self.assertEqual(len(SCREAMING_SNAKE_CASE_							)						,       SCREAMING_SNAKE_CASE_							)

         # verify the first attentions (first block, first layer)
         A__				=			(self.model_tester.image_size // 4) ** 2
         A__				=			(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
         self.assertListEqual(
             list(attentions[0].shape[-3:]							)						,       [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]						,       )

         # verify the last attentions (last block, last layer)
         A__				=			(self.model_tester.image_size // 32) ** 2
         A__				=			(self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
         self.assertListEqual(
             list(attentions[-1].shape[-3:]							)						,       [self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]						,       )
         A__				=			len(SCREAMING_SNAKE_CASE_							)

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

         self.assertEqual(out_len + 1						,       len(SCREAMING_SNAKE_CASE_							)							)

         A__				=			outputs.attentions

         self.assertEqual(len(SCREAMING_SNAKE_CASE_							)						,       SCREAMING_SNAKE_CASE_							)
         # verify the first attentions (first block, first layer)
         A__				=			(self.model_tester.image_size // 4) ** 2
         A__				=			(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
         self.assertListEqual(
             list(self_attentions[0].shape[-3:]							)						,       [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]						,       )
 def      UpperCAmelCase_							(				self      :List[Any]							)->							Optional[Any]:
     def check_hidden_states_output(lowercase_      :Optional[int]						,       lowercase_      :List[Any]						,       lowercase_      :str							):
         A__				=			model_class(SCREAMING_SNAKE_CASE_							)
         model.to(SCREAMING_SNAKE_CASE_							)
         model.eval()

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

         A__				=			outputs.hidden_states

         A__				=			self.model_tester.num_encoder_blocks
         self.assertEqual(len(SCREAMING_SNAKE_CASE_							)						,       SCREAMING_SNAKE_CASE_							)

         # verify the first hidden states (first block)
         self.assertListEqual(
             list(hidden_states[0].shape[-3:]							)						,       [
                 self.model_tester.hidden_sizes[0],
                 self.model_tester.image_size // 4,
                 self.model_tester.image_size // 4,
             ]						,       )

     A__				=			self.model_tester.prepare_config_and_inputs_for_common()

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

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

         check_hidden_states_output(SCREAMING_SNAKE_CASE_						,       SCREAMING_SNAKE_CASE_						,       SCREAMING_SNAKE_CASE_							)
 def      UpperCAmelCase_							(				self      :Any							)->							str:
     if not self.model_tester.is_training:
         return

     A__				=			self.model_tester.prepare_config_and_inputs_for_common()
     A__				=			True

     for model_class in self.all_model_classes:
         if model_class in get_values(SCREAMING_SNAKE_CASE_							):
             continue

         A__				=			model_class(SCREAMING_SNAKE_CASE_							)
         model.to(SCREAMING_SNAKE_CASE_							)
         model.train()
         A__				=			self._prepare_for_class(SCREAMING_SNAKE_CASE_						,       SCREAMING_SNAKE_CASE_						,       return_labels=SCREAMING_SNAKE_CASE_							)
         A__				=			model(**SCREAMING_SNAKE_CASE_							).loss
         loss.backward()
 @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."							)
 def      UpperCAmelCase_							(				self      :Dict							)->							Tuple:
     pass



 @slow
 def      UpperCAmelCase_							(				self      :List[str]							)->							Union[str, Any]:
     for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         A__				=			SegformerModel.from_pretrained(SCREAMING_SNAKE_CASE_							)
         self.assertIsNotNone(SCREAMING_SNAKE_CASE_							)





def 						UpperCamelCase				(							):
    A__				=			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
    return image






@require_torch
class    UpperCAmelCase	(       unittest.TestCase				):
 @slow
 def      UpperCAmelCase_							(				self      :Tuple							)->							Union[str, Any]:
     # only resize + normalize
     A__				=			SegformerImageProcessor(
         image_scale=(5_12, 5_12)						,       keep_ratio=SCREAMING_SNAKE_CASE_						,       align=SCREAMING_SNAKE_CASE_						,       do_random_crop=SCREAMING_SNAKE_CASE_							)
     A__				=			SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512"							).to(
         SCREAMING_SNAKE_CASE_							)

     A__				=			prepare_img()
     A__				=			image_processor(images=SCREAMING_SNAKE_CASE_						,       return_tensors="pt"							)
     A__				=			encoded_inputs.pixel_values.to(SCREAMING_SNAKE_CASE_							)

     with torch.no_grad():
         A__				=			model(SCREAMING_SNAKE_CASE_							)

     A__				=			torch.Size((1, model.config.num_labels, 1_28, 1_28)							)
     self.assertEqual(outputs.logits.shape						,       SCREAMING_SNAKE_CASE_							)

     A__				=			torch.tensor(
         [
             [[-4.6_3_1_0, -5.5_2_3_2, -6.2_3_5_6], [-5.1_9_2_1, -6.1_4_4_4, -6.5_9_9_6], [-5.4_4_2_4, -6.2_7_9_0, -6.7_5_7_4]],
             [[-1_2.1_3_9_1, -1_3.3_1_2_2, -1_3.9_5_5_4], [-1_2.8_7_3_2, -1_3.9_3_5_2, -1_4.3_5_6_3], [-1_2.9_4_3_8, -1_3.8_2_2_6, -1_4.2_5_1_3]],
             [[-1_2.5_1_3_4, -1_3.4_6_8_6, -1_4.4_9_1_5], [-1_2.8_6_6_9, -1_4.4_3_4_3, -1_4.7_7_5_8], [-1_3.2_5_2_3, -1_4.5_8_1_9, -1_5.0_6_9_4]],
         ]							).to(SCREAMING_SNAKE_CASE_							)
     self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]						,       SCREAMING_SNAKE_CASE_						,       atol=1E-4							)							)
 @slow
 def      UpperCAmelCase_							(				self      :Union[str, Any]							)->							List[str]:
     # only resize + normalize
     A__				=			SegformerImageProcessor(
         image_scale=(5_12, 5_12)						,       keep_ratio=SCREAMING_SNAKE_CASE_						,       align=SCREAMING_SNAKE_CASE_						,       do_random_crop=SCREAMING_SNAKE_CASE_							)
     A__				=			SegformerForSemanticSegmentation.from_pretrained(
         "nvidia/segformer-b1-finetuned-cityscapes-1024-1024"							).to(SCREAMING_SNAKE_CASE_							)

     A__				=			prepare_img()
     A__				=			image_processor(images=SCREAMING_SNAKE_CASE_						,       return_tensors="pt"							)
     A__				=			encoded_inputs.pixel_values.to(SCREAMING_SNAKE_CASE_							)

     with torch.no_grad():
         A__				=			model(SCREAMING_SNAKE_CASE_							)

     A__				=			torch.Size((1, model.config.num_labels, 1_28, 1_28)							)
     self.assertEqual(outputs.logits.shape						,       SCREAMING_SNAKE_CASE_							)

     A__				=			torch.tensor(
         [
             [[-1_3.5_7_4_8, -1_3.9_1_1_1, -1_2.6_5_0_0], [-1_4.3_5_0_0, -1_5.3_6_8_3, -1_4.2_3_2_8], [-1_4.7_5_3_2, -1_6.0_4_2_4, -1_5.6_0_8_7]],
             [[-1_7.1_6_5_1, -1_5.8_7_2_5, -1_2.9_6_5_3], [-1_7.2_5_8_0, -1_7.3_7_1_8, -1_4.8_2_2_3], [-1_6.6_0_5_8, -1_6.8_7_8_3, -1_6.7_4_5_2]],
             [[-3.6_4_5_6, -3.0_2_0_9, -1.4_2_0_3], [-3.0_7_9_7, -3.1_9_5_9, -2.0_0_0_0], [-1.8_7_5_7, -1.9_2_1_7, -1.6_9_9_7]],
         ]							).to(SCREAMING_SNAKE_CASE_							)
     self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]						,       SCREAMING_SNAKE_CASE_						,       atol=1E-1							)							)



 @slow
 def      UpperCAmelCase_							(				self      :Any							)->							Union[str, Any]:
     # only resize + normalize
     A__				=			SegformerImageProcessor(
         image_scale=(5_12, 5_12)						,       keep_ratio=SCREAMING_SNAKE_CASE_						,       align=SCREAMING_SNAKE_CASE_						,       do_random_crop=SCREAMING_SNAKE_CASE_							)
     A__				=			SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512"							).to(
         SCREAMING_SNAKE_CASE_							)

     A__				=			prepare_img()
     A__				=			image_processor(images=SCREAMING_SNAKE_CASE_						,       return_tensors="pt"							)
     A__				=			encoded_inputs.pixel_values.to(SCREAMING_SNAKE_CASE_							)

     with torch.no_grad():
         A__				=			model(SCREAMING_SNAKE_CASE_							)

     A__				=			outputs.logits.detach().cpu()

     A__				=			image_processor.post_process_semantic_segmentation(outputs=SCREAMING_SNAKE_CASE_						,       target_sizes=[(5_00, 3_00)]							)
     A__				=			torch.Size((5_00, 3_00)							)
     self.assertEqual(segmentation[0].shape						,       SCREAMING_SNAKE_CASE_							)

     A__				=			image_processor.post_process_semantic_segmentation(outputs=SCREAMING_SNAKE_CASE_							)
     A__				=			torch.Size((1_28, 1_28)							)
     self.assertEqual(segmentation[0].shape						,       SCREAMING_SNAKE_CASE_							)








"""simple docstring"""







from __future__ import annotations

def 				UpperCamelCase_    (    lowerCAmelCase__      :				list[int]    ,   lowerCAmelCase__      :				int						)						->   bool:

  """simple docstring"""




  if len(lowerCAmelCase__						) == 0:
    return False
  lowerCAmelCase_   :				Union[str, Any]								= len(lowerCAmelCase__						) // 2
  if a_list[midpoint] == item:
    return True
  if item < a_list[midpoint]:
    return binary_search(a_list[:midpoint]    ,   lowerCAmelCase__						)
  else:
    return binary_search(a_list[midpoint + 1 :]    ,   lowerCAmelCase__						)


if __name__ == "__main__":
     lowercase__		:				str          =	input("""Enter numbers separated by comma:\n""").strip()
     lowercase__		:				Optional[int]          =	[int(item.strip()) for item in user_input.split(""",""")]
     lowercase__		:				Optional[Any]          =	int(input("""Enter the number to be found in the list:\n""").strip())
     lowercase__		:				int          =	"""""" if binary_search(sequence, target) else """not """
     print(f'{target} was {not_str}found in {sequence}')





