


import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling


def        _UpperCamelCase							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Dict					=		[2, 2, 6, 2] if '''tiny''' in model_name else [2, 2, 18, 2]
						__SCREAMING_SNAKE_CASE						:     Tuple					=		True if '''large''' in model_name or '''huge''' in model_name else False
						__SCREAMING_SNAKE_CASE						:     str					=		True if '''large''' in model_name or '''huge''' in model_name else False
						__SCREAMING_SNAKE_CASE						:     Any					=		True if '''large''' in model_name or '''huge''' in model_name else False

						if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
												if "fl3" in model_name:
																		__SCREAMING_SNAKE_CASE						:     Any					=		[3, 3, 3, 3]
																		__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		[5, 5, 5, 5]
												elif "fl4" in model_name:
																		__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		[4, 4, 4, 4]
																		__SCREAMING_SNAKE_CASE						:     str					=		[3, 3, 3, 3]

						if "tiny" in model_name or "small" in model_name or "base" in model_name:
												__SCREAMING_SNAKE_CASE						:     List[Any]					=		[3, 3, 3, 3]
												if "lrf" in model_name:
																		__SCREAMING_SNAKE_CASE						:     List[str]					=		[3, 3, 3, 3]
												else:
																		__SCREAMING_SNAKE_CASE						:     str					=		[2, 2, 2, 2]

						if "tiny" in model_name:
												__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		96
						elif "small" in model_name:
												__SCREAMING_SNAKE_CASE						:     List[str]					=		96
						elif "base" in model_name:
												__SCREAMING_SNAKE_CASE						:     List[str]					=		128
						elif "large" in model_name:
												__SCREAMING_SNAKE_CASE						:     List[str]					=		192
						elif "xlarge" in model_name:
												__SCREAMING_SNAKE_CASE						:     List[str]					=		256
						elif "huge" in model_name:
												__SCREAMING_SNAKE_CASE						:     Tuple					=		352

						# set label information
						__SCREAMING_SNAKE_CASE						:     Dict					=		'''huggingface/label-files'''
						if "large" in model_name or "huge" in model_name:
												__SCREAMING_SNAKE_CASE						:     int					=		'''imagenet-22k-id2label.json'''
						else:
												__SCREAMING_SNAKE_CASE						:     Dict					=		'''imagenet-1k-id2label.json'''

						__SCREAMING_SNAKE_CASE						:     List[str]					=		json.load(open(hf_hub_download(lowercase__    ,       lowercase__    ,       repo_type='''dataset'''      )    ,       '''r'''      )      )
						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		{int(lowercase__      ): v for k, v in idalabel.items()}
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		{v: k for k, v in idalabel.items()}

						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		FocalNetConfig(
						    embed_dim=lowercase__    ,       depths=lowercase__    ,       focal_levels=lowercase__    ,       focal_windows=lowercase__    ,       use_conv_embed=lowercase__    ,       idalabel=lowercase__    ,       labelaid=lowercase__    ,       use_post_layernorm=lowercase__    ,       use_layerscale=lowercase__    ,       )

						return config


def        _UpperCamelCase							(      lowercase__      ):
						if "patch_embed.proj" in name:
												__SCREAMING_SNAKE_CASE						:     Optional[int]					=		name.replace('''patch_embed.proj'''    ,       '''embeddings.patch_embeddings.projection'''      )
						if "patch_embed.norm" in name:
												__SCREAMING_SNAKE_CASE						:     str					=		name.replace('''patch_embed.norm'''    ,       '''embeddings.norm'''      )
						if "layers" in name:
												__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		'''encoder.''' + name
						if "encoder.layers" in name:
												__SCREAMING_SNAKE_CASE						:     Dict					=		name.replace('''encoder.layers'''    ,       '''encoder.stages'''      )
						if "downsample.proj" in name:
												__SCREAMING_SNAKE_CASE						:     int					=		name.replace('''downsample.proj'''    ,       '''downsample.projection'''      )
						if "blocks" in name:
												__SCREAMING_SNAKE_CASE						:     Tuple					=		name.replace('''blocks'''    ,       '''layers'''      )
						if "modulation.f.weight" in name or "modulation.f.bias" in name:
												__SCREAMING_SNAKE_CASE						:     List[Any]					=		name.replace('''modulation.f'''    ,       '''modulation.projection_in'''      )
						if "modulation.h.weight" in name or "modulation.h.bias" in name:
												__SCREAMING_SNAKE_CASE						:     Any					=		name.replace('''modulation.h'''    ,       '''modulation.projection_context'''      )
						if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
												__SCREAMING_SNAKE_CASE						:     str					=		name.replace('''modulation.proj'''    ,       '''modulation.projection_out'''      )

						if name == "norm.weight":
												__SCREAMING_SNAKE_CASE						:     Optional[int]					=		'''layernorm.weight'''
						if name == "norm.bias":
												__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		'''layernorm.bias'''

						if "head" in name:
												__SCREAMING_SNAKE_CASE						:     Tuple					=		name.replace('''head'''    ,       '''classifier'''      )
						else:
												__SCREAMING_SNAKE_CASE						:     List[str]					=		'''focalnet.''' + name

						return name


