train_loader subgraphs data from Neighborloader not corresponding with the data from the graph

[Rexedoziem]

import networkx as nx
import pandas as pd
from collections import defaultdict
import torch
from torch_geometric.data import Data, HeteroData
import gensim.downloader as api
from gensim.models import Word2Vec
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from torch_geometric.loader import NeighborLoader
import torch_geometric.transforms as T
from torch_geometric.transforms import RandomNodeSplit

Load pre-trained Word2Vec model

wv_model = api.load("glove-wiki-gigaword-50")

def encode_text(text):
    """Encode text using Word2Vec or GloVe"""
    words = text.split()
    embeddings = []
    for word in words:
        try:
            embedding = wv_model.get_vector(word)
            embeddings.append(embedding)
        except KeyError:
            # If the word is not in the vocabulary, skip it
            pass
    if len(embeddings) == 0:
        # If no words are found, return a random vector
        return torch.randn(wv_model.vector_size)   
    return torch.mean(torch.tensor(embeddings), dim=0)

scaler = StandardScaler()
encoder = OneHotEncoder(sparse=False)

def preprocess_data(data):
    """Preprocess the data by handling missing values, splitting categories, and encoding features."""
    data = data.fillna({'text': '', 'categories': ''})
    data['categories'] = data['categories'].str.split(', ') 
    # Scale numerical features
    data = scale_numerical_features(data, ['longitude', 'latitude', 'review_count_x', 'review_count']) 
    # Encode categorical features
    data = encode_categorical_features(data, ['city'])
    return data

def scale_numerical_features(data, features):
    """Scale numerical features using StandardScaler"""
    scaled_data = data.copy()
    scaled_data[features] = scaler.fit_transform(scaled_data[features])
    return scaled_data

def encode_categorical_features(data, features):
    """Encode categorical features using OneHotEncoder"""
    encoded_data = data.copy()
    encoded_data[features] = encoder.fit_transform(encoded_data[features])
    return encoded_data

def create_bipartite_graphs(data):
    """Create user-restaurant and user-category bipartite graphs."""
    user_restaurant_graph = nx.Graph()
    user_category_graph = nx.Graph()

    # Unique nodes
    unique_users = data['user_id'].unique()
    unique_restaurants = data['business_id'].unique()
    unique_categories = set(category for categories in data['categories'] for category in categories)

    # Add nodes to user-restaurant graph
    user_restaurant_graph.add_nodes_from(unique_users, bipartite='user')
    user_restaurant_graph.add_nodes_from(unique_restaurants, bipartite='restaurant')

    # Add nodes to user-category graph
    user_category_graph.add_nodes_from(unique_users, bipartite='user')
    user_category_graph.add_nodes_from(unique_categories, bipartite='category')

    # Add edges to user-restaurant graph
    user_restaurant_edges = [(row['user_id'], row['business_id']) for _, row in data.iterrows()]
    user_restaurant_graph.add_edges_from(user_restaurant_edges)

    # Add 'stars_x' as a node attribute for users
    user_star_x = dict(zip(data['user_id'], data['stars_x']))
    nx.set_node_attributes(user_restaurant_graph, user_star_x, name='y')

    # Add edges to user-category graph
    user_category_edges = [(row['user_id'], category) for _, row in data.iterrows() for category in row['categories']]
    user_category_graph.add_edges_from(user_category_edges)

    # Add 'stars_y' as a weighted edge attribute to user-category graph
    star_y_edges = [(row['user_id'], category, {'star_y': row['stars_y']}) for _, row in data.iterrows() for category in row['categories']]
    user_category_graph.add_edges_from(star_y_edges)
    return user_restaurant_graph, user_category_graph

def add_node_features(user_restaurant_graph, user_category_graph, data):
    """Add node features to the bipartite graphs."""
    # Add 'review_count' as a node feature
    user_review_count = dict(zip(data['user_id'], data['review_count_x']))
    restaurant_review_count = dict(zip(data['business_id'], data['review_count']))
    nx.set_node_attributes(user_restaurant_graph, user_review_count, name='review_count_user')
    nx.set_node_attributes(user_restaurant_graph, restaurant_review_count, name='review_count_restaurant')

    # Add 'city' as a node feature
    restaurant_city = dict(zip(data['business_id'], data['city']))
    nx.set_node_attributes(user_restaurant_graph, restaurant_city, name='city_restaurant')

    # Add 'longitude' and 'latitude' as node features for restaurants
    restaurant_longitude = dict(zip(data['business_id'], data['longitude']))
    restaurant_latitude = dict(zip(data['business_id'], data['latitude']))
    nx.set_node_attributes(user_restaurant_graph, restaurant_longitude, name='longitude_restaurant')
    nx.set_node_attributes(user_restaurant_graph, restaurant_latitude, name='latitude_restaurant')

    # Add categories as a node feature for users
    user_categories = defaultdict(list)
    for _, row in data.iterrows():
        user_categories[row['user_id']].extend(row['categories'])
    nx.set_node_attributes(user_category_graph, {user: list(set(categories)) for user, categories in user_categories.items()}, name='categories_user')

