


import unittest

import numpy as np

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 EfficientNetImageProcessor






class        UpperCAmelCase__			(   unittest.TestCase						):



    """simple docstring"""






    def __init__(     self   ,  A_   ,  A_=13   ,  A_=3   ,  A_=18   ,  A_=30   ,  A_=400   ,  A_=True   ,  A_=None   ,  A_=True   ,  A_=[0.5, 0.5, 0.5]   ,  A_=[0.5, 0.5, 0.5]   ,  )    ->			List[Any]:
         __UpperCamelCase       				=size if size is not None else {'height': 18, 'width': 18}
         __UpperCamelCase       				=parent
         __UpperCamelCase       				=batch_size
         __UpperCamelCase       				=num_channels
         __UpperCamelCase       				=image_size
         __UpperCamelCase       				=min_resolution
         __UpperCamelCase       				=max_resolution
         __UpperCamelCase       				=do_resize
         __UpperCamelCase       				=size
         __UpperCamelCase       				=do_normalize
         __UpperCamelCase       				=image_mean
         __UpperCamelCase       				=image_std






    def _a   (     self       )    ->			Tuple:
         return {
             "image_mean": self.image_mean,
             "image_std": self.image_std,
             "do_normalize": self.do_normalize,
             "do_resize": self.do_resize,
             "size": self.size,
         }






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



    """simple docstring"""






    UpperCAmelCase__		:						List[Any]    =    EfficientNetImageProcessor if is_vision_available() else None






    def _a   (     self       )    ->			Any:
         __UpperCamelCase       				=EfficientNetImageProcessorTester(self       )






    @property
    def _a   (     self       )    ->			str:
         return self.image_processor_tester.prepare_image_processor_dict()






    def _a   (     self       )    ->			List[str]:
         __UpperCamelCase       				=self.image_processing_class(**self.image_processor_dict       )
         self.assertTrue(hasattr(lowerCAmelCase_   ,  'image_mean'       )       )
         self.assertTrue(hasattr(lowerCAmelCase_   ,  'image_std'       )       )
         self.assertTrue(hasattr(lowerCAmelCase_   ,  'do_normalize'       )       )
         self.assertTrue(hasattr(lowerCAmelCase_   ,  'do_resize'       )       )
         self.assertTrue(hasattr(lowerCAmelCase_   ,  'size'       )       )






    def _a   (     self       )    ->			str:
         __UpperCamelCase       				=self.image_processing_class.from_dict(self.image_processor_dict       )
         self.assertEqual(image_processor.size   ,  {'height': 18, 'width': 18}       )

         __UpperCamelCase       				=self.image_processing_class.from_dict(self.image_processor_dict   ,  size=42       )
         self.assertEqual(image_processor.size   ,  {'height': 42, 'width': 42}       )






    def _a   (     self       )    ->			Dict:
         __UpperCamelCase       				=self.image_processing_class(**self.image_processor_dict       )
         # create random PIL images
         __UpperCamelCase       				=prepare_image_inputs(self.image_processor_tester   ,  equal_resolution=lowerCAmelCase_       )
         for image in image_inputs:
              self.assertIsInstance(lowerCAmelCase_   ,  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(lowerCAmelCase_   ,  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 _a   (     self       )    ->			Dict:
         __UpperCamelCase       				=self.image_processing_class(**self.image_processor_dict       )
         # create random numpy tensors
         __UpperCamelCase       				=prepare_image_inputs(self.image_processor_tester   ,  equal_resolution=lowerCAmelCase_   ,  numpify=lowerCAmelCase_       )
         for image in image_inputs:
              self.assertIsInstance(lowerCAmelCase_   ,  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(lowerCAmelCase_   ,  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 _a   (     self       )    ->			Any:
         __UpperCamelCase       				=self.image_processing_class(**self.image_processor_dict       )
         # create random PyTorch tensors
         __UpperCamelCase       				=prepare_image_inputs(self.image_processor_tester   ,  equal_resolution=lowerCAmelCase_   ,  torchify=lowerCAmelCase_       )
         for image in image_inputs:
              self.assertIsInstance(lowerCAmelCase_   ,  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(lowerCAmelCase_   ,  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'],
             )   ,  )










'''simple docstring'''


from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


lowercase											=      logging.get_logger(__name__)

lowercase											=      {
    '''gpt2''': '''https://huggingface.co/gpt2/resolve/main/config.json''',
    '''gpt2-medium''': '''https://huggingface.co/gpt2-medium/resolve/main/config.json''',
    '''gpt2-large''': '''https://huggingface.co/gpt2-large/resolve/main/config.json''',
    '''gpt2-xl''': '''https://huggingface.co/gpt2-xl/resolve/main/config.json''',
    '''distilgpt2''': '''https://huggingface.co/distilgpt2/resolve/main/config.json''',
}







class 						UpperCAmelCase						(		__a):


 '''simple docstring'''




 __magic_name__       :			str	=   "gpt2"
 __magic_name__       :			str	=   ["past_key_values"]
 __magic_name__       :			Dict	=   {
     "hidden_size": "n_embd",
     "max_position_embeddings": "n_positions",
     "num_attention_heads": "n_head",
     "num_hidden_layers": "n_layer",
 }




 def __init__( self				,	lowerCAmelCase_=5_0_2_5_7				,	lowerCAmelCase_=1_0_2_4				,	lowerCAmelCase_=7_6_8				,	lowerCAmelCase_=1_2				,	lowerCAmelCase_=1_2				,	lowerCAmelCase_=None				,	lowerCAmelCase_="gelu_new"				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=1e-5				,	lowerCAmelCase_=0.0_2				,	lowerCAmelCase_="cls_index"				,	lowerCAmelCase_=True				,	lowerCAmelCase_=None				,	lowerCAmelCase_=True				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=True				,	lowerCAmelCase_=True				,	lowerCAmelCase_=5_0_2_5_6				,	lowerCAmelCase_=5_0_2_5_6				,	lowerCAmelCase_=False				,	lowerCAmelCase_=False				,	**lowerCAmelCase_				,	)			->   Dict:



      """simple docstring"""







      a_									=vocab_size
      a_									=n_positions
      a_									=n_embd
      a_									=n_layer
      a_									=n_head
      a_									=n_inner
      a_									=activation_function
      a_									=resid_pdrop
      a_									=embd_pdrop
      a_									=attn_pdrop
      a_									=layer_norm_epsilon
      a_									=initializer_range
      a_									=summary_type
      a_									=summary_use_proj
      a_									=summary_activation
      a_									=summary_first_dropout
      a_									=summary_proj_to_labels
      a_									=scale_attn_weights
      a_									=use_cache
      a_									=scale_attn_by_inverse_layer_idx
      a_									=reorder_and_upcast_attn

      a_									=bos_token_id
      a_									=eos_token_id

      super().__init__(bos_token_id=lowerCAmelCase_				,	eos_token_id=lowerCAmelCase_				,	**lowerCAmelCase_)







class 						UpperCAmelCase						(		__a):


 '''simple docstring'''




 def __init__( self				,	lowerCAmelCase_				,	lowerCAmelCase_ = "default"				,	lowerCAmelCase_ = None				,	lowerCAmelCase_ = False				,	)			->   List[str]:



      """simple docstring"""







      super().__init__(lowerCAmelCase_				,	task=lowerCAmelCase_				,	patching_specs=lowerCAmelCase_				,	use_past=lowerCAmelCase_)
      if not getattr(self._config				,	"pad_token_id"				,	lowerCAmelCase_):
           # TODO: how to do that better?
           a_									=0




 @property
 def    lowercase_	( self)			->   Mapping[str, Mapping[int, str]]:



      """simple docstring"""







      a_									=OrderedDict({"input_ids": {0: "batch", 1: "sequence"}})
      if self.use_past:
           self.fill_with_past_key_values_(lowerCAmelCase_				,	direction="inputs")
           a_									={0: "batch", 1: "past_sequence + sequence"}
      else:
           a_									={0: "batch", 1: "sequence"}

      return common_inputs




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return self._config.n_layer




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return self._config.n_head




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_ = -1				,	lowerCAmelCase_ = -1				,	lowerCAmelCase_ = False				,	lowerCAmelCase_ = None				,	)			->   Mapping[str, Any]:



      """simple docstring"""







      a_									=super(lowerCAmelCase_				,	self).generate_dummy_inputs(
          lowerCAmelCase_				,	batch_size=lowerCAmelCase_				,	seq_length=lowerCAmelCase_				,	is_pair=lowerCAmelCase_				,	framework=lowerCAmelCase_)

      # We need to order the input in the way they appears in the forward()
      a_									=OrderedDict({"input_ids": common_inputs["input_ids"]})

      # Need to add the past_keys
      if self.use_past:
           if not is_torch_available():
                raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
           else:
                import torch

                a_		,    a_									=common_inputs["input_ids"].shape
                # Not using the same length for past_key_values
                a_									=seqlen + 2
                a_									=(
                    batch,
                    self.num_attention_heads,
                    past_key_values_length,
                    self._config.hidden_size // self.num_attention_heads,
                )
                a_									=[
                    (torch.zeros(lowerCAmelCase_), torch.zeros(lowerCAmelCase_)) for _ in range(self.num_layers)
                ]

      a_									=common_inputs["attention_mask"]
      if self.use_past:
           a_									=ordered_inputs["attention_mask"].dtype
           a_									=torch.cat(
               [ordered_inputs["attention_mask"], torch.ones(lowerCAmelCase_				,	lowerCAmelCase_				,	dtype=lowerCAmelCase_)]				,	dim=1)

      return ordered_inputs




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return 1_3


