Create a TUDataset type of data

[riskiem]

I have the following graph:

f1 = np.random.randint(10, size=(31))
f2 = np.random.randint(10,20, size=(31))
f3 = np.random.randint(20,30, size=(31))
f_final = np.stack((f1,f2,f3), axis=1)
capital = 2*f1 + f2 - f3
f1_t = torch.from_numpy(f1)
f2_t = torch.from_numpy(f2)
f3_t =  torch.from_numpy(f3)
capital_t =  torch.Tensor(capital)      
capital_t = capital_t.type(torch.LongTensor)
x = torch.from_numpy(f_final)
x = x.type(torch.FloatTensor)
edge_index = edge_index = torch.tensor([[0,1],[0,5],[0,4],[1, 2],
                           [1,3],[1,4],[2,7],[2,6],[2,3],[3,6],[3,5],[4,5],
                           [5,9],[6,10],[6,8],[6,7],[6,11],[7,12],[3,8],[8,9],
                           [8,10],[8,14],[9,13],[9,10],[10,11],[12,4],[12,14],
                           [12,13],[9,13],[13,5],[14,4],[1,15],[4,15],
                           [3,15],[2,16],[5,16],[13,16],[17,9],[17,12],
                           [14,17],[2,18],[7,18],[11,18],[19,11],[19,12],
                           [19,10],[20,4],[20,5],[13,20],[15,21],[8,21],[21,6],[3,22],[4,22],[22,17],[5,22],[7,22],[14,22],[4,23],
                           [23,17],[15,23],[21,23],[19,24],[20,24],[4,24],[0,25],[3,25],[6,25],[7,25],[12,26],[15,26],[1,26],[4,27],[27,15],[27,12],[1,28],[28,5],[13,28],[5,29],[13,29],[28,29],[4,30],[25,30]], dtype=torch.long)
#edge_attr = torch.tensor([[5],[-5],[2],[-2],[3],[-3],[6],[-6],[3],[-3],[1],[-1],[4],[-4],[2],[-2],[7],
       ##                   [-7],[11],[-11],[12],[-12],[4],[-4],[3],[-3],[2],[-2],[5],[-5],[1],[-1],[2],[-2],[3],[-3],], dtype=torch.float)
edge_attr = torch.tensor([[1],[4],[3],[5],[2],[3],[7],[1],[3],[6],[1],[3],[2],[4],[2],[7],[6],[5],
                          [11],[7],[3],[7],[3],[4],[12],[2],[4],[5],[3],[1],[2],[3],[4],[7],[6],[15],[3],[5],[4],
                          [4],[6],[3],[5],[7],[7],[6],[9],[1],[7],[8],[6],[2],[5],[3],[1],[2],[3],[9],[5],[3],[4],[5],[6],[8],[2],[1],[5],[6],[1],[4],[2],[4],[7],[9],[5],[5],[3],[5],[6],[5],[4],[6],[7]],dtype=torch.float)
data = Data(x = x, edge_index = edge_index.t().contiguous(), y = capital_t, edge_attr=edge_attr )
print(data)

What I want to do is follow the same data generation process as the first few lines of the code, but create not just 1, but 1000 graphs. In essence something like the TUDataset which has 600 graphs. I am not sure how to go about this.

Any suugestions?

[rusty1s]

This will look something as follows:

class MyDataset(InMemoryDataset):
    def __init__(self, root, transform):
        super().__init__(root, transform)
        self.data, self.slices = torch.load(self.processed_paths[0])

    @property
    def processed_file_names(self) -> List[str]:
        return ['data.pt']

    def process(self):
        data_list = []
        for _ in range(1000):
            # Create the data objects just like you did above
            data_list.append(data)
        torch.save(self.collate(data_list), self.processed_paths[0])

[riskiem]

Thanks!.

To start off I did something simpler:

data_list = []
ngraphs = 500
for i in range(ngraphs):
      num_nodes = randint(10,500)
      num_edges = randint(10,num_nodes*(num_nodes - 1))
      f1 = np.random.randint(10, size=(num_nodes))
      f2 = np.random.randint(10,20, size=(num_nodes))
      f3 = np.random.randint(20,30, size=(num_nodes))
      f_final = np.stack((f1,f2,f3), axis=1)
      capital = 2*f1 + f2 - f3
      f1_t = torch.from_numpy(f1)
      f2_t = torch.from_numpy(f2)
      f3_t =  torch.from_numpy(f3)   
      capital_t =  torch.from_numpy(capital)
      capital_t = capital_t.type(torch.LongTensor)
      x = torch.from_numpy(f_final)
      x = x.type(torch.LongTensor)
      #edge_index = torch.randint(low=0, high=num_nodes, size=(2, num_edges), dtype=torch.long)
      edge_index = torch.randint(low=0, high=num_nodes, size=(num_edges,2), dtype=torch.long)
      edge_attr  = torch.randint(low=0, high=50, size=(num_edges,1), dtype=torch.long)
      data = Data(x = x, edge_index = edge_index.t().contiguous(), y = capital_t, edge_attr=edge_attr )
      data_list.append(data)

