





import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import SegformerImageProcessor

class 			__A(    unittest.TestCase			):

     def __init__(   self,							A,							A=7,							A=3,							A=30,							A=400,							A=True,							A=None,							A=True,							A=[0.5, 0.5, 0.5],							A=[0.5, 0.5, 0.5],							A=False,							):





            """simple docstring"""

            _UpperCamelCase														=    size if size is not None else {'''height''': 30, '''width''': 30}
            _UpperCamelCase														=    parent
            _UpperCamelCase														=    batch_size
            _UpperCamelCase														=    num_channels
            _UpperCamelCase														=    min_resolution
            _UpperCamelCase														=    max_resolution
            _UpperCamelCase														=    do_resize
            _UpperCamelCase														=    size
            _UpperCamelCase														=    do_normalize
            _UpperCamelCase														=    image_mean
            _UpperCamelCase														=    image_std
            _UpperCamelCase														=    do_reduce_labels



     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            return {
                "do_resize": self.do_resize,
                "size": self.size,
                "do_normalize": self.do_normalize,
                "image_mean": self.image_mean,
                "image_std": self.image_std,
                "do_reduce_labels": self.do_reduce_labels,
            }






def      SCREAMING_SNAKE_CASE      (   ):
       _UpperCamelCase														=    load_dataset('''hf-internal-testing/fixtures_ade20k'''     ,							split='''test'''       )

       _UpperCamelCase														=    Image.open(dataset[0]['''file''']       )
       _UpperCamelCase														=    Image.open(dataset[1]['''file''']       )

       return image, map


def      SCREAMING_SNAKE_CASE      (   ):
       _UpperCamelCase														=    load_dataset('''hf-internal-testing/fixtures_ade20k'''     ,							split='''test'''       )

       _UpperCamelCase														=    Image.open(dataset[0]['''file''']       )
       _UpperCamelCase														=    Image.open(dataset[1]['''file''']       )
       _UpperCamelCase														=    Image.open(dataset[2]['''file''']       )
       _UpperCamelCase														=    Image.open(dataset[3]['''file''']       )

       return [imagea, imagea], [mapa, mapa]

