code: def main():
      parser = argparse.ArgumentParser(
          description="OGBN-MAG (Full-Batch)"
      )
      parser.add_argument("--device", type=int, default=0)
      parser.add_argument("--log_steps", type=int, default=1)
      parser.add_argument("--num_layers", type=int, default=2)
      parser.add_argument("--hidden_channels", type=int, default=64)
      parser.add_argument("--dropout", type=float, default=0.5)
      parser.add_argument("--lr", type=float, default=0.01)
      parser.add_argument("--epochs", type=int, default=50)
      parser.add_argument("--runs", type=int, default=10)
      args = parser.parse_args()
      print(args)
  
      device = (
          f"cuda:{args.device}" if torch.cuda.is_available() else "cpu"
      )
      device = torch.device(device)
  
      dataset = PygNodePropPredDataset(name="ogbn-mag")
      split_idx = dataset.get_idx_split()
      data = dataset[0]
  
      # We do not consider those attributes for now.
      data.node_year_dict = None
      data.edge_reltype_dict = None
  
      print(data)
  
      # Convert to new transposed `SparseTensor` format and add reverse edges.
      data.adj_t_dict = {}
      for keys, (row, col) in data.edge_index_dict.items():
          sizes = (
              data.num_nodes_dict[keys[0]],
              data.num_nodes_dict[keys[2]],
          )
          adj = SparseTensor(row=row, col=col, sparse_sizes=sizes)
          # adj = SparseTensor(row=row, col=col)[:sizes[0], :sizes[1]] # TEST
          if keys[0] != keys[2]:
              data.adj_t_dict[keys] = adj.t()
              data.adj_t_dict[(keys[2], "to", keys[0])] = adj
          else:
              data.adj_t_dict[keys] = adj.to_symmetric()
      data.edge_index_dict = None
  
      x_types = list(data.x_dict.keys())
      edge_types = list(data.adj_t_dict.keys())
  
      model = RGCN(
          data.x_dict["paper"].size(-1),
          args.hidden_channels,
          dataset.num_classes,
          args.num_layers,
          args.dropout,
          data.num_nodes_dict,
          x_types,
          edge_types,
      )
  
      data = data.to(device)
      model = model.to(device)
      train_idx = split_idx["train"]["paper"].to(device)
  
      evaluator = Evaluator(name="ogbn-mag")
      logger = Logger(args.runs, args)
  
      for run in range(args.runs):
          model.reset_parameters()
          optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
          for epoch in range(1, 1 + args.epochs):
              loss = train(
                  model,
                  data.x_dict,
                  data.adj_t_dict,
                  data.y_dict["paper"],
                  train_idx,
                  optimizer,
              )
              result = test(
                  model,
                  data.x_dict,
                  data.adj_t_dict,
                  data.y_dict["paper"],
                  split_idx,
                  evaluator,
              )
              logger.add_result(run, result)
  
              if epoch % args.log_steps == 0:
                  train_acc, valid_acc, test_acc = result
                  print(
                      f"Run: {run + 1:02d}, "
                      f"Epoch: {epoch:02d}, "
                      f"Loss: {loss:.4f}, "
                      f"Train: {100 * train_acc:.2f}%, "
                      f"Valid: {100 * valid_acc:.2f}% "
                      f"Test: {100 * test_acc:.2f}%"
                  )
  
          logger.print_statistics(run)
      logger.print_statistics()
  
imports: import copy
  import argparse
  import torch
  import torch.nn.functional
  from torch.nn import Parameter, ModuleDict, ModuleList, Linear, ParameterDict
  from torch_sparse import SparseTensor
  from ogb.nodeproppred import PygNodePropPredDataset, Evaluator
  from logger import Logger
label_desc: Use image node_id 3 for calling a global function with example usage: main() without return types