


from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers.models.openai.modeling_tf_openai import (
        TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFOpenAIGPTDoubleHeadsModel,
        TFOpenAIGPTForSequenceClassification,
        TFOpenAIGPTLMHeadModel,
        TFOpenAIGPTModel,
    )



class   __lowerCamelCase :







       def __init__( self:   List[Any],A_:   Any,):






            '''simple docstring'''




            __UpperCamelCase   = parent
            __UpperCamelCase   = 13
            __UpperCamelCase   = 7
            __UpperCamelCase   = True
            __UpperCamelCase   = True
            __UpperCamelCase   = True
            __UpperCamelCase   = True
            __UpperCamelCase   = True
            __UpperCamelCase   = 99
            __UpperCamelCase   = 32
            __UpperCamelCase   = 2
            __UpperCamelCase   = 4
            __UpperCamelCase   = 37
            __UpperCamelCase   = 'gelu'
            __UpperCamelCase   = 0.1
            __UpperCamelCase   = 0.1
            __UpperCamelCase   = 512
            __UpperCamelCase   = 16
            __UpperCamelCase   = 2
            __UpperCamelCase   = 0.0_2
            __UpperCamelCase   = 3
            __UpperCamelCase   = 4
            __UpperCamelCase   = None
            __UpperCamelCase   = self.vocab_size - 1







       def 		snake_case_  ( self:   int				):






            '''simple docstring'''




            __UpperCamelCase   = ids_tensor([self.batch_size, self.seq_length],self.vocab_size				)

            __UpperCamelCase   = None
            if self.use_input_mask:
                 __UpperCamelCase   = random_attention_mask([self.batch_size, self.seq_length]				)

            __UpperCamelCase   = None
            if self.use_token_type_ids:
                 __UpperCamelCase   = ids_tensor([self.batch_size, self.seq_length],self.type_vocab_size				)

            __UpperCamelCase   = None
            if self.use_mc_token_ids:
                 __UpperCamelCase   = ids_tensor([self.batch_size, self.num_choices],self.seq_length				)

            __UpperCamelCase   = None
            __UpperCamelCase   = None
            __UpperCamelCase   = None
            if self.use_labels:
                 __UpperCamelCase   = ids_tensor([self.batch_size],self.type_sequence_label_size				)
                 __UpperCamelCase   = ids_tensor([self.batch_size, self.seq_length],self.num_labels				)
                 __UpperCamelCase   = ids_tensor([self.batch_size],self.num_choices				)

            __UpperCamelCase   = OpenAIGPTConfig(
                vocab_size=self.vocab_size,n_embd=self.hidden_size,n_layer=self.num_hidden_layers,n_head=self.num_attention_heads,n_positions=self.max_position_embeddings,pad_token_id=self.pad_token_id,)

            __UpperCamelCase   = ids_tensor([self.num_hidden_layers, self.num_attention_heads],2				)

            return (
                config,
                input_ids,
                input_mask,
                head_mask,
                token_type_ids,
                mc_token_ids,
                sequence_labels,
                token_labels,
                choice_labels,
            )







       def 		snake_case_  ( self:   Tuple,A_:   Optional[int],A_:   Any,A_:   Union[str, Any],A_:   str,A_:   Union[str, Any],*A_:   str				):






            '''simple docstring'''




            __UpperCamelCase   = TFOpenAIGPTModel(config=A_				)
            __UpperCamelCase   = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
            __UpperCamelCase   = model(A_				)

            __UpperCamelCase   = [input_ids, input_mask]
            __UpperCamelCase   = model(A_				)

            __UpperCamelCase   = model(A_				)

            self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size)				)







       def 		snake_case_  ( self:   str,A_:   List[str],A_:   int,A_:   Any,A_:   List[Any],A_:   Optional[Any],*A_:   Union[str, Any]				):






            '''simple docstring'''




            __UpperCamelCase   = TFOpenAIGPTLMHeadModel(config=A_				)
            __UpperCamelCase   = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
            __UpperCamelCase   = model(A_				)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.vocab_size)				)







       def 		snake_case_  ( self:   Optional[Any],A_:   Tuple,A_:   Dict,A_:   List[Any],A_:   List[Any],A_:   Any,A_:   Union[str, Any],*A_:   str				):






            '''simple docstring'''




            __UpperCamelCase   = TFOpenAIGPTDoubleHeadsModel(config=A_				)

            __UpperCamelCase   = tf.tile(tf.expand_dims(A_,1				),(1, self.num_choices, 1)				)
            __UpperCamelCase   = tf.tile(tf.expand_dims(A_,1				),(1, self.num_choices, 1)				)
            __UpperCamelCase   = tf.tile(tf.expand_dims(A_,1				),(1, self.num_choices, 1)				)

            __UpperCamelCase   = {
                'input_ids': multiple_choice_inputs_ids,
                'mc_token_ids': mc_token_ids,
                'attention_mask': multiple_choice_input_mask,
                'token_type_ids': multiple_choice_token_type_ids,
            }
            __UpperCamelCase   = model(A_				)
            self.parent.assertEqual(
                result.logits.shape,(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)				)
            self.parent.assertEqual(result.mc_logits.shape,(self.batch_size, self.num_choices)				)







       def 		snake_case_  ( self:   Union[str, Any],A_:   int,A_:   int,A_:   int,A_:   Any,A_:   int,*A_:   Tuple				):






            '''simple docstring'''




            __UpperCamelCase   = self.num_labels
            __UpperCamelCase   = ids_tensor([self.batch_size],self.type_sequence_label_size				)
            __UpperCamelCase   = {
                'input_ids': input_ids,
                'attention_mask': input_mask,
                'token_type_ids': token_type_ids,
                'labels': sequence_labels,
            }
            __UpperCamelCase   = TFOpenAIGPTForSequenceClassification(A_				)
            __UpperCamelCase   = model(A_				)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels)				)







       def 		snake_case_  ( self:   List[str]				):






            '''simple docstring'''




            __UpperCamelCase   = self.prepare_config_and_inputs()

            (
                (
                __UpperCamelCase
            ),						(
                __UpperCamelCase
            ),						(
                __UpperCamelCase
            ),						(
                __UpperCamelCase
            ),						(
                __UpperCamelCase
            ),						(
                __UpperCamelCase
            ),						(
                __UpperCamelCase
            ),						(
                __UpperCamelCase
            ),						(
                __UpperCamelCase
            ),						
            )   = config_and_inputs

            __UpperCamelCase   = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
            return config, inputs_dict



