Autoencoder loss, AUC frozen - possible issue with custom data object creation

[ccciara]

Hello! I'm new to PyG and enjoying it very much, however I have run into an issue creating a data object that I just can't seem to figure out. I'm trying to use Graph Autoencoder on a custom PyG Data object, but when I attempt to train it, the loss, AUC and AP do not change. The exact same autoencoder works when using PyG's example data objects (Cora, etc), so I think I am making an error somewhere in the process of creating my custom data object. I used data from Geoff Boeing's street network node/edge lists, specifically from Aberdeen in this example. Here's the process of making my data object consisting of node features (xy coords) and edge index (source and destination nodes) from node and edge csv's (already converted to dfs nodes_ab and edges_ab).

Create custom data object

node_features = nodes_ab[['x', 'y']].values
node_features = torch.tensor(node_features, dtype=torch.float)

edge_index = edges_ab[['source', 'dest']].values.T
edge_index = torch.tensor(edge_index, dtype=torch.long)

data = Data(x=node_features, edge_index=edge_index)

Data splitting, adding positive and negative edges for autoencoder

transform = T.RandomLinkSplit(num_val=0.05,
                              num_test=0.1,
                              is_undirected=True,
                              add_negative_train_samples=True)
train_data, val_data, test_data = transform(data)

def get_pos_neg_edges(data):
    pos_edge_index = data.edge_label_index[:, data.edge_label == 1]
    neg_edge_index = data.edge_label_index[:, data.edge_label == 0]
    return pos_edge_index, neg_edge_index

train_pos_edge_index, train_neg_edge_index = get_pos_neg_edges(train_data)
val_pos_edge_index, val_neg_edge_index = get_pos_neg_edges(val_data)
test_pos_edge_index, test_neg_edge_index = get_pos_neg_edges(test_data)

data.train_pos_edge_index = train_pos_edge_index
data.train_neg_edge_index = train_neg_edge_index
data.val_pos_edge_index = val_pos_edge_index
data.val_neg_edge_index = val_neg_edge_index
data.test_pos_edge_index = test_pos_edge_index
data.test_neg_edge_index = test_neg_edge_index

Creating and running autoencoder

class GCNEncoder(torch.nn.Module):
    def __init__(self, in_channels, out_channels):
        super(GCNEncoder, self).__init__()
        self.conv1 = GCNConv(in_channels, 2 * out_channels, cached=True) # cached only for transductive learning
        self.conv2 = GCNConv(2 * out_channels, out_channels, cached=True) # cached only for transductive learning

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

Parameters

out_channels = 2
num_features = data.num_features
epochs = 100

model = GAE(GCNEncoder(num_features, out_channels))

Set up environment

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
x = data.x.to(device)
train_pos_edge_index = data.train_pos_edge_index.to(device)

Initialize the optimizer

optimizer = torch.optim.Adam(model.parameters(), lr=0.03)

Set up and run the encoder

def train():
    model.train()
    optimizer.zero_grad()
    z = model.encode(x, train_pos_edge_index)
    loss = model.recon_loss(z, train_pos_edge_index)
    loss.backward()
    optimizer.step()
    print(f"Training loss: {loss.item()}")
    return float(loss)

def test(pos_edge_index, neg_edge_index):
    model.eval()
    with torch.no_grad():
        z = model.encode(x, train_pos_edge_index)
    auc, ap = model.test(z, pos_edge_index, neg_edge_index)
    return auc, ap

for epoch in range(1, epochs + 1):
    loss = train()

auc, ap = test(data.test_pos_edge_index, data.test_neg_edge_index)
print('Epoch: {:03d}, AUC: {:.4f}, AP: {:.4f}\n _________________________'.format(epoch, auc, ap))

Sorry for the massive code wall! I don't know where the issue is occurring so wanted to include everything. Here is the output from running this.

Training loss: 34.538780212402344 Epoch: 001, AUC: 0.5000, AP: 0.5000

Training loss: 34.538780212402344 Epoch: 002, AUC: 0.5000, AP: 0.5000

Training loss: 34.538780212402344 Epoch: 003, AUC: 0.5000, AP: 0.5000

Etc etc, for 100 epochs.

I've tried incorporating node labels (y), using dummy variables for the node features, using node index for node labels, relabeling the index numbers, and adjusting the learning rate and optimizer. I am still running into the same issue. I found two other people who experienced this here, but their issues were solved after incorporating (non-index) node features, which hasn't worked for me. Thanks in advance and let me know if I was unclear or more info is needed.

[rusty1s]

Can you try to replace GCNConv with SAGEConv?