



"""simple docstring"""
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
          OpenAIGPTConfig,
          OpenAIGPTDoubleHeadsModel,
          OpenAIGPTForSequenceClassification,
          OpenAIGPTLMHeadModel,
          OpenAIGPTModel,
      )



class       SCREAMING_SNAKE_CASE__  :

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=13      ,     _SCREAMING_SNAKE_CASE=7      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=99      ,     _SCREAMING_SNAKE_CASE=32      ,     _SCREAMING_SNAKE_CASE=5      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=37      ,     _SCREAMING_SNAKE_CASE="gelu"      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=512      ,     _SCREAMING_SNAKE_CASE=16      ,     _SCREAMING_SNAKE_CASE=2      ,     _SCREAMING_SNAKE_CASE=0.02      ,     _SCREAMING_SNAKE_CASE=3      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=None      ,     )  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	parent
    UpperCAmelCase	:					Tuple	=	batch_size
    UpperCAmelCase	:					Optional[int]	=	seq_length
    UpperCAmelCase	:					int	=	is_training
    UpperCAmelCase	:					str	=	use_token_type_ids
    UpperCAmelCase	:					Optional[int]	=	use_labels
    UpperCAmelCase	:					List[Any]	=	vocab_size
    UpperCAmelCase	:					Optional[Any]	=	hidden_size
    UpperCAmelCase	:					Optional[Any]	=	num_hidden_layers
    UpperCAmelCase	:					int	=	num_attention_heads
    UpperCAmelCase	:					List[Any]	=	intermediate_size
    UpperCAmelCase	:					int	=	hidden_act
    UpperCAmelCase	:					Dict	=	hidden_dropout_prob
    UpperCAmelCase	:					List[Any]	=	attention_probs_dropout_prob
    UpperCAmelCase	:					Optional[int]	=	max_position_embeddings
    UpperCAmelCase	:					int	=	type_vocab_size
    UpperCAmelCase	:					Any	=	type_sequence_label_size
    UpperCAmelCase	:					Optional[Any]	=	initializer_range
    UpperCAmelCase	:					Union[str, Any]	=	num_labels
    UpperCAmelCase	:					Any	=	num_choices
    UpperCAmelCase	:					str	=	scope
    UpperCAmelCase	:					str	=	self.vocab_size - 1

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.vocab_size						)

    UpperCAmelCase	:					Any	=	None
    if self.use_token_type_ids:
     UpperCAmelCase	:					Union[str, Any]	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.type_vocab_size						)

    UpperCAmelCase	:					Union[str, Any]	=	None
    UpperCAmelCase	:					Dict	=	None
    UpperCAmelCase	:					Tuple	=	None
    if self.use_labels:
     UpperCAmelCase	:					Any	=	ids_tensor([self.batch_size]      ,     self.type_sequence_label_size						)
     UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.num_labels						)
     UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size]      ,     self.num_choices						)

    UpperCAmelCase	:					Union[str, Any]	=	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	:					str	=	ids_tensor([self.num_hidden_layers, self.num_attention_heads]      ,     2						)

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

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	OpenAIGPTModel(config=_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					List[str]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     head_mask=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					List[Any]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Tuple	=	model(_SCREAMING_SNAKE_CASE						)

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

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	OpenAIGPTLMHeadModel(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     labels=_SCREAMING_SNAKE_CASE						)
    self.parent.assertEqual(result.loss.shape      ,     ()						)
    self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.seq_length, self.vocab_size)						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	OpenAIGPTDoubleHeadsModel(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					Optional[int]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     labels=_SCREAMING_SNAKE_CASE						)
    self.parent.assertEqual(result.loss.shape      ,     ()						)
    self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.seq_length, self.vocab_size)						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	self.num_labels
    UpperCAmelCase	:					Optional[int]	=	OpenAIGPTForSequenceClassification(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size]      ,     self.type_sequence_label_size						)
    UpperCAmelCase	:					Optional[int]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     labels=_SCREAMING_SNAKE_CASE						)
    self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.num_labels)						)




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.prepare_config_and_inputs()
    (
        (
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		
    )	:					Any	=	config_and_inputs
    UpperCAmelCase	:					Dict	=	{
        """input_ids""": input_ids,
        """token_type_ids""": token_type_ids,
        """head_mask""": head_mask,
    }

    return config, inputs_dict



@require_torch
class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			UpperCAmelCase__      ,			UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   Union[str, Any]						=						(
       (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
       if is_torch_available()
       else ()
   )
   __lowerCAmelCase  :   Union[str, Any]						=						(
       (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
   )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
   __lowerCAmelCase  :   int						=						(
       {
           'feature-extraction': OpenAIGPTModel,
           'text-classification': OpenAIGPTForSequenceClassification,
           'text-generation': OpenAIGPTLMHeadModel,
           'zero-shot': OpenAIGPTForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      List[str]:





    '''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 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=False						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	super()._prepare_for_class(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_labels=_SCREAMING_SNAKE_CASE						)

    if return_labels:
     if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
      UpperCAmelCase	:					Union[str, Any]	=	torch.zeros(
          (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE      ,     )
      UpperCAmelCase	:					str	=	inputs_dict["""labels"""]
      UpperCAmelCase	:					List[Any]	=	inputs_dict["""labels"""]
      UpperCAmelCase	:					Union[str, Any]	=	torch.zeros(
          (self.model_tester.batch_size, self.model_tester.num_choices)      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE      ,     )
      UpperCAmelCase	:					str	=	torch.zeros(
          self.model_tester.batch_size      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE						)
    return inputs_dict

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	OpenAIGPTModelTester(self						)
    UpperCAmelCase	:					Any	=	ConfigTester(self      ,     config_class=_SCREAMING_SNAKE_CASE      ,     n_embd=37						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    self.config_tester.run_common_tests()

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_openai_gpt_model(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_lm_head_model(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[str]:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_double_lm_head_model(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_SCREAMING_SNAKE_CASE						)




   @slow
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     UpperCAmelCase	:					Optional[Any]	=	OpenAIGPTModel.from_pretrained(_SCREAMING_SNAKE_CASE						)
     self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)



@require_torch
class       SCREAMING_SNAKE_CASE__  (					unittest.TestCase ):

   @slow
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Union[str, Any]	=	OpenAIGPTLMHeadModel.from_pretrained("""openai-gpt"""						)
    model.to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Dict	=	torch.tensor([[481, 4735, 544]]      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE						)  # the president is
    UpperCAmelCase	:					Optional[int]	=	[
        481,
        4735,
        544,
        246,
        963,
        870,
        762,
        239,
        244,
        40477,
        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	:					List[Any]	=	model.generate(_SCREAMING_SNAKE_CASE      ,     do_sample=_SCREAMING_SNAKE_CASE						)
    self.assertListEqual(output_ids[0].tolist()      ,     _SCREAMING_SNAKE_CASE						)







from typing import Any, Dict, List, Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_vision_available():
     from PIL import Image

     from ..image_utils import load_image

if is_torch_available():
     import torch

     from transformers.modeling_outputs import BaseModelOutput

     from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

__A									=				logging.get_logger(__name__)



@add_end_docstrings(__SCREAMING_SNAKE_CASE    )
class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ):







 '''simple docstring'''

 def __init__(self				:   Tuple       , **UpperCAmelCase_				:   Tuple)       ->Any:



   '''simple docstring'''



   super().__init__(**UpperCAmelCase_)

   if self.framework == "tf":
     raise ValueError(F"""The {self.__class__} is only available in PyTorch.""")

   requires_backends(self       , "vision")
   self.check_model_type(UpperCAmelCase_)

 def __call__(self				:   Optional[int]       , UpperCAmelCase_				:   Union[str, "Image.Image", List[Dict[str, Any]]]       , UpperCAmelCase_				:   Union[str, List[str]] = None       , **UpperCAmelCase_				:   List[str]       , )       ->Union[str, Any]:



   '''simple docstring'''



   if "text_queries" in kwargs:
     lowerCamelCase__:      Any			  =kwargs.pop("text_queries")

   if isinstance(UpperCAmelCase_       , (str, Image.Image)):
     lowerCamelCase__:      List[Any]			  ={"image": image, "candidate_labels": candidate_labels}
   else:
     lowerCamelCase__:      Any			  =image
   lowerCamelCase__:      Dict			  =super().__call__(UpperCAmelCase_       , **UpperCAmelCase_)
   return results

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int]       , **UpperCAmelCase_				:   Union[str, Any])       ->Dict:



   '''simple docstring'''



   lowerCamelCase__:      List[str]			  ={}
   if "threshold" in kwargs:
     lowerCamelCase__:      List[Any]			  =kwargs["threshold"]
   if "top_k" in kwargs:
     lowerCamelCase__:      Any			  =kwargs["top_k"]
   return {}, {}, postprocess_params

 def 							SCREAMING_SNAKE_CASE_					(self				:   str       , UpperCAmelCase_				:   List[Any])       ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:      List[Any]			  =load_image(inputs["image"])
   lowerCamelCase__:      Dict			  =inputs["candidate_labels"]
   if isinstance(UpperCAmelCase_       , UpperCAmelCase_):
     lowerCamelCase__:      Any			  =candidate_labels.split(",")

   lowerCamelCase__:      Optional[int]			  =torch.tensor([[image.height, image.width]]       , dtype=torch.intaa)
   for i, candidate_label in enumerate(UpperCAmelCase_):
     lowerCamelCase__:      Dict			  =self.tokenizer(UpperCAmelCase_       , return_tensors=self.framework)
     lowerCamelCase__:      Union[str, Any]			  =self.image_processor(UpperCAmelCase_       , return_tensors=self.framework)
     yield {
         "is_last": i == len(UpperCAmelCase_) - 1,
         "target_size": target_size,
         "candidate_label": candidate_label,
         **text_inputs,
         **image_features,
     }

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[Any]       , UpperCAmelCase_				:   Tuple)       ->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__:      Dict			  =model_inputs.pop("target_size")
   lowerCamelCase__:      Dict			  =model_inputs.pop("candidate_label")
   lowerCamelCase__:      Dict			  =model_inputs.pop("is_last")

   lowerCamelCase__:      Union[str, Any]			  =self.model(**UpperCAmelCase_)

   lowerCamelCase__:      Dict			  ={"target_size": target_size, "candidate_label": candidate_label, "is_last": is_last, **outputs}
   return model_outputs

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int]       , UpperCAmelCase_				:   int       , UpperCAmelCase_				:   Any=0.1       , UpperCAmelCase_				:   str=None)       ->Tuple:



   '''simple docstring'''



   lowerCamelCase__:      Union[str, Any]			  =[]
   for model_output in model_outputs:
     lowerCamelCase__:      Optional[Any]			  =model_output["candidate_label"]
     lowerCamelCase__:      Tuple			  =BaseModelOutput(UpperCAmelCase_)
     lowerCamelCase__:      Dict			  =self.image_processor.post_process_object_detection(
         outputs=UpperCAmelCase_       , threshold=UpperCAmelCase_       , target_sizes=model_output["target_size"])[0]

     for index in outputs["scores"].nonzero():
       lowerCamelCase__:      Dict			  =outputs["scores"][index].item()
       lowerCamelCase__:      Dict			  =self._get_bounding_box(outputs["boxes"][index][0])

       lowerCamelCase__:      Optional[Any]			  ={"score": score, "label": label, "box": box}
       results.append(UpperCAmelCase_)

   lowerCamelCase__:      List[str]			  =sorted(UpperCAmelCase_       , key=lambda UpperCAmelCase_: x["score"]       , reverse=UpperCAmelCase_)
   if top_k:
     lowerCamelCase__:      Dict			  =results[:top_k]

   return results







 def 							SCREAMING_SNAKE_CASE_					(self				:   str       , UpperCAmelCase_				:   "torch.Tensor")       ->Dict[str, int]:



   '''simple docstring'''



   if self.framework != "pt":
     raise ValueError("The ZeroShotObjectDetectionPipeline is only available in PyTorch.")
   lowerCamelCase__  ,					lowerCamelCase__  ,					lowerCamelCase__  ,					lowerCamelCase__:      Optional[Any]			  =box.int().tolist()
   lowerCamelCase__:      Optional[int]			  ={
       "xmin": xmin,
       "ymin": ymin,
       "xmax": xmax,
       "ymax": ymax,
   }
   return bbox

