AutoEncoder for Heterogeneous Graph

[othmanelhoufi]

Hello everyone,

I'm struggling with the task of building an AutoEncoder for a Heterogeneous Graph, I need some guidance please.
There is not a lot of documentation around Heterogeneous Graph representation learning.

Here is a sample of my dataset:

====================
Number of graphs: 560
Number of features: {'article': 769, 'user': 772}

HeteroData(
  y=[1],
  article={ x=[1, 769] },
  user={ x=[67, 772] },
  (user, tweeted, article)={ edge_index=[2, 54] },
  (user, retweeted, user)={ edge_index=[2, 4] },
  (user, liked, user)={ edge_index=[2, 11] }
)
=============================================================
Number of nodes: 68
Number of edges: 69
Average node degree: 1.01
Has isolated nodes: True
Has self-loops: False
Is undirected: False

Here is my model:

from dataset import FakeNewsDataset
from torch.utils.data import random_split

import torch.nn as nn
from torch_geometric.nn import GCNConv, GAE, InnerProductDecoder, GATConv, Linear, to_hetero
from torch_geometric.loader import DataLoader
import torch 
from tqdm import tqdm

device = torch.device('cpu')

class GCNEncoder(torch.nn.Module):
  
    def __init__(self, in_channels, hidden_size, out_channels, dropout):
        super(GCNEncoder, self).__init__()
        self.conv1 = GATConv((-1, -1), hidden_size, add_self_loops=False)
        self.lin1 = Linear(-1, hidden_size)
        self.conv2 = GATConv((-1, -1), out_channels, add_self_loops=False)
        self.lin2 = Linear(-1, out_channels)
        self.decoder = InnerProductDecoder()
        self.dropout = nn.Dropout(dropout)

    def encode(self, x, edge_index):
        x = self.conv1(x, edge_index) + self.lin1(x)
        x = x.relu()
        x = self.conv2(x, edge_index) + self.lin2(x)
        return x

    def decode(self, x, edge_index):
        return self.decoder(x, edge_index)

    # Our model will take the feature matrix X and the edge list
    # representation of the graph as inputs.
    def forward(self, x, edge_index):
        x = self.encode(x, edge_index)
        x = self.decode(x, edge_index)
        return x

def train(model, optimizer, train_loader, training_set):
    
    loss_all = 0
    for data in tqdm(train_loader, leave=False):
        optimizer.zero_grad()
        z = model(data.x_dict, data.edge_index_dict)
        loss = model.recon_loss(z, data.edge_index_dict)
        loss.backward()
        optimizer.step()
        loss_all += loss.item()
    return loss_all / len(training_set)
    

dataset = FakeNewsDataset(name='politifact', encoder='all-MiniLM-L6-v2')
data = dataset[0]
    
num_training = int(len(dataset) * 0.6)
num_val = int(len(dataset) * 0.2)
num_test = len(dataset) - (num_training + num_val)
training_set, validation_set, test_set = random_split(dataset, [num_training, num_val, num_test])
    
num_epochs = 4
batch_size = 10
in_channels, out_channels = dataset.num_features['article'], 128
hidden_dim = 50
dropout = 0.2

model = GCNEncoder(in_channels, hidden_dim, out_channels, dropout)
model = to_hetero(model, dataset[0].metadata(), aggr='sum')
model = model.to(device)
    
optimizer = torch.optim.Adam(model.parameters(), lr=0.005)
train_loader = DataLoader(training_set, batch_size=batch_size)
    
for epoch in tqdm(range(num_epochs)):
    loss = train(model, optimizer, train_loader, training_set)
    print('Loss = ', loss)

Here is the error that I get (it comes from the decoder because when I use only the encoder everything works fine):

Traceback (most recent call last):                                                                                                                                                                                                             
  File "/home/thorium90/FactChecking-For-Complex-Networks/utils/./gnn.py", line 116, in <module>
    main()
  File "/home/thorium90/FactChecking-For-Complex-Networks/utils/./gnn.py", line 109, in main
    loss = train(model, optimizer, train_loader, training_set)
  File "/home/thorium90/FactChecking-For-Complex-Networks/utils/./gnn.py", line 73, in train
    z = model(data.x_dict, data.edge_index_dict)
  File "/home/thorium90/.local/lib/python3.10/site-packages/torch/fx/graph_module.py", line 652, in call_wrapped
    return self._wrapped_call(self, *args, **kwargs)
  File "/home/thorium90/.local/lib/python3.10/site-packages/torch/fx/graph_module.py", line 277, in __call__
    raise e
  File "/home/thorium90/.local/lib/python3.10/site-packages/torch/fx/graph_module.py", line 267, in __call__
    return super(self.cls, obj).__call__(*args, **kwargs)  # type: ignore[misc]
  File "/home/thorium90/.local/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1130, in _call_impl
    return forward_call(*input, **kwargs)
  File "<eval_with_key>.1", line 30, in forward
  File "/home/thorium90/.local/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1130, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/thorium90/.local/lib/python3.10/site-packages/torch_geometric/nn/models/autoencoder.py", line 30, in forward
    value = (z[edge_index[0]] * z[edge_index[1]]).sum(dim=1)
TypeError: only integer tensors of a single element can be converted to an index

[rusty1s]

Please see my answer here: #5334