Hypergraph Attention in PyG

[malikhizar]

I have got a matrix H that stores hyperedge information. The size of H is |nodes| * |nodes| and the type of nodes is homogeneous. Each row in the H is a hyperedge with the neighbors of a node. Hij = 1, if the nodes are neighbors and connected in a hyperedge, 0 otherwise. Now, I want to apply attention as we do in the simple graph. How can we use this information to apply attention to this hypergraph? And how will the attention process differ if the type of nodes is homogeneous and/or heterogeneous?

[rusty1s]

Are you sure you are dealing with hypergraphs here? This sounds like a normal adjacency matrix to me, which you can input into GATConv or TransformerConv. In contrast, a hypergraph utilizes an incidence matrix instead.

[malikhizar]

Ok thanks, I'll have a look and get back if the problem still persists.

[malikhizar]

Dear @rusty1s I tried to check out the link you provided me with and have the following issues:

1. What are x and hyperedge_index in the forward method?
2. What is the shape of these two tensors?

Our x shape is [num_nodes, nodes features], hyperedge_index is 2577 rows and each row has a different number of entries.

Can you please clarify these?

Thanks.

[rusty1s]

x is the usual node feature matrix of shape [num_nodes, num_node_features]. hyperedge_index refers to the (sparse) incidence matrix of hypergraphs, i.e., it will hold the indices of a sparse matrix of shape [num_nodes, num_hyperedges].

[malikhizar]

Thank you.

Actually, I already have a hypergraph with 2577 hyperedges and 2703 nodes and now want to apply node and edge level attention to this graph but not getting the right function to use like GATConv but that is for a simple graph, not a hypergraph. I used the following code to generate my hypergraph data.

import argparse
import matplotlib.pyplot as plt
import networkx as nx
import hypernetx as hnx
import pandas as pd

def read_args():
    ''' read commandline args'''
    parser = argparse.ArgumentParser()
    parser.add_argument("--graph", type = str, help= "graph data in csv file")
    parser.add_argument("--draw_detail", action= "store_true", help="draw hypergraph and show details")
    return parser.parse_args()

def graph_data(grah_data):
    """strore graph data into a dict
    Args: graph_csv(csv file) storing graph data
    return: graph connnection dictionary
    """
    graph_connection = {} 
    rows = grah_data.iloc[:, 0].tolist()
    cols = grah_data.columns.tolist()
    del cols[0]
    # interate over rows
    for i, row in enumerate(rows):
        record = []
        record.append(row)
        for j, col in enumerate(cols):
            if grah_data.iloc[i, j] == 1:
                record.append(int(col))
            else:
                pass
        graph_connection[f"E{i}"] = record
    return graph_connection


def main():
    '''rest of the code goes here'''
    args = read_args()
    if args.graph:
        g_data = pd.read_csv(args.graph)
        print("generating graph connection dictionary!!")
        graph_connection = graph_data(g_data)
        print('done!!!\n')
        print('now deleting keys with one item')
        keys = list(graph_connection.keys())
        for key in keys:
            len_ = len(graph_connection[key])
            if len_ == 1:
                del graph_connection[key]
        print("done!!\n")

        print("generating hypergraph now...")
        H = hnx.Hypergraph(graph_connection)
        print("done!!!")
        if args.draw_detail:
            # hnx.draw(H)
            print(f"number of nodes: {len(H.nodes)}")
            print(f"number of edges: {len(H.edges)}")
        print('finished.!!')
if __name__ == "__main__":
    main()

[rusty1s]

This looks good. You should be able to transform this into a [2, num_edges] matrix to input that into HypergraphConv.

[faizan1234567]

@rusty1s We are using the Cora dataset here. Here is how we generated graph data:

• First, we calculated the length between target and source nodes from edge data in the Cora dataset, if the length is less than a threshold value k we assigned one to those two nodes (meaning that they are neighbors), and if the length is greater than k we assigned 0 to those source and target nodes (meaning that they are not neighbors)
• Secondly, we had 2708 nodes in the Cora dataset we compared them with each other for generating a connection matrix between graphs using step one (source, target)
• Thirdly, we managed to get a CSV file with 2708 x 2708 file with 0 and 1s entries
• For generating a hypergraph, we converted this CSV file into a dictionary above. In this dict, we have 2577 edges, each edge has many nodes in it. Each edge has a row of different sizes.
• Now we want to apply attention to this hypergraph.

According to your suggestion, if we make it [2, num_edges], then our edge connection matrix will be of size [2, 2577]. But in our case each edge has a sequence of nodes, for instance, in an edge there could be 10, or somewhere it could be 50 nodes. I will show you an example from hypernetx library

[faizan1234567]

