






"""simple docstring"""






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 BeitImageProcessor




class 							lowerCAmelCase__				(			unittest.TestCase ):






      '''simple docstring'''

      def __init__(						self     :  Union[str, Any]						,	lowercase_     :  Optional[Any]						,	lowercase_     :  Union[str, Any]=7						,	lowercase_     :  Optional[Any]=3						,	lowercase_     :  List[Any]=18						,	lowercase_     :  str=30						,	lowercase_     :  int=400						,	lowercase_     :  Optional[int]=True						,	lowercase_     :  Optional[Any]=None						,	lowercase_     :  Union[str, Any]=True						,	lowercase_     :  List[str]=None						,	lowercase_     :  List[Any]=True						,	lowercase_     :  Optional[int]=[0.5, 0.5, 0.5]						,	lowercase_     :  List[Any]=[0.5, 0.5, 0.5]						,	lowercase_     :  List[Any]=False						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  int    						=		size if size is not None else {'''height''': 20, '''width''': 20}
          SCREAMING_SNAKE_CASE_      :  Dict    						=		crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		parent
          SCREAMING_SNAKE_CASE_      :  Dict    						=		batch_size
          SCREAMING_SNAKE_CASE_      :  Any    						=		num_channels
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		image_size
          SCREAMING_SNAKE_CASE_      :  Any    						=		min_resolution
          SCREAMING_SNAKE_CASE_      :  Dict    						=		max_resolution
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		do_resize
          SCREAMING_SNAKE_CASE_      :  Any    						=		size
          SCREAMING_SNAKE_CASE_      :  Any    						=		do_center_crop
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		crop_size
          SCREAMING_SNAKE_CASE_      :  int    						=		do_normalize
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		image_mean
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		image_std
          SCREAMING_SNAKE_CASE_      :  int    						=		do_reduce_labels



      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


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



def 					_A			() ->       List[Any]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  Tuple    						=		load_dataset('''hf-internal-testing/fixtures_ade20k'''    ,				split='''test'''							)

    SCREAMING_SNAKE_CASE_      :  Tuple    						=		Image.open(dataset[0]['''file''']							)
    SCREAMING_SNAKE_CASE_      :  str    						=		Image.open(dataset[1]['''file''']							)

    return image, map



def 					_A			() ->       Union[str, Any]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  Tuple    						=		load_dataset('''hf-internal-testing/fixtures_ade20k'''    ,				split='''test'''							)

    SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		Image.open(ds[0]['''file''']							)
    SCREAMING_SNAKE_CASE_      :  List[Any]    						=		Image.open(ds[1]['''file''']							)
    SCREAMING_SNAKE_CASE_      :  Any    						=		Image.open(ds[2]['''file''']							)
    SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		Image.open(ds[3]['''file''']							)

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





@require_torch
@require_vision
class 							lowerCAmelCase__				(			UpperCAmelCase__				,		unittest.TestCase ):






      '''simple docstring'''

      __UpperCamelCase	 =  BeitImageProcessor if is_vision_available() else None
      def _SCREAMING_SNAKE_CASE (						self     :  int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		BeitImageProcessingTester(self)
      @property
      def _SCREAMING_SNAKE_CASE (						self     :  int):




          '''simple docstring'''


          return self.image_processor_tester.prepare_image_processor_dict()
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  str    						=		self.image_processing_class(**self.image_processor_dict)
          self.assertTrue(hasattr(lowercase_						,	'''do_resize'''))
          self.assertTrue(hasattr(lowercase_						,	'''size'''))
          self.assertTrue(hasattr(lowercase_						,	'''do_center_crop'''))
          self.assertTrue(hasattr(lowercase_						,	'''center_crop'''))
          self.assertTrue(hasattr(lowercase_						,	'''do_normalize'''))
          self.assertTrue(hasattr(lowercase_						,	'''image_mean'''))
          self.assertTrue(hasattr(lowercase_						,	'''image_std'''))
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		self.image_processing_class.from_dict(self.image_processor_dict)
          self.assertEqual(image_processor.size						,	{'''height''': 20, '''width''': 20})
          self.assertEqual(image_processor.crop_size						,	{'''height''': 18, '''width''': 18})
          self.assertEqual(image_processor.do_reduce_labels						,	lowercase_)

          SCREAMING_SNAKE_CASE_      :  Dict    						=		self.image_processing_class.from_dict(
              self.image_processor_dict						,	size=42						,	crop_size=84						,	reduce_labels=lowercase_)
          self.assertEqual(image_processor.size						,	{'''height''': 42, '''width''': 42})
          self.assertEqual(image_processor.crop_size						,	{'''height''': 84, '''width''': 84})
          self.assertEqual(image_processor.do_reduce_labels						,	lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          pass
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.image_processing_class(**self.image_processor_dict)
          # create random PIL images
          SCREAMING_SNAKE_CASE_      :  Any    						=		prepare_image_inputs(self.image_processor_tester						,	equal_resolution=lowercase_)
          for image in image_inputs:
              self.assertIsInstance(lowercase_						,	Image.Image)

          # Test not batched input
          SCREAMING_SNAKE_CASE_      :  Dict    						=		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.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)

          # Test batched
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		image_processing(lowercase_						,	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.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.image_processing_class(**self.image_processor_dict)
          # create random numpy tensors
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		prepare_image_inputs(self.image_processor_tester						,	equal_resolution=lowercase_						,	numpify=lowercase_)
          for image in image_inputs:
              self.assertIsInstance(lowercase_						,	np.ndarray)

          # Test not batched input
          SCREAMING_SNAKE_CASE_      :  int    						=		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.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)

          # Test batched
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		image_processing(lowercase_						,	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.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.image_processing_class(**self.image_processor_dict)
          # create random PyTorch tensors
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		prepare_image_inputs(self.image_processor_tester						,	equal_resolution=lowercase_						,	torchify=lowercase_)
          for image in image_inputs:
              self.assertIsInstance(lowercase_						,	torch.Tensor)

          # Test not batched input
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		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.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)

          # Test batched
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image_processing(lowercase_						,	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.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)
      def _SCREAMING_SNAKE_CASE (						self     :  Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.image_processing_class(**self.image_processor_dict)
          # create random PyTorch tensors
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		prepare_image_inputs(self.image_processor_tester						,	equal_resolution=lowercase_						,	torchify=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		[]
          for image in image_inputs:
              self.assertIsInstance(lowercase_						,	torch.Tensor)
              maps.append(torch.zeros(image.shape[-2:]).long())

          # Test not batched input
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		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.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)
          self.assertEqual(
              encoding['''labels'''].shape						,	(
                  1,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_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
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image_processing(lowercase_						,	lowercase_						,	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.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)
          self.assertEqual(
              encoding['''labels'''].shape						,	(
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_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)
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Any    						=		prepare_semantic_single_inputs()

          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image_processing(lowercase_						,	lowercase_						,	return_tensors='''pt''')
          self.assertEqual(
              encoding['''pixel_values'''].shape						,	(
                  1,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )						,	)
          self.assertEqual(
              encoding['''labels'''].shape						,	(
                  1,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_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)
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  int    						=		prepare_semantic_batch_inputs()

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



      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		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
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		prepare_semantic_single_inputs()
          SCREAMING_SNAKE_CASE_      :  Any    						=		image_processing(lowercase_						,	lowercase_						,	return_tensors='''pt''')
          self.assertTrue(encoding['''labels'''].min().item() >= 0)
          self.assertTrue(encoding['''labels'''].max().item() <= 150)

          SCREAMING_SNAKE_CASE_      :  Tuple    						=		True
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		image_processing(lowercase_						,	lowercase_						,	return_tensors='''pt''')
          self.assertTrue(encoding['''labels'''].min().item() >= 0)
          self.assertTrue(encoding['''labels'''].max().item() <= 255)










"""simple docstring"""






from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_   : Optional[int]   			= logging.get_logger(__name__)

UpperCAmelCase_   : Any   			= {"""openai-gpt""": """https://huggingface.co/openai-gpt/resolve/main/config.json"""}




class 							lowerCAmelCase__				(			UpperCAmelCase__ ):






      '''simple docstring'''

      __UpperCamelCase	 =  "openai-gpt"
      __UpperCamelCase	 =  {
          "max_position_embeddings": "n_positions",
          "hidden_size": "n_embd",
          "num_attention_heads": "n_head",
          "num_hidden_layers": "n_layer",
      }
      def __init__(						self     :  List[str]						,	lowercase_     :  List[str]=40478						,	lowercase_     :  List[str]=512						,	lowercase_     :  Optional[Any]=768						,	lowercase_     :  Tuple=12						,	lowercase_     :  Tuple=12						,	lowercase_     :  Union[str, Any]="gelu"						,	lowercase_     :  List[Any]=0.1						,	lowercase_     :  Tuple=0.1						,	lowercase_     :  List[Any]=0.1						,	lowercase_     :  List[Any]=1e-5						,	lowercase_     :  int=0.02						,	lowercase_     :  Optional[int]="cls_index"						,	lowercase_     :  Any=True						,	lowercase_     :  List[Any]=None						,	lowercase_     :  List[str]=True						,	lowercase_     :  Optional[Any]=0.1						,	**lowercase_     :  List[str]						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		vocab_size
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		n_positions
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		n_embd
          SCREAMING_SNAKE_CASE_      :  Dict    						=		n_layer
          SCREAMING_SNAKE_CASE_      :  Any    						=		n_head
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		afn
          SCREAMING_SNAKE_CASE_      :  int    						=		resid_pdrop
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		embd_pdrop
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		attn_pdrop
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		layer_norm_epsilon
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		initializer_range
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		summary_type
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		summary_use_proj
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		summary_activation
          SCREAMING_SNAKE_CASE_      :  Any    						=		summary_first_dropout
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		summary_proj_to_labels
          super().__init__(**lowercase_)


