code: def test_gdc():
      data = KarateClub()[0]
  
      gdc = GDC(
          self_loop_weight=1,
          normalization_in="sym",
          normalization_out="sym",
          diffusion_kwargs=dict(method="ppr", alpha=0.15),
          sparsification_kwargs=dict(method="threshold", avg_degree=2),
          exact=True,
      )
      out = gdc(data)
      mat = to_dense_adj(
          out.edge_index, edge_attr=out.edge_attr
      ).squeeze()
      assert torch.all(mat >= -1e-8)
      assert torch.allclose(mat, mat.t(), atol=1e-4)
  
      gdc = GDC(
          self_loop_weight=1,
          normalization_in="sym",
          normalization_out="sym",
          diffusion_kwargs=dict(method="heat", t=10),
          sparsification_kwargs=dict(method="threshold", avg_degree=2),
          exact=True,
      )
      out = gdc(data)
      mat = to_dense_adj(
          out.edge_index, edge_attr=out.edge_attr
      ).squeeze()
      assert torch.all(mat >= -1e-8)
      assert torch.allclose(mat, mat.t(), atol=1e-4)
  
      gdc = GDC(
          self_loop_weight=1,
          normalization_in="col",
          normalization_out="col",
          diffusion_kwargs=dict(method="heat", t=10),
          sparsification_kwargs=dict(method="topk", k=2, dim=0),
          exact=True,
      )
      out = gdc(data)
      mat = to_dense_adj(
          out.edge_index, edge_attr=out.edge_attr
      ).squeeze()
      col_sum = mat.sum(0)
      assert torch.all(mat >= -1e-8)
      assert torch.all(
          torch.isclose(col_sum, torch.tensor(1.0))
          | torch.isclose(col_sum, torch.tensor(0.0))
      )
      assert torch.all(
          (~torch.isclose(mat, torch.tensor(0.0))).sum(0) == 2
      )
  
      gdc = GDC(
          self_loop_weight=1,
          normalization_in="row",
          normalization_out="row",
          diffusion_kwargs=dict(method="heat", t=5),
          sparsification_kwargs=dict(method="topk", k=2, dim=1),
          exact=True,
      )
      out = gdc(data)
      mat = to_dense_adj(
          out.edge_index, edge_attr=out.edge_attr
      ).squeeze()
      row_sum = mat.sum(1)
      assert torch.all(mat >= -1e-8)
      assert torch.all(
          torch.isclose(row_sum, torch.tensor(1.0))
          | torch.isclose(row_sum, torch.tensor(0.0))
      )
      assert torch.all(
          (~torch.isclose(mat, torch.tensor(0.0))).sum(1) == 2
      )
  
      gdc = GDC(
          self_loop_weight=1,
          normalization_in="row",
          normalization_out="row",
          diffusion_kwargs=dict(method="coeff", coeffs=[0.8, 0.3, 0.1]),
          sparsification_kwargs=dict(method="threshold", eps=0.1),
          exact=True,
      )
      out = gdc(data)
      mat = to_dense_adj(
          out.edge_index, edge_attr=out.edge_attr
      ).squeeze()
      row_sum = mat.sum(1)
      assert torch.all(mat >= -1e-8)
      assert torch.all(
          torch.isclose(row_sum, torch.tensor(1.0))
          | torch.isclose(row_sum, torch.tensor(0.0))
      )
  
      gdc = GDC(
          self_loop_weight=1,
          normalization_in="sym",
          normalization_out="col",
          diffusion_kwargs=dict(method="ppr", alpha=0.15, eps=1e-4),
          sparsification_kwargs=dict(method="threshold", avg_degree=2),
          exact=False,
      )
      out = gdc(data)
      mat = to_dense_adj(
          out.edge_index, edge_attr=out.edge_attr
      ).squeeze()
      col_sum = mat.sum(0)
      assert torch.all(mat >= -1e-8)
      assert torch.all(
          torch.isclose(col_sum, torch.tensor(1.0))
          | torch.isclose(col_sum, torch.tensor(0.0))
      )
  
imports: import torch
  from torch_geometric.datasets import KarateClub
  from torch_geometric.testing import withPackage
  from torch_geometric.transforms import GDC
  from torch_geometric.utils import to_dense_adj
label_desc: Use image node_id 1 for calling a global function with example usage: test_gdc() without return types