Trying to assign y to dataset

[anthonysirico]

Here is the code:

from abc import ABC
from tqdm import tqdm
import pandas as pd
import torch
from torch_geometric.data import InMemoryDataset
from torch_geometric.utils import from_networkx
import networkx as nx
from sklearn.preprocessing import LabelEncoder
from scipy.io import loadmat
import numpy as np
from PCA import CreatePCA


def _get_node_features(networkx_graph, encoded_node_features):
    harmonic = list(nx.harmonic_centrality(networkx_graph).values())
    features = dict(enumerate(zip(encoded_node_features, harmonic)))
    nx.set_node_attributes(networkx_graph, features, 'feature')
    return networkx_graph


def _get_graph_features(A):
    eigenvalues = np.linalg.eigvals(A)
    largest_eigenvalue = np.max(np.abs(eigenvalues))

    return torch.tensor(largest_eigenvalue, dtype=torch.float32)


class TMSDataset(InMemoryDataset, ABC):
    def __init__(self, root, transform=None, pre_transform=None, pre_filter=None):
        super(TMSDataset, self).__init__(root, transform, pre_transform, pre_filter)
        self.data, self.slices = torch.load(self.processed_paths[0])

    def raw_file_names(self):
        return ['latest_data.mat']

    def processed_file_names(self):
        return 'tms_graphs.pt'

    def download(self):
        pass

    def process(self):
        global y
        tms_graphs = []

        raw_data = loadmat(self.raw_paths[0], squeeze_me=True)
        graph_data = pd.DataFrame(raw_data['python_graph_data'])
        node_features = graph_data['nl']
        encoder = LabelEncoder()
        encoded_node_features = node_features.apply(encoder.fit_transform)

        for index in tqdm(range(len(graph_data))):
            nx_graph = nx.DiGraph(graph_data['A'][index])
            nx_graph = _get_node_features(nx_graph, encoded_node_features[index])
            pyg = from_networkx(nx_graph, group_node_attrs=['feature'])
            pyg.index = index
            # pyg.graph_features = _get_graph_features(graph_data['A'][index])
            pyg.compile = torch.tensor(graph_data['comp'][index], dtype=torch.long)
            pyg.simulate = torch.tensor(graph_data['sim'][index], dtype=torch.long)
            pyg.catalog = torch.tensor(graph_data['CatalogCodeIndex'][index], dtype=torch.long)
            pyg.obj = torch.tensor(graph_data['bestObj'][index], dtype=torch.float32)

            pyg.y = None
            print(f"Index: {index}, Compile: {graph_data['comp'][index]}, Simulate: {graph_data['sim'][index]}")

            if graph_data['comp'][index] == 0:  # Does not compile
                y = [1, 0, 1, 0]
            elif graph_data['comp'][index] == 1 and graph_data['sim'][index] == 0:  # Compiles but does not simulate
                y = [0, 1, 1, 0]
            elif graph_data['comp'][index] == 1 and graph_data['sim'][index] == 1:  # Compiles and simulates
                y = [0, 0, 1, 1]

            print(f"y for index {index}: {y}")
            pyg.y = torch.tensor(y, dtype=torch.float32).reshape(1, -1)
            print(f"y for index {index}: {pyg.y}")  # Verify y is set as expected

            tms_graphs.append(pyg)

        principle_components = CreatePCA(tms_graphs, 2)
        principle_components = principle_components.process_principle_components()

        for i in range(len(tms_graphs)):
            tms_graphs[i].graph_features = torch.tensor(principle_components.iloc[i].values,
                                                        dtype=torch.float32).unsqueeze(0)

        if self.pre_filter is not None:
            tms_graphs = [graph for graph in tms_graphs if self.pre_filter(graph)]

        if self.pre_transform is not None:
            tms_graphs = [self.pre_transform(graph) for graph in tms_graphs]

        torch.save(self.collate(tms_graphs), self.processed_paths[0])

But when I create the dataset, dataset.data.y and dataset[I].y is no where to be found. What am I doing wrong?

[anthonysirico]

UPDATE: I checked and rechecked the code using print statements, the if statements are working, y is being created properly, by pyg.y is not being assigned properly.

[anthonysirico]

UPDATE: It would not take the y value. I changed it to graph_label and it worked. Why is that?

[rusty1s]

Mh, does that have to do something with global y? I tried to reproduce this but it worked totally fine:

import torch

from torch_geometric.data import Data, InMemoryDataset


class TMSDataset(InMemoryDataset):
    def __init__(self, root):
        super().__init__(root)
        self.load(self.processed_paths[0])

    def processed_file_names(self):
        return 'data.pt'

    def process(self):
        graphs = []
        for _ in range(10):
            pyg = Data()
            pyg.y = torch.randn(1, 10)
            graphs.append(pyg)

        torch.save(self.collate(graphs), self.processed_paths[0])


dataset = TMSDataset('./data')
print(dataset.data.y)
print(dataset[0].y)