code: def main():
      parser = argparse.ArgumentParser()
      parser.add_argument(
          "--model_type",
          default=None,
          type=str,
          required=True,
          help="Model type selected in the list: "
          + ", ".join(MODEL_CLASSES.keys()),
      )
      parser.add_argument(
          "--model_name_or_path",
          default=None,
          type=str,
          required=True,
          help="Path to pre-trained model or shortcut name selected in the list: "
          + ", ".join(MODEL_CLASSES.keys()),
      )
  
      parser.add_argument("--prompt", type=str, default="")
      parser.add_argument("--length", type=int, default=20)
      parser.add_argument(
          "--stop_token",
          type=str,
          default=None,
          help="Token at which text generation is stopped",
      )
  
      parser.add_argument(
          "--temperature",
          type=float,
          default=1.0,
          help="temperature of 1.0 has no effect, lower tend toward greedy sampling",
      )
      parser.add_argument(
          "--repetition_penalty",
          type=float,
          default=1.0,
          help="primarily useful for CTRL model; in that case, use 1.2",
      )
      parser.add_argument("--k", type=int, default=0)
      parser.add_argument("--p", type=float, default=0.9)
  
      parser.add_argument(
          "--prefix",
          type=str,
          default="",
          help="Text added prior to input.",
      )
      parser.add_argument(
          "--padding_text",
          type=str,
          default="",
          help="Deprecated, the use of `--prefix` is preferred.",
      )
      parser.add_argument(
          "--xlm_language",
          type=str,
          default="",
          help="Optional language when used with the XLM model.",
      )
  
      parser.add_argument(
          "--seed",
          type=int,
          default=42,
          help="random seed for initialization",
      )
      parser.add_argument(
          "--no_cuda",
          action="store_true",
          help="Avoid using CUDA when available",
      )
      parser.add_argument(
          "--num_return_sequences",
          type=int,
          default=1,
          help="The number of samples to generate.",
      )
      parser.add_argument(
          "--fp16",
          action="store_true",
          help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit",
      )
      parser.add_argument(
          "--load_adapter",
          type=str,
          default=None,
          help="Path to a trained adapter",
      )
      args = parser.parse_args()
  
      args.device = torch.device(
          "cuda"
          if torch.cuda.is_available() and not args.no_cuda
          else "cpu"
      )
      args.n_gpu = 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.fp16}"
      )
  
      set_seed(args)
  
      # Initialize the model and tokenizer
      try:
          args.model_type = args.model_type.lower()
          model_class, tokenizer_class = MODEL_CLASSES[args.model_type]
      except KeyError:
          raise KeyError(
              "the model {} you specified is not supported. You are welcome to add it and open a PR :)"
          )
  
      tokenizer = tokenizer_class.from_pretrained(
          args.model_name_or_path
      )
      model = model_class.from_pretrained(args.model_name_or_path)
  
      # Convert the model into an adapter model
      adapters.init(model)
  
      model.to(args.device)
  
      # Setup adapters
      if args.load_adapter:
          model.load_adapter(args.load_adapter, load_as="generation")
          model.set_active_adapters(["generation"])
  
      if args.fp16:
          model.half()
  
      args.length = adjust_length_to_model(
          args.length,
          max_sequence_length=model.config.max_position_embeddings,
      )
      logger.info(args)
  
      prompt_text = (
          args.prompt if args.prompt else input("Model prompt >>> ")
      )
  
      # Different models need different input formatting and/or extra arguments
      requires_preprocessing = (
          args.model_type in PREPROCESSING_FUNCTIONS.keys()
      )
      if requires_preprocessing:
          prepare_input = PREPROCESSING_FUNCTIONS.get(args.model_type)
          preprocessed_prompt_text = prepare_input(
              args, model, tokenizer, prompt_text
          )
  
          if model.__class__.__name__ in ["TransfoXLLMHeadModel"]:
              tokenizer_kwargs = {"add_space_before_punct_symbol": True}
          else:
              tokenizer_kwargs = {}
  
          encoded_prompt = tokenizer.encode(
              preprocessed_prompt_text,
              add_special_tokens=False,
              return_tensors="pt",
              **tokenizer_kwargs,
          )
      else:
          prefix = args.prefix if args.prefix else args.padding_text
          encoded_prompt = tokenizer.encode(
              prefix + prompt_text,
              add_special_tokens=False,
              return_tensors="pt",
          )
      encoded_prompt = encoded_prompt.to(args.device)
  
      if encoded_prompt.size()[-1] == 0:
          input_ids = None
      else:
          input_ids = encoded_prompt
  
      output_sequences = model.generate(
          input_ids=input_ids,
          max_length=args.length + len(encoded_prompt[0]),
          temperature=args.temperature,
          top_k=args.k,
          top_p=args.p,
          repetition_penalty=args.repetition_penalty,
          do_sample=True,
          num_return_sequences=args.num_return_sequences,
      )
  
      # Remove the batch dimension when returning multiple sequences
      if len(output_sequences.shape) > 2:
          output_sequences.squeeze_()
  
      generated_sequences = []
  
      for generated_sequence_idx, generated_sequence in enumerate(
          output_sequences
      ):
          print(
              f"=== GENERATED SEQUENCE {generated_sequence_idx + 1} ==="
          )
          generated_sequence = generated_sequence.tolist()
  
          # Decode text
          text = tokenizer.decode(
              generated_sequence, clean_up_tokenization_spaces=True
          )
  
          # Remove all text after the stop token
          text = 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
          total_sequence = (
              prompt_text
              + text[
                  len(
                      tokenizer.decode(
                          encoded_prompt[0],
                          clean_up_tokenization_spaces=True,
                      )
                  ) :
              ]
          )
  
          generated_sequences.append(total_sequence)
          print(total_sequence)
  
      return generated_sequences
  
file_path: adapters/examples/pytorch/text-generation/run_generation.py
imports: import argparse
  import logging
  import numpy
  import torch
  import adapters
  from transformers import CTRLLMHeadModel, CTRLTokenizer, GPT2LMHeadModel, GPT2Tokenizer, OpenAIGPTLMHeadModel, OpenAIGPTTokenizer, TransfoXLLMHeadModel, TransfoXLTokenizer, XLMTokenizer, XLMWithLMHeadModel, XLNetLMHeadModel, XLNetTokenizer
label_desc: Use image node_id 7 for calling a global function with example usage: main() and returns: generated_sequences