code: def verify_lm_run(wps, golden_config, args):
      """Verify that words per second for a given benchmark run matches the golden data."""
  
      if torch.distributed.get_rank() == 0:
          # Assert that words per second is within 3 standard deviations of the average
          # of five golden runs
          logging.info("Throughput(wps) is {:.2f}.".format(wps))
          if not wps > (
              golden_config["avg_wps"]
              - (3 * golden_config["std_dev_wps"])
          ):
              raise RuntimeError(
                  "Throughput(wps):{:.2f} is below the golden threshold of an "
                  "average value of {:.2f} and standard dev of {:.2f}.".format(
                      wps,
                      golden_config["avg_wps"],
                      golden_config["std_dev_wps"],
                  )
              )
  
      for i in range(torch.cuda.device_count()):
          verify_peak_memory(i, golden_config, 1.1)
  
imports: import argparse
  from collections import defaultdict
  from functools import reduce
  import gc
  import logging
  import math
  import operator
  import time
  from datasets.wikitext2_data import get_real_dataloaders
  from datasets.wikitext2_data import get_synthetic_dataloaders
  from models import transformer_lm
  import numpy
  import torch
  import torch.distributed
  import torch.multiprocessing
  from torch.nn.parallel import DistributedDataParallel
  from torch.optim import Adam
  from benchmarks.golden_configs.lm_wikitext2 import FSDP
  from fairscale.nn import auto_wrap, default_auto_wrap_policy, enable_wrap
  from fairscale.nn.data_parallel import FullyShardedDataParallel
label_desc: Use image node_id 2 for calling a global function with example usage: verify_lm_run(wps, golden_config, args) without return types