def        _UpperCamelCase							(      lowercase__    ,       lowercase__    ,       lowercase__=False      ):
						# fmt: off
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		{
						    '''focalnet-tiny''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth''',
						    '''focalnet-tiny-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth''',
						    '''focalnet-small''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth''',
						    '''focalnet-small-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth''',
						    '''focalnet-base''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth''',
						    '''focalnet-base-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth''',
						    '''focalnet-large-lrf-fl3''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth''',
						    '''focalnet-large-lrf-fl4''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth''',
						    '''focalnet-xlarge-lrf-fl3''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth''',
						    '''focalnet-xlarge-lrf-fl4''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth''',
						}
						# fmt: on

						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		model_name_to_url[model_name]
						print('''Checkpoint URL: '''    ,       lowercase__      )
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		torch.hub.load_state_dict_from_url(lowercase__    ,       map_location='''cpu'''      )['''model''']

						# rename keys
						for key in state_dict.copy().keys():
												__SCREAMING_SNAKE_CASE						:     str					=		state_dict.pop(lowercase__      )
												__SCREAMING_SNAKE_CASE						:     List[Any]					=		val

						__SCREAMING_SNAKE_CASE						:     List[str]					=		get_focalnet_config(lowercase__      )
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		FocalNetForImageClassification(lowercase__      )
						model.eval()

						# load state dict
						model.load_state_dict(lowercase__      )

						# verify conversion
						__SCREAMING_SNAKE_CASE						:     Any					=		'''http://images.cocodataset.org/val2017/000000039769.jpg'''

						__SCREAMING_SNAKE_CASE						:     str					=		BitImageProcessor(
						    do_resize=lowercase__    ,       size={'''shortest_edge''': 256}    ,       resample=PILImageResampling.BILINEAR    ,       do_center_crop=lowercase__    ,       crop_size=224    ,       do_normalize=lowercase__    ,       image_mean=lowercase__    ,       image_std=lowercase__    ,       )
						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		Image.open(requests.get(lowercase__    ,       stream=lowercase__      ).raw      )
						__SCREAMING_SNAKE_CASE						:     Tuple					=		processor(images=lowercase__    ,       return_tensors='''pt'''      )

						__SCREAMING_SNAKE_CASE						:     List[Any]					=		transforms.Compose(
						    [
						        transforms.Resize(256      ),
						        transforms.CenterCrop(224      ),
						        transforms.ToTensor(),
						        transforms.Normalize(mean=[0.485, 0.456, 0.406]    ,       std=[0.229, 0.224, 0.225]      ),
						    ]      )

						__SCREAMING_SNAKE_CASE						:     int					=		image_transforms(lowercase__      ).unsqueeze(0      )

						# verify pixel_values
						assert torch.allclose(inputs.pixel_values    ,       lowercase__    ,       atol=1e-4      )

						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		model(**lowercase__      )

						__SCREAMING_SNAKE_CASE						:     Any					=		outputs.logits.argmax(-1      ).item()
						print('''Predicted class:'''    ,       model.config.idalabel[predicted_class_idx]      )

						print('''First values of logits:'''    ,       outputs.logits[0, :3]      )

						if model_name == "focalnet-tiny":
												__SCREAMING_SNAKE_CASE						:     int					=		torch.tensor([0.2166, -0.4368, 0.2191]      )
						elif model_name == "focalnet-tiny-lrf":
												__SCREAMING_SNAKE_CASE						:     List[Any]					=		torch.tensor([1.1669, 0.0125, -0.1695]      )
						elif model_name == "focalnet-small":
												__SCREAMING_SNAKE_CASE						:     Any					=		torch.tensor([0.4917, -0.0430, 0.1341]      )
						elif model_name == "focalnet-small-lrf":
												__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		torch.tensor([-0.2588, -0.5342, -0.2331]      )
						elif model_name == "focalnet-base":
												__SCREAMING_SNAKE_CASE						:     Tuple					=		torch.tensor([-0.1655, -0.4090, -0.1730]      )
						elif model_name == "focalnet-base-lrf":
												__SCREAMING_SNAKE_CASE						:     List[Any]					=		torch.tensor([0.5306, -0.0483, -0.3928]      )
						assert torch.allclose(outputs.logits[0, :3]    ,       lowercase__    ,       atol=1e-4      )
						print('''Looks ok!'''      )

						if pytorch_dump_folder_path is not None:
												print(F'''Saving model and processor of {model_name} to {pytorch_dump_folder_path}'''      )
												model.save_pretrained(lowercase__      )
												processor.save_pretrained(lowercase__      )

						if push_to_hub:
												print(F'''Pushing model and processor of {model_name} to the hub...'''      )
												model.push_to_hub(F'''{model_name}'''      )
												processor.push_to_hub(F'''{model_name}'''      )


