



'''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,
)
lowercase											=      logging.getLogger(__name__)






def 			UpperCAmelCase_							(		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 			UpperCAmelCase_							(		):


     '''simple docstring'''







     a_									=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=2_0							)
     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=4_2							,						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"							,						)
     a_									=parser.parse_args()

     a_									=torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu"							)
     a_									=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
     a_									=AutoTokenizer.from_pretrained(args.model_name_or_path							)
     a_									=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__							)
     a_									=args.prompt if args.prompt else input("Model prompt >>> "							)

     a_									=tokenizer(lowercase__							,						return_tensors="pt"							,						add_special_tokens=lowercase__							)
     a_									={key: value.to(args.device							) for key, value in inputs.items()}

     a_									=model.generate(
         **lowercase__							,						max_length=args.length + len(inputs["input_ids"][0]							)							,						penalty_alpha=args.penalty_alpha							,						top_k=args.k							,						)

     a_									=[]
     for generated_sequence_idx, generated_sequence in enumerate(lowercase__							):
          print(F"""=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==="""							)
          a_									=generated_sequence.tolist()

          # Decode text
          a_									=tokenizer.decode(lowercase__							,						clean_up_tokenization_spaces=lowercase__							,						add_special_tokens=lowercase__							)

          # Remove all text after the stop token
          a_									=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
          a_									=(
              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'''


from dataclasses import dataclass
from typing import Callable, Optional

import datasets







@dataclass
class 						UpperCAmelCase						(		datasets.BuilderConfig):


 '''simple docstring'''




 __magic_name__       :			Optional[Callable]	=   None
 __magic_name__       :			Optional[dict]	=   None
 __magic_name__       :			Optional[datasets.Features]	=   None




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



      """simple docstring"""







      assert self.generator is not None, "generator must be specified"

      if self.gen_kwargs is None:
           a_									={}







class 						UpperCAmelCase						(		datasets.GeneratorBasedBuilder):


 '''simple docstring'''




 __magic_name__       :			Tuple	=   GeneratorConfig




 def    lowercase_	( self)			->   Tuple:



      """simple docstring"""







      return datasets.DatasetInfo(features=self.config.features)




 def    lowercase_	( self				,	lowerCAmelCase_)			->   int:



      """simple docstring"""







      return [datasets.SplitGenerator(name=datasets.Split.TRAIN				,	gen_kwargs=self.config.gen_kwargs)]




 def    lowercase_	( self				,	**lowerCAmelCase_)			->   List[Any]:



      """simple docstring"""







      for idx, ex in enumerate(self.config.generator(**lowerCAmelCase_)):
           yield idx, ex


