





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




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_=13			,  lowerCAmelCase_=7			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=99			,  lowerCAmelCase_=32			,  lowerCAmelCase_=5			,  lowerCAmelCase_=4			,  lowerCAmelCase_=37			,  lowerCAmelCase_="gelu"			,  lowerCAmelCase_=0.1			,  lowerCAmelCase_=0.1			,  lowerCAmelCase_=512			,  lowerCAmelCase_=16			,  lowerCAmelCase_=2			,  lowerCAmelCase_=0.02			,  lowerCAmelCase_=3			,  lowerCAmelCase_=4			,  lowerCAmelCase_=None			,  )						->							int:
										_snake_case													=			parent
										_snake_case													=			batch_size
										_snake_case													=			seq_length
										_snake_case													=			is_training
										_snake_case													=			use_token_type_ids
										_snake_case													=			use_labels
										_snake_case													=			vocab_size
										_snake_case													=			hidden_size
										_snake_case													=			num_hidden_layers
										_snake_case													=			num_attention_heads
										_snake_case													=			intermediate_size
										_snake_case													=			hidden_act
										_snake_case													=			hidden_dropout_prob
										_snake_case													=			attention_probs_dropout_prob
										_snake_case													=			max_position_embeddings
										_snake_case													=			type_vocab_size
										_snake_case													=			type_sequence_label_size
										_snake_case													=			initializer_range
										_snake_case													=			num_labels
										_snake_case													=			num_choices
										_snake_case													=			scope
										_snake_case													=			self.vocab_size - 1




					def 		lowerCAmelCase     (						self					)						->							int:
										_snake_case													=			ids_tensor([self.batch_size, self.seq_length]			,  self.vocab_size					)

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

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

										_snake_case													=			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			,  )

										_snake_case													=			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 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  *lowerCAmelCase_					)						->							Optional[Any]:
										_snake_case													=			OpenAIGPTModel(config=lowerCAmelCase_					)
										model.to(lowerCAmelCase_					)
										model.eval()

										_snake_case													=			model(lowerCAmelCase_			,  token_type_ids=lowerCAmelCase_			,  head_mask=lowerCAmelCase_					)
										_snake_case													=			model(lowerCAmelCase_			,  token_type_ids=lowerCAmelCase_					)
										_snake_case													=			model(lowerCAmelCase_					)

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




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  *lowerCAmelCase_					)						->							Dict:
										_snake_case													=			OpenAIGPTLMHeadModel(lowerCAmelCase_					)
										model.to(lowerCAmelCase_					)
										model.eval()

										_snake_case													=			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 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  *lowerCAmelCase_					)						->							List[str]:
										_snake_case													=			OpenAIGPTDoubleHeadsModel(lowerCAmelCase_					)
										model.to(lowerCAmelCase_					)
										model.eval()

										_snake_case													=			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 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  *lowerCAmelCase_					)						->							Dict:
										_snake_case													=			self.num_labels
										_snake_case													=			OpenAIGPTForSequenceClassification(lowerCAmelCase_					)
										model.to(lowerCAmelCase_					)
										model.eval()

										_snake_case													=			ids_tensor([self.batch_size]			,  self.type_sequence_label_size					)
										_snake_case													=			model(lowerCAmelCase_			,  token_type_ids=lowerCAmelCase_			,  labels=lowerCAmelCase_					)
										self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)					)






					def 		lowerCAmelCase     (						self					)						->							List[Any]:
										_snake_case													=			self.prepare_config_and_inputs()
										(
										    (
										    _snake_case
										)							,       (
										    _snake_case
										)							,       (
										    _snake_case
										)							,       (
										    _snake_case
										)							,       (
										    _snake_case
										)							,       (
										    _snake_case
										)							,       (
										    _snake_case
										)							,       
										)													=			config_and_inputs
										_snake_case													=			{
										    'input_ids': input_ids,
										    'token_type_ids': token_type_ids,
										    'head_mask': head_mask,
										}

										return config, inputs_dict