@require_tf
class   __lowerCamelCase (_a							,			_a							,			unittest.TestCase	):
       _lowercase       							=    (
           (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
           if is_tf_available()
           else ()
       )
       _lowercase       							=    (
           (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
       _lowercase       							=    (
           {
               """feature-extraction""": TFOpenAIGPTModel,
               """text-classification""": TFOpenAIGPTForSequenceClassification,
               """text-generation""": TFOpenAIGPTLMHeadModel,
               """zero-shot""": TFOpenAIGPTForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       _lowercase       							=    False
       _lowercase       							=    False







       def 		snake_case_  ( self:   Union[str, Any],A_:   Optional[int],A_:   Dict,A_:   Optional[int],A_:   Tuple,A_:   Optional[int]				):






            '''simple docstring'''




            if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
                 # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
                 # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
                 # tiny config could not be created.
                 return True

            return False







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






            '''simple docstring'''




            __UpperCamelCase   = TFOpenAIGPTModelTester(self				)
            __UpperCamelCase   = ConfigTester(self,config_class=A_,n_embd=37				)







       def 		snake_case_  ( self:   List[str]				):






            '''simple docstring'''




            self.config_tester.run_common_tests()







       def 		snake_case_  ( self:   Dict				):






            '''simple docstring'''




            __UpperCamelCase   = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_openai_gpt_model(*A_				)







       def 		snake_case_  ( self:   Optional[Any]				):






            '''simple docstring'''




            __UpperCamelCase   = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_openai_gpt_lm_head(*A_				)







       def 		snake_case_  ( self:   Optional[int]				):






            '''simple docstring'''




            __UpperCamelCase   = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_openai_gpt_double_head(*A_				)







       def 		snake_case_  ( self:   List[Any]				):






            '''simple docstring'''




            __UpperCamelCase   = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*A_				)







       @slow
       def 		snake_case_  ( self:   str				):






            '''simple docstring'''




            for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __UpperCamelCase   = TFOpenAIGPTModel.from_pretrained(A_				)
                 self.assertIsNotNone(A_				)



@require_tf
class   __lowerCamelCase (unittest.TestCase	):







       @slow
       def 		snake_case_  ( self:   Optional[Any]				):






            '''simple docstring'''




            __UpperCamelCase   = TFOpenAIGPTLMHeadModel.from_pretrained('openai-gpt'				)
            __UpperCamelCase   = tf.convert_to_tensor([[481, 4735, 544]],dtype=tf.intaa				)  # the president is
            __UpperCamelCase   = [
                481,
                4735,
                544,
                246,
                963,
                870,
                762,
                239,
                244,
                4_0477,
                244,
                249,
                719,
                881,
                487,
                544,
                240,
                244,
                603,
                481,
            ]  # the president is a very good man. " \n " i\'m sure he is, " said the

            __UpperCamelCase   = model.generate(A_,do_sample=A_				)
            self.assertListEqual(output_ids[0].numpy().tolist(),A_				)






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 DeiTImageProcessor



class   __lowerCamelCase (unittest.TestCase	):







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






            '''simple docstring'''




            __UpperCamelCase   = size if size is not None else {'height': 20, 'width': 20}
            __UpperCamelCase   = crop_size if crop_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_center_crop
            __UpperCamelCase   = crop_size
            __UpperCamelCase   = do_normalize
            __UpperCamelCase   = image_mean
            __UpperCamelCase   = image_std







       def 		snake_case_  ( self:   List[str]				):






            '''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,
            }



@require_torch
@require_vision
class   __lowerCamelCase (_a							,			unittest.TestCase	):
       _lowercase       							=    DeiTImageProcessor if is_vision_available() else None
       _lowercase       							=    True







       def 		snake_case_  ( self:   List[Any]				):






            '''simple docstring'''




            __UpperCamelCase   = DeiTImageProcessingTester(self				)







       @property
       def 		snake_case_  ( self:   Optional[int]				):






            '''simple docstring'''




            return self.image_processor_tester.prepare_image_processor_dict()







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






            '''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_center_crop'				)				)
            self.assertTrue(hasattr(A_,'center_crop'				)				)
            self.assertTrue(hasattr(A_,'do_normalize'				)				)
            self.assertTrue(hasattr(A_,'image_mean'				)				)
            self.assertTrue(hasattr(A_,'image_std'				)				)







       def 		snake_case_  ( self:   Optional[int]				):






            '''simple docstring'''




            __UpperCamelCase   = 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}				)

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







       def 		snake_case_  ( self:   Tuple				):






            '''simple docstring'''




            pass







       def 		snake_case_  ( self:   Optional[int]				):






            '''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.crop_size['height'],
                    self.image_processor_tester.crop_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.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),)







       def 		snake_case_  ( self:   List[str]				):






            '''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.crop_size['height'],
                    self.image_processor_tester.crop_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.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),)







       def 		snake_case_  ( self:   Any				):






            '''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.crop_size['height'],
                    self.image_processor_tester.crop_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.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),)


