code: def process_step(self, step_counter, step, epoch):
      for i in range(self.discriminator_updates):
          sample_latent = np.random.normal(
              size=[self.training_batch_size, self.latent_size]
          )
  
          reference_data = next(self.training_data_generator)[
              self.input_data
          ]
          reference_data = self.sess.run(
              self.input_volumes,
              feed_dict={self.raw_volumes: reference_data},
          )
  
          if self.transition:
              reference_data = self.sess.run(
                  self.real_images,
                  feed_dict={self.reference_images: reference_data},
              )
  
          self.sess.run(
              self.opti_D,
              feed_dict={
                  self.reference_images: reference_data,
                  self.latent: sample_latent,
              },
          )
  
      # Update Generator
      for i in range(self.generator_updates):
          self.sess.run(
              self.opti_G, feed_dict={self.latent: sample_latent}
          )
  
      # the alpha of fake_in process
      if self.transition:
          self.sess.run(
              self.alpha_transition_assign,
              feed_dict={
                  self.step_pl: (
                      epoch * float(self.training_steps_per_epoch)
                  )
                  + (step + 1)
              },
          )
  
      d_loss, d_loss_origin, g_loss, transition = self.sess.run(
          [
              self.D_loss,
              self.G_loss,
              self.D_origin_loss,
              self.alpha_transition,
          ],
          feed_dict={
              self.reference_images: reference_data,
              self.latent: sample_latent,
          },
      )
  
      self.log(
          [d_loss, d_loss_origin, g_loss, transition],
          headers=["Dis-WP Loss", "Dis Loss", "Gen Loss", "Alpha"],
          verbose=self.hyperverbose,
      )
  
      if self.transition:
          step_counter.set_description(
              "Generator Loss: {0:.5f}".format(g_loss)
              + " Discriminator Loss: {0:.5f}".format(d_loss)
              + " Alpha: {0:.2f}".format(transition)
          )
      else:
          step_counter.set_description(
              "Generator Loss: {0:.5f}".format(g_loss)
              + " Discriminator Loss: {0:.5f}".format(d_loss)
          )
  
      summary_str = self.sess.run(
          self.summary_op,
          feed_dict={
              self.reference_images: reference_data,
              self.latent: sample_latent,
          },
      )
      if self.tensorboard_directory is not None:
          self.summary_writer.add_summary(
              summary_str,
              (
                  self.num_epochs
                  * self.training_steps_per_epoch
                  * self.training_stage
              )
              + (self.training_steps_per_epoch * epoch)
              + step,
          )
  
      return reference_data
  
imports: import math
  import numpy
  import tensorflow
  import os
  import imageio
  import keras
  import scipy
  from tqdm import tqdm
  from collections import defaultdict
  from deepneuro.utilities.util import add_parameter
  from deepneuro.models.blocks import generator, discriminator
  from deepneuro.models.cost_functions import wasserstein_loss
  from deepneuro.models.gan import GAN
  from deepneuro.models.ops import upscale2d, downscale2d
  from deepneuro.utilities.visualize import check_data
label_desc: Use image node_id 5 for calling the PGGAN obj's underlying member method code with example usage: obj.process_step(step_counter, step, epoch) and returns: reference_data