@require_torch
class      UpperCamelCase_						(					_lowerCamelCase							,					_lowerCamelCase							,					_lowerCamelCase							,					unittest.TestCase   ):
					lowerCAmelCase_							=		(
					    (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
					    if is_torch_available()
					    else ()
					)
					lowerCAmelCase_							=		(
					    (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
					)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
					lowerCAmelCase_							=		(
					    {
					        '''feature-extraction''': OpenAIGPTModel,
					        '''text-classification''': OpenAIGPTForSequenceClassification,
					        '''text-generation''': OpenAIGPTLMHeadModel,
					        '''zero-shot''': OpenAIGPTForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							str:
										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 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_=False					)						->							Union[str, Any]:
										_snake_case													=			super()._prepare_for_class(lowerCAmelCase_			,  lowerCAmelCase_			,  return_labels=lowerCAmelCase_					)

										if return_labels:
															if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
																				_snake_case													=			torch.zeros(
																				    (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)			,  dtype=torch.long			,  device=lowerCAmelCase_			,  )
																				_snake_case													=			inputs_dict['labels']
																				_snake_case													=			inputs_dict['labels']
																				_snake_case													=			torch.zeros(
																				    (self.model_tester.batch_size, self.model_tester.num_choices)			,  dtype=torch.long			,  device=lowerCAmelCase_			,  )
																				_snake_case													=			torch.zeros(
																				    self.model_tester.batch_size			,  dtype=torch.long			,  device=lowerCAmelCase_					)
										return inputs_dict




					def 		lowerCAmelCase     (						self					)						->							List[str]:
										_snake_case													=			OpenAIGPTModelTester(self					)
										_snake_case													=			ConfigTester(self			,  config_class=lowerCAmelCase_			,  n_embd=37					)




					def 		lowerCAmelCase     (						self					)						->							Any:
										self.config_tester.run_common_tests()




					def 		lowerCAmelCase     (						self					)						->							List[Any]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_model(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							Dict:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_lm_head_model(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							Any:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_double_lm_head_model(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							List[Any]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowerCAmelCase_					)






					@slow
					def 		lowerCAmelCase     (						self					)						->							Dict:
										for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case													=			OpenAIGPTModel.from_pretrained(lowerCAmelCase_					)
															self.assertIsNotNone(lowerCAmelCase_					)





@require_torch
class      UpperCamelCase_						(					unittest.TestCase   ):




					@slow
					def 		lowerCAmelCase     (						self					)						->							Optional[Any]:
										_snake_case													=			OpenAIGPTLMHeadModel.from_pretrained('openai-gpt'					)
										model.to(lowerCAmelCase_					)
										_snake_case													=			torch.tensor([[481, 4735, 544]]			,  dtype=torch.long			,  device=lowerCAmelCase_					)  # the president is
										_snake_case													=			[
										    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

										_snake_case													=			model.generate(lowerCAmelCase_			,  do_sample=lowerCAmelCase_					)
										self.assertListEqual(output_ids[0].tolist()			,  lowerCAmelCase_					)










import random





def   lowerCamelCase__       (       UpperCamelCase__     :    int    ,      UpperCamelCase__     :    float    ,      UpperCamelCase__     :    bool = False  )     ->	dict:



					'''simple docstring'''




					_snake_case													=			{i: [] for i in range(UpperCamelCase__  )}

					# if probability is greater or equal than 1, then generate a complete graph
					if probability >= 1:
										return complete_graph(UpperCamelCase__  )
					# if probability is lower or equal than 0, then return a graph without edges
					if probability <= 0:
										return graph

					# for each couple of nodes, add an edge from u to v
					# if the number randomly generated is greater than probability probability
					for i in range(UpperCamelCase__  ):
										for j in range(i + 1    ,      UpperCamelCase__  ):
															if random.random() < probability:
																				graph[i].append(UpperCamelCase__  )
																				if not directed:
																									# if the graph is undirected, add an edge in from j to i, either
																									graph[j].append(UpperCamelCase__  )
					return graph





def   lowerCamelCase__       (       UpperCamelCase__     :    int  )     ->	dict:



					'''simple docstring'''




					return {
					    i: [j for j in range(UpperCamelCase__  ) if i != j] for i in range(UpperCamelCase__  )
					}


if __name__ == "__main__":
					import doctest

					doctest.testmod()



