code: def main(args):
      """main function"""
      dataset = GINDataset(
          args.data_path,
          args.dataset_name,
          self_loop=not args.train_eps,
          degree_as_nlabel=True,
      )
      train_dataset, test_dataset = fold10_split(
          dataset, fold_idx=args.fold_idx, seed=args.seed
      )
  
      train_loader = GraphDataloader(
          train_dataset, batch_size=args.batch_size
      )
      test_loader = GraphDataloader(
          test_dataset, batch_size=args.batch_size, shuffle=False
      )
  
      place = fluid.CUDAPlace(0) if args.use_cuda else fluid.CPUPlace()
      train_program = fluid.Program()
      startup_program = fluid.Program()
  
      with fluid.program_guard(train_program, startup_program):
          gw = pgl.graph_wrapper.GraphWrapper(
              "gw",
              place=place,
              node_feat=dataset[0][0].node_feat_info(),
          )
  
          model = GINModel(args, gw, dataset.gclasses)
          model.forward()
  
      infer_program = train_program.clone(for_test=True)
  
      with fluid.program_guard(train_program, startup_program):
          epoch_step = int(len(train_dataset) / args.batch_size) + 1
          boundaries = [
              i
              for i in range(
                  50 * epoch_step,
                  args.epochs * epoch_step,
                  epoch_step * 50,
              )
          ]
          values = [
              args.lr * 0.5**i for i in range(0, len(boundaries) + 1)
          ]
          lr = fl.piecewise_decay(boundaries=boundaries, values=values)
          train_op = fluid.optimizer.Adam(lr).minimize(model.loss)
  
      exe = fluid.Executor(place)
      exe.run(startup_program)
  
      # train and evaluate
      global_step = 0
      for epoch in range(1, args.epochs + 1):
          for idx, batch_data in enumerate(train_loader):
              g, labels = batch_data
              feed_dict = gw.to_feed(g)
              feed_dict["labels"] = labels
              ret_loss, ret_lr, ret_acc = exe.run(
                  train_program,
                  feed=feed_dict,
                  fetch_list=[model.loss, lr, model.acc],
              )
  
              global_step += 1
              if global_step % 10 == 0:
                  message = "epoch %d | step %d | " % (
                      epoch,
                      global_step,
                  )
                  message += "lr %.6f | loss %.6f | acc %.4f" % (
                      ret_lr,
                      ret_loss,
                      ret_acc,
                  )
                  log.info(message)
  
          # evaluate
          result = evaluate(exe, infer_program, model, gw, test_loader)
  
          message = "evaluating result"
          for key, value in result.items():
              message += " | %s %.6f" % (key, value)
          log.info(message)
  
file_path: PGL/legacy/examples/gin/main.py
imports: import os
  import sys
  import time
  import argparse
  import numpy
  import paddle.fluid
  import paddle.fluid.layers
  import pgl
  from pgl.utils.logger import log
  from Dataset import GINDataset, fold10_split, random_split
  from dataloader import GraphDataloader
  from model import GINModel
label_desc: Use image node_id 1 for calling a global function with example usage: main(args) without return types