ValueError: Cannot generate a graph node by to_hetero

[mortezaezzabady]

Hi,
I'm trying to do link prediction on a heterogeneous graph but encountered the same problem here.

Data builder:

def parse_one_hot(data):
    if isinstance(data.iloc[0], str):
        return [ast.literal_eval(row) for row in data]
    return data.tolist()

A = pd.read_csv(PATH + 'A.csv')
S = pd.read_csv(PATH + 'S.csv')
W = pd.read_csv(PATH + 'W.csv')
P = pd.read_csv(PATH + 'P.csv')
I = pd.read_csv(PATH + 'I.csv')
edges = pd.concat([A[['source', 'target', 'relation']], S[['source', 'target', 'relation']], W[['source', 'target', 'relation']], P[['source', 'target', 'relation']], I[['source', 'target', 'relation']]], ignore_index=True)
nodes = set(edges['source']).union(set(edges['target']))

E1 = pd.read_csv(PATH + 'E1.csv')
E1 = E1[E1['id'].isin(nodes)]
E2 = pd.read_csv(PATH + 'E2.csv')
E2 = E2[E2['id'].isin(nodes)]

data = HeteroData()
f1 = torch.tensor(E1[['f1']].values, dtype=torch.float32)
f2 = torch.tensor(parse_one_hot(E1['f2']), dtype=torch.float32)
data['E1'].x = torch.cat([f1, f2], dim=1)
data['E1'].node_id = torch.tensor(E1['id'].values, dtype=torch.long)

E2_scalar_features = torch.tensor(E2[['f1', 'f2']].values, dtype=torch.long)
f3 = torch.tensor(parse_one_hot(E2['f3']), dtype=torch.float32)
f4 = torch.tensor(parse_one_hot(E2['f4']), dtype=torch.float32)
f5 = torch.tensor(parse_one_hot(E2['f5']), dtype=torch.float32)
data['E2'].x = torch.cat([E2_scalar_features, f3, f4, f5], dim=1)
data['E2'].node_id = torch.tensor(E2['id'].values, dtype=torch.long)

data['E1', 'S', 'E2'].edge_index = torch.tensor(study_at[['source', 'target']].values.T, dtype=torch.long)
data['E1', 'W', 'E2'].edge_index = torch.tensor(work_at[['source', 'target']].values.T, dtype=torch.long)
data['E1', 'I', 'E2'].edge_index = torch.tensor(invest_on[invest_on['source'].isin(E1['id'])][['source', 'target']].values.T, dtype=torch.long)
data['E2', 'I', 'E2'].edge_index = torch.tensor(invest_on[invest_on['source'].isin(E2['id'])][['source', 'target']].values.T, dtype=torch.long)
data['E2', 'A', 'E2'].edge_index = torch.tensor(acquire[['source', 'target']].values.T, dtype=torch.long)
data['E2', 'P', 'E2'].edge_index = torch.tensor(parent_of[['source', 'target']].values.T, dtype=torch.long)

data['E2', 'A', 'E2'].edge_attr = torch.tensor(acquire[['date', 'f1']].values, dtype=torch.long)
data['E2', 'I', 'E2'].edge_attr = torch.tensor(invest_on[['date', 'f1']].values, dtype=torch.long)
data['E1', 'I', 'E2'].edge_attr = torch.tensor(invest_on[['date', 'f1']].values, dtype=torch.long)
data['E1', 'W', 'E2'].edge_attr = torch.tensor(work_at[['date', 'f1']].values, dtype=torch.long)
data['E1', 'S', 'E2'].edge_attr = torch.tensor(study_at[['date']].values, dtype=torch.long)

Data:

HeteroData(
  E1={
    x=[33422, 23],
    node_id=[33422],
  },
  E2={
    x=[4318, 74],
    node_id=[4318],
  },
  (E1, S, E2)={
    edge_index=[2, 463],
    edge_attr=[463, 1],
  },
  (E1, W, E2)={
    edge_index=[2, 56131],
    edge_attr=[56131, 2],
  },
  (E1, I, E2)={
    edge_index=[2, 1324],
    edge_attr=[13542, 2],
  },
  (E2, I, E2)={
    edge_index=[2, 12218],
    edge_attr=[13542, 2],
  },
  (E2, A, E2)={
    edge_index=[2, 1223],
    edge_attr=[1223, 2],
  },
  (E2, P, E2)={ edge_index=[2, 229] }
)

DataLoader:

link_splitter = RandomLinkSplit(
    num_val=0.1,
    num_test=0.1,
    disjoint_train_ratio=0.3,
    neg_sampling_ratio=2.0,
    add_negative_train_samples=False,
    edge_types=[('E2', 'A', 'E2')],
    rev_edge_types=None
)

train_data, val_data, test_data = link_splitter(data)

data_loader = LinkNeighborLoader(
    data=train_data,
    num_neighbors=[3, 2],
    neg_sampling_ratio=2.0,
    edge_label_index=(('E2', 'A', 'E2'), train_data['E2', 'A', 'E2'].edge_label_index),
    edge_label=train_data['E2', 'A', 'E2'].edge_label,
    batch_size=2,
    shuffle=True
)

Model:

class GNN(torch.nn.Module):
    def __init__(self, hidden_channels, num_layers=2):
        super().__init__()
        self.conv1 = SAGEConv(hidden_channels, hidden_channels)
        self.conv2 = SAGEConv(hidden_channels, hidden_channels)
    
    def forward(self, x, edge_index):
        x = F.relu(self.conv1(x, edge_index))
        x = self.conv2(x, edge_index)
        return x

class Classifier(torch.nn.Module):
    def forward(self, x_e1, x_e2, edge_label_index):
        edge_feat_e1 = x_e1[edge_label_index[0]]
        edge_feat_e2 = x_e2[edge_label_index[1]]
        return (edge_feat_e1 * edge_feat_e2).sum(dim=-1)

class Model(torch.nn.Module):
    def __init__(self, hidden_channels, data):
        super().__init__()
        self.E2_lin = torch.nn.Linear(data['E2'].num_features, hidden_channels)
        self.E1_lin = torch.nn.Linear(data['E1'].num_features, hidden_channels)
        self.E2_emb = torch.nn.Embedding(data['E2'].num_nodes, hidden_channels)
        self.E1_emb = torch.nn.Embedding(data['E1'].num_nodes, hidden_channels)
        self.gnn = GNN(hidden_channels)
        self.gnn = to_hetero(self.gnn, metadata=data.metadata())
        self.classifier = Classifier()

    def forward(self, data):
        x_dict = {
            'E1': self.E1_lin(data['E1'].x) + self.E1_emb(data['E1'].node_id),
            'E2': self.E2_lin(data['E2'].x) + self.E2_emb(data['E2'].node_id),
        }
        x_dict = self.gnn(x_dict, data.edge_index_dict)
        pred = self.classifier(x_dict['E2'], x_dict['E2'], data['E2', 'A', 'E2'].edge_label_index)
        return pred

Error:

ValueError: Cannot generate a graph node 'relu' for type 'E1' since it does not exist. Please make sure that all node types get updated during message passing.

All the E1 nodes have at least one edge. Also, I even added dummy features to E1 to be like E2 but didn't work.
Where is my fault?
Thanks in advance.

[wsad1]

Could you share what the x_dict and edge_index_dict looks like in self.gnn(x_dict, data.edge_index_dict)

[mortezaezzabady]

I solved the problems:
1- node ids should be 0-based, so I map my ids to (0, data['person'].node_id.shape[0]).
2- There was no incoming edge to person nodes, so I made my graph undirected T.ToUndirected()(data).