if __name__ == "__main__":
						__lowerCAmelCase	: Optional[int]  				=argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '--model_name',
						    default='focalnet-tiny',
						    type=str,
						    help='Name of the FocalNet model you\'d like to convert.',
						)
						parser.add_argument(
						    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
						)
						parser.add_argument(
						    '--push_to_hub',
						    action='store_true',
						    help='Whether to push the model and processor to the hub.',
						)

						__lowerCAmelCase	: Tuple  				=parser.parse_args()
						convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




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        _lowercase      :






				'''simple docstring'''



				def __init__(       self			:Optional[int]			,			lowerCAmelCase__			:Optional[Any]			,			lowerCAmelCase__			:int=13			,			lowerCAmelCase__			:List[str]=7			,			lowerCAmelCase__			:Dict=True			,			lowerCAmelCase__			:List[str]=True			,			lowerCAmelCase__			:str=True			,			lowerCAmelCase__			:List[Any]=99			,			lowerCAmelCase__			:List[str]=32			,			lowerCAmelCase__			:Any=5			,			lowerCAmelCase__			:List[str]=4			,			lowerCAmelCase__			:int=37			,			lowerCAmelCase__			:Optional[int]="gelu"			,			lowerCAmelCase__			:str=0.1			,			lowerCAmelCase__			:str=0.1			,			lowerCAmelCase__			:Optional[Any]=512			,			lowerCAmelCase__			:Union[str, Any]=16			,			lowerCAmelCase__			:Dict=2			,			lowerCAmelCase__			:Tuple=0.02			,			lowerCAmelCase__			:List[Any]=3			,			lowerCAmelCase__			:Tuple=4			,			lowerCAmelCase__			:int=None			,			)		->			int:
										__SCREAMING_SNAKE_CASE						:     Dict					=		parent
										__SCREAMING_SNAKE_CASE						:     Any					=		batch_size
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		seq_length
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		is_training
										__SCREAMING_SNAKE_CASE						:     int					=		use_token_type_ids
										__SCREAMING_SNAKE_CASE						:     Any					=		use_labels
										__SCREAMING_SNAKE_CASE						:     Any					=		vocab_size
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		hidden_size
										__SCREAMING_SNAKE_CASE						:     int					=		num_hidden_layers
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		num_attention_heads
										__SCREAMING_SNAKE_CASE						:     str					=		intermediate_size
										__SCREAMING_SNAKE_CASE						:     Tuple					=		hidden_act
										__SCREAMING_SNAKE_CASE						:     Dict					=		hidden_dropout_prob
										__SCREAMING_SNAKE_CASE						:     int					=		attention_probs_dropout_prob
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		max_position_embeddings
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		type_vocab_size
										__SCREAMING_SNAKE_CASE						:     List[str]					=		type_sequence_label_size
										__SCREAMING_SNAKE_CASE						:     List[str]					=		initializer_range
										__SCREAMING_SNAKE_CASE						:     Tuple					=		num_labels
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		num_choices
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		scope
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		self.vocab_size - 1


				def 		__magic_name__(       self			:Optional[Any]	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		ids_tensor([self.batch_size, self.seq_length]			,			self.vocab_size	)

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

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

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		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			,			)

										__SCREAMING_SNAKE_CASE						:     Any					=		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 		__magic_name__(       self			:Tuple			,			lowerCAmelCase__			:List[Any]			,			lowerCAmelCase__			:List[str]			,			lowerCAmelCase__			:Dict			,			lowerCAmelCase__			:Any			,			*lowerCAmelCase__			:Union[str, Any]	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     Any					=		OpenAIGPTModel(config=lowerCAmelCase__	)
										model.to(lowerCAmelCase__	)
										model.eval()

										__SCREAMING_SNAKE_CASE						:     Dict					=		model(lowerCAmelCase__			,			token_type_ids=lowerCAmelCase__			,			head_mask=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Tuple					=		model(lowerCAmelCase__			,			token_type_ids=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     str					=		model(lowerCAmelCase__	)

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


				def 		__magic_name__(       self			:Optional[Any]			,			lowerCAmelCase__			:Union[str, Any]			,			lowerCAmelCase__			:Union[str, Any]			,			lowerCAmelCase__			:Any			,			lowerCAmelCase__			:Dict			,			*lowerCAmelCase__			:List[Any]	)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		OpenAIGPTLMHeadModel(lowerCAmelCase__	)
										model.to(lowerCAmelCase__	)
										model.eval()

										__SCREAMING_SNAKE_CASE						:     Tuple					=		model(lowerCAmelCase__			,			token_type_ids=lowerCAmelCase__			,			labels=lowerCAmelCase__	)
										self.parent.assertEqual(result.loss.shape			,			()	)
										self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.seq_length, self.vocab_size)	)


				def 		__magic_name__(       self			:Tuple			,			lowerCAmelCase__			:Dict			,			lowerCAmelCase__			:str			,			lowerCAmelCase__			:Optional[Any]			,			lowerCAmelCase__			:List[str]			,			*lowerCAmelCase__			:Optional[Any]	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     Any					=		OpenAIGPTDoubleHeadsModel(lowerCAmelCase__	)
										model.to(lowerCAmelCase__	)
										model.eval()

										__SCREAMING_SNAKE_CASE						:     Any					=		model(lowerCAmelCase__			,			token_type_ids=lowerCAmelCase__			,			labels=lowerCAmelCase__	)
										self.parent.assertEqual(result.loss.shape			,			()	)
										self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.seq_length, self.vocab_size)	)


				def 		__magic_name__(       self			:Dict			,			lowerCAmelCase__			:List[Any]			,			lowerCAmelCase__			:Union[str, Any]			,			lowerCAmelCase__			:List[Any]			,			lowerCAmelCase__			:str			,			*lowerCAmelCase__			:Optional[int]	)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		self.num_labels
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		OpenAIGPTForSequenceClassification(lowerCAmelCase__	)
										model.to(lowerCAmelCase__	)
										model.eval()

										__SCREAMING_SNAKE_CASE						:     List[str]					=		ids_tensor([self.batch_size]			,			self.type_sequence_label_size	)
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		model(lowerCAmelCase__			,			token_type_ids=lowerCAmelCase__			,			labels=lowerCAmelCase__	)
										self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.num_labels)	)



				def 		__magic_name__(       self			:Optional[Any]	)		->			str:
										__SCREAMING_SNAKE_CASE						:     str					=		self.prepare_config_and_inputs()
										(
										    (
										    __SCREAMING_SNAKE_CASE
										)			,			(
										    __SCREAMING_SNAKE_CASE
										)			,			(
										    __SCREAMING_SNAKE_CASE
										)			,			(
										    __SCREAMING_SNAKE_CASE
										)			,			(
										    __SCREAMING_SNAKE_CASE
										)			,			(
										    __SCREAMING_SNAKE_CASE
										)			,			(
										    __SCREAMING_SNAKE_CASE
										)			,			
										)						:     List[str]					=		config_and_inputs
										__SCREAMING_SNAKE_CASE						:     List[str]					=		{
										    '''input_ids''': input_ids,
										    '''token_type_ids''': token_type_ids,
										    '''head_mask''': head_mask,
										}

										return config, inputs_dict




