Graph signal processing for recommendation

[vicbeldo98]

Hello!

I am a student trying to learn all the ways that recommendation can be made through GNNs. For the moment, I have experimented with PyG and its made examples for recommendation.

I have seen another approach that uses the similarity of the items and the signals made by the users on those items to make a prediction of the rating of an item based on the signal. Example

My aim is to implement this approach in PyG. The problem is that I do not know how to handle the graph signals inside the convolutions (or if there is a way).

I have seen there is another library called Pytorch Geomtric Temporal (an extension of this one), but i am unsure if that is what i am looking for, as it seems to focus more on a temporal prediction.

Is there a way to achieve this behaviour on PyG, or PyGT is the solution? I would appreciate some clarification.
Thank you in advanced.

[rusty1s]

I am not that familiar with the LocalGNN approach mentioned in the blog, but I see no reason why we cannot replace that layer with any GNN layer from PyG. This indeed looks like a task better handled by PyG rather than PyG Temporal. If you let me know the issues you have in implementing the graph filter, I am happy to help out further.

[rusty1s]

Yes, this is equivalent. For aggr="sum", self.propagate(edge_index, x=x) will perform A @ X, where A is the sparse + binary adjacency matrix given in edge_index, and X is the node feature matrix of shape [num_nodes, num_features].

[vicbeldo98]

I did a small test and not getting the same results for some reason. Do you see something strange?

import numpy as np
from torch_geometric.nn import MessagePassing
import torch


x = torch.tensor(np.array([[5,3,2],[0,1,2],[0,5,1],[1,0,4]]).transpose())
edge_index = torch.tensor([[0,2,1,2],[2,0,2,1]])
edge_weights = torch.tensor([0.8, 0.8, 0.2, 0.2])

class MyConv(MessagePassing):
    def __init__(self):
        super().__init__(aggr='sum')

    def forward(self, x, edge_index):
        x = self.propagate(edge_index, x=x)
        return x

    def message(self, x_j):
        return x_j

conv = MyConv()
with torch.no_grad():
    new_x = conv(x, edge_index)
    print(new_x)

S = np.array([[0,0,0.8],[0,0,0.2],[0.8,0.2,0]])
print(np.matmul(S,x))

[rusty1s]

The results match once you incorporate edge_weight into the MessagePassing formulation as well:

import numpy as np
from torch_geometric.nn import MessagePassing
import torch

x = torch.tensor(
    np.array([[5, 3, 2], [0, 1, 2], [0, 5, 1], [1, 0, 4]]).transpose())
edge_index = torch.tensor([[0, 2, 1, 2], [2, 0, 2, 1]])
edge_weight = torch.tensor([0.8, 0.8, 0.2, 0.2])


class MyConv(MessagePassing):
    def __init__(self):
        super().__init__(aggr='sum')

    def forward(self, x, edge_index, edge_weight):
        x = self.propagate(edge_index, x=x, edge_weight=edge_weight)
        return x

    def message(self, x_j, edge_weight):
        return x_j * edge_weight.view(-1, 1)


conv = MyConv()
with torch.no_grad():
    new_x = conv(x, edge_index, edge_weight)
    print(new_x)

S = np.array([[0, 0, 0.8], [0, 0, 0.2], [0.8, 0.2, 0]])
print(np.matmul(S, x))

[vicbeldo98]

Okay, of course, my mind!
I finally have it working!

Here is what the model looks like (if you want to take a look):

class MyConv(MessagePassing):
    def __init__(self, in_features=1, out_features=64, K=5):
        super().__init__(aggr='add')
        self.K = K
        self.in_features = in_features
        self.out_features = out_features
        self.weight = torch.nn.Parameter(torch.Tensor(self.out_features, self.K, self.in_features))
        #TODO: ADD BIASself.bias = nn.parameter.Parameter(torch.Tensor(F, 1))
        self.reset_parameters()

    def reset_parameters(self):
        stdv = 1. / math.sqrt(self.in_features * self.K)
        self.weight.data.uniform_(-stdv, stdv)
        '''if self.bias is not None:
            self.bias.data.uniform_(-stdv, stdv)'''

    def forward(self, x, edge_index, edge_weight):
        # conv dimensions == B * F_in * K * N
        conv = x.permute(1, 0).reshape([-1, self.in_features, 1, N_movies])

        for k in range(1, self.K):
            x = self.propagate(edge_index, x=x, edge_weight=edge_weight)
            x_aux = x.permute(1, 0).reshape([-1, self.in_features, 1, N_movies])
            conv = torch.cat((conv, x_aux), dim=2)

        # Actually multiply by the parameters
        # Reshape conv must be KG x F ===> order to B x N_movies x K x in_features and  reshape to B x N x (K*in_features)
        reshaped_conv = conv.permute(0, 3, 2, 1).reshape([-1, N_movies, self.K*self.in_features])

        # h convert KG x F
        h = self.weight.reshape([self.out_features, self.K*self.in_features]).permute(1, 0)

        y = torch.matmul(reshaped_conv, h)
        return y

    def message(self, x_j, edge_weight):
        return x_j * edge_weight.view(-1, 1)


class Encoder(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = MyConv()

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


class Decoder(torch.nn.Module):
    def __init__(self, out_features=64, dim_readout=1):
        super().__init__()
        self.lin1 = Linear(out_features, dim_readout)

    def forward(self, z):
        z = self.lin1(z)
        z = z.reshape(-1, N_movies).permute(1,0)
        return z


class Model(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.encoder = Encoder()
        self.decoder = Decoder()

    def forward(self, x_dict, edge_index_dict, edge_label_index):
        y = self.encoder(x_dict, edge_index_dict, edge_label_index)
        z_dict = self.decoder(y)
        return z_dict

Basically, I am just doing the same as they are but using the propagate of PyG.
This is like doing a convolution on the signals.
My lowest RMSE arrives now to 0.97 (even though of coure this is just learning for one movie).
But this was what I wanted to mimic.

Thank you very much for all your help! Not only with code but also for helping me understand was was done!

[rusty1s]

Amazing :) Glad that this is finally working :)