MessagePassing.propagate only supports integer tensors of shape [2, num_messages], torch_sparse.SparseTensor or torch.sparse.Tensor for argument edge_index.

[Rexedoziem]

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import SAGEConv

class ProjectionLayer(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(ProjectionLayer, self).__init__()
        self.projection = nn.Linear(input_dim, output_dim)

    def forward(self, x, node_type):
        return self.projection(x)

class ModifiedGraphSAGE(nn.Module):
    def __init__(self, input_dims, hidden_dim, output_dim, num_layers):
        super(ModifiedGraphSAGE, self).__init__()
        self.input_projection = nn.ModuleDict({
            node_type: ProjectionLayer(input_dim, hidden_dim)
            for node_type, input_dim in input_dims.items()
        })
        self.conv_layers = nn.ModuleList([
            SAGEConv(hidden_dim, hidden_dim)
            for _ in range(num_layers)
        ])
        self.output_layer = SAGEConv(hidden_dim, output_dim)

    def forward(self, x, edge_index, edge_weight, node_types):
        x = {
            node_type: self.input_projection[node_type](feat, node_type)
            for node_type, feat in x.items()
        }

        for conv_layer in self.conv_layers:
            x = self.aggregate_and_update(conv_layer, x, edge_index, edge_weight, node_types)

        x = self.output_layer(x, edge_index, edge_weight=edge_weight)

        # Extract node embeddings for each node type
        user_embeddings = x['user']
        restaurant_embeddings = x['restaurant']
        category_embeddings = x['category']

        return user_embeddings, restaurant_embeddings, category_embeddings

    def aggregate_and_update(self, conv_layer, x, edge_index, edge_weight, node_types):
        updated_x = {}
        for node_type in x.keys():
            neighbors = self.get_neighbors(node_type, edge_index, node_types)
            aggregated = conv_layer(x[node_type], neighbors, edge_weight)
            updated_x[node_type] = aggregated
        return updated_x

    def get_neighbors(self, node_type, edge_index, node_types):
        reverse_types = {v: k for k, v in node_types.items()}
        source_node_type = reverse_types[node_type]
        neighbors = []
        for src, dst in zip(edge_index[0], edge_index[1]):
            if node_types[int(src.item())] == source_node_type:
                neighbors.append(True)
            else:
                neighbors.append(False)
        return neighbors

class HingeLossWithLowRankPositives(nn.Module):
    def __init__(self, margin_negative, margin_positive, alpha):
        super(HingeLossWithLowRankPositives, self).__init__()
        self.margin_negative = margin_negative
        self.margin_positive = margin_positive
        self.alpha = alpha

    def forward(self, user_embeddings, positive_item_embeddings, negative_item_embeddings, low_rank_positive_item_embeddings, positive_weights, low_rank_positive_weights):
        # Compute negative loss
        negative_scores = torch.sum(user_embeddings * negative_item_embeddings, dim=1)
        positive_scores = torch.sum(user_embeddings * positive_item_embeddings, dim=1)
        negative_loss = torch.mean(torch.clamp(self.margin_negative - positive_scores + negative_scores, min=0))

        # Compute low-rank positive loss
        low_rank_positive_scores = torch.sum(user_embeddings * low_rank_positive_item_embeddings, dim=1)
        positive_low_rank_scores = torch.sum(positive_item_embeddings * low_rank_positive_item_embeddings, dim=1)
        low_rank_positive_loss = torch.mean(positive_weights * torch.clamp(self.margin_positive - positive_scores + low_rank_positive_scores, min=0) + low_rank_positive_weights * torch.clamp(self.margin_positive - positive_low_rank_scores + low_rank_positive_scores, min=0))

        return self.alpha * negative_loss + (1 - self.alpha) * low_rank_positive_loss

# Assume you have a PyTorch Geometric HeteroData object 'data' with the following attributes:
# data.x: A dictionary mapping node types to their input features
# data.edge_index: Edge indices for the user-item and user-restaurant graphs
# data.edge_weight: Edge weights representing order frequencies and ratings
# data.node_types: A dictionary mapping node indices to their node types

input_dims = {
    'user': combined_data['user'].x.shape[1],
    'restaurant': combined_data['restaurant'].x.shape[1],
    'category': combined_data['category'].x.shape[1]
}

hidden_dim = 64
output_dim = 32
num_layers = 2

model = ModifiedGraphSAGE(input_dims, hidden_dim, output_dim, num_layers)
print(model)

x = combined_data.x_dict

# Concatenate edge indices for user-restaurant and user-category edges separately
user_restaurant_edge_index = combined_data[('user', 'to', 'restaurant')].edge_index
user_category_edge_index = combined_data[('user', 'to', 'category')].edge_index
# Concatenate the edge indices
edge_index = torch.cat([user_restaurant_edge_index, user_category_edge_index], dim=1)
print(f'edge index: {edge_index.shape}')
# Convert edge_weight to the correct format

user_category_edge_weight = combined_data[('user', 'to', 'category')].edge_weight

print("user_category_edge_weight shape:", user_category_edge_weight.shape)

# Concatenate the padded tensors along the 1st dimension
edge_weight = user_category_edge_weight

print("edge_weight shape:", edge_weight.shape)
# Create the node_types dictionary in the correct format
node_types = {}
start = 0
for node_type, features in x.items():
    end = start + features.shape[0]
    node_types.update({i: node_type for i in range(start, end)})
    start = end

# Get the node embeddings
user_embeddings, restaurant_embeddings, category_embeddings = model(x, edge_index, edge_weight, node_types)
print(user_embeddings)
print(restaurant_embeddings)
print(category_embeddings)

edge index: torch.Size([2, 7338])
user_category_edge_weight shape: torch.Size([3077])
edge_weight shape: torch.Size([3077])

I've tried debugging and checking where the issue is, but i just need help?.

[rusty1s]

It looks like you pass a boolean mask as edge_index to the GNN layer:

conv_layer(x[node_type], neighbors, edge_weight)

[Rexedoziem]

After turning it to tensors, but must the edge weight[3077] be compatible to the edge index [2, 7338] and should it have the same number of elements as the number of edges represented by the edge_index tensor?

[Rexedoziem]

And since it’s a heteroData, and Graphsage doesn’t support edge weight, should I also remove the weights in the Model? Or can it still be added?.

[rusty1s]

Yes, shapes of edge_weight and edge_index needs to match, e.g., edge_index has shape [2, num_edges] and edge_weight has shape [num_edges]. If you want to incorporate edge weights, you can use GraphConv instead of SAGEConv.