NeighborLoader - k-hop neighbors

[Vid201]

Hi, is it possible to construct bipartite graph (like returned from NeighborSampler) with batch from NeighborLoader? How to know to which depth sampled nodes/edges belong?

[rusty1s]

Currently, there is no such way, as the NeighborLoader tries to simplify the GNN model implementation in a neighbor sampling scenario. Can you explain a bit more what's the benefit of such information?

One thing I could imagine is that we add a sizes attribute to the returned data (holding information about which slices of nodes where sampled in which iteration), but this requires both changes to PyG and torch-sparse.

[rusty1s]

Yes, that is correct.

[MDrance]

Hello,
I'm sorry to answer an ancient topic but I have a question related to Misterion777 question about the number of iterations in the NeighborLoader. Is the number or iterations or hops something I can have an impact on directly using the NeighborLoader class, or is it defined by default by the number of layers in my model ?
I'm currently working with a simple GAE, I have embeddings for my nodes that I'm trying to encode and decode, planing on using the output of my encoder for an other task. I would like to take the information about nodes in 2 iterations/hops away from current node and I'm not sure how to do it.
If I understand correctly the computation graph for a node and the number of layers, the code below should use the neighbors of the current node and their neighbors too ?

class EncoderGATConv(torch.nn.Module):
    def __init__(self, in_channels, out_channels):
        super(EncoderGATConv, self).__init__()
        self.conv1 = GATConv(in_channels, 2 * out_channels)
        self.conv2 = GATConv(2 * out_channels, out_channels)
    
    def forward(self, data):        
        x = data.x
        edge_index = data.edge_index
        z = self.conv1(x, edge_index).relu()
        z = self.conv2(x, edge_index)    
        return z
    
class DecoderGATConv(torch.nn.Module):        
    def __init__(self, in_channels, out_channels):
        super(DecoderGATConv, self).__init__()        
        self.conv1 = GATConv(in_channels, 2 * out_channels)
        self.conv2 = GATConv(2 *  out_channels, out_channels)
        
    def forward(self, z, edge_index):        
        out = self.conv1(z, edge_index).relu()
        out = self.conv2(out, edge_index)
        return out

Best,
Martin

[Padarn]

This is defined in your NeighborLoader:

        num_neighbors (List[int] or Dict[Tuple[str, str, str], List[int]]): The
            number of neighbors to sample for each node in each iteration.
            In heterogeneous graphs, may also take in a dictionary denoting
            the amount of neighbors to sample for each individual edge type.
            If an entry is set to :obj:`-1`, all neighbors will be included.

[MDrance]

Hello Padarn and thanks for your answer,
I understand that the NeighborLoader allow me to chose the number of neighbors to sample at each iterations/hops, but I'm not sure about the number of iterations/hops I'm using right now ?
In the computation graph in example below, to update yellow node features, I want to take the direct neighbors features (blue nodes) and the green node features too (so 2 iterations/hops from the current node).

[Padarn]

The number of neighbours your model uses will depend on your graph. So I guess it depends on the maximum degree of a node in your data.