code: def run(args, data, device):
      (
          feats,
          labels,
          in_size,
          num_classes,
          train_nid,
          val_nid,
          test_nid,
          evaluator,
      ) = data
      train_loader = torch.utils.data.DataLoader(
          train_nid,
          batch_size=args.batch_size,
          shuffle=True,
          drop_last=False,
      )
      test_loader = torch.utils.data.DataLoader(
          torch.arange(labels.shape[0]),
          batch_size=args.eval_batch_size,
          shuffle=False,
          drop_last=False,
      )
  
      # Initialize model and optimizer for each run
      num_hops = args.R + 1
      model = SIGN(
          in_size,
          args.num_hidden,
          num_classes,
          num_hops,
          args.ff_layer,
          args.dropout,
          args.input_dropout,
      )
      model = model.to(device)
      print("# Params:", get_n_params(model))
  
      loss_fcn = nn.CrossEntropyLoss()
      optimizer = torch.optim.Adam(
          model.parameters(), lr=args.lr, weight_decay=args.weight_decay
      )
  
      # Start training
      best_epoch = 0
      best_val = 0
      best_test = 0
      for epoch in range(1, args.num_epochs + 1):
          start = time.time()
          train(model, feats, labels, loss_fcn, optimizer, train_loader)
  
          if epoch % args.eval_every == 0:
              with torch.no_grad():
                  acc = test(
                      model,
                      feats,
                      labels,
                      test_loader,
                      evaluator,
                      train_nid,
                      val_nid,
                      test_nid,
                  )
              end = time.time()
              log = "Epoch {}, Time(s): {:.4f}, ".format(
                  epoch, end - start
              )
              log += (
                  "Acc: Train {:.4f}, Val {:.4f}, Test {:.4f}".format(
                      *acc
                  )
              )
              print(log)
              if acc[1] > best_val:
                  best_epoch = epoch
                  best_val = acc[1]
                  best_test = acc[2]
  
      print(
          "Best Epoch {}, Val {:.4f}, Test {:.4f}".format(
              best_epoch, best_val, best_test
          )
      )
      return best_val, best_test
  
imports: import argparse
  import time
  import dgl
  import dgl.function
  import numpy
  import torch
  import torch.nn
  from dataset import load_dataset
label_desc: Use image node_id 6 for calling a global function with example usage: run(args, data, device) and returns: best_val,  best_test