code: def track_acc(data):
      data = utils.process_data(data)
      device = utils.get_bench_device()
      g = data[0]
      g.ndata["features"] = g.ndata["feat"]
      g.ndata["labels"] = g.ndata["label"]
      in_feats = g.ndata["features"].shape[1]
      n_classes = data.num_classes
  
      # Create csr/coo/csc formats before launching training processes with multi-gpu.
      # This avoids creating certain formats in each sub-process, which saves momory and CPU.
      g.create_formats_()
  
      num_epochs = 20
      num_hidden = 16
      num_layers = 2
      fan_out = "5,10"
      batch_size = 1024
      lr = 0.003
      dropout = 0.5
      num_workers = 4
  
      train_nid = th.nonzero(g.ndata["train_mask"], as_tuple=True)[0]
  
      # Create PyTorch DataLoader for constructing blocks
      sampler = dgl.dataloading.MultiLayerNeighborSampler(
          [int(fanout) for fanout in fan_out.split(",")]
      )
      dataloader = dgl.dataloading.DataLoader(
          g,
          train_nid,
          sampler,
          batch_size=batch_size,
          shuffle=True,
          drop_last=False,
          num_workers=num_workers,
      )
  
      # Define model and optimizer
      model = SAGE(
          in_feats, num_hidden, n_classes, num_layers, F.relu, dropout
      )
      model = model.to(device)
      loss_fcn = nn.CrossEntropyLoss()
      loss_fcn = loss_fcn.to(device)
      optimizer = optim.Adam(model.parameters(), lr=lr)
  
      # dry run one epoch
      for step, (input_nodes, seeds, blocks) in enumerate(dataloader):
          # Load the input features as well as output labels
          # batch_inputs, batch_labels = load_subtensor(g, seeds, input_nodes, device)
          blocks = [block.int().to(device) for block in blocks]
          batch_inputs = blocks[0].srcdata["features"]
          batch_labels = blocks[-1].dstdata["labels"]
  
          # Compute loss and prediction
          batch_pred = model(blocks, batch_inputs)
          loss = loss_fcn(batch_pred, batch_labels)
          optimizer.zero_grad()
          loss.backward()
          optimizer.step()
  
      # Training loop
      for epoch in range(num_epochs):
          # Loop over the dataloader to sample the computation dependency graph as a list of
          # blocks.
          for step, (input_nodes, seeds, blocks) in enumerate(
              dataloader
          ):
              # Load the input features as well as output labels
              # batch_inputs, batch_labels = load_subtensor(g, seeds, input_nodes, device)
              blocks = [block.int().to(device) for block in blocks]
              batch_inputs = blocks[0].srcdata["features"]
              batch_labels = blocks[-1].dstdata["labels"]
  
              # Compute loss and prediction
              batch_pred = model(blocks, batch_inputs)
              loss = loss_fcn(batch_pred, batch_labels)
              optimizer.zero_grad()
              loss.backward()
              optimizer.step()
  
      test_g = g
      test_nid = th.nonzero(
          ~(test_g.ndata["train_mask"] | test_g.ndata["val_mask"]),
          as_tuple=True,
      )[0]
      test_acc = evaluate(
          model,
          test_g,
          test_g.ndata["features"],
          test_g.ndata["labels"],
          test_nid,
          batch_size,
          device,
      )
  
      return test_acc.item()
  
file_path: dgl/benchmarks/benchmarks/model_acc/bench_sage_ns.py
imports: import time
  import dgl
  import dgl.nn.pytorch
  import torch
  import torch.multiprocessing
  import torch.nn
  import torch.nn.functional
  import torch.optim
  from torch.utils.data import DataLoader
  from ..None import utils
label_desc: Use image node_id 4 for calling a global function with example usage: track_acc(data) and returns: test_acc