code: 
  
  
  """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,
  )
  __magic_name__	:   Any          =							logging.getLogger(__name__)
  
  
  
  
  
  def 			a_   (  lowercase__   :int    ):
  			np.random.seed(args.seed    )
  			torch.manual_seed(args.seed    )
  			if args.n_gpu > 0:
  						torch.cuda.manual_seed_all(args.seed    )
  
  
  
  
  
  def 			a_   (  ):
  			__lowerCamelCase        =			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        =			parser.parse_args()
  
  			__lowerCamelCase        =			torch.device("""cuda""" if torch.cuda.is_available() and not args.no_cuda else """cpu"""    )
  			__lowerCamelCase        =			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        =			AutoTokenizer.from_pretrained(args.model_name_or_path    )
  			__lowerCamelCase        =			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        =			args.prompt if args.prompt else input("""Model prompt >>> """    )
  
  			__lowerCamelCase        =			tokenizer(lowercase__, return_tensors="""pt""", add_special_tokens=lowercase__    )
  			__lowerCamelCase        =			{key: value.to(args.device    ) for key, value in inputs.items()}
  
  			__lowerCamelCase        =			model.generate(
  			    **lowercase__, max_length=args.length + len(inputs["""input_ids"""][0]    ), penalty_alpha=args.penalty_alpha, top_k=args.k, )
  
  			__lowerCamelCase        =			[]
  			for generated_sequence_idx, generated_sequence in enumerate(lowercase__    ):
  						print(f'=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==='    )
  						__lowerCamelCase        =			generated_sequence.tolist()
  
  						# Decode text
  						__lowerCamelCase        =			tokenizer.decode(lowercase__, clean_up_tokenization_spaces=lowercase__, add_special_tokens=lowercase__    )
  
  						# Remove all text after the stop token
  						__lowerCamelCase        =			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        =			(
  						    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()
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  from __future__ import annotations
  
  import re
  
  
  
  
  
  def 			a_   (  lowercase__   :list[str]    ):
  
  			def alphanum_key(lowercase__   :int    ):
  						return [int(lowercase__    ) if s.isdigit() else s.lower() for s in re.split("""([0-9]+)""", lowercase__    )]
  
  			return sorted(lowercase__, key=lowercase__    )
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  
  
  
  
  