def add_edge_features(user_restaurant_graph, user_category_graph, data):
    """Add edge features to the bipartite graphs."""
    # Add 'text' as an edge feature
    user_restaurant_text = {(row['user_id'], row['business_id']): row['text'] for _, row in data.iterrows()}
    user_category_text = {(row['user_id'], category): row['text'] for _, row in data.iterrows() for category in row['categories']}
    nx.set_edge_attributes(user_restaurant_graph, user_restaurant_text, name='review_text')
    nx.set_edge_attributes(user_category_graph, user_category_text, name='review_text')

    # Add 'name' and 'categories' as edge features for user-restaurant graph
    user_restaurant_name = {(row['user_id'], row['business_id']): row['name'] for _, row in data.iterrows()}
    user_restaurant_categories = {(row['user_id'], row['business_id']): row['categories'] for _, row in data.iterrows()}
    nx.set_edge_attributes(user_restaurant_graph, user_restaurant_name, name='restaurant_name')
    nx.set_edge_attributes(user_restaurant_graph, user_restaurant_categories, name='restaurant_categories')
    # Add 'star_x' as an edge feature with weights

    star_x_edges = [(row['user_id'], row['business_id'], {'star_x': row['stars_x']}) for _, row in data.iterrows()]
    user_restaurant_graph.add_edges_from(star_x_edges)
    # Add 'stars_y' as a weighted edge attribute to user-category graph
    star_y_edges = [(row['user_id'], category, {'star_y': row['stars_y']}) for _, row in data.iterrows() for category in row['categories']]
    user_category_graph.add_edges_from(star_y_edges)

def encode_node_features(node_data):
    """Encode node features using node attributes and review text."""
    #print(f"Node data: {node_data}")  # Add this line
    node_attributes = []

    # Encode categorical attributes
    city = node_data.get('city', '')
    if city:
        city_encoding = encoder.transform([[city]]).toarray().flatten()
        node_attributes.extend(city_encoding)
    else:
        node_attributes.extend([0] * len(encoder.categories_[0]))

    # Encode numerical attributes
    review_count = node_data.get('review_count', 0)
    node_attributes.append(review_count)

    # Encode boolean attributes
    is_open = node_data.get('is_open', 0)
    node_attributes.append(float(is_open))

    # Encode review text
    review_text = encode_text(node_data.get('review_text', ''))
    node_attributes.extend(review_text.tolist())
    return torch.tensor(node_attributes)

