code: 
  
  
  
  import argparse
  import time
  
  import torch
  import transformers
  from measures_util import end_measure, log_measures, start_measure
  from transformers import AutoConfig, AutoModelForCausalLM, AutoModelForSeqaSeqLM, AutoTokenizer
  
  from accelerate.utils import compute_module_sizes
  
  
  __lowerCamelCase  				=					{
      """gpt-j-6b""": {"""is_causal""": True, """model""": """sgugger/sharded-gpt-j-6B""", """tokenizer""": """EleutherAI/gpt-j-6B"""},
      """gpt-neox""": {"""is_causal""": True, """model""": """EleutherAI/gpt-neox-20b"""},
      """opt""": {"""is_causal""": True, """model""": """facebook/opt-30b"""},
      """T0pp""": {"""is_causal""": False, """model""": """bigscience/T0pp""", """model_revision""": """sharded"""},
  }
  
  __lowerCamelCase  				=					[
      """Hello, my name is""",
      """Are unicorns real? Unicorns are""",
      """For the first time in several years,""",
      """My name is Julien and I am""",
      """The goal of life is""",
      """Whenever I\'m sad, I like to""",
  ]
  
  
  
  
  def     UpperCAmelCase__ (							):
    _A           =    argparse.ArgumentParser(description='''Run and time generations on a big model using Accelerate.'''							)
    parser.add_argument('''model_name'''						,				type=snake_case__						,				default=snake_case__						,				help='''The name of the model to try.'''							)
    parser.add_argument(
        '''--tokenizer_name'''						,				type=snake_case__						,				default=snake_case__						,				help='''The name of the tokenizer (if different from the model.'''							)
    parser.add_argument('''--is_causal'''						,				type=snake_case__						,				default=snake_case__						,				help='''Whether or not the model is causal.'''							)
    parser.add_argument(
        '''--model_revision'''						,				type=snake_case__						,				default=snake_case__						,				help='''The revision to use for the model checkpoint.'''							)
    parser.add_argument('''--torch_dtype'''						,				type=snake_case__						,				default=snake_case__						,				help='''The dtype for the model.'''							)
    parser.add_argument('''--disk_offload'''						,				action='''store_true'''							)
  
    _A           =    parser.parse_args()
  
    # Sanitize args
    if args.model_name in DEFAULT_MODELS:
      _A           =    DEFAULT_MODELS[args.model_name]
      _A           =    defaults['model']
      if args.tokenizer_name is None:
        _A           =    defaults.get('''tokenizer'''						,				args.model_name							)
      if args.is_causal is None:
        _A           =    defaults['is_causal']
      if args.model_revision is None:
        _A           =    defaults.get('''model_revision'''						,				'''main'''							)
  
    if args.is_causal is None:
      raise ValueError('''Could not infer the default for `--is_causal`, pass either True or False for it.'''							)
    if args.tokenizer_name is None:
      _A           =    args.model_name
    if args.model_revision is None:
      _A           =    'main'
  
    return args
  
  
  
  
  def     UpperCAmelCase__ (							):
    transformers.utils.logging.set_verbosity_error()
    _A           =    parse_args()
  
    if args.torch_dtype is None:
      _A           =    AutoConfig.from_pretrained(args.model_name							)
      _A           =    getattr(snake_case__						,				'''torch_dtype'''						,				torch.floataa							)
    else:
      _A           =    getattr(snake_case__						,				args.torch_dtype							)
    _A           =    AutoModelForCausalLM if args.is_causal else AutoModelForSeqaSeqLM
    _A           =    {
        'torch_dtype': torch_dtype,
        'revision': args.model_revision,
    }
    if args.disk_offload:
      _A           =    'tmp_offload'
      _A           =    True
  
    _A           =    start_measure()
    _A           =    model_cls.from_pretrained(args.model_name						,				device_map='''auto'''						,				**snake_case__							)
    _A           =    end_measure(snake_case__							)
    log_measures(snake_case__						,				'''Model loading'''							)
  
    _A           =    compute_module_sizes(snake_case__							)
    _A           =    {v: 0 for v in model.hf_device_map.values()}
    for module, device in model.hf_device_map.items():
      device_size[device] += module_sizes[module]
    _A           =    '\n'.join([F'''- {device}: {size // 2**20}MiB''' for device, size in device_size.items()]							)
    print(F'''\nTheoretical use:\n{message}'''							)
  
    _A           =    AutoTokenizer.from_pretrained(args.tokenizer_name							)
  
    _A           =    start_measure()
    _A           =    []
    _A           =    []
    _A           =    []
    for prompt in PROMPTS:
      _A           =    tokenizer(snake_case__						,				return_tensors='''pt'''							).to(0							)
      _A           =    inputs['input_ids'][0].tolist()
      _A           =    time.time()
      _A           =    model.generate(inputs['''input_ids''']							)
      _A           =    time.time()
      _A           =    outputs[0].tolist()
      _A           =    len(snake_case__							) if outputs[: len(snake_case__							)] != tokens else len(snake_case__							) - len(snake_case__							)
      _A           =    after_generate - before_generate
  
      _A           =    tokenizer.decode(snake_case__						,				skip_special_tokens=snake_case__							)
      texts_outs.append(snake_case__							)
      generation_times.append(snake_case__							)
      gen_tokens.append(snake_case__							)
      print(F'''Prompt: {prompt}\nGeneration {text_out}\nIn {generation_time:.2f}s for {num_gen_tokens} tokens\n'''							)
  
    _A           =    end_measure(snake_case__							)
    log_measures(snake_case__						,				'''Model generation'''							)
  
    _A           =    [gen / tok for gen, tok in zip(snake_case__						,				snake_case__							)]
    _A           =    sum(snake_case__							) / len(snake_case__							)
    print(F'''Average time of generation per token: {avg_gen:.2f}s'''							)
    print(F'''First generation (avg time per token): {generation_times_per_token[0]:.2f}s'''							)
    _A           =    sum(generation_times_per_token[1:]							) / (len(snake_case__							) - 1)
    print(F'''Average time of generation per token (excluding the first): {avg_gen:.2f}s'''							)
  
  
  if __name__ == "__main__":
      main()
style_context: 
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case = 1_000							)   -> str:
    if (not isinstance(__snake_case						,				__snake_case							)) or (digit_position <= 0):
      raise ValueError('''Digit position must be a positive integer'''							)
    elif (not isinstance(__snake_case						,				__snake_case							)) or (precision < 0):
      raise ValueError('''Precision must be a nonnegative integer'''							)
  
    # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
    # accurate
    _A           =    (
        4 * _subsum(__snake_case						,				1						,				__snake_case							)
        - 2 * _subsum(__snake_case						,				4						,				__snake_case							)
        - _subsum(__snake_case						,				5						,				__snake_case							)
        - _subsum(__snake_case						,				6						,				__snake_case							)
    )
  
    # return the first hex digit of the fractional part of the result
    return hex(int((sum_result % 1) * 16							)							)[2:]
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case							)   -> float:
    _A           =    0.0
    for sum_index in range(digit_pos_to_extract + precision							):
      _A           =    8 * sum_index + denominator_addend
      if sum_index < digit_pos_to_extract:
        # if the exponential term is an integer and we mod it by the denominator
        # before dividing, only the integer part of the sum will change;
        # the fractional part will not
        _A           =    pow(
            16						,				digit_pos_to_extract - 1 - sum_index						,				__snake_case							)
      else:
        _A           =    pow(16						,				digit_pos_to_extract - 1 - sum_index							)
      total += exponential_term / denominator
    return total
  
  
  if __name__ == "__main__":
      import doctest
  
      doctest.testmod()