"""simple docstring"""




import argparse
import logging

import numpy as np
import torch

from transformers import AutoModelForCausalLM, AutoTokenizer


logging.basicConfig(
    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
    datefmt="%m/%d/%Y %H:%M:%S",
    level=logging.INFO,
)
UpperCAmelCase       :    List[str]									=			logging.getLogger(__name__)



def 				__a       (			_lowercase						):







					"""simple docstring"""





					np.random.seed(args.seed						)
					torch.manual_seed(args.seed						)
					if args.n_gpu > 0:
										torch.cuda.manual_seed_all(args.seed						)



def 				__a       (			):







					"""simple docstring"""





					lowerCamelCase__		:   Dict  				=					argparse.ArgumentParser()
					parser.add_argument(
					    '''--model_name_or_path'''							, default=_lowercase							, type=_lowercase							, required=_lowercase							, )
					parser.add_argument('''--prompt'''							, type=_lowercase							, default=''''''						)
					parser.add_argument('''--length'''							, type=_lowercase							, default=20						)
					parser.add_argument('''--stop_token'''							, type=_lowercase							, default=_lowercase							, help='''Token at which text generation is stopped'''						)
					parser.add_argument(
					    '''--temperature'''							, type=_lowercase							, default=1.0							, help='''temperature of 1.0 has no effect, lower tend toward greedy sampling'''							, )
					parser.add_argument(
					    '''--repetition_penalty'''							, type=_lowercase							, default=1.0							, help='''primarily useful for CTRL model; in that case, use 1.2'''						)
					parser.add_argument('''--k'''							, type=_lowercase							, default=0						)
					parser.add_argument('''--penalty_alpha'''							, type=_lowercase							, default=0.0						)
					parser.add_argument('''--p'''							, type=_lowercase							, default=0.9						)

					parser.add_argument('''--prefix'''							, type=_lowercase							, default=''''''							, help='''Text added prior to input.'''						)
					parser.add_argument('''--padding_text'''							, type=_lowercase							, default=''''''							, help='''Deprecated, the use of `--prefix` is preferred.'''						)
					parser.add_argument('''--xlm_language'''							, type=_lowercase							, default=''''''							, help='''Optional language when used with the XLM model.'''						)

					parser.add_argument('''--seed'''							, type=_lowercase							, default=42							, help='''random seed for initialization'''						)
					parser.add_argument('''--no_cuda'''							, action='''store_true'''							, help='''Avoid using CUDA when available'''						)
					parser.add_argument(
					    '''--fp16'''							, action='''store_true'''							, help='''Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit'''							, )
					lowerCamelCase__		:   Any  				=					parser.parse_args()

					lowerCamelCase__		:   Any  				=					torch.device('''cuda''' if torch.cuda.is_available() and not args.no_cuda else '''cpu'''						)
					lowerCamelCase__		:   Tuple  				=					0 if args.no_cuda else torch.cuda.device_count()

					logger.warning(f"""device: {args.device}, n_gpu: {args.n_gpu}, 16-bits training: {args.fpaa}"""						)

					set_seed(_lowercase						)

					# Initialize the model and tokenizer
					lowerCamelCase__		:   List[str]  				=					AutoTokenizer.from_pretrained(args.model_name_or_path						)
					lowerCamelCase__		:   Dict  				=					AutoModelForCausalLM.from_pretrained(args.model_name_or_path						)

					# tokenizer = GPT2Tokenizer.from_pretrained(args.model_name_or_path)
					# model = OPTForCausalLM.from_pretrained(args.model_name_or_path)
					model.to(args.device						)

					if args.fpaa:
										model.half()

					logger.info(_lowercase						)
					lowerCamelCase__		:   Optional[Any]  				=					args.prompt if args.prompt else input('''Model prompt >>> '''						)

					lowerCamelCase__		:   Dict  				=					tokenizer(_lowercase							, return_tensors='''pt'''							, add_special_tokens=_lowercase						)
					lowerCamelCase__		:   Dict  				=					{key: value.to(args.device						) for key, value in inputs.items()}

					lowerCamelCase__		:   str  				=					model.generate(
					    **_lowercase							, max_length=args.length + len(inputs['''input_ids'''][0]						)							, penalty_alpha=args.penalty_alpha							, top_k=args.k							, )

					lowerCamelCase__		:   Any  				=					[]
					for generated_sequence_idx, generated_sequence in enumerate(_lowercase						):
										print(f"""=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==="""						)
										lowerCamelCase__		:   List[str]  				=					generated_sequence.tolist()

										# Decode text
										lowerCamelCase__		:   Any  				=					tokenizer.decode(_lowercase							, clean_up_tokenization_spaces=_lowercase							, add_special_tokens=_lowercase						)

										# Remove all text after the stop token
										lowerCamelCase__		:   Union[str, Any]  				=					text[: text.find(args.stop_token						) if args.stop_token else None]

										# Add the prompt at the beginning of the sequence. Remove the excess text that was used for pre-processing
										lowerCamelCase__		:   Dict  				=					(
										    prompt_text + text[len(tokenizer.decode(inputs['''input_ids'''][0]							, clean_up_tokenization_spaces=_lowercase						)						) :]
										)

										generated_sequences.append(_lowercase						)
										print(_lowercase						)

					return generated_sequences


