code: def main():
      parser = argparse.ArgumentParser(
          description="Which dataset are you going to use?"
      )
      parser.add_argument(
          "--dataset",
          type=str,
          default="ogbn-arxiv",
          help='Name of the dataset to use (e.g., "ogbn-products", "ogbn-arxiv")',
      )
      args = parser.parse_args()
      dataset_name = args.dataset
      dataset = gb.BuiltinDataset(dataset_name).load()
      graph = dataset.graph
      feature = dataset.feature
      train_set = dataset.tasks[0].train_set
      valid_set = dataset.tasks[0].validation_set
      test_set = dataset.tasks[0].test_set
      num_classes = dataset.tasks[0].metadata["num_classes"]
      device = torch.device(
          "cuda" if torch.cuda.is_available() else "cpu"
      )
  
      train_dataloader = create_dataloader(
          train_set, graph, feature, device, is_train=True
      )
      valid_dataloader = create_dataloader(
          valid_set, graph, feature, device, is_train=False
      )
      test_dataloader = create_dataloader(
          test_set, graph, feature, device, is_train=False
      )
      in_channels = feature.size("node", None, "feat")[0]
      hidden_channels = 128
      model = GraphSAGE(in_channels, hidden_channels, num_classes).to(
          device
      )
      optimizer = torch.optim.Adam(
          model.parameters(), lr=0.01, weight_decay=5e-4
      )
      criterion = torch.nn.CrossEntropyLoss()
      for epoch in range(10):
          train_loss, train_accuracy = train(
              model,
              train_dataloader,
              optimizer,
              criterion,
              device,
              num_classes,
          )
  
          valid_accuracy = evaluate(
              model, valid_dataloader, device, num_classes
          )
          print(
              f"Epoch {epoch}, Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}, "
              f"Valid Accuracy: {valid_accuracy:.4f}"
          )
      test_accuracy = evaluate(
          model, test_dataloader, device, num_classes
      )
      print(f"Test Accuracy: {test_accuracy:.4f}")
  
file_path: dgl/examples/sampling/pyg/node_classification.py
imports: import argparse
  import dgl.graphbolt
  import torch
  import torch.nn.functional
  import torchmetrics.functional
  from torch_geometric.nn import SAGEConv
label_desc: Use image node_id 4 for calling a global function with example usage: main() without return types