def create_pyg_data(graph, node_type1, node_type2, node_type3=None):
    """Create a PyG Data or HeteroData object from a bipartite graph."""
    data = HeteroData()
    # Set num_nodes for each node type
    data[node_type1].num_nodes = len(set([n for n, d in graph.nodes(data=True) if d.get('bipartite') == node_type1]))
    data[node_type2].num_nodes = len(set([n for n, d in graph.nodes(data=True) if d.get('bipartite') == node_type2]))
    if node_type3 is not None:
        data[node_type3].num_nodes = len(set([n for n, d in graph.nodes(data=True) if d.get('bipartite') == node_type3]))

    # Add 'y' (star_x) as a node attribute for node_type1 (user)
    user_y = []
    for _, node_data in graph.nodes(data=True):
        if node_data.get('bipartite') == node_type1:
            user_y.append(node_data.get('y', 0))
    data[node_type1].y = torch.tensor(user_y)
    # Add node features for node_type1
    node_type1_features = []
    for _, node_data in graph.nodes(data=True):
        if node_data.get('bipartite') == node_type1:
            node_type1_features.append(encode_node_features(node_data))
    data[node_type1].x = torch.stack(node_type1_features)

    # Add node features for node_type2
    node_type2_features = []
    for _, node_data in graph.nodes(data=True):
        if node_data.get('bipartite') == node_type2:
            node_type2_features.append(encode_node_features(node_data))
    data[node_type2].x = torch.stack(node_type2_features)

    # Add node features for node_type3 (if provided)
    if node_type3 is not None:
        node_type3_features = []
        for _, node_data in graph.nodes(data=True):
            if node_data.get('bipartite') == node_type3:
                node_type3_features.append(encode_node_features(node_data))
        data[node_type3].x = torch.stack(node_type3_features)

    # Add edge indices
    node_type_mapping = {'user': 0, 'restaurant': 1, 'category': 2}
    edges = [(node_type_mapping[graph.nodes[u]['bipartite']], node_type_mapping[graph.nodes[v]['bipartite']]) for u, v in graph.edges()]
    row, col = zip(*edges)
    data[(node_type1, 'to', node_type2)].edge_index = torch.tensor([row, col], dtype=torch.long)
    if node_type3 is not None:
        data[(node_type1, 'to', node_type3)].edge_index = torch.tensor([row, col], dtype=torch.long)

    # Add edge features
    edge_features = [encode_text(graph.edges[u, v]['review_text']) for u, v in graph.edges()]
    data[(node_type1, 'to', node_type2)].edge_attr = torch.stack(edge_features)
    if node_type3 is not None:
        data[(node_type1, 'to', node_type3)].edge_attr = torch.stack(edge_features)

    # Add 'star_x' as an edge weight for user-restaurant graph
    user_restaurant_star_x = [graph.edges[u, v].get('star_x', 0) for u, v in graph.edges() if graph.nodes[u]['bipartite'] == node_type1 and graph.nodes[v]['bipartite'] == node_type2]
    data[(node_type1, 'to', node_type2)].edge_weight = torch.tensor(user_restaurant_star_x)

    # Add 'star_y' as an edge feature for user-category graph
    if node_type3 is not None:
        user_category_star_y = [graph.edges[u, v].get('star_y', 0) for u, v in graph.edges() if graph.nodes[u]['bipartite'] == node_type1 and graph.nodes[v]['bipartite'] == node_type3]
        data[(node_type1, 'to', node_type3)].edge_weight = torch.tensor(user_category_star_y)
    return data

def create_combined_data(user_restaurant_graph, user_category_graph, preprocessed_data):
    """Create the combined HeteroData object."""
    # Add node features
    add_node_features(user_restaurant_graph, user_category_graph, preprocessed_data)

    # Add edge features
    add_edge_features(user_restaurant_graph, user_category_graph, preprocessed_data)

    # Create PyG Data objects
    user_restaurant_data = create_pyg_data(user_restaurant_graph, 'user', 'restaurant')
    user_category_data = create_pyg_data(user_category_graph, 'user', 'category')

    # Create PyG homogeneous Data object (optional)
    combined_graph = nx.compose(user_restaurant_graph, user_category_graph)
    combined_data = create_pyg_data(combined_graph, 'user', 'restaurant', 'category')
    return combined_data, combined_graph

def main():
    # Load the dataset
    data = pd.read_csv("/kaggle/working/subset_review_merged1.csv")
    # Preprocess the data
    preprocessed_data = preprocess_data(data)

    # Create bipartite graphs
    user_restaurant_graph, user_category_graph = create_bipartite_graphs(preprocessed_data)

    # Create the combined HeteroData object and the combined graph
    combined_data, combined_graph = create_combined_data(user_restaurant_graph, user_category_graph, preprocessed_data)
    
    # Split the combined_data into train, validation, and test sets based on 'user' node type
    combined_data = T.RandomNodeSplit(split='train_rest', num_val=0.1, num_test=0.1)(combined_data)

    # Convert the graphs to undirected (if needed)
    combined_data = T.ToUndirected()(combined_data)
    print(f"combined data: {combined_data}")
    return combined_graph, combined_data, preprocessed_data


    # Define the is_connected function
    def is_connected(graph):
        """Check if a graph is connected using BFS."""
        # Initialize visited set and queue for BFS
        visited = set()
        queue = []

        # Choose an arbitrary starting node
        start_node = next(iter(graph.nodes()))

        # Start BFS from the chosen node
        queue.append(start_node)
        visited.add(start_node)

        while queue:
            # Dequeue a node from the queue
            node = queue.pop(0)

            # Visit neighbors of the current node
            for neighbor in graph.neighbors(node):
                if neighbor not in visited:
                    visited.add(neighbor)
                    queue.append(neighbor)

        # If all nodes are visited, the graph is connected
        return len(visited) == len(graph.nodes())

    # Check if the combined graph is connected
    combined_connected = is_connected(combined_graph)
    print("Is the combined graph connected?", combined_connected)

    # Check if the combined graph is bipartite
    combined_bipartite = nx.is_bipartite(combined_graph)

    # Visualization
    plt.figure(figsize=(10, 6))
    nx.draw(combined_graph, with_labels=True)
    plt.title(f'Combined Bipartite Graph\nBipartite: {combined_bipartite}')
    plt.show()
    return combined_graph, combined_data

