code: def track_time(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 = "10,25"
      batch_size = 1024
      lr = 0.003
      dropout = 0.5
      num_workers = 4
      iter_start = 3
      iter_count = 10
  
      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)
  
      # Enable dataloader cpu affinitization for cpu devices (no effect on gpu)
      with dataloader.enable_cpu_affinity():
          # Training loop
          avg = 0
          iter_tput = []
  
          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()
  
              # start timer at before iter_start
              if step == iter_start - 1:
                  t0 = time.time()
              elif (
                  step == iter_count + iter_start - 1
              ):  # time iter_count iterations
                  break
  
      t1 = time.time()
  
      return (t1 - t0) / iter_count
  
file_path: dgl/benchmarks/benchmarks/model_speed/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 2 for calling a global function with example usage: track_time(data) and returns: unknown