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,
  )
  _lowerCamelCase				:	Tuple				    =       logging.getLogger(__name__)
  
  
  
  
  def    __a (     UpperCAmelCase    )      ->Any:
  
  
  
  	"""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 (     )      ->Optional[Any]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      argparse.ArgumentParser()
  	parser.add_argument(
  	    """--model_name_or_path"""       ,			default=UpperCAmelCase       ,			type=UpperCAmelCase       ,			required=UpperCAmelCase       ,			)
  	parser.add_argument("""--prompt"""       ,			type=UpperCAmelCase       ,			default=""""""    )
  	parser.add_argument("""--length"""       ,			type=UpperCAmelCase       ,			default=20    )
  	parser.add_argument("""--stop_token"""       ,			type=UpperCAmelCase       ,			default=UpperCAmelCase       ,			help="""Token at which text generation is stopped"""    )
  	parser.add_argument(
  	    """--temperature"""       ,			type=UpperCAmelCase       ,			default=1.0       ,			help="""temperature of 1.0 has no effect, lower tend toward greedy sampling"""       ,			)
  	parser.add_argument(
  	    """--repetition_penalty"""       ,			type=UpperCAmelCase       ,			default=1.0       ,			help="""primarily useful for CTRL model; in that case, use 1.2"""    )
  	parser.add_argument("""--k"""       ,			type=UpperCAmelCase       ,			default=0    )
  	parser.add_argument("""--penalty_alpha"""       ,			type=UpperCAmelCase       ,			default=0.0    )
  	parser.add_argument("""--p"""       ,			type=UpperCAmelCase       ,			default=0.9    )
  
  	parser.add_argument("""--prefix"""       ,			type=UpperCAmelCase       ,			default=""""""       ,			help="""Text added prior to input."""    )
  	parser.add_argument("""--padding_text"""       ,			type=UpperCAmelCase       ,			default=""""""       ,			help="""Deprecated, the use of `--prefix` is preferred."""    )
  	parser.add_argument("""--xlm_language"""       ,			type=UpperCAmelCase       ,			default=""""""       ,			help="""Optional language when used with the XLM model."""    )
  
  	parser.add_argument("""--seed"""       ,			type=UpperCAmelCase       ,			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"""       ,			)
  	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(UpperCAmelCase    )
  
  	# 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(UpperCAmelCase    )
  	A							  =      args.prompt if args.prompt else input("""Model prompt >>> """    )
  
  	A							  =      tokenizer(UpperCAmelCase       ,			return_tensors="""pt"""       ,			add_special_tokens=UpperCAmelCase    )
  	A							  =      {key: value.to(args.device    ) for key, value in inputs.items()}
  
  	A							  =      model.generate(
  	    **UpperCAmelCase       ,			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(UpperCAmelCase    ):
  		print(f"""=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==="""    )
  		A							  =      generated_sequence.tolist()
  
  		# Decode text
  		A							  =      tokenizer.decode(UpperCAmelCase       ,			clean_up_tokenization_spaces=UpperCAmelCase       ,			add_special_tokens=UpperCAmelCase    )
  
  		# 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=UpperCAmelCase    )    ) :]
  		)
  
  		generated_sequences.append(UpperCAmelCase    )
  		print(UpperCAmelCase    )
  
  	return generated_sequences
  
  
  if __name__ == "__main__":
  				main()
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  import torch
  
  from diffusers import KDPMaAncestralDiscreteScheduler
  from diffusers.utils import torch_device
  
  from .test_schedulers import SchedulerCommonTest
  
  
  
  class 							__UpperCAmelCase  (       A__						):
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowerCAmelCase 				=    (KDPMaAncestralDiscreteScheduler,)
  		__lowerCAmelCase 				=    10
  
  
  
  
  
  
  
  		def        A     (self						:      Any      ,      **_lowerCAmelCase						:      List[Any]      ):
  			A							  =      {
  			    """num_train_timesteps""": 1100,
  			    """beta_start""": 0.0_001,
  			    """beta_end""": 0.02,
  			    """beta_schedule""": """linear""",
  			}
  
  			config.update(**_lowerCAmelCase      )
  			return config
  
  
  
  
  
  
  
  		def        A     (self						:      Dict      ):
  			for timesteps in [10, 50, 100, 1000]:
  				self.check_over_configs(num_train_timesteps=_lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      Optional[int]      ):
  			for beta_start, beta_end in zip([0.00_001, 0.0_001, 0.001]      ,      [0.0_002, 0.002, 0.02]      ):
  				self.check_over_configs(beta_start=_lowerCAmelCase      ,      beta_end=_lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      Tuple      ):
  			for schedule in ["linear", "scaled_linear"]:
  				self.check_over_configs(beta_schedule=_lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      Dict      ):
  			if torch_device == "mps":
  				return
  			A							  =      self.scheduler_classes[0]
  			A							  =      self.get_scheduler_config()
  			A							  =      scheduler_class(**_lowerCAmelCase      )
  
  			scheduler.set_timesteps(self.num_inference_steps      )
  
  			A							  =      torch.manual_seed(0      )
  
  			A							  =      self.dummy_model()
  			A							  =      self.dummy_sample_deter * scheduler.init_noise_sigma
  			A							  =      sample.to(_lowerCAmelCase      )
  
  			for i, t in enumerate(scheduler.timesteps      ):
  				A							  =      scheduler.scale_model_input(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      model(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      scheduler.step(_lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      ,      generator=_lowerCAmelCase      )
  				A							  =      output.prev_sample
  
  			A							  =      torch.sum(torch.abs(_lowerCAmelCase      )      )
  			A							  =      torch.mean(torch.abs(_lowerCAmelCase      )      )
  
  			assert abs(result_sum.item() - 13_849.3_877      ) < 1e-2
  			assert abs(result_mean.item() - 18.0_331      ) < 5e-3
  
  
  
  
  
  
  
  		def        A     (self						:      Union[str, Any]      ):
  			for prediction_type in ["epsilon", "v_prediction"]:
  				self.check_over_configs(prediction_type=_lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      Dict      ):
  			if torch_device == "mps":
  				return
  			A							  =      self.scheduler_classes[0]
  			A							  =      self.get_scheduler_config(prediction_type="""v_prediction"""      )
  			A							  =      scheduler_class(**_lowerCAmelCase      )
  
  			scheduler.set_timesteps(self.num_inference_steps      )
  
  			A							  =      self.dummy_model()
  			A							  =      self.dummy_sample_deter * scheduler.init_noise_sigma
  			A							  =      sample.to(_lowerCAmelCase      )
  
  			A							  =      torch.manual_seed(0      )
  
  			for i, t in enumerate(scheduler.timesteps      ):
  				A							  =      scheduler.scale_model_input(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      model(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      scheduler.step(_lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      ,      generator=_lowerCAmelCase      )
  				A							  =      output.prev_sample
  
  			A							  =      torch.sum(torch.abs(_lowerCAmelCase      )      )
  			A							  =      torch.mean(torch.abs(_lowerCAmelCase      )      )
  
  			assert abs(result_sum.item() - 328.9_970      ) < 1e-2
  			assert abs(result_mean.item() - 0.4_284      ) < 1e-3
  
  
  
  
  
  
  
  		def        A     (self						:      Optional[int]      ):
  			if torch_device == "mps":
  				return
  			A							  =      self.scheduler_classes[0]
  			A							  =      self.get_scheduler_config()
  			A							  =      scheduler_class(**_lowerCAmelCase      )
  
  			scheduler.set_timesteps(self.num_inference_steps      ,      device=_lowerCAmelCase      )
  			A							  =      torch.manual_seed(0      )
  
  			A							  =      self.dummy_model()
  			A							  =      self.dummy_sample_deter.to(_lowerCAmelCase      ) * scheduler.init_noise_sigma
  
  			for t in scheduler.timesteps:
  				A							  =      scheduler.scale_model_input(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      model(_lowerCAmelCase      ,      _lowerCAmelCase      )
  
  				A							  =      scheduler.step(_lowerCAmelCase      ,      _lowerCAmelCase      ,      _lowerCAmelCase      ,      generator=_lowerCAmelCase      )
  				A							  =      output.prev_sample
  
  			A							  =      torch.sum(torch.abs(_lowerCAmelCase      )      )
  			A							  =      torch.mean(torch.abs(_lowerCAmelCase      )      )
  
  			assert abs(result_sum.item() - 13_849.3_818      ) < 1e-1
  			assert abs(result_mean.item() - 18.0_331      ) < 1e-3
  
  