def METHOD_NAME(data, num_negs, batch_size):
    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 = 2
    num_hidden = 16
    num_layers = 2
    fan_out = "10,25"
    lr = 0.003
    dropout = 0.5
    num_workers = 4
    num_negs = 2
    iter_start = 3
    iter_count = 10
    n_edges = g.num_edges()
    train_seeds = np.arange(n_edges)
    # Create PyTorch DataLoader for constructing blocks
    sampler = dgl.dataloading.MultiLayerNeighborSampler(
        [int(fanout) for fanout in fan_out.split(",")]
    )
    sampler = dgl.dataloading.as_edge_prediction_sampler(
        sampler,
        exclude="reverse_id",
        # For each edge with ID e in Reddit dataset, the reverse edge is e ± |E|/2.
        reverse_eids=th.cat(
            [th.arange(n_edges // 2, n_edges), th.arange(0, n_edges // 2)]
        ),
        negative_sampler=NegativeSampler(g, num_negs),
    )
    dataloader = dgl.dataloading.DataLoader(
        g,
        train_seeds,
        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 = CrossEntropyLoss()
    loss_fcn = loss_fcn.to(device)
    optimizer = optim.Adam(model.parameters(), lr=lr)
    # Training loop
    avg = 0
    iter_tput = []
    for step, (input_nodes, pos_graph, neg_graph, blocks) in enumerate(
        dataloader
    ):
        # Load the input features as well as output labels
        batch_inputs = load_subtensor(g, input_nodes, device)
        pos_graph = pos_graph.to(device)
        neg_graph = neg_graph.to(device)
        blocks = [block.int().to(device) for block in blocks]
        # Compute loss and prediction
        batch_pred = model(blocks, batch_inputs)
        loss = loss_fcn(batch_pred, pos_graph, neg_graph)
        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