@require_torch
@require_vision
class 			__A(    A_    ,      unittest.TestCase			):
     __A							=							SegformerImageProcessor if is_vision_available() else None

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    SegformerImageProcessingTester(self   )

     @property
     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            return self.image_processor_tester.prepare_image_processor_dict()

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.image_processing_class(**self.image_processor_dict   )
            self.assertTrue(hasattr(A_,							'''do_resize'''   )   )
            self.assertTrue(hasattr(A_,							'''size'''   )   )
            self.assertTrue(hasattr(A_,							'''do_normalize'''   )   )
            self.assertTrue(hasattr(A_,							'''image_mean'''   )   )
            self.assertTrue(hasattr(A_,							'''image_std'''   )   )
            self.assertTrue(hasattr(A_,							'''do_reduce_labels'''   )   )

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.image_processing_class.from_dict(self.image_processor_dict   )
            self.assertEqual(image_processor.size,							{'''height''': 30, '''width''': 30}   )
            self.assertEqual(image_processor.do_reduce_labels,							A_   )

            _UpperCamelCase														=    self.image_processing_class.from_dict(self.image_processor_dict,							size=42,							reduce_labels=A_   )
            self.assertEqual(image_processor.size,							{'''height''': 42, '''width''': 42}   )
            self.assertEqual(image_processor.do_reduce_labels,							A_   )

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            pass

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.image_processing_class(**self.image_processor_dict   )
            # create random PIL images
            _UpperCamelCase														=    prepare_image_inputs(self.image_processor_tester,							equal_resolution=A_   )
            for image in image_inputs:
                   self.assertIsInstance(A_,							Image.Image   )

            # Test not batched input
            _UpperCamelCase														=    image_processing(image_inputs[0],							return_tensors='''pt'''   ).pixel_values
            self.assertEqual(
                encoded_images.shape,							(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)

            # Test batched
            _UpperCamelCase														=    image_processing(A_,							return_tensors='''pt'''   ).pixel_values
            self.assertEqual(
                encoded_images.shape,							(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.image_processing_class(**self.image_processor_dict   )
            # create random numpy tensors
            _UpperCamelCase														=    prepare_image_inputs(self.image_processor_tester,							equal_resolution=A_,							numpify=A_   )
            for image in image_inputs:
                   self.assertIsInstance(A_,							np.ndarray   )

            # Test not batched input
            _UpperCamelCase														=    image_processing(image_inputs[0],							return_tensors='''pt'''   ).pixel_values
            self.assertEqual(
                encoded_images.shape,							(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)

            # Test batched
            _UpperCamelCase														=    image_processing(A_,							return_tensors='''pt'''   ).pixel_values
            self.assertEqual(
                encoded_images.shape,							(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.image_processing_class(**self.image_processor_dict   )
            # create random PyTorch tensors
            _UpperCamelCase														=    prepare_image_inputs(self.image_processor_tester,							equal_resolution=A_,							torchify=A_   )
            for image in image_inputs:
                   self.assertIsInstance(A_,							torch.Tensor   )

            # Test not batched input
            _UpperCamelCase														=    image_processing(image_inputs[0],							return_tensors='''pt'''   ).pixel_values
            self.assertEqual(
                encoded_images.shape,							(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)

            # Test batched
            _UpperCamelCase														=    image_processing(A_,							return_tensors='''pt'''   ).pixel_values
            self.assertEqual(
                encoded_images.shape,							(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)

     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.image_processing_class(**self.image_processor_dict   )
            # create random PyTorch tensors
            _UpperCamelCase														=    prepare_image_inputs(self.image_processor_tester,							equal_resolution=A_,							torchify=A_   )
            _UpperCamelCase														=    []
            for image in image_inputs:
                   self.assertIsInstance(A_,							torch.Tensor   )
                   maps.append(torch.zeros(image.shape[-2:]   ).long()   )

            # Test not batched input
            _UpperCamelCase														=    image_processing(image_inputs[0],							maps[0],							return_tensors='''pt'''   )
            self.assertEqual(
                encoding['''pixel_values'''].shape,							(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)
            self.assertEqual(
                encoding['''labels'''].shape,							(
                    1,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)
            self.assertEqual(encoding['''labels'''].dtype,							torch.long   )
            self.assertTrue(encoding['''labels'''].min().item() >= 0   )
            self.assertTrue(encoding['''labels'''].max().item() <= 255   )

            # Test batched
            _UpperCamelCase														=    image_processing(A_,							A_,							return_tensors='''pt'''   )
            self.assertEqual(
                encoding['''pixel_values'''].shape,							(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)
            self.assertEqual(
                encoding['''labels'''].shape,							(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)
            self.assertEqual(encoding['''labels'''].dtype,							torch.long   )
            self.assertTrue(encoding['''labels'''].min().item() >= 0   )
            self.assertTrue(encoding['''labels'''].max().item() <= 255   )

            # Test not batched input (PIL images)
            _UpperCamelCase							,		_UpperCamelCase														=    prepare_semantic_single_inputs()

            _UpperCamelCase														=    image_processing(A_,							A_,							return_tensors='''pt'''   )
            self.assertEqual(
                encoding['''pixel_values'''].shape,							(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)
            self.assertEqual(
                encoding['''labels'''].shape,							(
                    1,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)
            self.assertEqual(encoding['''labels'''].dtype,							torch.long   )
            self.assertTrue(encoding['''labels'''].min().item() >= 0   )
            self.assertTrue(encoding['''labels'''].max().item() <= 255   )

            # Test batched input (PIL images)
            _UpperCamelCase							,		_UpperCamelCase														=    prepare_semantic_batch_inputs()

            _UpperCamelCase														=    image_processing(A_,							A_,							return_tensors='''pt'''   )
            self.assertEqual(
                encoding['''pixel_values'''].shape,							(
                    2,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)
            self.assertEqual(
                encoding['''labels'''].shape,							(
                    2,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                ),							)
            self.assertEqual(encoding['''labels'''].dtype,							torch.long   )
            self.assertTrue(encoding['''labels'''].min().item() >= 0   )
            self.assertTrue(encoding['''labels'''].max().item() <= 255   )



     def 						_UpperCamelCase  (   self   ):





            """simple docstring"""

            _UpperCamelCase														=    self.image_processing_class(**self.image_processor_dict   )

            # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
            _UpperCamelCase							,		_UpperCamelCase														=    prepare_semantic_single_inputs()
            _UpperCamelCase														=    image_processing(A_,							A_,							return_tensors='''pt'''   )
            self.assertTrue(encoding['''labels'''].min().item() >= 0   )
            self.assertTrue(encoding['''labels'''].max().item() <= 150   )

            _UpperCamelCase														=    True
            _UpperCamelCase														=    image_processing(A_,							A_,							return_tensors='''pt'''   )
            self.assertTrue(encoding['''labels'''].min().item() >= 0   )
            self.assertTrue(encoding['''labels'''].max().item() <= 255   )










import math

def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   int							):
     __UpperCamelCase       				=math.log(2     ,	10							) * number
     __UpperCamelCase       				=round((log_number - int(SCREAMING_SNAKE_CASE__							))     ,	15							)

     return difference

def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   int = 67_89_10							):
     __UpperCamelCase       				=90
     __UpperCamelCase       				=0

     __UpperCamelCase       				=math.log(1.23     ,	10							)
     __UpperCamelCase       				=math.log(1.24     ,	10							)
     __UpperCamelCase       				=0

     while position < number:
          __UpperCamelCase       				=log_difference(SCREAMING_SNAKE_CASE__							)

          if difference >= upper_limit:
               power_iterator += 93

          elif difference < lower_limit:
               power_iterator += 1_96

          else:
               __UpperCamelCase       				=power_iterator
               power_iterator += 1_96
               position += 1

     return previous_power


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   print(f"""{solution() = }""")





