



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    _A	(     __UpperCAmelCase   ):



       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           __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    _A	:



       def __init__(		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					Any=13					,		__SCREAMING_SNAKE_CASE							:					str=64					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]=3					,		__SCREAMING_SNAKE_CASE							:					str=4					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=[2, 2, 2, 2]					,		__SCREAMING_SNAKE_CASE							:					List[str]=[8, 4, 2, 1]					,		__SCREAMING_SNAKE_CASE							:					Any=[16, 32, 64, 128]					,		__SCREAMING_SNAKE_CASE							:					List[Any]=[1, 4, 8, 16]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=[1, 2, 4, 8]					,		__SCREAMING_SNAKE_CASE							:					int=True					,		__SCREAMING_SNAKE_CASE							:					List[str]=True					,		__SCREAMING_SNAKE_CASE							:					str="gelu"					,		__SCREAMING_SNAKE_CASE							:					Dict=0.1					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=0.1					,		__SCREAMING_SNAKE_CASE							:					Any=0.02					,		__SCREAMING_SNAKE_CASE							:					int=3					,		__SCREAMING_SNAKE_CASE							:					int=None					,		):


           '''simple docstring'''

           __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 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __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 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

           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 		_lowerCamelCase      (		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Any):


           '''simple docstring'''

           __a							=    SegformerModel(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a							=    model(__SCREAMING_SNAKE_CASE)
           __a							=    __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 		_lowerCamelCase      (		self							:					List[Any]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					Optional[int]):


           '''simple docstring'''

           __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 		_lowerCamelCase      (		self							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					str):


           '''simple docstring'''

           __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 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

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


@require_torch
class    _A	(     __UpperCAmelCase				,__UpperCAmelCase				,unittest.TestCase   ):
       UpperCamelCase__  :   Any						 =						(
           (
               SegformerModel,
               SegformerForSemanticSegmentation,
               SegformerForImageClassification,
           )
           if is_torch_available()
           else ()
       )
       UpperCamelCase__  :   Optional[int]						 =						(
           {
               '''feature-extraction''': SegformerModel,
               '''image-classification''': SegformerForImageClassification,
               '''image-segmentation''': SegformerForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       UpperCamelCase__  :   List[Any]						 =						True
       UpperCamelCase__  :   int						 =						False
       UpperCamelCase__  :   Tuple						 =						False
       UpperCamelCase__  :   Optional[int]						 =						False



       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           __a							=    SegformerModelTester(self)
           __a							=    SegformerConfigTester(self					,		config_class=__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           self.config_tester.run_common_tests()



       def 		_lowerCamelCase      (		self							:					int):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_binary_image_segmentation(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					int):


           '''simple docstring'''

           __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 		_lowerCamelCase      (		self							:					int):


           '''simple docstring'''

           pass



       @unittest.skip('''SegFormer does not have get_input_embeddings method and get_output_embeddings methods''')
       def 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

           pass



       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __a	,       __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 		_lowerCamelCase      (		self							:					int):


           '''simple docstring'''

           __a	,       __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 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           def check_hidden_states_output(__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					str					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]):
               __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	,       __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 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           if not self.model_tester.is_training:
               return

           __a	,       __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 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           pass





       @slow
       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __a							=    SegformerModel.from_pretrained(__SCREAMING_SNAKE_CASE)
               self.assertIsNotNone(__SCREAMING_SNAKE_CASE)





def 					__snake_case     (      ):
    __a							=    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
    return image

@require_torch
class    _A	(     unittest.TestCase   ):



       @slow
       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           __a							=    SegformerImageProcessor(
               image_scale=(512, 512)					,		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, 128, 128))
           self.assertEqual(outputs.logits.shape					,		__SCREAMING_SNAKE_CASE)

           __a							=    torch.tensor(
               [
                   [[-4.63_10, -5.52_32, -6.23_56], [-5.19_21, -6.14_44, -6.59_96], [-5.44_24, -6.27_90, -6.75_74]],
                   [[-12.13_91, -13.31_22, -13.95_54], [-12.87_32, -13.93_52, -14.35_63], [-12.94_38, -13.82_26, -14.25_13]],
                   [[-12.51_34, -13.46_86, -14.49_15], [-12.86_69, -14.43_43, -14.77_58], [-13.25_23, -14.58_19, -15.06_94]],
               ]).to(__SCREAMING_SNAKE_CASE)
           self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]					,		__SCREAMING_SNAKE_CASE					,		atol=1E-4))



       @slow
       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           __a							=    SegformerImageProcessor(
               image_scale=(512, 512)					,		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, 128, 128))
           self.assertEqual(outputs.logits.shape					,		__SCREAMING_SNAKE_CASE)

           __a							=    torch.tensor(
               [
                   [[-13.57_48, -13.91_11, -12.65_00], [-14.35_00, -15.36_83, -14.23_28], [-14.75_32, -16.04_24, -15.60_87]],
                   [[-17.16_51, -15.87_25, -12.96_53], [-17.25_80, -17.37_18, -14.82_23], [-16.60_58, -16.87_83, -16.74_52]],
                   [[-3.64_56, -3.02_09, -1.42_03], [-3.07_97, -3.19_59, -2.00_00], [-1.87_57, -1.92_17, -1.69_97]],
               ]).to(__SCREAMING_SNAKE_CASE)
           self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]					,		__SCREAMING_SNAKE_CASE					,		atol=1E-1))





       @slow
       def 		_lowerCamelCase      (		self							:					List[str]):


           '''simple docstring'''

           __a							=    SegformerImageProcessor(
               image_scale=(512, 512)					,		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=[(500, 300)])
           __a							=    torch.Size((500, 300))
           self.assertEqual(segmentation[0].shape					,		__SCREAMING_SNAKE_CASE)

           __a							=    image_processor.post_process_semantic_segmentation(outputs=__SCREAMING_SNAKE_CASE)
           __a							=    torch.Size((128, 128))
           self.assertEqual(segmentation[0].shape					,		__SCREAMING_SNAKE_CASE)