if __name__ == '__main__':
    combined_graph, combined_data, preprocessed_data = main()

    # Access edge attributes for ('user', 'to', 'restaurant') edge type
    user_restaurant_edge_index = combined_data[('user', 'to', 'restaurant')].edge_index
    user_restaurant_edge_attr = combined_data[('user', 'to', 'restaurant')].edge_attr
    user_restaurant_edge_weight = combined_data[('user', 'to', 'restaurant')].edge_weight
    # Access edge attributes for ('user', 'to', 'category') edge type

    user_category_edge_index = combined_data[('user', 'to', 'category')].edge_index
    user_category_edge_attr = combined_data[('user', 'to', 'category')].edge_attr
    user_category_edge_weight = combined_data[('user', 'to', 'category')].edge_weight

    # Print the dimensions of edge attributes for each edge type
    print(f"Shape of data['user'].x: {combined_data['user'].x.shape}")
    print("User to Restaurant Edge Index shape:", user_restaurant_edge_index.shape)
    print("User to Restaurant Edge Weight shape:", user_restaurant_edge_weight.shape)
    print("User to Categories Edge Weight shape:", user_category_edge_weight.shape)
    print("User to Categories Edge Index shape:", user_category_edge_index.shape)
    print("User to Restaurant Edge Attribute shape:", user_restaurant_edge_attr.shape)

combined data: HeteroData(
  user={
    num_nodes=583,
    y=[583],
    x=[583, 53],
    train_mask=[583],
    val_mask=[583],
    test_mask=[583]
  },
  restaurant={
    num_nodes=142,
    x=[142, 53]
  },
  category={
    num_nodes=122,
    x=[122, 53]
  },
  (user, to, restaurant)={
    edge_index=[2, 3669],
    edge_attr=[3669, 50],
    edge_weight=[592]
  },
  (user, to, category)={
    edge_index=[2, 3669],
    edge_attr=[3669, 50],
    edge_weight=[3077]
  },
  (restaurant, rev_to, user)={
    edge_index=[2, 3669],
    edge_attr=[3669, 50]
  },
  (category, rev_to, user)={
    edge_index=[2, 3669],
    edge_attr=[3669, 50]
  }
)

Shape of data['user'].x: torch.Size([583, 53])
User to Restaurant Edge Index shape: torch.Size([2, 3669])
User to Restaurant Edge Weight shape: torch.Size([592])
User to Categories Edge Weight shape: torch.Size([3077])
User to Categories Edge Index shape: torch.Size([2, 3669])
User to Restaurant Edge Attribute shape: torch.Size([3669, 50])

import torch_sparse
from torch_geometric.loader import NeighborLoader

# Create the train_loader
train_loader = NeighborLoader(
    combined_data,
    num_neighbors=[5] * 2,  # Adjust these values as needed
    batch_size=32,
    shuffle=True,
    input_nodes=('user', combined_data['user'].train_mask)
)
next(iter(train_loader))

HeteroData(
   user={
    num_nodes=32,
    y=[32],
    x=[32, 53],
    train_mask=[32],
    val_mask=[32],
    test_mask=[32],
    n_id=[32],
    input_id=[32],
    batch_size=32
  },
  restaurant={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  category={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  (user, to, restaurant)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[592],
    e_id=[0]
  },
  (user, to, category)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[3077],
    e_id=[0]
  },
  (restaurant, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  },
  (category, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  }
)

Im having issues with the train_loader, since it the num_nodes for restaurants and categories are 0, but the data for the combine_data is showing the exact data as it should. and the train_loader has the same data for all subgraphs?. i need help?.
This is the subgrahs data:

Processing subgraph 0: HeteroData(
  user={
    num_nodes=32,
    y=[32],
    x=[32, 53],
    train_mask=[32],
    val_mask=[32],
    test_mask=[32],
    n_id=[32],
    input_id=[32],
    batch_size=32
  },
  restaurant={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  category={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  (user, to, restaurant)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[592],
    e_id=[0]
  },
  (user, to, category)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[3077],
    e_id=[0]
  },
  (restaurant, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  },
  (category, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  }
)

