How can I establish the relation between each graph with its respective News's id?

[Humberto-Turioni]

Hi!

I have faced difficulties to establish the releation graphs and News's id.

For example,
train_data = UPFD(root="C:\Users\user\Desktop\execucao", name="gossipcop", feature="content", split="train")

In the train_data[x] I couldn't estabilish the relation with gos_news_list.txt.

I want to know which news each graph belongs

[isefos]

Hi! If you are still looking for an answer to this, I think I may be able to help (since I needed this for my own use case as well).
Here I am using the pytorch geometric dataset of politifact (train), but it should be easy to modify for your configuration.
You will need these two data files:

• <your-path>/politifact/raw/train_idx.npy: tells you which indices of the total list of graphs are in the training dataset (and in which order).
• pol_id_twitter_mapping.pkl: contains a mapping from each node (of all graphs) to the corresponding politifact-ID if it is a node, or Twitter-ID if it is not a root node.

Here is a sample code of how to get the IDs. The comments should explain the steps:

import numpy as np
import pickle
from torch_geometric.datasets import UPFD


with open("<your-path>/pol_id_twitter_mapping.pkl", "rb") as f:
    id_mapping = pickle.load(f)

# the id_indices (keys) should be in ascending order:
assert np.all(np.array([k for k in id_mapping]) == np.arange(len(id_mapping)))
# therefore the id_values are also iterated in the correct order

# now we just need to find root ids, we can abuse the fact that
# root node ids are always strings, while the twitter ids are integers
graph_ids: list[list[str]] = []
for v in id_mapping.values():
    try:
        _ = int(v)
        graph_ids[-1].append(v)
    except ValueError:
        graph_ids.append([v])
root_ids: list[str] = [i[0] for i in graph_ids]

# alternatively (maybe less "hacky", but involves more steps and another file) we could use
# <your-path>/politifact/raw/node_graph_idx.npy
# then find the first node (root) index of each graph
# then use the root indices as keys in id_mapping to get the root ids

# now we have the root ids, and can index the training graph positions
train_indices = np.load("<your-path>/politifact/raw/train_idx.npy")
train_root_ids = [root_ids[i] for i in train_indices]
train_all_ids = {root_ids[i]: graph_ids[i] for i in train_indices}

# done! you should now have what you were looking for
# as extra insurance that this is the correct mapping, you can check that the graph sizes match the
# number of ids that we collected for each graph above:
train_dataset = UPFD("<your-path>", "politifact", "content", "train")
assert len(train_dataset) == len(train_root_ids)
for graph_id, graph in zip(train_root_ids, train_dataset):
    assert len(train_all_ids[graph_id]) == graph.x.shape[0]
    print(graph_id)

[Humberto-Turioni]

Hi, Philipp! Thank you very much for your answer! It really helped me.

Yingtong answered me some questions, and there is an alternative way to acess the dataset too. I think it can be helpful to other people, so I will explain it to let documented.

In the repository, we have a file called data_loader.py, we can use it to bring the entire dataset (train + test + val). And the file gos_id_twitter_mapping.pkl constains the graph nodes informations in the same order that the entire dataset.

In the repository, below folder utils, we have the file data_loader.py. I only needed to modify the function donwload() as below:

def download(self):
	pass

After it, I created a file to bring the dataset, transform it in a graph and visualize it, the file is below:

import torch
from torch import Tensor
import matplotlib.pyplot as plt
from torch_geometric.nn import GCNConv
from torch_geometric.data import Data
from torch_geometric.data import InMemoryDataset
from torch_geometric.datasets import UPFD
from data_loader import FNNDataset
import networkx as nx

#function to construct the graph
def to_networkx(data, node_attrs=None, edge_attrs=None, to_undirected=False,
                remove_self_loops=False):
    if to_undirected:
        G = nx.Graph()
    else:
        G = nx.DiGraph()
    G.add_nodes_from(range(data.num_nodes))
    node_attrs, edge_attrs = node_attrs or [], edge_attrs or []
    values = {}
    for key, item in data(*(node_attrs + edge_attrs)):
        if torch.is_tensor(item):
            values[key] = item.squeeze().tolist()
        else:
            values[key] = item
        if isinstance(values[key], (list, tuple)) and len(values[key]) == 1:
            values[key] = item[0]
    for i, (u, v) in enumerate(data.edge_index.t().tolist()):
        if to_undirected and v > u:
            continue
        if remove_self_loops and u == v:
            continue
        if u != v: 
            G.add_edge(u, v)
            for key in edge_attrs:
                G[u][v][key] = values[key][i]
    for key in node_attrs:
        for i, feat_dict in G.nodes(data=True):
            feat_dict.update({key: values[key][i]})
    return G
#function to print graphs
def print_graph(graph):
    plt.figure(figsize=(10, 10))
    pos = nx.spring_layout(graph, seed=42)  # Posições dos nós usando layout spring
    nx.draw(graph, pos, with_labels=True, node_color='skyblue', node_size=1000, font_size=10, font_color='black')
    plt.title(f'Graph Visualization - Sample {sample_id}')
    plt.show()


root_directory =  """dataset path"""
dataset_name = 'gossipcop'
feature_type = 'content'

#class call to build the entire dataset (train + test + val)
dataset = FNNDataset(root=root_directory, name=dataset_name, feature=feature_type)
sample_id = 0
print(dataset[sample_id].edge_index)
graph = to_networkx(dataset[sample_id])
print_graph(graph)

[Humberto-Turioni]

Thank you Yingtong and Philipp!