How to import the HeteroData from .csv file containing triplet?

[songsong0425]

Dear PyG community,

Greetings, I have questions about the knowledge graph embedding(KGE) using pytorch geometric.

When I have a knowledge graph with a .csv file containing triplet as below, how can I import it as HeteroData format?
I want to use KGE in torch_geometric using my dataset (reference code: https://github.com/pyg-team/pytorch_geometric/blob/master/examples/kge_fb15k_237.py).
For the exercise, I attached the example knowledge graph file. If anyone needs a dataset for reproducing, please use it.

kg_ex.csv

Note that there were any initial feature vectors for entities and relations. In this case, how can features be initialized?

[wsad1]

Pyg doesn't have an inbuilt functions to generate HeteroData object from the kind of data you shared. You'll have to write your own functions which does something like

1. Read the csv as a pandas dataframe.
2. For each unique head_label and tail_label pair construct an edge_index, and add it to HeteroData object.

Now since you don't have node features, you could

1. Construct node features like degree, centrality etc
2. If this is an inductive task you could use Embedding

[songsong0425]

For what it's worth, I attach the error log. In summary, edge_label is set to torch.float32 after running RandomLinkSplit due to the default type of Python. Although I should set the type of edge_label like edge_index = torch.zeros((2, len(mapped_relation_df)), dtype=torch.long), it would be better to set the type of edge_label to torch.long or torch.int64 automatically or add a type setting in freebase.py file.

---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
Cell In [38], line 2
      1 for epoch in range(1, 501):
----> 2     loss = train()
      3     print(f"Epoch: {epoch:03d}, Loss: {loss:.4f}")
      4     if epoch % 25 == 0:

Cell In [36], line 6, in train()
      4 for head_index, rel_type, tail_index in loader:
      5     optimizer.zero_grad()
----> 6     loss = model.loss(head_index, rel_type, tail_index)
      7     loss.backward()
      8     optimizer.step()

File ~/.venv/torch1.12.1-py3.8-cuda11.3/lib/python3.8/site-packages/torch_geometric/nn/kge/transe.py:90, in TransE.loss(self, head_index, rel_type, tail_index)
     83 def loss(
     84     self,
     85     head_index: Tensor,
     86     rel_type: Tensor,
     87     tail_index: Tensor,
     88 ) -> Tensor:
---> 90     pos_score = self(head_index, rel_type, tail_index)
     91     neg_score = self(*self.random_sample(head_index, rel_type, tail_index))
     93     return F.margin_ranking_loss(
     94         pos_score,
     95         neg_score,
     96         target=torch.ones_like(pos_score),
     97         margin=self.margin,
     98     )

File ~/.venv/torch1.12.1-py3.8-cuda11.3/lib/python3.8/site-packages/torch/nn/modules/module.py:1130, in Module._call_impl(self, *input, **kwargs)
   1126 # If we don't have any hooks, we want to skip the rest of the logic in
   1127 # this function, and just call forward.
   1128 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1129         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1130     return forward_call(*input, **kwargs)
   1131 # Do not call functions when jit is used
   1132 full_backward_hooks, non_full_backward_hooks = [], []

File ~/.venv/torch1.12.1-py3.8-cuda11.3/lib/python3.8/site-packages/torch_geometric/nn/kge/transe.py:74, in TransE.forward(self, head_index, rel_type, tail_index)
     66 def forward(
     67     self,
     68     head_index: Tensor,
     69     rel_type: Tensor,
     70     tail_index: Tensor,
     71 ) -> Tensor:
     73     head = self.node_emb(head_index)
---> 74     rel = self.rel_emb(rel_type)
     75     tail = self.node_emb(tail_index)
     77     head = F.normalize(head, p=self.p_norm, dim=-1)

File ~/.venv/torch1.12.1-py3.8-cuda11.3/lib/python3.8/site-packages/torch/nn/modules/module.py:1130, in Module._call_impl(self, *input, **kwargs)
   1126 # If we don't have any hooks, we want to skip the rest of the logic in
   1127 # this function, and just call forward.
   1128 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks
   1129         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1130     return forward_call(*input, **kwargs)
   1131 # Do not call functions when jit is used
   1132 full_backward_hooks, non_full_backward_hooks = [], []

File ~/.venv/torch1.12.1-py3.8-cuda11.3/lib/python3.8/site-packages/torch/nn/modules/sparse.py:158, in Embedding.forward(self, input)
    157 def forward(self, input: Tensor) -> Tensor:
--> 158     return F.embedding(
    159         input, self.weight, self.padding_idx, self.max_norm,
    160         self.norm_type, self.scale_grad_by_freq, self.sparse)

File ~/.venv/torch1.12.1-py3.8-cuda11.3/lib/python3.8/site-packages/torch/nn/functional.py:2199, in embedding(input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse)
   2193     # Note [embedding_renorm set_grad_enabled]
   2194     # XXX: equivalent to
   2195     # with torch.no_grad():
   2196     #   torch.embedding_renorm_
   2197     # remove once script supports set_grad_enabled
   2198     _no_grad_embedding_renorm_(weight, input, max_norm, norm_type)
-> 2199 return torch.embedding(weight, input, padding_idx, scale_grad_by_freq, sparse)

RuntimeError: Expected tensor for argument #1 'indices' to have one of the following scalar types: Long, Int; but got torch.FloatTensor instead (while checking arguments for embedding)

[rusty1s]

edge_label is of dtype==torch.float to align with the usage of torch.nn.functional.binary_cross_entropy. From the code-block you posted above, it is not totally clear to me where edge_label is actually used on your end.

[songsong0425]

I almost followed the https://github.com/pyg-team/pytorch_geometric/blob/master/examples/kge_fb15k_237.py code.

In my answer written three days ago, I splitted Data into train:valid:test = 7:2:1 using RandomLinkSplit and the number of edge_label represented them (i.e., 3022954, 431850, 863700, repectively).

import torch_geometric.transforms as T

transform = T.RandomLinkSplit(num_val=0.1, num_test=0.2, is_undirected=False)
tr_d, val_d, test_d = transform(data_ex)

I don't know why RandomLinkSplit returned not only edge_index and edge_type but also edge_label and edge_label_index.
But edge_label and edge_label_index look as splitted relations and entities, I used them as edge_type and edge_index[x] in kge_fb15k_237.py file, respectively. (Also, I referenced the discussion in #3668 )

# Original kge_fb15k_237.py
loader = model.loader(
    head_index=train_data.edge_index[0], #
    rel_type=train_data.edge_type, # 
    tail_index=train_data.edge_index[1], #
    batch_size=1000,
    shuffle=True,
)

# Customized code
loader = model.loader(
    head_index=train_data.edge_label_index[0], #
    rel_type=train_data.edge_label, #
    tail_index=train_data.edge_label_index[1], #
    batch_size=1000,
    shuffle=True,
)

In conclusion, I used edge_label in data loader for running KGE model comparison code.

[rusty1s]

Understood. The RandomLinkSplit is not really designed for KGE-usage. I think you should just implement your own random-link split logic in that case, e.g.

perm = torch.randperm(data.edge_index.size(1))
test_idx = perm[1000:]
train_idx = perm[:1000]

model.loader(
    head_index = data.edge_index[0, train_idx],
    rel_type = data.edge_type[train_idx],
    tail_index = data.edge_index[1, train_idx],
    ...,
)

[songsong0425]

Okay. I'll try to change my code for splitting datasets with your suggestion. Thank you so much!