Using SplineConv: tensor does not have a device

[mkl-joseph]

I'm trying to implement SplineConv for a project and am getting the following error when trying to train my model:

RuntimeError: The following operation failed in the TorchScript interpreter.
Traceback of TorchScript (most recent call last):
  File "/home/mikl7684/venv_6084/lib/python3.8/site-packages/torch_spline_conv/basis.py", line 12, in spline_basis
    return torch.ops.torch_spline_conv.spline_basis(pseudo, kernel_size,
           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ <--- HERE
                                                    is_open_spline, degree)
RuntimeError: tensor does not have a device

I'm not sure what spline_basis is doing, but it looks like pseudo is the tensor that isn't cuda. All of my training data is cuda so I'm not sure where the error is coming from.

For reference, here is my model:

class Net(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super().__init__()
        self.conv1 = SplineConv(in_channels, hidden_channels, kernel_size=5, dim=3, aggr='add')
        self.conv2 = SplineConv(hidden_channels, hidden_channels, kernel_size=5, dim=3, aggr='add')
        self.conv3 = SplineConv(hidden_channels, hidden_channels, kernel_size=5, dim=3, aggr='add')
        self.conv4 = SplineConv(hidden_channels, hidden_channels, kernel_size=5, dim=3, aggr='add')
        self.conv5 = SplineConv(hidden_channels, hidden_channels, kernel_size=5, dim=3, aggr='add')
        self.conv6 = SplineConv(hidden_channels, hidden_channels, kernel_size=5, dim=3, aggr='add')
        self.mlp = MLP([hidden_channels * 2, out_channels], act=None)

    def forward(self, data):
        src, dst = data.edge_index
        # Use relu activation for hidden layers
        x = torch.relu(self.conv1(data.x, data.edge_index))
        x = torch.relu(self.conv2(x, data.edge_index))
        x = torch.relu(self.conv3(x, data.edge_index))
        x = torch.relu(self.conv4(x, data.edge_index))
        x = torch.relu(self.conv5(x, data.edge_index))
        x = torch.relu(self.conv6(x, data.edge_index))
        edge_attr = torch.cat([x[src], x[dst]], dim=-1)  # Generate edge embedding
        return self.mlp(edge_attr)

Any help is appreciated!

[rusty1s]

Do you have an example to reproduce? Do the SplineConv examples in the examples/ folder work for you?

[mkl-joseph]

I just ran cora.py and it seems to work.

I have inspected all of my data during training and all the tensors have cuda as the device. Sending my data to cuda in

Here is what I am doing prior to training with my data:

model = Net(num_node_features, 64, num_edge_features).to(device)
# model = Net(num_node_features, 64, num_edge_features)
optimizer = torch.optim.Adam(params=model.parameters(), lr=0.001)
criterion = torch.nn.BCEWithLogitsLoss()


# Model training:
def train(data):
    model.train()
    optimizer.zero_grad()
    out = model.forward(data)
    loss = criterion(out, data.edge_attr
    loss.backward()
    optimizer.step()
    return float(loss)

epoch_history = []
for epoch in range(1, 201):
    running_loss = 0
    for i, data in enumerate(loader):
        data = data.to(device)
        print('Training batch {}'.format(i + 1))
        loss = train(data)
        running_loss += loss
    epoch_history.append(running_loss)

    print('Epoch {:03d}, Loss {:0.5f}'.format(epoch, running_loss))
    print('---------------------------------------')

[rusty1s]

Looks like you are missing a data.edge_attr which is a requirement for SplineConv.

[mkl-joseph]

So the layers should have an input like this?

    def forward(self, data):
        src, dst = data.edge_index
        # Use relu activation for hidden layers
        x = torch.relu(self.conv1(data.x, data.edge_index, data.edge_attr))
        x = torch.relu(self.conv2(x, data.edge_index, data.edge_attr))
        x = torch.relu(self.conv3(x, data.edge_index, data.edge_attr))
        x = torch.relu(self.conv4(x, data.edge_index, data.edge_attr))
        x = torch.relu(self.conv5(x, data.edge_index, data.edge_attr))
        x = torch.relu(self.conv6(x, data.edge_index, data.edge_attr))
        edge_attr = torch.cat([x[src], x[dst]], dim=-1)  # Generate edge embedding
        # Use sigmoid activation for output layer
        return self.mlp(edge_attr)

[mkl-joseph]

This worked! Thanks for your help.

[Xiamu-ssr]

Oh, hi. I had the same problem. I'm also working with the cora dataset, but I'm just curious that the edge_attr that introduces SplineConv on PyG is optional. So, is it necessary or not?

[rusty1s]

It is necessary. It is just marked as optional in the type hints to support both (edge_index, edge_attr) tensor format and SparseTensor within the same function signature.