Modifying mnist_graclus.py for regression

[hkim716]

Hi Matt, I'm trying to modify mnist_graclus.py with my own dataset.
My train_dataset[0] looks like this : Data(edge_attr=[74, 2], edge_index=[2, 74], pos=[74, 2], x=[74, 1], y=[2])
The dataset has 2-dimensional y value (float 64) for regression task. All I changed is just loss function from F.softmax to F.mse_loss, but I got some error like this..

      1 for epoch in range(1, 5): # initial epoch = 31
----> 2     train(epoch)
      3     test_acc = test()
      4     print('Epoch: {:02d}, Test: {:.4f}'.format(epoch, test_acc))
     13         data = data.to(device)
     14         optimizer.zero_grad()
---> 15         F.mse_loss(model(data), data.y).backward()
     16         optimizer.step()
RuntimeError: The following operation failed in the TorchScript interpreter.
Traceback of TorchScript (most recent call last):
  File "/home/hkimlx/miniconda3/envs/gnb_df_pyg/lib/python3.7/site-packages/torch_spline_conv/weighting.py", line 8, in spline_weighting
                     basis: torch.Tensor,
                     weight_index: torch.Tensor) -> torch.Tensor:
    return torch.ops.torch_spline_conv.spline_weighting(
           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ <--- HERE
        x, weight, basis, weight_index)
RuntimeError: expected scalar type Double but found Float

I compared dtype of MNIST superpixel dataset with mine, but everything has the same dtype except y.

This is my code below. I don't know why I got errors when I changed the loss function. Could you help me?

def normalized_cut_2d(edge_index, pos):
    row, col = edge_index
    edge_attr = torch.norm(pos[row] - pos[col], p=2, dim=1)
    return normalized_cut(edge_index, edge_attr, num_nodes=pos.size(0))


class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = SplineConv(1, 32, dim=2, kernel_size=5) # d.num_features:=1=in_channels, 32: out_channels
        self.conv2 = SplineConv(32, 64, dim=2, kernel_size=5)
        self.fc1 = torch.nn.Linear(64, 128)
        self.fc2 = torch.nn.Linear(128, 2)

    def forward(self, data):
        data.x = F.elu(self.conv1(data.x, data.edge_index, data.edge_attr))
        weight = normalized_cut_2d(data.edge_index, data.pos)
        cluster = graclus(data.edge_index, weight, data.x.size(0))
        data.edge_attr = None
        data = max_pool(cluster, data, transform=transform)

        data.x = F.elu(self.conv2(data.x, data.edge_index, data.edge_attr))
        weight = normalized_cut_2d(data.edge_index, data.pos)
        cluster = graclus(data.edge_index, weight, data.x.size(0))
        x, batch = max_pool_x(cluster, data.x, data.batch)

        x = global_mean_pool(x, batch)
        x = F.elu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        return x

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Net().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

def train(epoch):
    model.train()

    if epoch == 16:
        for param_group in optimizer.param_groups:
            param_group['lr'] = 0.001

    if epoch == 26:
        for param_group in optimizer.param_groups:
            param_group['lr'] = 0.0001

    for data in train_loader:
        data = data.to(device)
        optimizer.zero_grad()
        F.mse_loss(model(data), data.y).backward()
        optimizer.step()
# .to(torch.float32)

def test():
    model.eval()
    correct = 0

    for data in test_loader:
        data = data.to(device)
#         pred = model(data).max(1)[1]
        pred = model(data)
#         correct += pred.eq(data.y).sum().item()
        correct += F.mse_loss(pred, data.y)
#     return correct / len(test_dataset)
    return correct

for epoch in range(1, 5): # initial epoch = 31
    train(epoch)
    test_acc = test()
    print('Epoch: {:02d}, Test: {:.4f}'.format(epoch, test_acc))

[rusty1s]

What happens when you cast data.y to torch.float? And does this error occur during forward or backward propagation?

[rusty1s]

Can you upload the edge_index tensor so I can have a look?

[hkim716]

I copied dataset[0] information here.
https://pastebin.com/Rj8EHEBR

My dataset has ~20,000 graphs, and they have the same edge_index and pos, but different x and y.

[rusty1s]

It looks like the graclus CUDA method has a problem when operating on directed graphs. I suggest to convert your graph to an undirected one first when using graclus, e.g.:

from torch_geometric.utils import to_undirected

edge_index = to_undirected(edge_index)

[hkim716]

Thanks Matt! Now graclus is working once I convert my graphs to undirected one.
I have some more questions about graclus algorithm though.

You said graclus selects a random node, and connects it to random neighbor with the highest edge weight (pseudo-coordinates) to form a cluster.
However, I cannot see any algorithm that compares weights in graclus_cluster method.
I saw weight is used as an input argument in graclus_cluster, but I'm not sure how graclus_cluster connects nodes to neighbor with highest edge weight.
According to graclus_cluster, it returns torch.ops.torch_cluster.graclus(rowptr, col, weight).
Where was torch.ops.torch_cluster.graclus(rowptr, col, weight) method defined? and what does rowptr mean? Does it cluster nodes iteratively (because graclus_cluster does not return index of clustering nodes, but another method)?

[rusty1s]

You can see here that we iterate over all neighbors and select the neighbor with the highest weight that is still unmatched. rowptr and col denote the CSR sparse representation of the underlying sparse matrix.