




'''simple docstring'''


import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pytest

from datasets.arrow_dataset import Dataset
from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex

from .utils import require_elasticsearch, require_faiss


_lowercase  =			pytest.mark.integration
@require_faiss
class 						a_				(			UpperCAmelCase__						):




	def   lowercase__   (       self     :  List[Any]      ):
							__snake_case						 =   Dataset.from_dict({'filename': ['my_name-train' + '_' + str(__lowerCAmelCase      ) for x in np.arange(3_0      ).tolist()]}      )
							return dset




	def   lowercase__   (       self     :  List[str]      ):
							import faiss

							__snake_case						 =   self._create_dummy_dataset()
							__snake_case						 =   dset.map(
							    lambda __lowerCAmelCase       ,		__lowerCAmelCase      : {"vecs": i * np.ones(5       ,		dtype=np.floataa      )}       ,		with_indices=__lowerCAmelCase       ,		keep_in_memory=__lowerCAmelCase      )
							__snake_case						 =   dset.add_faiss_index('vecs'       ,		batch_size=1_0_0       ,		metric_type=faiss.METRIC_INNER_PRODUCT      )
							__snake_case ,       __snake_case						 =   dset.get_nearest_examples('vecs'       ,		np.ones(5       ,		dtype=np.floataa      )      )
							self.assertEqual(examples['filename'][0]       ,		'my_name-train_29'      )
							dset.drop_index('vecs'      )




	def   lowercase__   (       self     :  Optional[int]      ):
							import faiss

							__snake_case						 =   self._create_dummy_dataset()
							dset.add_faiss_index_from_external_arrays(
							    external_arrays=np.ones((3_0, 5)      ) * np.arange(3_0      ).reshape(-1       ,		1      )       ,		index_name='vecs'       ,		batch_size=1_0_0       ,		metric_type=faiss.METRIC_INNER_PRODUCT       ,		)
							__snake_case ,       __snake_case						 =   dset.get_nearest_examples('vecs'       ,		np.ones(5       ,		dtype=np.floataa      )      )
							self.assertEqual(examples['filename'][0]       ,		'my_name-train_29'      )




	def   lowercase__   (       self     :  Dict      ):
							import faiss

							__snake_case						 =   self._create_dummy_dataset()
							dset.add_faiss_index_from_external_arrays(
							    external_arrays=np.ones((3_0, 5)      ) * np.arange(3_0      ).reshape(-1       ,		1      )       ,		index_name='vecs'       ,		metric_type=faiss.METRIC_INNER_PRODUCT       ,		)

							# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
							# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
							# see https://bugs.python.org/issue14243 and
							# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
							with tempfile.NamedTemporaryFile(delete=__lowerCAmelCase      ) as tmp_file:
													dset.save_faiss_index('vecs'       ,		tmp_file.name      )
													dset.load_faiss_index('vecs2'       ,		tmp_file.name      )
							os.unlink(tmp_file.name      )

							__snake_case ,       __snake_case						 =   dset.get_nearest_examples('vecs2'       ,		np.ones(5       ,		dtype=np.floataa      )      )
							self.assertEqual(examples['filename'][0]       ,		'my_name-train_29'      )




	def   lowercase__   (       self     :  Union[str, Any]      ):
							__snake_case						 =   self._create_dummy_dataset()
							dset.add_faiss_index_from_external_arrays(
							    external_arrays=np.ones((3_0, 5)      ) * np.arange(3_0      ).reshape(-1       ,		1      )       ,		index_name='vecs'      )
							dset.drop_index('vecs'      )
							self.assertRaises(__lowerCAmelCase       ,		partial(dset.get_nearest_examples       ,		'vecs2'       ,		np.ones(5       ,		dtype=np.floataa      )      )      )




	def   lowercase__   (       self     :  List[str]      ):
							from elasticsearch import Elasticsearch

							__snake_case						 =   self._create_dummy_dataset()
							with patch('elasticsearch.Elasticsearch.search'      ) as mocked_search, patch(
							    'elasticsearch.client.IndicesClient.create'      ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk'      ) as mocked_bulk:
													__snake_case						 =   {'acknowledged': True}
													mocked_bulk.return_value([(True, None)] * 3_0      )
													__snake_case						 =   {'hits': {'hits': [{'_score': 1, '_id': 2_9}]}}
													__snake_case						 =   Elasticsearch()

													dset.add_elasticsearch_index('filename'       ,		es_client=__lowerCAmelCase      )
													__snake_case ,       __snake_case						 =   dset.get_nearest_examples('filename'       ,		'my_name-train_29'      )
													self.assertEqual(examples['filename'][0]       ,		'my_name-train_29'      )





@require_faiss
class 						a_				(			UpperCAmelCase__						):




	def   lowercase__   (       self     :  Dict      ):
							import faiss

							__snake_case						 =   FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT      )

							# add vectors
							index.add_vectors(np.eye(5       ,		dtype=np.floataa      )      )
							self.assertIsNotNone(index.faiss_index      )
							self.assertEqual(index.faiss_index.ntotal       ,		5      )
							index.add_vectors(np.zeros((5, 5)       ,		dtype=np.floataa      )      )
							self.assertEqual(index.faiss_index.ntotal       ,		1_0      )

							# single query
							__snake_case						 =   np.zeros(5       ,		dtype=np.floataa      )
							__snake_case						 =   1
							__snake_case ,       __snake_case						 =   index.search(__lowerCAmelCase      )
							self.assertRaises(__lowerCAmelCase       ,		index.search       ,		query.reshape(-1       ,		1      )      )
							self.assertGreater(scores[0]       ,		0      )
							self.assertEqual(indices[0]       ,		1      )

							# batched queries
							__snake_case						 =   np.eye(5       ,		dtype=np.floataa      )[::-1]
							__snake_case ,       __snake_case						 =   index.search_batch(__lowerCAmelCase      )
							self.assertRaises(__lowerCAmelCase       ,		index.search_batch       ,		queries[0]      )
							__snake_case						 =   [scores[0] for scores in total_scores]
							__snake_case						 =   [indices[0] for indices in total_indices]
							self.assertGreater(np.min(__lowerCAmelCase      )       ,		0      )
							self.assertListEqual([4, 3, 2, 1, 0]       ,		__lowerCAmelCase      )




	def   lowercase__   (       self     :  Optional[int]      ):
							import faiss

							__snake_case						 =   FaissIndex(string_factory='Flat'      )
							index.add_vectors(np.eye(5       ,		dtype=np.floataa      )      )
							self.assertIsInstance(index.faiss_index       ,		faiss.IndexFlat      )
							__snake_case						 =   FaissIndex(string_factory='LSH'      )
							index.add_vectors(np.eye(5       ,		dtype=np.floataa      )      )
							self.assertIsInstance(index.faiss_index       ,		faiss.IndexLSH      )
							with self.assertRaises(__lowerCAmelCase      ):
													__snake_case						 =   FaissIndex(string_factory='Flat'       ,		custom_index=faiss.IndexFlat(5      )      )




	def   lowercase__   (       self     :  int      ):
							import faiss

							__snake_case						 =   faiss.IndexFlat(5      )
							__snake_case						 =   FaissIndex(custom_index=__lowerCAmelCase      )
							index.add_vectors(np.eye(5       ,		dtype=np.floataa      )      )
							self.assertIsInstance(index.faiss_index       ,		faiss.IndexFlat      )




	def   lowercase__   (       self     :  Tuple      ):
							import faiss

							__snake_case						 =   FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT      )
							index.add_vectors(np.eye(5       ,		dtype=np.floataa      )      )

							# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
							# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
							# see https://bugs.python.org/issue14243 and
							# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
							with tempfile.NamedTemporaryFile(delete=__lowerCAmelCase      ) as tmp_file:
													index.save(tmp_file.name      )
													__snake_case						 =   FaissIndex.load(tmp_file.name      )
							os.unlink(tmp_file.name      )

							__snake_case						 =   np.zeros(5       ,		dtype=np.floataa      )
							__snake_case						 =   1
							__snake_case ,       __snake_case						 =   index.search(__lowerCAmelCase      )
							self.assertGreater(scores[0]       ,		0      )
							self.assertEqual(indices[0]       ,		1      )