User to Restaurant Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)
User to Categories Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)

Processing subgraph 1: HeteroData(
  user={
    num_nodes=32,
    y=[32],
    x=[32, 53],
    train_mask=[32],
    val_mask=[32],
    test_mask=[32],
    n_id=[32],
    input_id=[32],
    batch_size=32
  },
  restaurant={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  category={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  (user, to, restaurant)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[592],
    e_id=[0]
  },
  (user, to, category)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[3077],
    e_id=[0]
  },
  (restaurant, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  },
  (category, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  }
)
User to Restaurant Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)
User to Categories Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)
Processing subgraph 2: HeteroData(
  user={
    num_nodes=32,
    y=[32],
    x=[32, 53],
    train_mask=[32],
    val_mask=[32],
    test_mask=[32],
    n_id=[32],
    input_id=[32],
    batch_size=32
  },
  restaurant={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  category={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  (user, to, restaurant)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[592],
    e_id=[0]
  },
  (user, to, category)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[3077],
    e_id=[0]
  },
  (restaurant, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  },
  (category, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  }
)
User to Restaurant Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)
User to Categories Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)
Processing subgraph 3: HeteroData(
  user={
    num_nodes=32,
    y=[32],
    x=[32, 53],
    train_mask=[32],
    val_mask=[32],
    test_mask=[32],
    n_id=[32],
    input_id=[32],
    batch_size=32
  },
  restaurant={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  category={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  (user, to, restaurant)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[592],
    e_id=[0]
  },
  (user, to, category)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[3077],
    e_id=[0]
  },
  (restaurant, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  },
  (category, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  }
)
User to Restaurant Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)
User to Categories Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)
Processing subgraph 4: HeteroData(
  user={
    num_nodes=32,
    y=[32],
    x=[32, 53],
    train_mask=[32],
    val_mask=[32],
    test_mask=[32],
    n_id=[32],
    input_id=[32],
    batch_size=32
  },
  restaurant={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  category={
    num_nodes=0,
    x=[0, 53],
    n_id=[0]
  },
  (user, to, restaurant)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[592],
    e_id=[0]
  },
  (user, to, category)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    edge_weight=[3077],
    e_id=[0]
  },
  (restaurant, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  },
  (category, rev_to, user)={
    edge_index=[2, 0],
    edge_attr=[0, 50],
    e_id=[0]
  }
)
User to Restaurant Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)
User to Categories Edge Index shape: tensor([], size=(2, 0), dtype=torch.int64)

[rusty1s]

Can you show me the output of data.validate()? It looks like your edges might be wrongly encoded.

[Rexedoziem]

The output of the combined_data.validate() is True

[Rexedoziem]

This is the one for OGB_MAG data
from torch_geometric.datasets import OGB_MAG
from torch_geometric.loader import NeighborLoader

hetero_data = OGB_MAG(path)[0]
loader = NeighborLoader(
hetero_data,
# Sample 30 neighbors for each node and edge type for 2 iterations
num_neighbors={key: [30] * 2 for key in hetero_data.edge_types},
# Use a batch size of 128 for sampling training nodes of type paper
batch_size=128,
input_nodes=('paper', hetero_data['paper'].train_mask),
)
sampled_hetero_data = next(iter(loader))
print({key: [30] * 2 for key in hetero_data.edge_types})
print(sampled_hetero_data)

