code: def main(args):
      # load data
      print("loading training data...")
      dataset_directory = get_data_directory(__file__)
      dataset_path = os.path.join(
          dataset_directory, "faces_training.csv"
      )
      if not os.path.exists(dataset_path):
          try:
              os.makedirs(dataset_directory)
          except OSError as e:
              if e.errno != errno.EEXIST:
                  raise
              pass
          wget.download(
              "https://d2hg8soec8ck9v.cloudfront.net/datasets/faces_training.csv",
              dataset_path,
          )
      data = torch.tensor(
          np.loadtxt(dataset_path, delimiter=",")
      ).float()
  
      sparse_gamma_def = SparseGammaDEF()
  
      # Due to the special logic in the custom guide (e.g. parameter clipping), the custom guide
      # seems to be more amenable to higher learning rates.
      # Nevertheless, the easy guide performs the best (presumably because of numerical instabilities
      # related to the gamma distribution in the custom guide).
      learning_rate = 0.2 if args.guide in ["auto", "easy"] else 4.5
      momentum = 0.05 if args.guide in ["auto", "easy"] else 0.1
      opt = optim.AdagradRMSProp({"eta": learning_rate, "t": momentum})
  
      # use one of our three different guide types
      if args.guide == "auto":
          guide = AutoDiagonalNormal(
              sparse_gamma_def.model, init_loc_fn=init_to_feasible
          )
      elif args.guide == "easy":
          guide = MyEasyGuide(sparse_gamma_def.model)
      else:
          guide = sparse_gamma_def.guide
  
      # this is the svi object we use during training; we use TraceMeanField_ELBO to
      # get analytic KL divergences
      svi = SVI(
          sparse_gamma_def.model, guide, opt, loss=TraceMeanField_ELBO()
      )
  
      # we use svi_eval during evaluation; since we took care to write down our model in
      # a fully vectorized way, this computation can be done efficiently with large tensor ops
      svi_eval = SVI(
          sparse_gamma_def.model,
          guide,
          opt,
          loss=TraceMeanField_ELBO(
              num_particles=args.eval_particles,
              vectorize_particles=True,
          ),
      )
  
      print("\nbeginning training with %s guide..." % args.guide)
  
      # the training loop
      for k in range(args.num_epochs):
          loss = svi.step(data)
          # for the custom guide we clip parameters after each gradient step
          if args.guide == "custom":
              clip_params()
  
          if (
              k % args.eval_frequency == 0
              and k > 0
              or k == args.num_epochs - 1
          ):
              loss = svi_eval.evaluate_loss(data)
              print("[epoch %04d] training elbo: %.4g" % (k, -loss))
  
imports: import argparse
  import errno
  import os
  import numpy
  import torch
  import wget
  from torch.nn.functional import softplus
  import pyro
  import pyro.optim
  from pyro.contrib.easyguide import EasyGuide
  from pyro.contrib.examples.util import get_data_directory
  from pyro.distributions import Gamma, Normal, Poisson
  from pyro.infer import SVI, TraceMeanField_ELBO
  from pyro.infer.autoguide import AutoDiagonalNormal, init_to_feasible
label_desc: Use image node_id 3 for calling a global function with example usage: main(args) without return types