




'''simple docstring'''
import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
							from PIL import Image
else:
							class   __UpperCAmelCase				:



												'''simple docstring'''





												@staticmethod
												def     __snake_case						(	*_lowercase     :						Tuple      ,       **_lowercase     :						Union[str, Any])    ->							Union[str, Any]:
															pass
@is_pipeline_test
@require_vision
@require_torch
class   __UpperCAmelCase				(     unittest.TestCase				):



					'''simple docstring'''





					_UpperCamelCase							=		MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING



					def     __snake_case						(	self     :						Dict      ,       _lowercase     :						List[Any]      ,       _lowercase     :						Optional[Any]      ,       _lowercase     :						Tuple)    ->							Any:
								A_									= pipeline(
								    'zero-shot-object-detection'      ,       model='hf-internal-testing/tiny-random-owlvit-object-detection')

								A_									= [
								    {
								        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
								        'candidate_labels': ['cat', 'remote', 'couch'],
								    }
								]
								return object_detector, examples



					def     __snake_case						(	self     :						List[str]      ,       _lowercase     :						Dict      ,       _lowercase     :						List[str])    ->							List[Any]:
								A_									= object_detector(examples[0]      ,       threshold=0.0)

								A_									= len(_lowercase)
								self.assertGreater(_lowercase      ,       0)
								self.assertEqual(
								    _lowercase      ,       [
								        {
								            'score': ANY(_lowercase),
								            'label': ANY(_lowercase),
								            'box': {'xmin': ANY(_lowercase), 'ymin': ANY(_lowercase), 'xmax': ANY(_lowercase), 'ymax': ANY(_lowercase)},
								        }
								        for i in range(_lowercase)
								    ]      ,       )



					@require_tf
					@unittest.skip('Zero Shot Object Detection not implemented in TF')
					def     __snake_case						(	self     :						Optional[Any])    ->							str:
								pass



					@require_torch
					def     __snake_case						(	self     :						List[Any])    ->							int:
								A_									= pipeline(
								    'zero-shot-object-detection'      ,       model='hf-internal-testing/tiny-random-owlvit-object-detection')

								A_									= object_detector(
								    './tests/fixtures/tests_samples/COCO/000000039769.png'      ,       candidate_labels=['cat', 'remote', 'couch']      ,       threshold=0.64      ,       )

								self.assertEqual(
								    nested_simplify(_lowercase      ,       decimals=4)      ,       [
								        {'score': 0.72_35, 'label': 'cat', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
								        {'score': 0.72_18, 'label': 'remote', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
								        {'score': 0.71_84, 'label': 'couch', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
								        {'score': 0.67_48, 'label': 'remote', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
								        {'score': 0.66_56, 'label': 'cat', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
								        {'score': 0.66_14, 'label': 'couch', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
								        {'score': 0.64_56, 'label': 'remote', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
								        {'score': 0.6_42, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 274, 'xmax': 93, 'ymax': 297}},
								        {'score': 0.64_19, 'label': 'cat', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
								    ]      ,       )

								A_									= object_detector(
								    [
								        {
								            'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
								            'candidate_labels': ['cat', 'remote', 'couch'],
								        }
								    ]      ,       threshold=0.64      ,       )

								self.assertEqual(
								    nested_simplify(_lowercase      ,       decimals=4)      ,       [
								        [
								            {'score': 0.72_35, 'label': 'cat', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
								            {'score': 0.72_18, 'label': 'remote', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
								            {'score': 0.71_84, 'label': 'couch', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
								            {'score': 0.67_48, 'label': 'remote', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
								            {'score': 0.66_56, 'label': 'cat', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
								            {'score': 0.66_14, 'label': 'couch', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
								            {'score': 0.64_56, 'label': 'remote', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
								            {'score': 0.6_42, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 274, 'xmax': 93, 'ymax': 297}},
								            {'score': 0.64_19, 'label': 'cat', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
								        ]
								    ]      ,       )



					@require_torch
					@slow
					def     __snake_case						(	self     :						Union[str, Any])    ->							Optional[Any]:
								A_									= pipeline('zero-shot-object-detection')

								A_									= object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'      ,       candidate_labels=['cat', 'remote', 'couch']      ,       )
								self.assertEqual(
								    nested_simplify(_lowercase      ,       decimals=4)      ,       [
								        {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
								        {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
								        {'score': 0.25_37, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
								        {'score': 0.14_74, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
								        {'score': 0.12_08, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
								    ]      ,       )

								A_									= object_detector(
								    [
								        {
								            'image': 'http://images.cocodataset.org/val2017/000000039769.jpg',
								            'candidate_labels': ['cat', 'remote', 'couch'],
								        },
								        {
								            'image': 'http://images.cocodataset.org/val2017/000000039769.jpg',
								            'candidate_labels': ['cat', 'remote', 'couch'],
								        },
								    ]      ,       )
								self.assertEqual(
								    nested_simplify(_lowercase      ,       decimals=4)      ,       [
								        [
								            {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
								            {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
								            {'score': 0.25_37, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
								            {'score': 0.14_74, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
								            {'score': 0.12_08, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
								        ],
								        [
								            {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
								            {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
								            {'score': 0.25_37, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
								            {'score': 0.14_74, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
								            {'score': 0.12_08, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
								        ],
								    ]      ,       )



					@require_tf
					@unittest.skip('Zero Shot Object Detection not implemented in TF')
					def     __snake_case						(	self     :						int)    ->							List[str]:
								pass



					@require_torch
					@slow
					def     __snake_case						(	self     :						int)    ->							str:
								A_									= 0.2
								A_									= pipeline('zero-shot-object-detection')

								A_									= object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'      ,       candidate_labels=['cat', 'remote', 'couch']      ,       threshold=_lowercase      ,       )
								self.assertEqual(
								    nested_simplify(_lowercase      ,       decimals=4)      ,       [
								        {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
								        {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
								        {'score': 0.25_37, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
								    ]      ,       )



					@require_torch
					@slow
					def     __snake_case						(	self     :						int)    ->							Any:
								A_									= 2
								A_									= pipeline('zero-shot-object-detection')

								A_									= object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'      ,       candidate_labels=['cat', 'remote', 'couch']      ,       top_k=_lowercase      ,       )
								self.assertEqual(
								    nested_simplify(_lowercase      ,       decimals=4)      ,       [
								        {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
								        {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
								    ]      ,       )










'''simple docstring'''
import argparse

import torch

from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()





def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_     )		->		str:
			# Construct model
			if openai_config_file == "":
						A_									= OpenAIGPTConfig()
			else:
						A_									= OpenAIGPTConfig.from_json_file(SCREAMING_SNAKE_CASE_     )
			A_									= OpenAIGPTModel(SCREAMING_SNAKE_CASE_     )

			# Load weights from numpy
			load_tf_weights_in_openai_gpt(SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_     )

			# Save pytorch-model
			A_									= pytorch_dump_folder_path + '/' + WEIGHTS_NAME
			A_									= pytorch_dump_folder_path + '/' + CONFIG_NAME
			print(F'Save PyTorch model to {pytorch_weights_dump_path}'     )
			torch.save(model.state_dict()       ,SCREAMING_SNAKE_CASE_     )
			print(F'Save configuration file to {pytorch_config_dump_path}'     )
			with open(SCREAMING_SNAKE_CASE_       ,'w'       ,encoding='utf-8'     ) as f:
						f.write(config.to_json_string()     )


if __name__ == "__main__":
							_SCREAMING_SNAKE_CASE			=						argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    "--openai_checkpoint_folder_path",
							    default=None,
							    type=str,
							    required=True,
							    help="Path to the TensorFlow checkpoint path.",
							)
							parser.add_argument(
							    "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
							)
							parser.add_argument(
							    "--openai_config_file",
							    default="",
							    type=str,
							    help=(
							        "An optional config json file corresponding to the pre-trained OpenAI model. \n"
							        "This specifies the model architecture."
							    ),
							)
							_SCREAMING_SNAKE_CASE			=						parser.parse_args()
							convert_openai_checkpoint_to_pytorch(
							    args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
							)