@require_faiss
def 						lowerCamelCase__   (				a							):
						import faiss

						__snake_case						 =   FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT							)
						index.add_vectors(np.eye(5    ,	dtype=np.floataa							)							)

						__snake_case						 =   'index.faiss'
						__snake_case						 =   f'mock://{index_name}'
						index.save(a    ,	storage_options=mockfs.storage_options							)
						__snake_case						 =   FaissIndex.load(a    ,	storage_options=mockfs.storage_options							)

						__snake_case						 =   np.zeros(5    ,	dtype=np.floataa							)
						__snake_case						 =   1
						__snake_case ,       __snake_case						 =   index.search(a							)
						assert scores[0] > 0
						assert indices[0] == 1






@require_elasticsearch
class 						a_				(			UpperCAmelCase__						):




	def   lowercase__   (       self     :  int      ):
							from elasticsearch import Elasticsearch

							with patch('elasticsearch.Elasticsearch.search'      ) as mocked_search, patch(
							    'elasticsearch.client.IndicesClient.create'      ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk'      ) as mocked_bulk:
													__snake_case						 =   Elasticsearch()
													__snake_case						 =   {'acknowledged': True}
													__snake_case						 =   ElasticSearchIndex(es_client=__lowerCAmelCase      )
													mocked_bulk.return_value([(True, None)] * 3      )
													index.add_documents(['foo', 'bar', 'foobar']      )

													# single query
													__snake_case						 =   'foo'
													__snake_case						 =   {'hits': {'hits': [{'_score': 1, '_id': 0}]}}
													__snake_case ,       __snake_case						 =   index.search(__lowerCAmelCase      )
													self.assertEqual(scores[0]       ,		1      )
													self.assertEqual(indices[0]       ,		0      )

													# single query with timeout
													__snake_case						 =   'foo'
													__snake_case						 =   {'hits': {'hits': [{'_score': 1, '_id': 0}]}}
													__snake_case ,       __snake_case						 =   index.search(__lowerCAmelCase       ,		request_timeout=3_0      )
													self.assertEqual(scores[0]       ,		1      )
													self.assertEqual(indices[0]       ,		0      )

													# batched queries
													__snake_case						 =   ['foo', 'bar', 'foobar']
													__snake_case						 =   {'hits': {'hits': [{'_score': 1, '_id': 1}]}}
													__snake_case ,       __snake_case						 =   index.search_batch(__lowerCAmelCase      )
													__snake_case						 =   [scores[0] for scores in total_scores]
													__snake_case						 =   [indices[0] for indices in total_indices]
													self.assertGreater(np.min(__lowerCAmelCase      )       ,		0      )
													self.assertListEqual([1, 1, 1]       ,		__lowerCAmelCase      )

													# batched queries with timeout
													__snake_case						 =   ['foo', 'bar', 'foobar']
													__snake_case						 =   {'hits': {'hits': [{'_score': 1, '_id': 1}]}}
													__snake_case ,       __snake_case						 =   index.search_batch(__lowerCAmelCase       ,		request_timeout=3_0      )
													__snake_case						 =   [scores[0] for scores in total_scores]
													__snake_case						 =   [indices[0] for indices in total_indices]
													self.assertGreater(np.min(__lowerCAmelCase      )       ,		0      )
													self.assertListEqual([1, 1, 1]       ,		__lowerCAmelCase      )







'''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 						a_				:




	def __init__(       self     :  Optional[Any]       ,		__lowerCAmelCase     :  Optional[Any]       ,		__lowerCAmelCase     :  Optional[int]=1_3       ,		__lowerCAmelCase     :  Tuple=7       ,		__lowerCAmelCase     :  Optional[int]=True       ,		__lowerCAmelCase     :  Any=True       ,		__lowerCAmelCase     :  List[Any]=True       ,		__lowerCAmelCase     :  Union[str, Any]=9_9       ,		__lowerCAmelCase     :  Any=3_2       ,		__lowerCAmelCase     :  Tuple=5       ,		__lowerCAmelCase     :  int=4       ,		__lowerCAmelCase     :  List[str]=3_7       ,		__lowerCAmelCase     :  List[Any]="gelu"       ,		__lowerCAmelCase     :  Union[str, Any]=0.1       ,		__lowerCAmelCase     :  int=0.1       ,		__lowerCAmelCase     :  Any=5_1_2       ,		__lowerCAmelCase     :  Dict=1_6       ,		__lowerCAmelCase     :  Dict=2       ,		__lowerCAmelCase     :  Union[str, Any]=0.02       ,		__lowerCAmelCase     :  Optional[Any]=3       ,		__lowerCAmelCase     :  str=4       ,		__lowerCAmelCase     :  List[str]=None       ,		):
							__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   lowercase__   (       self     :  Union[str, Any]      ):
							__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   lowercase__   (       self     :  List[str]       ,		__lowerCAmelCase     :  Tuple       ,		__lowerCAmelCase     :  Optional[Any]       ,		__lowerCAmelCase     :  Any       ,		__lowerCAmelCase     :  Union[str, Any]       ,		*__lowerCAmelCase     :  List[str]      ):
							__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   lowercase__   (       self     :  Union[str, Any]       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  Dict       ,		__lowerCAmelCase     :  Dict       ,		__lowerCAmelCase     :  Dict       ,		*__lowerCAmelCase     :  str      ):
							__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   lowercase__   (       self     :  Optional[Any]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  Any       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  List[Any]       ,		*__lowerCAmelCase     :  Tuple      ):
							__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   lowercase__   (       self     :  Optional[int]       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  Tuple       ,		__lowerCAmelCase     :  int       ,		*__lowerCAmelCase     :  int      ):
							__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   lowercase__   (       self     :  List[str]      ):
							__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 						a_				(			UpperCAmelCase__     ,						UpperCAmelCase__     ,						UpperCAmelCase__     ,						unittest.TestCase						):
	lowercase_       :     List[str]			  =      (
	    (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
	    if is_torch_available()
	    else ()
	)
	lowercase_       :     Union[str, Any]			  =      (
	    (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
	)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
	lowercase_       :     str			  =      (
	    {
	        '''feature-extraction''': OpenAIGPTModel,
	        '''text-classification''': OpenAIGPTForSequenceClassification,
	        '''text-generation''': OpenAIGPTLMHeadModel,
	        '''zero-shot''': OpenAIGPTForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)




	def   lowercase__   (       self     :  Optional[Any]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  int       ,		__lowerCAmelCase     :  Any      ):
							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   lowercase__   (       self     :  Tuple       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  List[str]       ,		__lowerCAmelCase     :  List[str]=False      ):
							__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   lowercase__   (       self     :  Tuple      ):
							__snake_case						 =   OpenAIGPTModelTester(self      )
							__snake_case						 =   ConfigTester(self       ,		config_class=__lowerCAmelCase       ,		n_embd=3_7      )




	def   lowercase__   (       self     :  int      ):
							self.config_tester.run_common_tests()




	def   lowercase__   (       self     :  Optional[Any]      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_openai_gpt_model(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  int      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_lm_head_model(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  Any      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_double_lm_head_model(*__lowerCAmelCase      )




	def   lowercase__   (       self     :  str      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*__lowerCAmelCase      )




	@slow
	def   lowercase__   (       self     :  str      ):
							for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__snake_case						 =   OpenAIGPTModel.from_pretrained(__lowerCAmelCase      )
													self.assertIsNotNone(__lowerCAmelCase      )





@require_torch
class 						a_				(			unittest.TestCase						):




	@slow
	def   lowercase__   (       self     :  int      ):
							__snake_case						 =   OpenAIGPTLMHeadModel.from_pretrained('openai-gpt'      )
							model.to(__lowerCAmelCase      )
							__snake_case						 =   torch.tensor([[4_8_1, 4_7_3_5, 5_4_4]]       ,		dtype=torch.long       ,		device=__lowerCAmelCase      )  # the president is
							__snake_case						 =   [
							    4_8_1,
							    4_7_3_5,
							    5_4_4,
							    2_4_6,
							    9_6_3,
							    8_7_0,
							    7_6_2,
							    2_3_9,
							    2_4_4,
							    4_0_4_7_7,
							    2_4_4,
							    2_4_9,
							    7_1_9,
							    8_8_1,
							    4_8_7,
							    5_4_4,
							    2_4_0,
							    2_4_4,
							    6_0_3,
							    4_8_1,
							]  # 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      )