from __future__ import annotations

from collections import namedtuple
from dataclasses import dataclass

@dataclass
class    _A	:
       UpperCamelCase__  :   int
       UpperCamelCase__  :   TreeNode | None						 =						None
       UpperCamelCase__  :   TreeNode | None						 =						None


__snake_case						:Optional[Any]						=					namedtuple('''CoinsDistribResult''', '''moves excess''')





def 					__snake_case     (      _UpperCAmelCase    ):

    if root is None:
        return 0

    # Validation
    def count_nodes(_UpperCAmelCase    ) -> int:
        if node is None:
            return 0

        return count_nodes(node.left    ) + count_nodes(node.right    ) + 1

    def count_coins(_UpperCAmelCase    ) -> int:
        if node is None:
            return 0

        return count_coins(node.left    ) + count_coins(node.right    ) + node.data

    if count_nodes(_UpperCAmelCase    ) != count_coins(_UpperCAmelCase    ):
        raise ValueError('''The nodes number should be same as the number of coins'''    )

    # Main calculation
    def get_distrib(_UpperCAmelCase    ) -> CoinsDistribResult:

        if node is None:
            return CoinsDistribResult(0       ,			1    )

        __a	,       __a							=    get_distrib(node.left    )
        __a	,       __a							=    get_distrib(node.right    )

        __a							=    1 - left_distrib_excess
        __a							=    1 - right_distrib_excess

        __a							=    (
            left_distrib_moves
            + right_distrib_moves
            + abs(_UpperCAmelCase    )
            + abs(_UpperCAmelCase    )
        )
        __a							=    node.data - coins_to_left - coins_to_right

        return CoinsDistribResult(_UpperCAmelCase       ,			_UpperCAmelCase    )

    return get_distrib(_UpperCAmelCase    )[0]


if __name__ == "__main__":
 import doctest

 doctest.testmod()





