Issue with Heterogenous Graph embedding (GraphSage)

[Charles-Ca]

Hello everyone,
Thanks for the wonderful framework, i'm excited to learn the capabilities of PyG
I'm a beginner in Pytorch and PyG

I'm trying to do a simple exemple with Heterogenous data, i read a lot of Q&A and search in the documentation but i was not able to find exactly what's wrong in what i trying to do.

Based on : #8380

I'm trying to create an embedding for the item nodes
i'm using the following code :

import os.path as osp
import shutil

import torch
import torch.nn.functional as F
import numpy as np 
import pandas as pd
import tqdm
from sklearn.metrics import roc_auc_score
from torch.nn import Embedding, Linear

import torch_geometric.transforms as T
from torch_geometric.datasets import Taobao
from torch_geometric.loader import LinkNeighborLoader
from torch_geometric.nn import SAGEConv, to_hetero
from torch_geometric.utils.convert import to_scipy_sparse_matrix
from torch_geometric.data import HeteroData

# Create synthetic reproductible data : 
np.random.seed(42)
#=======================#
DF_user = pd.DataFrame(np.random.randint(100, size=(3000, 4)), columns=list('ABCD'))
DF_user = DF_user.reset_index(names='ID_USER')
#=======================#

#=======================#
DF_item = pd.DataFrame(np.random.randint(100, size=(50, 7)), columns=['C1','C2','C3','C4','C5','C6','C7'])
DF_item = DF_item.reset_index(names='ID_ITEM')
#=======================#

#=======================#
random_numbers = np.random.randint(0, 101, 10)
random_user = np.random.choice(DF_user['ID_USER'], 10000)
random_item = np.random.choice(DF_item['ID_ITEM'], 10000)
df_transac = pd.DataFrame({'ID_USER': random_user, 'ID_ITEM': random_item, 'Amount': np.random.randint(10000)})
#=======================#

display(DF_user.head(3))
display(DF_item.head(3))
display(df_transac.head(3))

So you can note here i add some feature to the transactions with the amout

Converting the toys datasets to graph :

data = HeteroData()

#=============================#
data["user"].node_id = torch.arange(DF_user.shape[0])
data["user"].x = torch.from_numpy(DF_user[list('ABCD')].to_numpy())
#=============================#

#=============================#
data["item"].node_id = torch.arange(DF_item.shape[0])
data["item"].x = torch.from_numpy(DF_item[['C1','C2','C3','C4','C5','C6','C7']].to_numpy())
#=============================#

#=============================#
data['user', 'buy', 'item'].edge_index = torch.from_numpy(df_transac[['ID_USER','ID_ITEM']].values.T) # [2, nb_de_transactions]
''' I would like to try to use Amount in the embedding later, can't make the model working for now '''
''' data['user', 'buy', 'item'].edge_attr = torch.from_numpy(df_transac[['Amount']].values.T) # [2, nb_de_transactions] '''
#=============================#
#---------------------------------------------#
data = T.ToUndirected()(data) 
print(data)

print(data.has_isolated_nodes())
print(data.has_self_loops())
print(data.is_undirected()) 

Sampling

transform = T.RandomLinkSplit(
    num_val=0.1,
    num_test=0.1,
    disjoint_train_ratio=0.3,
    neg_sampling_ratio=3.0,
    add_negative_train_samples=False,
    edge_types=('user','buy','item'),
    rev_edge_types=('item','rev_buy','user'),)

train_data, val_data, test_data = transform(data)
edge_label_index = train_data["user", "buy", "item"].edge_label_index
edge_label = train_data["user", "buy", "item"].edge_label

Definition of the model

class GNN(torch.nn.Module):
    def __init__(self, hidden_channels, out_channels):
        super().__init__()
        self.conv1 = SAGEConv((-1,-1), hidden_channels)
        self.conv2 = SAGEConv(hidden_channels, out_channels)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index).relu()
        x = self.conv2(x, edge_index)
        return x

class EdgeDecoder(torch.nn.Module):
    def __init__(self):
        super().__init__()
     
    def forward(self, z_dict, edge_label_index):
        row, col = edge_label_index
        z_src = z_dict["user"][row]
        z_dst = z_dict["item"][col]
        
        return torch.sum(z_src * z_dst, dim=-1)

class Model(torch.nn.Module):
    def __init__(self, hidden_channels):
        super().__init__()
        self.encoder = GNN(hidden_channels, hidden_channels)
        self.encoder = to_hetero(self.encoder, data.metadata(), aggr='sum')
        self.decoder = EdgeDecoder()
        self.linear = torch.nn.Linear(hidden_channels, 2)
     
    def forward(self, x_dict, edge_index_dict ,edge_label_index):
        z_dict = self.encoder(x_dict,  edge_index_dict)
        return self.decoder(z_dict, edge_label_index)

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

model = Model(hidden_channels=32).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
loss_fn = torch.nn.BCELoss()

def train():
    model.train()
    optimizer.zero_grad()

    out = model(train_data.x_dict,
                train_data.edge_index_dict,
                train_data['user','buy','item'].edge_label_index,
    )
    loss = loss_function(out, train_data['user','buy','item'].edge_label)
    target = edge_label
    l = loss_fn (pred, target)
    l.backward()
    optimizer.step()
    
    return float(l)

@torch.no_grad()
def evaluate(data):
    model.eval()
    pred = model(data, data['user', 'buy', 'item'].edge_label_index).sigmoid()

    target = data['user', 'buy', 'item'].edge_label
    pred = torch.round(pred)
    l = esm(target,pred) """ not sure what esm is, my code doesn't work so far"""
    return l

epo_loss = []
all_res = pd.DataFrame()

for epoch in range(1, 6):
    loss = train()
    epo_loss.append(loss)
#     val_loss = evaluate(val_data)

    test_loss = evaluate(test_data)
    new_data = test_loss['scores'].to_frame().T
    all_res = pd.concat([all_res,new_data])

I'm getting over and over :

z_dict = self.encoder(x_dict, edge_index_dict) <--- Here i get the main issue is in the encoder part, during the forward process (In GNN class)
--> 11 conv1__item = self.conv1.user__buy__item((x__user, x__item), edge_index__user__buy__item)
return F.linear(x, self.weight, self.bias)

RuntimeError: expected m1 and m2 to have the same dtype, but got: long int != float

don't understand why i have some type issue, they all got the same type when i inspect the tensor i created, they have all the same type (For exemple data['user'].x.dtype)
i tried something like .to(torch.[specific_dtypes]) but it didn't resolve the issue
I'm trying to run an exemple to understand the working end-to-end and playing around then

Thanks for you help

Versions

PyG==2.5.0
Torch==2.1.2
Python==3.10