RGATConv for Heterogeneous graph with multiple edge types and edge attributes

[Famirreza]

Dear all,

I created my Heterogeneous graph with multiple edge types (multi relational graph) and edge attributes via https://pytorch-geometric.readthedocs.io/en/latest/notes/heterogeneous.html and tried to use RGATConv based on https://github.com/pyg-team/pytorch_geometric/blob/master/examples/rgat.py.

For example we have to set the following variables:
init(self, in_channels, hidden_channels, out_channels, num_relations, edge_dim)
forward(self, x, edge_index, edge_type, edge_attr)

How should give these values as input to the model? Because if we want to simply use edge_index, edge_type or edge_attr we face the following errors:
AttributeError: 'HeteroData' has no attribute 'edge_index,

I have to mention I tried model(data.x_dict, data.edge_index_dict, data.edge_types, data.edge_attr_dict) but I faced the following error:

ValueError: MessagePassing.propagate only supports torch.LongTensor of shape [2, num_messages] or torch_sparse.SparseTensor for argument edge_index.

My edge_index_dict:

{('a', 'A', 'a'): tensor([[ 0, 0, 0, ..., 163, 163, 163],
[ 0, 1, 2, ..., 161, 162, 163]]), ('a', 'B', 'a'): tensor([[ 0, 0, 0, ..., 163, 163, 163],
[ 0, 1, 2, ..., 161, 162, 163]]), ('a', 'C', 'a'): tensor([[ 0, 0, 0, ..., 163, 163, 163],
[ 0, 1, 2, ..., 161, 162, 163]])}

Thank you in advance.

Best regards,

[rusty1s]

Can you share some reproducible script with us? In general, RGATConv expects a single node feature matrix x, a single matrix edge_index and a corresponding edge_type vector. In that sense, its input is somewhat different from the input given by HeteroData (which represents features and edges across types within a dictionary). As such, you can use HeteroConv or to_hetero (as discussed in the doucmentation) for use with HeteroData.

[Famirreza]

Hetero data creator:

  data = HeteroData()
  data['person'].x = torch.from_numpy(Node_features) # [num_operations, num_features_person]
  for edge_type in [('person', 'A', 'person'),
                      ('person', 'B', 'person'),
                      ('person', 'C', 'person')]:

    if edge_type [1] ==  'A':
      edge_attr =  torch.from_numpy(Graph_edges_A) # [num_edges of A, num_edge features of A]
      edge_index = tensor([[  0,   0,   0,  ..., 163, 163, 163], [  0,   1,   2,  ..., 161, 162, 163]])
  
    elif edge_type [1] ==  'B':
      edge_attr =  torch.from_numpy(Graph_edges_B)   # [num_edges of B, num_edge features of B]
      edge_index = tensor([[  0,   0,   0,  ..., 163, 163, 163], [  0,   1,   2,  ..., 161, 162, 163]])
  
    else:
      edge_attr =  torch.from_numpy(Graph_edges_C)  # [num_edges of C, num_edge features of C]
      edge_index = tensor([[  0,   0,   0,  ..., 163, 163, 163], [  0,   1,   2,  ..., 161, 162, 163]])
  
    data[edge_type].edge_index = edge_index
    data[edge_type].edge_attr = edge_attr

Output:

HeteroData(
  person={ x=[164, 7] },
  (person, A, person)={
    edge_index=[2, 26896],
    edge_attr=[26896, 1]
  },
  (person, B, person)={
    edge_index=[2, 26896],
    edge_attr=[26896, 1]
  },
  (person, C, person)={
    edge_index=[2, 26896],
    edge_attr=[26896, 1]
  }
)

RGAT part:

class RGAT(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels, num_relations, edge_dim):
        super().__init__()
        self.conv1 = RGATConv(in_channels= in_channels, out_channels=hidden_channels,  num_relations=num_relations, edge_dim=edge_dim)
        self.conv2 = RGATConv(in_channels=hidden_channels, out_channels=hidden_channels,  num_relations=num_relations, edge_dim=edge_dim)
        self.lin = torch.nn.Linear(hidden_channels, out_channels)
    def forward(self, x, edge_index, edge_type, edge_attr):
        for type in edge_type:
          print("inja", edge_index)
          x = self.conv1(x, edge_index, edge_type, edge_attr).relu()
          x = self.conv2(x, edge_index, edge_type, edge_attr).relu()
          x = self.lin(x)
        return F.log_softmax(x, dim=-1)

Training part:

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
data = data.to(device)
model = RGAT(data['person'].num_node_features, 128, data.num_nodes, 3, 1).to(device)
model(data.x_dict, data.edge_index_dict, data.edge_types, data.edge_attr_dict)

Could you please share an example how to use HeteroConv when we have edge attribute?

Based on your GNN cheatsheet (https://pytorch-geometric.readthedocs.io/en/latest/notes/cheatsheet.html#heterogeneous-graph-neural-network-operators) RGATConv and HEATConv can support my case (heterogeneous graph with multiple edge types and edge attributes). However, in your RGAT example (https://github.com/pyg-team/pytorch_geometric/blob/master/examples/rgat.py) you did not have edge attributes, also for HEATConv I did not find any example in your documentation.

I hope I have explained my problem well. Could you please share an example for heterogeneous graph with multiple edge types and edge attributes?

Thank you in advance for your help.

[rusty1s]

Yes, this does not work. You would first need to convert your HeteroData into a "typed" homogeneous one:

data = data.to_homogeneous()

model(data.x, data.edge_index, data.edge_type, data.edge_attr)