code: def train_loop(
      parser,
      start_program,
      main_program,
      test_program,
      model,
      graph,
      label,
      split_idx,
      exe,
      run_id,
      wf=None,
  ):
      # build up training program
      exe.run(start_program)
  
      max_acc = 0  # best test_acc
      max_step = 0  # step for best test_acc
      max_val_acc = 0  # best val_acc
      max_cor_acc = 0  # test_acc for best val_acc
      max_cor_step = 0  # step for best val_acc
      # training loop
  
      graph.node_feat["label"] = label
      graph.node_feat["nid"] = np.arange(0, graph.num_nodes)
  
      if parser.use_label_e:
          train_idx = copy.deepcopy(split_idx["train"])
          np.random.shuffle(train_idx[:50125])
          label_idx = train_idx[: int(50125 * parser.label_rate)]
          unlabel_idx = train_idx[int(50125 * parser.label_rate) :]
          label_idx_total = set(label_idx)
          unlabel_idx_total = set(unlabel_idx)
  
      for epoch_id in tqdm(range(parser.epochs)):
          for subgraph in random_partition(
              num_clusters=9, graph=graph, shuffle=True
          ):
              # start training
              if parser.use_label_e:
                  feed_dict = model.gw.to_feed(subgraph)
                  sub_idx = set(subgraph.node_feat["nid"])
  
                  train_idx_temp = label_idx_total & sub_idx
                  label_idx = subgraph.reindex_from_parrent_nodes(
                      list(train_idx_temp)
                  )
  
                  train_idx_temp = unlabel_idx_total & sub_idx
                  unlabel_idx = subgraph.reindex_from_parrent_nodes(
                      list(train_idx_temp)
                  )
  
                  feed_dict["label"] = subgraph.node_feat["label"]
                  feed_dict["label_idx"] = label_idx
                  feed_dict["train_idx"] = unlabel_idx
              else:
                  feed_dict = model.gw.to_feed(subgraph)
                  # feed_dict['label'] = label
                  train_idx_temp = set(split_idx["train"]) & set(
                      subgraph.node_feat["nid"]
                  )
                  train_idx_temp = subgraph.reindex_from_parrent_nodes(
                      list(train_idx_temp)
                  )
                  feed_dict["label"] = subgraph.node_feat["label"]
                  feed_dict["train_idx"] = train_idx_temp
  
              loss = exe.run(
                  main_program,
                  feed=feed_dict,
                  fetch_list=[model.avg_cost],
              )
              loss = loss[0]
  
          # eval result
          if (epoch_id + 1) > parser.epochs * 0.9:
              result = eval_test(
                  parser,
                  test_program,
                  model,
                  exe,
                  graph,
                  label,
                  split_idx,
              )
              train_acc, valid_acc, test_acc = result
  
              max_acc = max(test_acc, max_acc)
              if max_acc == test_acc:
                  max_step = epoch_id
              max_val_acc = max(valid_acc, max_val_acc)
              if max_val_acc == valid_acc:
                  max_cor_acc = test_acc
                  max_cor_step = epoch_id
              max_acc = max(result[2], max_acc)
              if max_acc == result[2]:
                  max_step = epoch_id
              result_t = (
                  f"Run: {run_id:02d}, "
                  f"Epoch: {epoch_id:02d}, "
                  # f'Loss: {loss[0]:.4f}, '
                  f"Train: {100 * train_acc:.2f}%, "
                  f"Valid: {100 * valid_acc:.2f}%, "
                  f"Test: {100 * test_acc:.2f}% \n"
                  f"max_Test: {100 * max_acc:.2f}%, "
                  f"max_step: {max_step}\n"
                  f"max_val: {100 * max_val_acc:.2f}%, "
                  f"max_val_Test: {100 * max_cor_acc:.2f}%, "
                  f"max_val_step: {max_cor_step}\n"
              )
              print(result_t)
              wf.write(result_t)
              wf.write("\n")
              wf.flush()
      return max_cor_acc
  
imports: import math
  import torch
  import paddle
  import pgl
  import numpy
  import paddle.fluid
  import paddle.fluid.layers
  from pgl.contrib.ogb.nodeproppred.dataset_pgl import PglNodePropPredDataset
  import time
  import copy
  from ogb.nodeproppred import Evaluator
  from utils import to_undirected, add_self_loop, linear_warmup_decay
  from model import Proteins_baseline_model, Proteins_label_embedding_model
  from partition import random_partition_v2
  import argparse
  from tqdm import tqdm
label_desc: Use image node_id 4 for calling a global function with example usage: train_loop(parser, start_program, main_program, test_program, model, graph, label, split_idx, exe, run_id, wf) and returns: max_cor_acc