This is the subgraph data for OGB data, and it has almost similar properties like mine, but i don't know if i'm on track or that the way neighborloader splits the data to subgraphs?
This is the OGB data from PYG Documentation:
Processing subgraph 0: HeteroData(
paper={
x=[3598, 128],
year=[3598],
y=[3598],
train_mask=[3598],
val_mask=[3598],
test_mask=[3598],
n_id=[3598],
input_id=[128],
batch_size=128
},
author={
num_nodes=3494,
n_id=[3494]
},
institution={
num_nodes=0,
n_id=[0]
},
field_of_study={
num_nodes=0,
n_id=[0]
},
(author, affiliated_with, institution)={
edge_index=[2, 0],
e_id=[0]
},
(author, writes, paper)={
edge_index=[2, 4979],
e_id=[4979]
},
(paper, cites, paper)={
edge_index=[2, 4831],
e_id=[4831]
},
(paper, has_topic, field_of_study)={
edge_index=[2, 0],
e_id=[0]
}
)
Processing subgraph 1: HeteroData(
paper={
x=[5317, 128],
year=[5317],
y=[5317],
train_mask=[5317],
val_mask=[5317],
test_mask=[5317],
n_id=[5317],
input_id=[128],
batch_size=128
},
author={
num_nodes=3776,
n_id=[3776]
},
institution={
num_nodes=0,
n_id=[0]
},
field_of_study={
num_nodes=0,
n_id=[0]
},
(author, affiliated_with, institution)={
edge_index=[2, 0],
e_id=[0]
},
(author, writes, paper)={
edge_index=[2, 5094],
e_id=[5094]
},
(paper, cites, paper)={
edge_index=[2, 7372],
e_id=[7372]
},
(paper, has_topic, field_of_study)={
edge_index=[2, 0],
e_id=[0]
}
)
Processing subgraph 2: HeteroData(
paper={
x=[4407, 128],
year=[4407],
y=[4407],
train_mask=[4407],
val_mask=[4407],
test_mask=[4407],
n_id=[4407],
input_id=[128],
batch_size=128
},
author={
num_nodes=3183,
n_id=[3183]
},
institution={
num_nodes=0,
n_id=[0]
},
field_of_study={
num_nodes=0,
n_id=[0]
},
(author, affiliated_with, institution)={
edge_index=[2, 0],
e_id=[0]
},
(author, writes, paper)={
edge_index=[2, 4339],
e_id=[4339]
},
(paper, cites, paper)={
edge_index=[2, 6446],
e_id=[6446]
},
(paper, has_topic, field_of_study)={
edge_index=[2, 0],
e_id=[0]
}
)
Processing subgraph 3: HeteroData(
paper={
x=[4410, 128],
year=[4410],
y=[4410],
train_mask=[4410],
val_mask=[4410],
test_mask=[4410],
n_id=[4410],
input_id=[128],
batch_size=128
},
author={
num_nodes=3268,
n_id=[3268]
},
institution={
num_nodes=0,
n_id=[0]
},
field_of_study={
num_nodes=0,
n_id=[0]
},
(author, affiliated_with, institution)={
edge_index=[2, 0],
e_id=[0]
},
(author, writes, paper)={
edge_index=[2, 4352],
e_id=[4352]
},
(paper, cites, paper)={
edge_index=[2, 5830],
e_id=[5830]
},
(paper, has_topic, field_of_study)={
edge_index=[2, 0],
e_id=[0]
}
)
Processing subgraph 4: HeteroData(
paper={
x=[3729, 128],
year=[3729],
y=[3729],
train_mask=[3729],
val_mask=[3729],
test_mask=[3729],
n_id=[3729],
input_id=[128],
batch_size=128
},
author={
num_nodes=3137,
n_id=[3137]
},
institution={
num_nodes=0,
n_id=[0]
},
field_of_study={
num_nodes=0,
n_id=[0]
},
(author, affiliated_with, institution)={
edge_index=[2, 0],
e_id=[0]
},
(author, writes, paper)={
edge_index=[2, 3902],
e_id=[3902]
},
(paper, cites, paper)={
edge_index=[2, 4854],
e_id=[4854]
},
(paper, has_topic, field_of_study)={
edge_index=[2, 0],
e_id=[0]
}
)
Processing subgraph 5: HeteroData(
paper={
x=[4415, 128],
year=[4415],
y=[4415],
train_mask=[4415],
val_mask=[4415],
test_mask=[4415],
n_id=[4415],
input_id=[128],
batch_size=128
},
author={
num_nodes=3151,
n_id=[3151]
},
institution={
num_nodes=0,
n_id=[0]
},
field_of_study={
num_nodes=0,
n_id=[0]
},
(author, affiliated_with, institution)={
edge_index=[2, 0],
e_id=[0]
},
(author, writes, paper)={
edge_index=[2, 3888],
e_id=[3888]
},
(paper, cites, paper)={
edge_index=[2, 6345],
e_id=[6345]
},
(paper, has_topic, field_of_study)={
edge_index=[2, 0],
e_id=[0]
}
)

[rusty1s]

Note that OGB_MAG does not come with reverse edges by default.

import torch_geometric.transforms as T
hetero_data = OGB_MAG('/tmp/OGB_MAG', transform=T.ToUndirected())[0]

fixes this.

[Rexedoziem]

Okay, for mine i did it to have the reverse of the forward edges too

[rusty1s]

Let's move the discussion to #9133 (reply in thread). If you can upload the data somewhere, I can take a closer look.