I then created a data loader for test and training sets:

from torch_geometric.data import DataLoader
test_dataset = data_list[:100]
train_dataset = data_list[100:]
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)

I then tried to use DeepGCN which I have been able to use successfully on a single graph:

import torch
from tqdm import tqdm
import torch.nn.functional as F
from torch.nn import Linear, LayerNorm, ReLU
from torch_scatter import scatter
from torch_geometric.nn import GENConv, DeepGCNLayer
from torch_geometric.data import RandomNodeSampler

class DeeperGCN(torch.nn.Module):
    def __init__(self, hidden_channels, num_layers):
        super(DeeperGCN, self).__init__()

        self.node_encoder = Linear(data.x.size(-1), hidden_channels)
        self.edge_encoder = Linear(data.edge_attr.size(-1), hidden_channels)

        self.layers = torch.nn.ModuleList()
        for i in range(1, num_layers + 1):
            conv = GENConv(hidden_channels, hidden_channels, aggr='softmax',
                           t=1.0, learn_t=True, num_layers=2, norm='layer')
            norm = LayerNorm(hidden_channels, elementwise_affine=True)
            act = ReLU(inplace=True)

            layer = DeepGCNLayer(conv, norm, act, block='res+', dropout=0.5,
                                 ckpt_grad=i % 3)
            self.layers.append(layer)

        self.lin = Linear(hidden_channels, 1)

    def forward(self, x, edge_index, edge_attr):
        x = self.node_encoder(x)
        edge_attr = self.edge_encoder(edge_attr)

        x = self.layers[0].conv(x, edge_index, edge_attr)

        for layer in self.layers[1:]:
            x = layer(x, edge_index, edge_attr)

        x = self.layers[0].act(self.layers[0].norm(x))
        

        return self.lin(x)

model = DeeperGCN(hidden_channels=64, num_layers=2)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
criterion = torch.nn.MSELoss()

I next try to train the network:

def train():
    model.train()

    total_loss = total_examples = 0
    for data in train_loader:
        optimizer.zero_grad()
        #data = data.to(device)
        out = model(data.x, data.edge_index, data.edge_attr)
        loss = criterion(out[data, data.y[data])
        loss.backward()
        optimizer.step()

        total_loss += float(loss) * int(data.train_mask.sum())
        total_examples += int(data.train_mask.sum())


    return total_loss / total_examples

for epoch in range(1, 500):
    loss = train()
    print(f'Loss: {loss:.4f}')

I keep getting the following error:

RuntimeError: expected scalar type Float but found Long

I am not sure what's wrong because while creating my dataset I used the data types as recommended in the pytorch geometric manuals.

[rusty1s]

I'm pretty sure this error stems from edge_attr being a LongTensor, while in practice it should be a valid floating point feature representation of its integer values. I think you should convert edge_attr to a one-hot-encoding first, e.g., edge_attr = torch.nn.functional.one_hot(edge_attr).to(torch.float)

[riskiem]

I see, I tried that. It causes some other issues:

data_list = []
ngraphs = 500
for i in range(ngraphs):
      num_nodes = randint(10,500)
      num_edges = randint(10,num_nodes*(num_nodes - 1))
      f1 = np.random.randint(10, size=(num_nodes))
      f2 = np.random.randint(10,20, size=(num_nodes))
      f3 = np.random.randint(20,30, size=(num_nodes))
      f_final = np.stack((f1,f2,f3), axis=1)
      capital = 2*f1 + f2 - f3
      f1_t = torch.from_numpy(f1)
      f2_t = torch.from_numpy(f2)
      f3_t =  torch.from_numpy(f3)   
      capital_t =  torch.from_numpy(capital)
      capital_t = capital_t.type(torch.LongTensor)
      x = torch.from_numpy(f_final)
      x = x.type(torch.LongTensor)
      #edge_index = torch.randint(low=0, high=num_nodes, size=(2, num_edges), dtype=torch.long)
      edge_index = torch.randint(low=0, high=num_nodes, size=(num_edges,2), dtype=torch.long)
      edge_attr  = torch.randint(low=0, high=50, size=(num_edges,1), dtype=torch.long)
      edge_attr = torch.nn.functional.one_hot(edge_attr).to(torch.float)
      data = Data(x = x, edge_index = edge_index.t().contiguous(), y = capital_t, edge_attr=edge_attr )
      data_list.append(data)

Gives the following error:

torch.cat(): Sizes of tensors must match except in dimension 0. Got 50 and 48 in dimension 2 (The offending index is 48)

[rusty1s]

Try to set the num_classes=50 argument of the one_hot function.

[rusty1s]

Is this issue resolved?