@require_torch
class        _lowercase      (			A__						,			A__						,			A__						,			unittest.TestCase       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			int						=		(
				    (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
				    if is_torch_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE__				:			str						=		(
				    (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
				)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
				SCREAMING_SNAKE_CASE__				:			str						=		(
				    {
				        '''feature-extraction''': OpenAIGPTModel,
				        '''text-classification''': OpenAIGPTForSequenceClassification,
				        '''text-generation''': OpenAIGPTLMHeadModel,
				        '''zero-shot''': OpenAIGPTForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)


				def 		__magic_name__(       self			:Optional[int]			,			lowerCAmelCase__			:str			,			lowerCAmelCase__			:List[Any]			,			lowerCAmelCase__			:List[Any]			,			lowerCAmelCase__			:List[Any]			,			lowerCAmelCase__			:Union[str, Any]	)		->			Tuple:
										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 		__magic_name__(       self			:List[str]			,			lowerCAmelCase__			:Dict			,			lowerCAmelCase__			:int			,			lowerCAmelCase__			:int=False	)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     Tuple					=		super()._prepare_for_class(lowerCAmelCase__			,			lowerCAmelCase__			,			return_labels=lowerCAmelCase__	)

										if return_labels:
																if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
																						__SCREAMING_SNAKE_CASE						:     Any					=		torch.zeros(
																						    (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)			,			dtype=torch.long			,			device=lowerCAmelCase__			,			)
																						__SCREAMING_SNAKE_CASE						:     Tuple					=		inputs_dict['''labels''']
																						__SCREAMING_SNAKE_CASE						:     Dict					=		inputs_dict['''labels''']
																						__SCREAMING_SNAKE_CASE						:     List[Any]					=		torch.zeros(
																						    (self.model_tester.batch_size, self.model_tester.num_choices)			,			dtype=torch.long			,			device=lowerCAmelCase__			,			)
																						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		torch.zeros(
																						    self.model_tester.batch_size			,			dtype=torch.long			,			device=lowerCAmelCase__	)
										return inputs_dict


				def 		__magic_name__(       self			:Optional[int]	)		->			Union[str, Any]:
										__SCREAMING_SNAKE_CASE						:     int					=		OpenAIGPTModelTester(self	)
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		ConfigTester(self			,			config_class=lowerCAmelCase__			,			n_embd=37	)


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


				def 		__magic_name__(       self			:List[str]	)		->			Union[str, Any]:
										__SCREAMING_SNAKE_CASE						:     Tuple					=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_model(*lowerCAmelCase__	)


				def 		__magic_name__(       self			:int	)		->			int:
										__SCREAMING_SNAKE_CASE						:     Tuple					=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_lm_head_model(*lowerCAmelCase__	)


				def 		__magic_name__(       self			:List[str]	)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     List[str]					=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_double_lm_head_model(*lowerCAmelCase__	)


				def 		__magic_name__(       self			:List[str]	)		->			str:
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowerCAmelCase__	)



				@slow
				def 		__magic_name__(       self			:Any	)		->			List[Any]:
										for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__SCREAMING_SNAKE_CASE						:     Dict					=		OpenAIGPTModel.from_pretrained(lowerCAmelCase__	)
																self.assertIsNotNone(lowerCAmelCase__	)




@require_torch
class        _lowercase      (			unittest.TestCase       ):






				'''simple docstring'''



				@slow
				def 		__magic_name__(       self			:Union[str, Any]	)		->			Optional[int]:
										__SCREAMING_SNAKE_CASE						:     List[str]					=		OpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''	)
										model.to(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		torch.tensor([[481, 4_735, 544]]			,			dtype=torch.long			,			device=lowerCAmelCase__	)  # the president is
										__SCREAMING_SNAKE_CASE						:     Dict					=		[
										    481,
										    4_735,
										    544,
										    246,
										    963,
										    870,
										    762,
										    239,
										    244,
										    40_477,
										    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

										__SCREAMING_SNAKE_CASE						:     Dict					=		model.generate(lowerCAmelCase__			,			do_sample=lowerCAmelCase__	)
										self.assertListEqual(output_ids[0].tolist()			,			lowerCAmelCase__	)
