




'''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
							)










'''simple docstring'''
import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import (
							    MODEL_MAPPING,
							    BeitForImageClassification,
							    BeitForMaskedImageModeling,
							    BeitForSemanticSegmentation,
							    BeitModel,
							)
							from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							import PIL
							from PIL import Image

							from transformers import BeitImageProcessor
class   __UpperCAmelCase				:



					'''simple docstring'''





					def __init__(	self     :						Optional[int]      ,       _lowercase     :						Dict      ,       _lowercase     :						Optional[int]=100      ,       _lowercase     :						List[str]=13      ,       _lowercase     :						Tuple=30      ,       _lowercase     :						Optional[int]=2      ,       _lowercase     :						Optional[int]=3      ,       _lowercase     :						Any=True      ,       _lowercase     :						Dict=True      ,       _lowercase     :						Any=32      ,       _lowercase     :						Union[str, Any]=4      ,       _lowercase     :						Union[str, Any]=4      ,       _lowercase     :						Tuple=37      ,       _lowercase     :						List[Any]="gelu"      ,       _lowercase     :						int=0.1      ,       _lowercase     :						str=0.1      ,       _lowercase     :						Tuple=10      ,       _lowercase     :						str=0.02      ,       _lowercase     :						Dict=3      ,       _lowercase     :						Dict=None      ,       _lowercase     :						Tuple=[0, 1, 2, 3]      ,       )    ->							str:
								A_									= parent
								A_									= 100
								A_									= batch_size
								A_									= image_size
								A_									= patch_size
								A_									= num_channels
								A_									= is_training
								A_									= use_labels
								A_									= hidden_size
								A_									= num_hidden_layers
								A_									= num_attention_heads
								A_									= intermediate_size
								A_									= hidden_act
								A_									= hidden_dropout_prob
								A_									= attention_probs_dropout_prob
								A_									= type_sequence_label_size
								A_									= initializer_range
								A_									= scope
								A_									= out_indices
								A_									= num_labels

								# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
								A_									= (image_size // patch_size) ** 2
								A_									= num_patches + 1



					def     __snake_case						(	self     :						List[Any])    ->							str:
								A_									= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

								A_									= None
								A_									= None
								if self.use_labels:
											A_									= ids_tensor([self.batch_size]      ,       self.type_sequence_label_size)
											A_									= ids_tensor([self.batch_size, self.image_size, self.image_size]      ,       self.num_labels)

								A_									= self.get_config()

								return config, pixel_values, labels, pixel_labels



					def     __snake_case						(	self     :						Union[str, Any])    ->							Optional[int]:
								return BeitConfig(
								    vocab_size=self.vocab_size      ,       image_size=self.image_size      ,       patch_size=self.patch_size      ,       num_channels=self.num_channels      ,       hidden_size=self.hidden_size      ,       num_hidden_layers=self.num_hidden_layers      ,       num_attention_heads=self.num_attention_heads      ,       intermediate_size=self.intermediate_size      ,       hidden_act=self.hidden_act      ,       hidden_dropout_prob=self.hidden_dropout_prob      ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,       is_decoder=_lowercase      ,       initializer_range=self.initializer_range      ,       out_indices=self.out_indices      ,       )



					def     __snake_case						(	self     :						List[Any]      ,       _lowercase     :						Any      ,       _lowercase     :						int      ,       _lowercase     :						Optional[Any]      ,       _lowercase     :						Tuple)    ->							Tuple:
								A_									= BeitModel(config=_lowercase)
								model.to(_lowercase)
								model.eval()
								A_									= model(_lowercase)
								self.parent.assertEqual(result.last_hidden_state.shape      ,       (self.batch_size, self.seq_length, self.hidden_size))



					def     __snake_case						(	self     :						Optional[int]      ,       _lowercase     :						str      ,       _lowercase     :						Optional[int]      ,       _lowercase     :						str      ,       _lowercase     :						Optional[Any])    ->							Union[str, Any]:
								A_									= BeitForMaskedImageModeling(config=_lowercase)
								model.to(_lowercase)
								model.eval()
								A_									= model(_lowercase)
								self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.seq_length - 1, self.vocab_size))



					def     __snake_case						(	self     :						Optional[int]      ,       _lowercase     :						Tuple      ,       _lowercase     :						Optional[Any]      ,       _lowercase     :						str      ,       _lowercase     :						Optional[int])    ->							Any:
								A_									= self.type_sequence_label_size
								A_									= BeitForImageClassification(_lowercase)
								model.to(_lowercase)
								model.eval()
								A_									= model(_lowercase      ,       labels=_lowercase)
								self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.type_sequence_label_size))

								# test greyscale images
								A_									= 1
								A_									= BeitForImageClassification(_lowercase)
								model.to(_lowercase)
								model.eval()

								A_									= floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
								A_									= model(_lowercase      ,       labels=_lowercase)
								self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.type_sequence_label_size))



					def     __snake_case						(	self     :						Tuple      ,       _lowercase     :						List[str]      ,       _lowercase     :						Any      ,       _lowercase     :						List[str]      ,       _lowercase     :						Optional[int])    ->							Union[str, Any]:
								A_									= self.num_labels
								A_									= BeitForSemanticSegmentation(_lowercase)
								model.to(_lowercase)
								model.eval()
								A_									= model(_lowercase)
								self.parent.assertEqual(
								    result.logits.shape      ,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2))
								A_									= model(_lowercase      ,       labels=_lowercase)
								self.parent.assertEqual(
								    result.logits.shape      ,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2))



					def     __snake_case						(	self     :						Optional[int])    ->							Dict:
								A_									= self.prepare_config_and_inputs()
								A_		, A_		, A_		, A_									= config_and_inputs
								A_									= {'pixel_values': pixel_values}
								return config, inputs_dict





@require_torch
class   __UpperCAmelCase				(     lowerCAmelCase			,lowerCAmelCase			,unittest.TestCase				):



					'''simple docstring'''





					_UpperCamelCase							=		(
					    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
					    if is_torch_available()
					    else ()
					)
					_UpperCamelCase							=		(
					    {
					        """feature-extraction""": BeitModel,
					        """image-classification""": BeitForImageClassification,
					        """image-segmentation""": BeitForSemanticSegmentation,
					    }
					    if is_torch_available()
					    else {}
					)

					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False



					def     __snake_case						(	self     :						str)    ->							str:
								A_									= BeitModelTester(self)
								A_									= ConfigTester(self      ,       config_class=_lowercase      ,       has_text_modality=_lowercase      ,       hidden_size=37)



					def     __snake_case						(	self     :						Optional[Any])    ->							Tuple:
								self.config_tester.run_common_tests()



					@unittest.skip(reason='BEiT does not use inputs_embeds')
					def     __snake_case						(	self     :						str)    ->							List[Any]:
								pass



					@require_torch_multi_gpu
					@unittest.skip(reason='BEiT has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`')
					def     __snake_case						(	self     :						Optional[Any])    ->							str:
								pass



					def     __snake_case						(	self     :						List[Any])    ->							Optional[int]:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											A_									= model_class(_lowercase)
											self.assertIsInstance(model.get_input_embeddings()      ,       (nn.Module))
											A_									= model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(_lowercase      ,       nn.Linear))



					def     __snake_case						(	self     :						Optional[Any])    ->							Optional[Any]:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											A_									= model_class(_lowercase)
											A_									= inspect.signature(model.forward)
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											A_									= [*signature.parameters.keys()]

											A_									= ['pixel_values']
											self.assertListEqual(arg_names[:1]      ,       _lowercase)



					def     __snake_case						(	self     :						List[str])    ->							str:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowercase)



					def     __snake_case						(	self     :						List[Any])    ->							Optional[int]:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*_lowercase)



					def     __snake_case						(	self     :						int)    ->							List[str]:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowercase)



					def     __snake_case						(	self     :						Union[str, Any])    ->							Optional[int]:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*_lowercase)



					def     __snake_case						(	self     :						int)    ->							str:
								if not self.model_tester.is_training:
											return

								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()
								A_									= True

								for model_class in self.all_model_classes:
											# we don't test BeitForMaskedImageModeling
											if model_class in [*get_values(_lowercase), BeitForMaskedImageModeling]:
														continue

											A_									= model_class(_lowercase)
											model.to(_lowercase)
											model.train()
											A_									= self._prepare_for_class(_lowercase      ,       _lowercase      ,       return_labels=_lowercase)
											A_									= model(**_lowercase).loss
											loss.backward()



					def     __snake_case						(	self     :						List[Any])    ->							Optional[int]:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()
								if not self.model_tester.is_training:
											return

								A_									= False
								A_									= True

								for model_class in self.all_model_classes:
											# we don't test BeitForMaskedImageModeling
											if (
											    model_class in [*get_values(_lowercase), BeitForMaskedImageModeling]
											    or not model_class.supports_gradient_checkpointing
											):
														continue

											A_									= model_class(_lowercase)
											model.gradient_checkpointing_enable()
											model.to(_lowercase)
											model.train()
											A_									= self._prepare_for_class(_lowercase      ,       _lowercase      ,       return_labels=_lowercase)
											A_									= model(**_lowercase).loss
											loss.backward()



					def     __snake_case						(	self     :						int)    ->							int:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

								A_									= _config_zero_init(_lowercase)
								for model_class in self.all_model_classes:
											A_									= model_class(config=_lowercase)
											for name, param in model.named_parameters():
														# we skip lambda parameters as these require special initial values
														# determined by config.layer_scale_init_value
														if "lambda" in name:
																	continue
														if param.requires_grad:
																	self.assertIn(
																	    ((param.data.mean() * 1E9).round() / 1E9).item()      ,       [0.0, 1.0]      ,       msg=F'Parameter {name} of model {model_class} seems not properly initialized'      ,       )



					@slow
					def     __snake_case						(	self     :						int)    ->							str:
								for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A_									= BeitModel.from_pretrained(_lowercase)
											self.assertIsNotNone(_lowercase)





def 			lowerCamelCase(							)		->		str:
			A_									= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
			return image






@require_torch
@require_vision
class   __UpperCAmelCase				(     unittest.TestCase				):



					'''simple docstring'''





					@cached_property
					def     __snake_case						(	self     :						Optional[Any])    ->							int:
								return BeitImageProcessor.from_pretrained('microsoft/beit-base-patch16-224') if is_vision_available() else None



					@slow
					def     __snake_case						(	self     :						Any)    ->							Optional[Any]:
								A_									= BeitForMaskedImageModeling.from_pretrained('microsoft/beit-base-patch16-224-pt22k').to(_lowercase)

								A_									= self.default_image_processor
								A_									= prepare_img()
								A_									= image_processor(images=_lowercase      ,       return_tensors='pt').pixel_values.to(_lowercase)

								# prepare bool_masked_pos
								A_									= torch.ones((1, 196)      ,       dtype=torch.bool).to(_lowercase)

								# forward pass
								with torch.no_grad():
											A_									= model(pixel_values=_lowercase      ,       bool_masked_pos=_lowercase)
								A_									= outputs.logits

								# verify the logits
								A_									= torch.Size((1, 196, 8_192))
								self.assertEqual(logits.shape      ,       _lowercase)

								A_									= torch.tensor(
								    [[-3.24_37, 0.50_72, -13.91_74], [-3.24_56, 0.49_48, -13.94_01], [-3.20_33, 0.51_21, -13.85_50]]).to(_lowercase)

								self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]      ,       _lowercase      ,       atol=1E-2))



					@slow
					def     __snake_case						(	self     :						List[str])    ->							Any:
								A_									= BeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224').to(_lowercase)

								A_									= self.default_image_processor
								A_									= prepare_img()
								A_									= image_processor(images=_lowercase      ,       return_tensors='pt').to(_lowercase)

								# forward pass
								with torch.no_grad():
											A_									= model(**_lowercase)
								A_									= outputs.logits

								# verify the logits
								A_									= torch.Size((1, 1_000))
								self.assertEqual(logits.shape      ,       _lowercase)

								A_									= torch.tensor([-1.23_85, -1.09_87, -1.01_08]).to(_lowercase)

								self.assertTrue(torch.allclose(logits[0, :3]      ,       _lowercase      ,       atol=1E-4))

								A_									= 281
								self.assertEqual(logits.argmax(-1).item()      ,       _lowercase)



					@slow
					def     __snake_case						(	self     :						Optional[int])    ->							List[Any]:
								A_									= BeitForImageClassification.from_pretrained('microsoft/beit-large-patch16-224-pt22k-ft22k').to(
								    _lowercase)

								A_									= self.default_image_processor
								A_									= prepare_img()
								A_									= image_processor(images=_lowercase      ,       return_tensors='pt').to(_lowercase)

								# forward pass
								with torch.no_grad():
											A_									= model(**_lowercase)
								A_									= outputs.logits

								# verify the logits
								A_									= torch.Size((1, 21_841))
								self.assertEqual(logits.shape      ,       _lowercase)

								A_									= torch.tensor([1.68_81, -0.27_87, 0.59_01]).to(_lowercase)

								self.assertTrue(torch.allclose(logits[0, :3]      ,       _lowercase      ,       atol=1E-4))

								A_									= 2_396
								self.assertEqual(logits.argmax(-1).item()      ,       _lowercase)



					@slow
					def     __snake_case						(	self     :						Tuple)    ->							Any:
								A_									= BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640')
								A_									= model.to(_lowercase)

								A_									= BeitImageProcessor(do_resize=_lowercase      ,       size=640      ,       do_center_crop=_lowercase)

								A_									= load_dataset('hf-internal-testing/fixtures_ade20k'      ,       split='test')
								A_									= Image.open(ds[0]['file'])
								A_									= image_processor(images=_lowercase      ,       return_tensors='pt').to(_lowercase)

								# forward pass
								with torch.no_grad():
											A_									= model(**_lowercase)
								A_									= outputs.logits

								# verify the logits
								A_									= torch.Size((1, 150, 160, 160))
								self.assertEqual(logits.shape      ,       _lowercase)

								A_									= version.parse(PIL.__version__) < version.parse('9.0.0')

								if is_pillow_less_than_a:
											A_									= torch.tensor(
											    [
											        [[-4.92_25, -2.39_54, -3.05_22], [-2.88_22, -1.00_46, -1.75_61], [-2.95_49, -1.32_28, -2.13_47]],
											        [[-5.81_68, -3.41_29, -4.07_78], [-3.86_51, -2.22_14, -3.02_77], [-3.83_56, -2.46_43, -3.35_35]],
											        [[-0.00_78, 3.99_52, 4.07_54], [2.98_56, 4.69_44, 5.00_35], [3.24_13, 4.78_13, 4.99_69]],
											    ]      ,       device=_lowercase      ,       )
								else:
											A_									= torch.tensor(
											    [
											        [[-4.89_60, -2.36_88, -3.03_55], [-2.84_78, -0.98_36, -1.74_18], [-2.94_49, -1.33_32, -2.14_56]],
											        [[-5.80_81, -3.41_24, -4.10_06], [-3.85_61, -2.20_81, -3.03_23], [-3.83_65, -2.46_01, -3.36_69]],
											        [[-0.03_09, 3.98_68, 4.05_40], [2.96_40, 4.68_77, 4.99_76], [3.20_81, 4.76_90, 4.99_42]],
											    ]      ,       device=_lowercase      ,       )

								self.assertTrue(torch.allclose(logits[0, :3, :3, :3]      ,       _lowercase      ,       atol=1E-4))



					@slow
					def     __snake_case						(	self     :						List[str])    ->							Tuple:
								A_									= BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640')
								A_									= model.to(_lowercase)

								A_									= BeitImageProcessor(do_resize=_lowercase      ,       size=640      ,       do_center_crop=_lowercase)

								A_									= load_dataset('hf-internal-testing/fixtures_ade20k'      ,       split='test')
								A_									= Image.open(ds[0]['file'])
								A_									= image_processor(images=_lowercase      ,       return_tensors='pt').to(_lowercase)

								# forward pass
								with torch.no_grad():
											A_									= model(**_lowercase)

								A_									= outputs.logits.detach().cpu()

								A_									= image_processor.post_process_semantic_segmentation(outputs=_lowercase      ,       target_sizes=[(500, 300)])
								A_									= torch.Size((500, 300))
								self.assertEqual(segmentation[0].shape      ,       _lowercase)

								A_									= image_processor.post_process_semantic_segmentation(outputs=_lowercase)
								A_									= torch.Size((160, 160))
								self.assertEqual(segmentation[0].shape      ,       _lowercase)




