code: def run_pplm_example(
      pretrained_model="gpt2-medium",
      cond_text="",
      uncond=False,
      num_samples=1,
      bag_of_words=None,
      discrim=None,
      discrim_weights=None,
      discrim_meta=None,
      class_label=-1,
      length=100,
      stepsize=0.02,
      temperature=1.0,
      top_k=10,
      sample=False,
      num_iterations=3,
      grad_length=10000,
      horizon_length=1,
      window_length=0,
      decay=False,
      gamma=1.5,
      gm_scale=0.9,
      kl_scale=0.01,
      seed=0,
      no_cuda=False,
      colorama=False,
      repetition_penalty=1.0,
  ):
      # set Random seed
      torch.manual_seed(seed)
      np.random.seed(seed)
  
      # set the device
      device = (
          "cuda" if torch.cuda.is_available() and not no_cuda else "cpu"
      )
  
      if discrim == "generic":
          set_generic_model_params(discrim_weights, discrim_meta)
  
      if discrim is not None:
          pretrained_model = DISCRIMINATOR_MODELS_PARAMS[discrim][
              "pretrained_model"
          ]
          print(
              "discrim = {}, pretrained_model set to discriminator's = {}".format(
                  discrim, pretrained_model
              )
          )
  
      # load pretrained model
      model = GPT2LMHeadModel.from_pretrained(
          pretrained_model, output_hidden_states=True
      )
      model.to(device)
      model.eval()
  
      # load tokenizer
      tokenizer = GPT2Tokenizer.from_pretrained(pretrained_model)
  
      # Freeze GPT-2 weights
      for param in model.parameters():
          param.requires_grad = False
  
      # figure out conditioning text
      if uncond:
          tokenized_cond_text = tokenizer.encode([tokenizer.bos_token])
      else:
          raw_text = cond_text
          while not raw_text:
              print("Did you forget to add `--cond_text`? ")
              raw_text = input("Model prompt >>> ")
          tokenized_cond_text = tokenizer.encode(
              tokenizer.bos_token + raw_text
          )
  
      print("= Prefix of sentence =")
      print(tokenizer.decode(tokenized_cond_text))
      print()
  
      # generate unperturbed and perturbed texts
  
      # full_text_generation returns:
      # unpert_gen_tok_text, pert_gen_tok_texts, discrim_losses, losses_in_time
      (
          unpert_gen_tok_text,
          pert_gen_tok_texts,
          _,
          _,
      ) = full_text_generation(
          model=model,
          tokenizer=tokenizer,
          context=tokenized_cond_text,
          device=device,
          num_samples=num_samples,
          bag_of_words=bag_of_words,
          discrim=discrim,
          class_label=class_label,
          length=length,
          stepsize=stepsize,
          temperature=temperature,
          top_k=top_k,
          sample=sample,
          num_iterations=num_iterations,
          grad_length=grad_length,
          horizon_length=horizon_length,
          window_length=window_length,
          decay=decay,
          gamma=gamma,
          gm_scale=gm_scale,
          kl_scale=kl_scale,
          repetition_penalty=repetition_penalty,
      )
  
      # untokenize unperturbed text
      unpert_gen_text = tokenizer.decode(
          unpert_gen_tok_text.tolist()[0]
      )
  
      print("=" * 80)
      print("= Unperturbed generated text =")
      print(unpert_gen_text)
      print()
  
      generated_texts = []
  
      bow_word_ids = set()
      if bag_of_words and colorama:
          bow_indices = get_bag_of_words_indices(
              bag_of_words.split(";"), tokenizer
          )
          for single_bow_list in bow_indices:
              # filtering all words in the list composed of more than 1 token
              filtered = list(
                  filter(lambda x: len(x) <= 1, single_bow_list)
              )
              # w[0] because we are sure w has only 1 item because previous fitler
              bow_word_ids.update(w[0] for w in filtered)
  
      # iterate through the perturbed texts
      for i, pert_gen_tok_text in enumerate(pert_gen_tok_texts):
          try:
              # untokenize unperturbed text
              if colorama:
                  import colorama
  
                  pert_gen_text = ""
                  for word_id in pert_gen_tok_text.tolist()[0]:
                      if word_id in bow_word_ids:
                          pert_gen_text += "{}{}{}".format(
                              colorama.Fore.RED,
                              tokenizer.decode([word_id]),
                              colorama.Style.RESET_ALL,
                          )
                      else:
                          pert_gen_text += tokenizer.decode([word_id])
              else:
                  pert_gen_text = tokenizer.decode(
                      pert_gen_tok_text.tolist()[0]
                  )
  
              print("= Perturbed generated text {} =".format(i + 1))
              print(pert_gen_text)
              print()
          except Exception as exc:
              print(
                  "Ignoring error while generating perturbed text:", exc
              )
  
          # keep the prefix, perturbed seq, original seq for each index
          generated_texts.append(
              (
                  tokenized_cond_text,
                  pert_gen_tok_text,
                  unpert_gen_tok_text,
              )
          )
  
      return
  
file_path: H2O/h2o_flexgen/benchmark/third_party/transformers/examples/research_projects/pplm/run_pplm.py
imports: import argparse
  import json
  from operator import add
  from typing import List, Optional, Tuple, Union
  import numpy
  import torch
  from torch import nn
  from tqdm import trange
  from pplm_classification_head import ClassificationHead
  from transformers import GPT2LMHeadModel, GPT2Tokenizer
  from transformers.file_utils import cached_path
label_desc: Use image node_id 9 for calling a global function with example usage: run_pplm_example(pretrained_model, cond_text, uncond, num_samples, bag_of_words, discrim, discrim_weights, discrim_meta, class_label, length, stepsize, temperature, top_k, sample, num_iterations, grad_length, horizon_length, window_length, decay, gamma, gm_scale, kl_scale, seed, no_cuda, colorama, repetition_penalty) without return types