Model with simple heterodata throws IndexError

[tristen-tooming]

Pytorch-geometric: 2.0.5

With data:

data: HeteroData(
  machine_0={ x=[1] },
  machine_1={ x=[1] },
  machine_2={ x=[1] },
  (machine_0, edge_0, machine_1)={ edge_index=[2, 1] },
  (machine_1, edge_1, machine_2)={ edge_index=[2, 1] },
  (machine_1, rev_edge_0, machine_0)={ edge_index=[2, 1] },
  (machine_2, rev_edge_1, machine_1)={ edge_index=[2, 1] }
)
edge_index_dict: {
  ('machine_0', 'edge_0', 'machine_1'): tensor([[0], [1]]),
  ('machine_1', 'edge_1', 'machine_2'): tensor([[1], [2]]),
  ('machine_1', 'rev_edge_0', 'machine_0'): tensor([[1], [0]]),
  ('machine_2', 'rev_edge_1', 'machine_1'): tensor([[2], [1]])}

and model defined as:

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

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

model = GNN(hidden_channels=32, out_channels=1)
model = to_hetero(model, data.metadata(), aggr='sum')
data, model = data.to(device), model.to(device)

with torch.no_grad():  # Initialize lazy modules.
    out = model(data.x_dict, data.edge_index_dict)

the code produces an IndexError in line out = model(data.x_dict, data.edge_index_dict):

[/usr/local/lib/python3.7/dist-packages/torch/fx/graph_module.py](https://localhost:8080/#) in wrapped_call(self, *args, **kwargs)
    614                     print(generate_error_message(topmost_framesummary),
    615                           file=sys.stderr)
--> 616                 raise e.with_traceback(None)
    617 
    618         cls.__call__ = wrapped_call

IndexError: Dimension out of range (expected to be in range of [-1, 0], but got -2)

The scenario is simple but I don't have a clue why the error is thrown. Could you help a bit to to get the out-value?

[rusty1s]

Can you convert your node features to be two-dimensional ([num_nodes, num_features])? For example, via:

data['machine_0'].x = data['machine_0'].x.view(1, 1)
data['machine_1'].x = data['machine_1'].x.view(1, 1)
data['machine_2'].x = data['machine_2'].x.view(1, 1)

[tristen-tooming]

It results a RuntimeError: index 1 is out of bounds for dimension 0 with size 1

The data is generated as:

from torch_geometric.data import HeteroData
import torch_geometric.transforms as T

n_nodes = 3
data = HeteroData()

for node in range(n_nodes): # Random features
    data[f'machine_{node}'].x = torch.randn(1).view(1, 1)

for edge in range(n_nodes - 1):
    data[f'machine_{edge}', f'edge_{edge}', f'machine_{edge + 1}'].edge_index = torch.tensor([[edge], [edge + 1]], dtype=torch.long)

data = T.ToUndirected()(data)

Also also tried to generate edge_indexas:

data[f'machine_{edge}', f'edge_{edge}', f'machine_{edge + 1}'].edge_index = torch.tensor([[edge, edge + 1], [edge + 1, edge]], dtype=torch.long)

resulting [2, 2] edge_index per node and after data = T.ToUndirected()(data) the edge_index_dict looks like:

{('machine_0', 'edge_0', 'machine_1'): tensor([[0, 1], [1, 0]]),
 ('machine_1', 'edge_1', 'machine_2'): tensor([[1, 2], [2, 1]]),
 ('machine_1', 'rev_edge_0', 'machine_0'): tensor([[1, 0], [0, 1]]),
 ('machine_2', 'rev_edge_1', 'machine_1'): tensor([[2, 1], [1, 2]])}

Is this supposed behaviour or should it raise error: "already as undirected" and does this mess up the message passing step as reversed edge and edge are both defined as undirected?

and by not calling data = T.ToUndirected()(data) the edge_index_dict looks like:

{('machine_0', 'edge_0', 'machine_1'): tensor([[0, 1], [1, 0]]),
 ('machine_1', 'edge_1', 'machine_2'): tensor([[1, 2], [2, 1]])}

which raises NotImplementedError in to_hetero(model, data.metadata(), aggr='sum')

Is there a method to generate the reversed edges in an undirected graph? Something like data = T.IncludeRevEdges()()data? I suppose it is on the way as to_hetero raises NotImplementedError.

[rusty1s]

I see, the issue is that edge_index runs out of bounds. In particular, the following must hold:

for edge_type in data.edge_types:
    src, _, dst = edge_type
    assert data[edge_type].edge_index[0].max() < data[src].num_nodes
    assert data[edge_type].edge_index[1].max() < data[dst].num_nodes

This is fixable by generating edge_index via:

for edge in range(n_nodes - 1):
    data[f'machine_{edge}', f'edge_{edge}',
         f'machine_{edge + 1}'].edge_index = torch.tensor([[0], [0]],
                                                          dtype=torch.long)

Note that edge_index connects local indices inside each node type (rather than global indices across all node types).

[tristen-tooming]

Thanks for the clarification!