LinkNeighborLoader temporal sampling based on edge timestamps

[zimengzhou1]

From what I understand we can specify edge_label_time and time_attr so that newly sampled neighbors will have a timestamp less than the edge being sampled on. Is there a way to only sample nodes such that the edges to those nodes have a timestamp less than the timestamp of the edge being sampled on?

[wsad1]

Currently we only support a time_attr for nodes, edges can't have a time attribute. So currently what you are suggesting isn't possible with Pyg.

[zimengzhou1]

Thanks for the answer! I thought edge_label_time specifies the timestamp for edge indices. If we wanted to sample from a dynamic graph wouldn't it make sense to only use edges that have a timestamp less than the timestamp of the edge being sampled? Would this be something that could be implemented?

[rusty1s]

Yes, we will add support for edge-time dependent sampling soon, but for now, we sadly only support node-time dependent sampling.

[LMscope]

Thank you for the question and the answer.
However, I have a follow up question, if this is the case (node-time dependent sampling) for now, does this mean the TGN implementation is considered a discrete time dynamic or continuous time dynamic?
I appreciate your answer.

[rusty1s]

The TGN implementation is considered a continuous time dynamic graph.

[GianlucaDeStefano]

Hi @rusty1s, apologies for resurrecting this old post. I am also interested in temporal edge sampling, has there been any update on this front by any chance?

[rusty1s]

Should land in about a week or two. Fingers crossed.

[GianlucaDeStefano]

That's great! Is the implementation available / being developed on one of the public branches by any chance?
I would really like to take a look at it.

In any case, thank you for the amazing work!

[akihironitta]

@GianlucaDeStefano It's in progress here: pyg-team/pyg-lib#280, #8372.

[Jieerbobo]

Hi @rusty1s, thanks for your excellent work on temporal sampling. Recently I have tried LinkNeighborLoader on a dynamic heterogeneous graph, and I found that the node number in a batch is much larger than the original graph. This only happens when using "time_attr". For static graphs, the node number in a batch is the same with the original graph.

For example, the user number and the item number in the original graph are 16379 and 12577, respectively. But when using LinkNeighborLoader to get batches, both numbers in a batch become larger. I am wondering why this happens? If this means each batch is larger than the original graph? Thanks in advance!

train_loader = LinkNeighborLoader(
data = train_data,
num_neighbors=[10,5],
edge_label_index= (("user", "to", "user"), train_data["user", "to", "user"].edge_label_index),
edge_label=train_data["user", "to", "user"].edge_label,
edge_label_time=train_data["user", "to", "user"].edge_label_time,
time_attr="node_time",
temporal_strategy="last",
neg_sampling_ratio=0.0,
batch_size = 256,
shuffle = True,
)

[rusty1s]

If you are using temporal sampling, then each subgraph across seed nodes will be disjoint from any other subgraph (see the disjoint option). This is required for temporal sampling in case seed times vary.

[Linnore]

Hi, thanks for the PyG's work on supporting temporal sampling! I am confused by how each disjoint subgraph is represented in each batch when using LinkNeighborLoader's temporal sampling.

As I observed, the disjoint=True will give batch.batch of shape batch.x.shape[0], which indicates the subgraph each node belongs to. But how about batch.edge_index? How can we get the edges in each disjoint subgraph?

Is there any documentation / example that can help understanding the workflow of temporal sampling using LinkNeighborLoader?