We have data in this form except, we are using the lists and they are using tuples, however, both work.

[rusty1s]

In this case, you would need to encode FN, TH, etc to indices:

FN TH JV BM FN JA ...
0  1  2  3  4  5

and your hyperedge_index would look as

[ 0 1 1 2 3 4 5 ... ]
[ 0 0 1 1 2 2 2 ... ]

Let me know if this makes sense!

[faizan1234567]

In the above example, there are 8 edges with 13 nodes. We have a data structure like that, however, we have 2577 edges with 2703 nodes.

[faizan1234567]

Thanks, I will do it. :)

[faizan1234567]

I encode it. The shape of hypergraph_index is [2, 174601]. The number of hyperedges is 2577. It's because there are a lot of nodes in each hyperedge, right?

[rusty1s]

Yes, you will encode an entry between every hyperedge and its set of nodes - this is likely a large matrix.

[faizan1234567]

code used to generate encoding

[faizan1234567]

@rusty1s There is a problem when I pass x (tensor: 2708 x 1433) and hyperedge_index (tensor: 2 x 2577) to HypergraphConv's forward method. It gives me the Run time Error:
index 100002 is out of bounds for dimension 0 with size 2708

100002 is a node ID, and I am using it in my hyperedeg_index tensor because these node ids make connections in the hypergraph. Could you please tell me what's wrong?

[rusty1s]

Indices in PyG need to be contiguous - that is, node indices need to go from 0 to number of nodes minus 1, and hyperedge indices need to go from 0 to number of hyperedges minus 1.

[faizan1234567]

Does it mean we should rename the nodes ID's?

[Hao-hui]

The HyperGraphConv defines attention based on a set of incidence matrix features (i.e., features for each non-zero element in H). I don't see a real reason why one cannot apply attention on nodes and hyper edges using two different attention modules: We first apply attention on the node-level to weight importance of certain nodes in a hyperedge, and then apply attention on a hyperedges to weight importance of hyperedges that belong to the same node.

Also, I would like to ask, in that answer(#5152 (reply in thread)), you mentioned that if there is no hyperedge feature, you can replace it with a node feature. But the node feature is [node_numbers=1k+, node feature], and the hyperedge_attr dimension of HyperGraphConv should be [edge_numbers=14 , in_channels]. How else do you think the hyperedge feature can be provided in this case?

Finally, I also want to ask, in terms of formula, isn't the hypergraph itself to first update the characteristics of each hyperedge according to H^T * X * W, and then update the characteristics of the vertices in each hyperedge with H * H^T * X * W ?

Maybe the last question is because my field is different. If you can't explain this question, I hope you can answer other questions

[rusty1s]

How else do you think the hyperedge feature can be provided in this case?

I think you can simply do x[edge_index[0]] to obtain node features as edge features. Please correct me if I am wrong.

Finally, I also want to ask, in terms of formula, isn't the hypergraph itself to first update the characteristics of each hyperedge according to H^T * X * W, and then update the characteristics of the vertices in each hyperedge with H * H^T * X * W ?

Yes, this is correct.

[Hao-hui]

I think you can simply do x[edge_index[0]] to obtain node features as edge features. Please correct me if I am wrong.
@rusty1s
If I treat node features as edge features, does the alpha I calculated in use_attention(

pytorch_geometric/torch_geometric/nn/conv/hypergraph_conv.py

Line 138 in 32c6b7a

if self.use_attention:

) make sense? Does this alpha represent a correlation between nodes within a hyperedge, or a correlation between different hyperedges? According to the paper, it should be the former, but I'm a little confused with the code. Hope you can answer it. Thank you!

[rusty1s]

As far as I understand, attention will be computed across all nodes that share a hyperedge, so it should be the former.

[Hao-hui]

As far as I understand, attention will be computed across all nodes that share a hyperedge, so it should be the former.

Thank you. I'll look at it again

[faizan1234567]

@rusty1s can we use:
hyperedge_attr (Tensor, optional) – Hyperedge feature matrix in. These features only need to get passed in case use_attention=True. (default: [None](https://docs.python.org/3/library/constants.html#None))
for hyperedge attention. I think we need to pass this tensor in order to calculate hyperedge attention. Does it mean this function (hypergraphConv) will do both hyperedge and node attention simultaneously? you said we could do both, could you please illustrate it with an example?

[faizan1234567]

@rusty1s @rfdavid
We generated a hypergraph from the CORA dataset (a simple graph), so how can we get the hyperedge feature matrix R (M x F) to apply hyperedge-level attention? There were 1433 node features in 2708 nodes, however, there were no edge features. How can we generate this matrix (R) now to apply attention?

[rusty1s]

If you have no edge features given, you could use the source node features as edge features. WDYT?