if __name__ == "__main__":
					main()







"""simple docstring"""




import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
					from tokenizers import Tokenizer
					from tokenizers.models import WordPiece

class        __SCREAMING_SNAKE_CASE     (   unittest.TestCase							):







				def   lowercase_		(    self    :Optional[Any]      ,__UpperCAmelCase    :Dict  )      ->					Optional[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					list(tokenizer_class.max_model_input_sizes.keys()  )
									for model_name in sa_models[:1]:
														lowerCamelCase__		:   Tuple  				=					tokenizer_class.from_pretrained(__UpperCAmelCase  )
														self.assertIsNotNone(__UpperCAmelCase  )
														self.assertIsInstance(__UpperCAmelCase      ,__UpperCAmelCase  )
														self.assertIsInstance(__UpperCAmelCase      ,__UpperCAmelCase  )

														for special_tok in tokenizer.all_special_tokens:
																			self.assertIsInstance(__UpperCAmelCase      ,__UpperCAmelCase  )
																			lowerCamelCase__		:   str  				=					tokenizer.convert_tokens_to_ids(__UpperCAmelCase  )
																			self.assertIsInstance(__UpperCAmelCase      ,__UpperCAmelCase  )







				def   lowercase_		(    self    :Any      ,__UpperCAmelCase    :BatchEncoding      ,__UpperCAmelCase    :Optional[Callable] = None  )      ->					Optional[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   List[str]  				=					pickle.dumps(__UpperCAmelCase  )
									self.assertIsNotNone(__UpperCAmelCase  )

									lowerCamelCase__		:   int  				=					pickle.loads(__UpperCAmelCase  )

									# Ensure is_fast is correctly restored
									self.assertEqual(be_restored.is_fast      ,be_original.is_fast  )

									# Ensure encodings are potentially correctly restored
									if be_original.is_fast:
														self.assertIsNotNone(be_restored.encodings  )
									else:
														self.assertIsNone(be_restored.encodings  )

									# Ensure the keys are the same
									for original_v, restored_v in zip(be_original.values()      ,be_restored.values()  ):
														if equal_op:
																			self.assertTrue(equal_op(__UpperCAmelCase      ,__UpperCAmelCase  )  )
														else:
																			self.assertEqual(__UpperCAmelCase      ,__UpperCAmelCase  )







				@slow
				def   lowercase_		(    self    :Tuple  )      ->					List[str]:




									"""simple docstring"""



									self.check_tokenizer_from_pretrained(__UpperCAmelCase  )







				def   lowercase_		(    self    :Optional[int]  )      ->					int:




									"""simple docstring"""



									self.assertEqual(TensorType('''tf'''  )      ,TensorType.TENSORFLOW  )
									self.assertEqual(TensorType('''pt'''  )      ,TensorType.PYTORCH  )
									self.assertEqual(TensorType('''np'''  )      ,TensorType.NUMPY  )







				@require_tokenizers
				def   lowercase_		(    self    :List[Any]  )      ->					Optional[Any]:




									"""simple docstring"""



									import numpy as np

									lowerCamelCase__		:   Any  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   Optional[int]  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )

									# Python no tensor
									with self.subTest('''BatchEncoding (Python, return_tensors=None)'''  ):
														self.assert_dump_and_restore(tokenizer_p('''Small example to encode'''  )  )

									with self.subTest('''BatchEncoding (Python, return_tensors=NUMPY)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode'''      ,return_tensors=TensorType.NUMPY  )      ,np.array_equal  )

									with self.subTest('''BatchEncoding (Rust, return_tensors=None)'''  ):
														self.assert_dump_and_restore(tokenizer_r('''Small example to encode'''  )  )

									with self.subTest('''BatchEncoding (Rust, return_tensors=NUMPY)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode'''      ,return_tensors=TensorType.NUMPY  )      ,np.array_equal  )







				@require_tf
				@require_tokenizers
				def   lowercase_		(    self    :Optional[int]  )      ->					int:




									"""simple docstring"""



									import tensorflow as tf

									def tf_array_equals(__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :List[Any]  ):
														return tf.reduce_all(tf.equal(__UpperCAmelCase      ,__UpperCAmelCase  )  )

									lowerCamelCase__		:   str  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   List[Any]  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )

									with self.subTest('''BatchEncoding (Python, return_tensors=TENSORFLOW)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode'''      ,return_tensors=TensorType.TENSORFLOW  )      ,__UpperCAmelCase  )

									with self.subTest('''BatchEncoding (Rust, return_tensors=TENSORFLOW)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode'''      ,return_tensors=TensorType.TENSORFLOW  )      ,__UpperCAmelCase  )







				@require_torch
				@require_tokenizers
				def   lowercase_		(    self    :Dict  )      ->					Optional[int]:




									"""simple docstring"""



									import torch

									lowerCamelCase__		:   Optional[int]  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   List[str]  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )

									with self.subTest('''BatchEncoding (Python, return_tensors=PYTORCH)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode'''      ,return_tensors=TensorType.PYTORCH  )      ,torch.equal  )

									with self.subTest('''BatchEncoding (Rust, return_tensors=PYTORCH)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode'''      ,return_tensors=TensorType.PYTORCH  )      ,torch.equal  )







				@require_tokenizers
				def   lowercase_		(    self    :Tuple  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   Any  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )

									with self.subTest('''Python Tokenizer'''  ):
														self.assertFalse(tokenizer_p('''Small example to_encode'''  ).is_fast  )

									with self.subTest('''Rust Tokenizer'''  ):
														self.assertTrue(tokenizer_r('''Small example to_encode'''  ).is_fast  )







				@require_tokenizers
				def   lowercase_		(    self    :List[str]  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   str  				=					tokenizer_r(['''Test''', '''\xad''', '''test''']      ,is_split_into_words=__UpperCAmelCase  )

									self.assertEqual(encoded.word_to_tokens(0  )      ,TokenSpan(start=1      ,end=2  )  )
									self.assertEqual(encoded.word_to_tokens(1  )      ,__UpperCAmelCase  )
									self.assertEqual(encoded.word_to_tokens(2  )      ,TokenSpan(start=2      ,end=3  )  )







				def   lowercase_		(    self    :Dict  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[int]  				=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}  )
									lowerCamelCase__		:   Tuple  				=					batch.convert_to_tensors(tensor_type='''np'''  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(2, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(2,)  )
									# test converting the converted
									with CaptureStderr() as cs:
														lowerCamelCase__		:   List[str]  				=					batch.convert_to_tensors(tensor_type='''np'''  )
									self.assertFalse(len(cs.err  )      ,msg=F"""should have no warning, but got {cs.err}"""  )

									lowerCamelCase__		:   Union[str, Any]  				=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}  )
									lowerCamelCase__		:   Dict  				=					batch.convert_to_tensors(tensor_type='''np'''      ,prepend_batch_axis=__UpperCAmelCase  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(1, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(1,)  )







				@require_torch
				def   lowercase_		(    self    :Optional[int]  )      ->					List[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}  )
									lowerCamelCase__		:   Any  				=					batch.convert_to_tensors(tensor_type='''pt'''  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(2, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(2,)  )
									# test converting the converted
									with CaptureStderr() as cs:
														lowerCamelCase__		:   Optional[int]  				=					batch.convert_to_tensors(tensor_type='''pt'''  )
									self.assertFalse(len(cs.err  )      ,msg=F"""should have no warning, but got {cs.err}"""  )

									lowerCamelCase__		:   Optional[int]  				=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}  )
									lowerCamelCase__		:   Optional[Any]  				=					batch.convert_to_tensors(tensor_type='''pt'''      ,prepend_batch_axis=__UpperCAmelCase  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(1, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(1,)  )







				@require_tf
				def   lowercase_		(    self    :Optional[Any]  )      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}  )
									lowerCamelCase__		:   Union[str, Any]  				=					batch.convert_to_tensors(tensor_type='''tf'''  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(2, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(2,)  )
									# test converting the converted
									with CaptureStderr() as cs:
														lowerCamelCase__		:   Optional[Any]  				=					batch.convert_to_tensors(tensor_type='''tf'''  )
									self.assertFalse(len(cs.err  )      ,msg=F"""should have no warning, but got {cs.err}"""  )

									lowerCamelCase__		:   int  				=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}  )
									lowerCamelCase__		:   Dict  				=					batch.convert_to_tensors(tensor_type='''tf'''      ,prepend_batch_axis=__UpperCAmelCase  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(1, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(1,)  )







				@require_flax
				def   lowercase_		(    self    :Optional[int]  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}  )
									lowerCamelCase__		:   str  				=					batch.convert_to_tensors(tensor_type='''jax'''  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(2, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(2,)  )
									# test converting the converted
									with CaptureStderr() as cs:
														lowerCamelCase__		:   Any  				=					batch.convert_to_tensors(tensor_type='''jax'''  )
									self.assertFalse(len(cs.err  )      ,msg=F"""should have no warning, but got {cs.err}"""  )

									lowerCamelCase__		:   List[Any]  				=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}  )
									lowerCamelCase__		:   Tuple  				=					batch.convert_to_tensors(tensor_type='''jax'''      ,prepend_batch_axis=__UpperCAmelCase  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(1, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(1,)  )







				def   lowercase_		(    self    :str  )      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   str  				=					[{'''input_ids''': np.array([0, 1, 2]  )}, {'''input_ids''': np.array([0, 1, 2, 3]  )}]
									lowerCamelCase__		:   Optional[Any]  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )

									lowerCamelCase__		:   Dict  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,np.ndarray  )  )
									self.assertEqual(batch['''input_ids'''].tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
									lowerCamelCase__		:   Optional[Any]  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase      ,return_tensors='''np'''  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,np.ndarray  )  )
									self.assertEqual(batch['''input_ids'''].tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )







				@require_torch
				def   lowercase_		(    self    :Tuple  )      ->					List[str]:




									"""simple docstring"""



									import torch

									lowerCamelCase__		:   Union[str, Any]  				=					[{'''input_ids''': torch.tensor([0, 1, 2]  )}, {'''input_ids''': torch.tensor([0, 1, 2, 3]  )}]
									lowerCamelCase__		:   Any  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )

									lowerCamelCase__		:   Tuple  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,torch.Tensor  )  )
									self.assertEqual(batch['''input_ids'''].tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
									lowerCamelCase__		:   Optional[int]  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase      ,return_tensors='''pt'''  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,torch.Tensor  )  )
									self.assertEqual(batch['''input_ids'''].tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )







				@require_tf
				def   lowercase_		(    self    :int  )      ->					Optional[int]:




									"""simple docstring"""



									import tensorflow as tf

									lowerCamelCase__		:   List[Any]  				=					[{'''input_ids''': tf.constant([0, 1, 2]  )}, {'''input_ids''': tf.constant([0, 1, 2, 3]  )}]
									lowerCamelCase__		:   str  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )

									lowerCamelCase__		:   Tuple  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,tf.Tensor  )  )
									self.assertEqual(batch['''input_ids'''].numpy().tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
									lowerCamelCase__		:   Tuple  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase      ,return_tensors='''tf'''  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,tf.Tensor  )  )
									self.assertEqual(batch['''input_ids'''].numpy().tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )







				@require_tokenizers
				def   lowercase_		(    self    :Dict  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					Tokenizer(WordPiece(unk_token='''[UNK]'''  )  )
									PreTrainedTokenizerFast(tokenizer_object=__UpperCAmelCase  )







				@require_tokenizers
				def   lowercase_		(    self    :str  )      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   int  				=					Tokenizer(WordPiece(unk_token='''[UNK]'''  )  )
									with tempfile.TemporaryDirectory() as tmpdirname:
														bert_tokenizer.save(os.path.join(__UpperCAmelCase      ,'''tokenizer.json'''  )  )
														PreTrainedTokenizerFast(tokenizer_file=os.path.join(__UpperCAmelCase      ,'''tokenizer.json'''  )  )






