diff --git a/configs/datasets/QM9.yaml b/configs/datasets/QM9.yaml new file mode 100644 index 00000000..55f2c51b --- /dev/null +++ b/configs/datasets/QM9.yaml @@ -0,0 +1,14 @@ +data_domain: graph +data_type: QM9 +data_name: QM9 +data_dir: datasets/${data_domain}/${data_type} +#data_split_dir: ${oc.env:PROJECT_ROOT}/datasets/data_splits/${data_name} + +# Dataset parameters +num_features: 11 +num_classes: 1 +task: regression +loss_type: mse +monitor_metric: mae +task_level: graph + diff --git a/configs/datasets/UniProt.yaml b/configs/datasets/UniProt.yaml new file mode 100644 index 00000000..f55c51d9 --- /dev/null +++ b/configs/datasets/UniProt.yaml @@ -0,0 +1,22 @@ +data_domain: graph +data_type: UniProt +data_name: UniProt +data_dir: datasets/${data_domain}/${data_type} +#data_split_dir: ${oc.env:PROJECT_ROOT}/datasets/data_splits/${data_name} + +# Some parameters to do the query +query: "length:[95 TO 155]" # number of residues per protein +format: "tsv" +fields: "accession,length" +size: 100 # number of proteins to load + +threshold: 6.0 # distance between proteins to create the initial graph + +# Dataset parameters +num_features: 20 +num_classes: 1 +task: regression +loss_type: mse +monitor_metric: mae +task_level: graph + diff --git a/configs/datasets/manual_prot.yaml b/configs/datasets/manual_prot.yaml new file mode 100755 index 00000000..67e0c9d0 --- /dev/null +++ b/configs/datasets/manual_prot.yaml @@ -0,0 +1,12 @@ +data_domain: graph +data_type: toy_dataset +data_name: manual_prot +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +num_features: 1 +num_classes: 2 +task: classification +loss_type: cross_entropy +monitor_metric: accuracy +task_level: node diff --git a/configs/transforms/liftings/graph2hypergraph/close_lifting.yaml b/configs/transforms/liftings/graph2hypergraph/close_lifting.yaml new file mode 100755 index 00000000..eccc66bd --- /dev/null +++ b/configs/transforms/liftings/graph2hypergraph/close_lifting.yaml @@ -0,0 +1,5 @@ +transform_type: 'lifting' +transform_name: "HypergraphCloseLifting" +feature_lifting: ProjectionSum + +distance: 6.0 diff --git a/loaders.py b/loaders.py new file mode 100755 index 00000000..b40b3ba0 --- /dev/null +++ b/loaders.py @@ -0,0 +1,227 @@ +import os + +import numpy as np +import rootutils +import torch_geometric +from omegaconf import DictConfig + +# silent RDKit warnings +from rdkit import Chem, RDLogger + +from modules.data.load.base import AbstractLoader +from modules.data.utils.concat2geometric_dataset import ConcatToGeometricDataset +from modules.data.utils.custom_dataset import CustomDataset +from modules.data.utils.utils import ( + load_cell_complex_dataset, + load_hypergraph_pickle_dataset, + load_manual_graph, + load_simplicial_dataset, +) + +RDLogger.DisableLog("rdApp.*") + + +class GraphLoader(AbstractLoader): + r"""Loader for graph datasets. + + Parameters + ---------- + parameters : DictConfig + Configuration parameters. + """ + + def __init__(self, parameters: DictConfig): + super().__init__(parameters) + self.parameters = parameters + + def is_valid_smiles(self, smiles): + """Check if a SMILES string is valid using RDKit.""" + mol = Chem.MolFromSmiles(smiles) + return mol is not None + + def filter_qm9_dataset(self, dataset): + """Filter the QM9 dataset to remove invalid SMILES strings.""" + return [data for data in dataset if self.is_valid_smiles(data.smiles)] + + def load(self) -> torch_geometric.data.Dataset: + r"""Load graph dataset. + + Parameters + ---------- + None + + Returns + ------- + torch_geometric.data.Dataset + torch_geometric.data.Dataset object containing the loaded data. + """ + # Define the path to the data directory + root_folder = rootutils.find_root() + root_data_dir = os.path.join(root_folder, self.parameters["data_dir"]) + + self.data_dir = os.path.join(root_data_dir, self.parameters["data_name"]) + if ( + self.parameters.data_name.lower() in ["cora", "citeseer", "pubmed"] + and self.parameters.data_type == "cocitation" + ): + dataset = torch_geometric.datasets.Planetoid( + root=root_data_dir, + name=self.parameters["data_name"], + ) + + elif self.parameters.data_name in [ + "MUTAG", + "ENZYMES", + "PROTEINS", + "COLLAB", + "IMDB-BINARY", + "IMDB-MULTI", + "REDDIT-BINARY", + "NCI1", + "NCI109", + ]: + dataset = torch_geometric.datasets.TUDataset( + root=root_data_dir, + name=self.parameters["data_name"], + use_node_attr=False, + ) + + elif self.parameters.data_name in ["ZINC", "AQSOL"]: + datasets = [] + for split in ["train", "val", "test"]: + if self.parameters.data_name == "ZINC": + datasets.append( + torch_geometric.datasets.ZINC( + root=root_data_dir, + subset=True, + split=split, + ) + ) + elif self.parameters.data_name == "AQSOL": + datasets.append( + torch_geometric.datasets.AQSOL( + root=root_data_dir, + split=split, + ) + ) + # The splits are predefined + # Extract and prepare split_idx + split_idx = {"train": np.arange(len(datasets[0]))} + split_idx["valid"] = np.arange( + len(datasets[0]), len(datasets[0]) + len(datasets[1]) + ) + split_idx["test"] = np.arange( + len(datasets[0]) + len(datasets[1]), + len(datasets[0]) + len(datasets[1]) + len(datasets[2]), + ) + # Join dataset to process it + dataset = datasets[0] + datasets[1] + datasets[2] + dataset = ConcatToGeometricDataset(dataset) + + elif self.parameters.data_name == "QM9": + dataset = torch_geometric.datasets.QM9(root=root_data_dir) + # Filter the QM9 dataset to remove invalid SMILES strings + valid_dataset = self.filter_qm9_dataset(dataset) + # dataset = ConcatToGeometricDataset(valid_dataset) + dataset = CustomDataset(valid_dataset, self.data_dir) + + elif self.parameters.data_name in ["manual"]: + data = load_manual_graph() + dataset = CustomDataset([data], self.data_dir) + + else: + raise NotImplementedError( + f"Dataset {self.parameters.data_name} not implemented" + ) + + return dataset + + +class CellComplexLoader(AbstractLoader): + r"""Loader for cell complex datasets. + + Parameters + ---------- + parameters : DictConfig + Configuration parameters. + """ + + def __init__(self, parameters: DictConfig): + super().__init__(parameters) + self.parameters = parameters + + def load( + self, + ) -> torch_geometric.data.Dataset: + r"""Load cell complex dataset. + + Parameters + ---------- + None + + Returns + ------- + torch_geometric.data.Dataset + torch_geometric.data.Dataset object containing the loaded data. + """ + return load_cell_complex_dataset(self.parameters) + + +class SimplicialLoader(AbstractLoader): + r"""Loader for simplicial datasets. + + Parameters + ---------- + parameters : DictConfig + Configuration parameters. + """ + + def __init__(self, parameters: DictConfig): + super().__init__(parameters) + self.parameters = parameters + + def load( + self, + ) -> torch_geometric.data.Dataset: + r"""Load simplicial dataset. + + Parameters + ---------- + None + + Returns + ------- + torch_geometric.data.Dataset + torch_geometric.data.Dataset object containing the loaded data. + """ + return load_simplicial_dataset(self.parameters) + + +class HypergraphLoader(AbstractLoader): + r"""Loader for hypergraph datasets. + + Parameters + ---------- + parameters : DictConfig + Configuration parameters. + """ + + def __init__(self, parameters: DictConfig): + super().__init__(parameters) + self.parameters = parameters + + def load( + self, + ) -> torch_geometric.data.Dataset: + r"""Load hypergraph dataset. + + Parameters + ---------- + None + + Returns + ------- + torch_geometric.data.Dataset + torch_geometric.data.Dataset object containing the loaded data. + """ + return load_hypergraph_pickle_dataset(self.parameters) diff --git a/modules/data/load/loaders.py b/modules/data/load/loaders.py index 8ccafb11..cba2f903 100755 --- a/modules/data/load/loaders.py +++ b/modules/data/load/loaders.py @@ -1,8 +1,13 @@ import os +import random +import networkx as nx import numpy as np +import requests import rootutils +import torch import torch_geometric +from Bio import PDB from omegaconf import DictConfig from modules.data.load.base import AbstractLoader @@ -12,6 +17,7 @@ load_cell_complex_dataset, load_hypergraph_pickle_dataset, load_manual_graph, + load_manual_prot, load_simplicial_dataset, ) @@ -29,6 +35,347 @@ def __init__(self, parameters: DictConfig): super().__init__(parameters) self.parameters = parameters + ####################################################################### + ############## Auxiliar functions for loading UniProt data ############ + ####################################################################### + + def fetch_uniprot_ids(self) -> list[dict]: + r"""Fetch UniProt IDs by its API under the parameters specified in the configuration file.""" + query_url = "https://rest.uniprot.org/uniprotkb/search" + params = { + "query": self.parameters.query, + "format": self.parameters.format, + "fields": self.parameters.fields, + "size": self.parameters.size + } + + response = requests.get(query_url, params=params) + if response.status_code != 200: + print(f"Failed to fetch data from UniProt. Status code: {response.status_code}") + return [] + + data = response.text.strip().split("\n")[1:] + proteins = [{"uniprot_id": row.split("\t")[0], "sequence_length": int(row.split("\t")[1])} for row in data] + + # Ensure we have at least the required proteins to sample from + if len(proteins) >= self.parameters.size: + sampled_proteins = random.sample(proteins, self.parameters.size) + else: + print(f"Only found {len(proteins)} proteins within the specified length range. Returning all available proteins.") + sampled_proteins = proteins + + # save sampled proteins to a csv file + # create directory if not exist + os.makedirs(self.data_dir, exist_ok=True) + with open(self.data_dir + "/uniprot_ids.csv", "w") as file: + for protein in sampled_proteins: + file.write(f"{protein}\n") + + return sampled_proteins + + def fetch_protein_mass( + self, uniprot_id : str + ) -> float: + r"""Returns the mass of a protein given its UniProt ID. + This will be used as our target variable. + + Parameters + ---------- + uniprot_id : str + The UniProt ID of the protein. + + Returns + ------- + float + The mass of the protein. + """ + url = f"https://www.ebi.ac.uk/proteins/api/proteins/{uniprot_id}" + response = requests.get(url, headers={"Accept": "application/json"}) + if response.status_code == 200: + data = response.json() + return data.get("sequence", {}).get("mass") + return None + + def fetch_alphafold_structure( + self, uniprot_id : str + ) -> str: + r"""Fetches the AlphaFold structure for a given UniProt ID. + Not all the proteins have a structure available. + This ones will be descarded. + + Parameters + ---------- + uniprot_id : str + The UniProt ID of the protein. + + Returns + ------- + str + The path to the downloaded PDB file. + """ + pdb_dir = self.data_dir + "/pdbs" + os.makedirs(pdb_dir, exist_ok=True) + file_path = os.path.join(pdb_dir, f"{uniprot_id}.pdb") + + if os.path.exists(file_path): + print(f"PDB file for {uniprot_id} already exists.") + else: + url = f"https://alphafold.ebi.ac.uk/files/AF-{uniprot_id}-F1-model_v4.pdb" + response = requests.get(url) + if response.status_code == 200: + with open(file_path, "w") as file: + file.write(response.text) + print(f"PDB file for {uniprot_id} downloaded successfully.") + else: + print(f"Failed to fetch the structure for {uniprot_id}. Status code: {response.status_code}") + return None + return file_path + + def parse_pdb( + self, file_path : str + ) -> PDB.Structure: + r"""Parse a PDB file and return a BioPython structure object. + + Parameters + ---------- + file_path : str + The path to the PDB file. + + Returns + ------- + PDB.Structure + The BioPython structure object. + """ + + return PDB.PDBParser(QUIET=True).get_structure("alphafold_structure", file_path) + + def residue_mapping( + self, uniprot_ids : list[str] + ) -> dict: + r"""Create a mapping of residue types to unique integers. + Each residue type will be represented as a one unique integer. + There are 20 standard amino acids, so we will have 20 unique integers (at maximum). + + Parameters + ---------- + uniprot_ids : list[str] + The list of UniProt IDs to process. + + Returns + ------- + dict + The mapping of residue types to unique integers. + """ + + residue_map = {} + residue_counter = 0 + + # First pass: determine unique residue types + for uniprot_id in uniprot_ids: + pdb_file = self.fetch_alphafold_structure(uniprot_id) + if pdb_file: + structure = self.parse_pdb(pdb_file) + residues = [residue for model in structure for chain in model for residue in chain] + for residue in residues: + residue_type = residue.get_resname() + if residue_type not in residue_map: + residue_map[residue_type] = residue_counter + residue_counter += 1 + return residue_map + + def calculate_residue_ca_distances_and_vectors( + self, structure : PDB.Structure + ): + r"""Calculate the distances between the alpha carbon atoms of the residues. + Also, calculate the vectors between the alpha carbon and beta carbon atoms of each residue. + + Parameters + ---------- + structure : PDB.Structure + The BioPython structure object. + + Returns + ------- + list + The list of residues. + dict + The dictionary of alpha carbon coordinates. + dict + The dictionary of beta carbon vectors. + np.ndarray + The matrix of distances between the residues. + """ + + residues = [residue for model in structure for chain in model for residue in chain] + ca_coordinates = {} + cb_vectors = {} + distances = np.zeros((len(residues), len(residues))) + + for i, residue in enumerate(residues): + if "CA" in residue: + ca_coord = residue["CA"].get_coord() + residue_type = residue.get_resname() + residue_number = residue.get_id()[1] + key = f"{residue_type}_{residue_number}" # this id is unique inside each protein + ca_coordinates[key] = ca_coord + + # Not all residues have a CB atom + cb_vectors[key] = residue["CB"].get_coord() - ca_coord if "CB" in residue else None + + + for j in range(i + 1, len(residues)): + if "CA" in residues[j]: + ca_coord2 = residues[j]["CA"].get_coord() + dist = np.linalg.norm(ca_coord - ca_coord2) + distances[i, j] = dist + distances[j, i] = dist + + return residues, ca_coordinates, cb_vectors , distances + + def calculate_vector_angle( + self, v1 : np.ndarray, v2 : np.ndarray + ) -> float: + r"""Calculate the angle between two vectors. + + Parameters + ---------- + v1 : np.ndarray + The first vector. + v2 : np.ndarray + The second vector. + + Returns + ------- + float + The angle between the two vectors. + """ + + cos_theta = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)) + return np.arccos(np.clip(cos_theta, -1.0, 1.0)) * 180 / np.pi + + def calculate_edges( + self, ca_coordinates : dict, cb_vectors : dict, distances : np.ndarray + ) -> list: + r"""Calculate the edges between the residues based on the distances and angles between them. + + Parameters + ---------- + ca_coordinates : dict + The dictionary of alpha carbon coordinates. + cb_vectors : dict + The dictionary of beta carbon vectors. + distances : np.ndarray + The matrix of distances between the residues. + + Returns + ------- + list + The list of edges. + """ + + edges = set() # Use a set to track unique edges + keys = list(ca_coordinates.keys()) # Which represent different residues + + for i in range(len(keys) - 1): + key1 = keys[i] + for j in range(i + 1, len(keys)): + key2 = keys[j] + dist = distances[i, j] + angle = self.calculate_vector_angle(cb_vectors[key1], cb_vectors[key2]) if cb_vectors[key1] is not None and cb_vectors[key2] is not None else None + + # If they are sequential, add the edge directly + # If they are not sequential, add the edge if the distance is less than the threshold + if j == i + 1 or (dist < self.parameters.threshold and angle and angle < 90): + edges.add((key1, key2, dist, angle)) + + return sorted(edges, key=lambda x: (int(x[0].split("_")[1]), int(x[1].split("_")[1]))) # Sort edges based on the ID after the underscore + + + def create_torch_geometric_data( + self, residues : list, ca_coordinates : dict, residue_map : dict, cb_vectors : dict, edges : list, y : float + ) -> None: + r"""Create a torch_geometric.data.Data object from the protein data. + + Parameters + ---------- + residues : list + The list of residues. + ca_coordinates : dict + The dictionary of alpha carbon coordinates. + residue_map : dict + The mapping of residue types to unique integers. + cb_vectors : dict + The dictionary of beta carbon vectors. + edges : list + The list of edges. + y : float + The target variable. + + Returns + ------- + torch_geometric.data.Data + The torch_geometric.data.Data object. + """ + + keys = list(ca_coordinates.keys()) # residue name + pos = [ca_coordinates[key] for key in keys] + # check if cb_vectors exists for the key + # Not all nodes have carbon beta, hence not all of them will have an attribute + node_attr = [cb_vectors[key] for key in keys if cb_vectors[key] is not None] + + # Make One-Hot encoding of residue types, keep it in node_key + num_residues = len(residue_map) + + node_key = [] + one_hot = torch.zeros(num_residues) + for residue in residues: + residue_type = residue.get_resname() + one_hot[residue_map[residue_type]] = 1 + node_key.append(one_hot) + # Does the same as the for loop above: + # node_key = [torch.zeros(num_residues).scatter_(0, torch.tensor([residue_map[residue.get_resname()]]), 1) for residue in residues] + + node_map = {key: i for i, key in enumerate(keys)} + # Set the edges + edge_index = [[node_map[edge[0]], node_map[edge[1]]] for edge in edges] + # Adding distance and angle as edge attributes + edge_attr = [[edge[2], edge[3]] if edge[3] is not None else [edge[2], 0] for edge in edges] + + for edge in edges: + edge_index.append([node_map[edge[0]], node_map[edge[1]]]) + # edge_attr.append([edge[2], edge[3]]) + if edge[3] is not None: + edge_attr.append([edge[2], edge[3]]) + else: + edge_attr.append([edge[2], 500]) # since to vectors can never have 500 as an angle + + # Create a graph + G = nx.Graph() + + # add vertices + G.add_nodes_from(node_map.values()) + + # add edges + G.add_edges_from(edge_index) + G.to_undirected() + edge_list = torch.tensor(list(G.edges)).T.long() + + # Convert to torch tensors + pos = torch.tensor(np.array(pos), dtype=torch.float) + node_key = torch.stack(node_key) + node_attr = torch.tensor(np.array(node_attr), dtype=torch.float) + edge_attr = torch.tensor(edge_attr, dtype=torch.float) + y = torch.tensor([y], dtype=torch.float) + + return torch_geometric.data.Data( + x=node_key, + pos=pos, + node_attr=node_attr, + edge_index=edge_list, + edge_attr=edge_attr, + y = y + ) + def load(self) -> torch_geometric.data.Dataset: r"""Load graph dataset. @@ -104,10 +451,43 @@ def load(self) -> torch_geometric.data.Dataset: dataset = datasets[0] + datasets[1] + datasets[2] dataset = ConcatToGeometricDataset(dataset) + elif self.parameters.data_name in ["UniProt"]: + """ + The UniProt dataset is a custom dataset that is created by fetching data from the UniProt API. + The dataset is created by fetching a list of proteins based on a query and then fetching the structure + of each protein using the AlphaFold API. The dataset is then created by creating a graph for each protein + where the nodes are the residues and the edges are the connected residues. The target variable is the mass + of the protein. + """ + datasets = [] + protein_data = self.fetch_uniprot_ids() + uniprot_ids = [protein["uniprot_id"] for protein in protein_data] + # Determine unique residue types and create a mapping + residue_map = self.residue_mapping(uniprot_ids) + # Process each protein and create datasets + for uniprot_id in uniprot_ids: + pdb_file = self.fetch_alphafold_structure(uniprot_id) + y = self.fetch_protein_mass(uniprot_id) + + if pdb_file and y: + structure = self.parse_pdb(pdb_file) + residues, ca_coordinates, cb_vectors, distances = self.calculate_residue_ca_distances_and_vectors(structure) + edges = self.calculate_edges(ca_coordinates, cb_vectors, distances) + + data = self.create_torch_geometric_data(residues, ca_coordinates, residue_map, cb_vectors, edges, y) + data.id = uniprot_id + datasets.append(data) + + dataset = CustomDataset(datasets, self.data_dir) + elif self.parameters.data_name in ["manual"]: data = load_manual_graph() dataset = CustomDataset([data], self.data_dir) + elif self.parameters.data_name in ["manual_prot"]: + data = load_manual_prot() + dataset = CustomDataset([data], self.data_dir) + else: raise NotImplementedError( f"Dataset {self.parameters.data_name} not implemented" diff --git a/modules/data/utils/utils.py b/modules/data/utils/utils.py index 93ab5021..96af4b65 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -333,6 +333,160 @@ def load_manual_graph(): y=torch.tensor(y), ) +def load_manual_prot(): + """Create a manual graph for testing protein data. + The graph corresponds to the representation of the + protein with uniprotid: P0DJJ1 + """ + + # Define the vertices + vertices = [i for i in range(16)] + y = [2005] + + # Define the edges + edges = [ + [0, 1], + [0, 2], + [1, 2], + [2, 3], + [2, 4], + [3, 4], + [3, 6], + [4, 5], + [4, 7], + [5, 6], + [5, 8], + [6, 7], + [6, 9], + [7, 8], + [8, 9], + [9, 10], + [10, 11], + [11, 12], + [11, 13], + [12, 13], + [12, 14], + [13, 14], + [13, 15], + [14, 15] + ] + + node_attr = [ + [ 1.3890, 0.6190, -0.1820], + [-0.9270, -0.9870, 0.7330], + [-0.2270, 1.4300, -0.5240], + [ 1.2680, 0.3270, 0.8000], + [ 0.1190, 1.1460, -1.0170], + [ 0.4530, -0.8660, -1.1890], + [ 1.4150, -0.3400, 0.5030], + [ 0.2660, 1.5060, -0.0980], + [-0.2630, 0.4330, -1.4480], + [ 1.0150, -0.7640, -0.8760], + [ 1.0040, 0.6400, 0.9630], + [-0.7060, 1.3490, -0.2130], + [ 0.8990, -1.1560, -0.4560], + [-1.0300, 1.1430, 0.0910], + [ 0.9240, -1.0550, 0.6270], + [-1.0380, 0.6640, -0.9280] + ] + + pos = [ + [ 7.5210, 0.0560, -6.7320], + [ 4.8200, 1.0530, -4.2620], + [ 6.1700, 4.2550, -2.6770], + [ 6.0640, 4.2840, 1.1930], + [ 3.1770, 6.8050, 0.7350], + [ 0.8630, 3.9710, -0.5950], + [ 1.4180, 1.9200, 2.6160], + [ -0.2780, 4.7140, 4.6930], + [ -3.6400, 3.8990, 3.0330], + [ -3.5740, 0.0960, 3.6640], + [ -3.8460, -0.2580, 7.5040], + [ -7.6510, 0.2670, 7.8800], + [ -8.4770, -3.4030, 7.2390], + [-11.1830, -3.1590, 9.8940], + [-12.1290, -6.7670, 10.4510], + [-15.7920, -5.9970, 11.1970] + ] + + edge_attr = [ + [3.7934558, 149.50481451169998], + [5.9916463, 73.61527190033692], + [3.8193624, 131.95556949748686], + [3.8715599, 95.81568896389793], + [5.2059865, 24.99968085162557], + [3.8600485, 97.01387095949963], + [5.403586, 28.039804503840163], + [3.892949, 83.4287695658028], + [5.6546497, 37.945642805792026], + [3.850344, 81.81569949178396], + [5.7831287, 58.674074660579485], + [3.872568, 94.49543679831403], + [5.4171343, 58.10693508314127], + [3.8370392, 72.06193427289432], + [3.8555577, 73.54177428094899], + [3.8658636, 97.62340401695313], + [3.8594074, 91.23113911037706], + [3.8160264, 152.7860125877105], + [5.316831, 18.30498413525865], + [3.7988148, 165.50490996053213], + [5.9135895, 41.512625041705014], + [3.771317, 152.5153703231938], + [5.56731, 42.83026706257669], + [3.816672, 161.06592876960846] + ] + + # Create a graph + G = nx.Graph() + # Add vertices + G.add_nodes_from(vertices) + # Add edges + G.add_edges_from(edges) + G.to_undirected() + edge_list = torch.Tensor(list(G.edges())).T.long() + + x = torch.tensor([[1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.], + [1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., + 0., 0.]]) + + return torch_geometric.data.Data( + x=x, + edge_index=edge_list, + num_nodes=len(vertices), + y=torch.tensor(y), + edge_attr=torch.tensor(edge_attr), + node_attr=torch.tensor(node_attr), + pos=torch.tensor(pos) + ) def get_Planetoid_pyg(cfg): r"""Loads Planetoid graph datasets from torch_geometric. diff --git a/modules/transforms/data_transform.py b/modules/transforms/data_transform.py index 59253ecf..8945b4d8 100755 --- a/modules/transforms/data_transform.py +++ b/modules/transforms/data_transform.py @@ -9,6 +9,9 @@ ) from modules.transforms.feature_liftings.feature_liftings import ProjectionSum from modules.transforms.liftings.graph2cell.cycle_lifting import CellCycleLifting +from modules.transforms.liftings.graph2hypergraph.close_lifting import ( + HypergraphCloseLifting, +) from modules.transforms.liftings.graph2hypergraph.knn_lifting import ( HypergraphKNNLifting, ) @@ -19,6 +22,7 @@ TRANSFORMS = { # Graph -> Hypergraph "HypergraphKNNLifting": HypergraphKNNLifting, + "HypergraphCloseLifting": HypergraphCloseLifting, # Graph -> Simplicial Complex "SimplicialCliqueLifting": SimplicialCliqueLifting, # Graph -> Cell Complex diff --git a/modules/transforms/liftings/graph2hypergraph/close_lifting.py b/modules/transforms/liftings/graph2hypergraph/close_lifting.py new file mode 100755 index 00000000..1e758658 --- /dev/null +++ b/modules/transforms/liftings/graph2hypergraph/close_lifting.py @@ -0,0 +1,89 @@ +import torch +import torch_geometric + +from modules.transforms.liftings.graph2hypergraph.base import Graph2HypergraphLifting + + +class HypergraphCloseLifting(Graph2HypergraphLifting): + r"""Lifts graphs to hypergraph domain by considering k-nearest neighbors. + + Parameters + ---------- + k_value : int, optional + The number of nearest neighbors to consider. Default is 1. + loop: boolean, optional + If True the hyperedges will contain the node they were created from. + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, distance, **kwargs): + super().__init__(**kwargs) + self.distance = distance + + def find_close_res( + self, data: torch_geometric.data.Data + ) -> list: + r"""Finds the closest nodes to each connectec node in the graph. + + Parameters + ---------- + data : torch_geometric.data.Data + Under edge_attr, the distances and angles between residues are stored. + + Returns + ------- + list + The list of the closest nodes to each connected node. + + Example: + [[0, 1, 2], ...] + where the first list is the index of the closest nodes to the first node + + """ + distances = data.edge_attr[:, 0] + + num_nodes = data.x.shape[0] + closest_nodes = [] + for i in range(num_nodes): + # Get the indices of the edges from the ith node + indices = torch.where(data.edge_index[0] == i)[0] + distances_i = distances[indices] + # Get the indices of the closest nodes + closest_nodes_i = torch.where(distances_i < self.distance)[0] + closest_nodes.append(closest_nodes_i) + return closest_nodes + + def lift_topology( + self, data: torch_geometric.data.Data + ) -> dict: + r"""Lifts the topology of a graph to hypergraph domain by considering k-nearest neighbors. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + dict + The lifted topology. + """ + num_nodes = data.x.shape[0] + data.pos = data.x + + # Find the closest nodes to each node + closest_nodes = self.find_close_res(data) + + # Now, I want to create hyperedges of the closest nodes + # Hyperedges = closest_nodes + edges + num_hyperedges = len(closest_nodes) + len(data.edge_index[0]) + + incidence_1 = torch.zeros(num_nodes, num_hyperedges) + incidence_1[data.edge_index[1], data.edge_index[0]] = 1 + incidence_1 = torch.Tensor(incidence_1).to_sparse_coo() + return { + "incidence_hyperedges": incidence_1, + "num_hyperedges": num_hyperedges, + "x_0": data.x, # have to do something with it + } diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 1dfcdc2e..d77d78f3 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -167,6 +167,7 @@ def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): print(f" - Features dimensions: {features_dim}") # Check if there are isolated nodes if hasattr(data, "edge_index") and hasattr(data, "x"): + print(data.edge_index) connected_nodes = torch.unique(data.edge_index) isolated_nodes = [] for i in range(data.x.shape[0]): diff --git a/pyproject.toml b/pyproject.toml index af67ad7c..47b9e2eb 100755 --- a/pyproject.toml +++ b/pyproject.toml @@ -42,6 +42,7 @@ dependencies=[ "rich", "rootutils", "pytest", + "Bio", "toponetx @ git+https://github.com/pyt-team/TopoNetX.git", "topomodelx @ git+https://github.com/pyt-team/TopoModelX.git", "topoembedx @ git+https://github.com/pyt-team/TopoEmbedX.git", diff --git a/test/transforms/liftings/graph2hypergraph/test_close_lifting.py b/test/transforms/liftings/graph2hypergraph/test_close_lifting.py new file mode 100644 index 00000000..8d529c54 --- /dev/null +++ b/test/transforms/liftings/graph2hypergraph/test_close_lifting.py @@ -0,0 +1,80 @@ +import torch + +from modules.data.utils.utils import load_manual_prot +from modules.transforms.liftings.graph2hypergraph.close_lifting import ( + HypergraphCloseLifting, +) + + +class TestHypergraphCloseLifting: + """Test the HypergraphCloseLifting class.""" + + def setup_method(self): + # Load the graph + self.data = load_manual_prot() + + # Initialise the CellCyclesLifting class + self.lifting = HypergraphCloseLifting(distance=6.0) + + def test_lift_topology(self): + # Test the lift_topology method + lifted_data = self.lifting.forward(self.data.clone()) + + expected_n_hyperedges = 40 + + expected_incidence_1 = torch.tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.], + [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., + 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., + 0., 0., 0., 0.]]) + + + assert ( + expected_incidence_1 == lifted_data.incidence_hyperedges.to_dense() + ).all(), "Something is wrong with incidence_hyperedges (k=1)." + assert ( + expected_n_hyperedges == lifted_data.num_hyperedges + ), "Something is wrong with the number of hyperedges (k=1)." diff --git a/tutorials/graph2cell/cycle_lifting.ipynb b/tutorials/graph2cell/cycle_lifting.ipynb index fe7834de..50cc6e8e 100644 --- a/tutorials/graph2cell/cycle_lifting.ipynb +++ b/tutorials/graph2cell/cycle_lifting.ipynb @@ -16,7 +16,7 @@ "\n", "The notebook is divided into sections:\n", "\n", - "- [Loading the dataset](#loading-the-dataset) loads the config files for the data and the desired tranformation, createsa a dataset object and visualizes it.\n", + "- [Loading the dataset](#loading-the-dataset) loads the config files for the data and the desired tranformation, creates a dataset object and visualizes it.\n", "- [Loading and applying the lifting](#loading-and-applying-the-lifting) defines a simple neural network to test that the lifting creates the expected incidence matrices.\n", "- [Create and run a simplicial nn model](#create-and-run-a-simplicial-nn-model) simply runs a forward pass of the model to check that everything is working as expected.\n", "\n", @@ -76,7 +76,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Here we just need to spicify the name of the available dataset that we want to load. First, the dataset config is read from the corresponding yaml file (located at `/configs/datasets/` directory), and then the data is loaded via the implemented `Loaders`.\n" + "Here we just need to specify the name of the available dataset that we want to load. First, the dataset config is read from the corresponding yaml file (located at `/configs/datasets/` directory), and then the data is loaded via the implemented `Loaders`.\n" ] }, { diff --git a/tutorials/graph2hypergraph/close_lifting.ipynb b/tutorials/graph2hypergraph/close_lifting.ipynb new file mode 100644 index 00000000..3e1a1804 --- /dev/null +++ b/tutorials/graph2hypergraph/close_lifting.ipynb @@ -0,0 +1,563 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Protein Close Residues Lifting (Graph to Hypergraph)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "This notebook imports UniProt protein data and creates a lifting from the graph of the protein to an hypergraph.\n", + "Then, a neural network is run using the loaded data.\n", + "\n", + "The UniProt dataset is a custom dataset that is created by fetching data from the UniProt API.\n", + "The dataset is created by fetching a list of proteins based on a query and then fetching the structure of each protein using the AlphaFold API. The dataset is then created by creating a graph for each protein where the nodes are the residues and edges are the connections between residues. These connections are usually done by the closeness of the residues. In this example, we connect the residues in two ways, representing the data into a graph:\n", + "- **Sequentialwise**: Connecting residues that appear in a sequential order (one after another). This approach is based on the presence of peptide bonds, which link the amino acids in a protein chain in a specific sequence.\n", + "- **Closewise**: Connecting residues that are close to each other (under than a *threshold*) and the direction between CarbonAlpha (CA) and CarbonBeta (CB) atoms of each residue are less than 90 degrees between different residues. This approach ensures that residues are connected when they are in close proximity and have a similar orientation, indicating that their spatial arrangement and orientation are biologically appropriate (the residues are appropriated with a similar orientation).\n", + "\n", + "The target variable is the mass of the protein.\n", + "\n", + "This representation can be improved by lifting it to an hypergraph. \n", + "As done in [Jiang et al. (2021)](https://www.nature.com/articles/s41524-021-00493-w), we will create an hypergraph by grouping the connected residues that are close to each other (less than a parameter).\n", + "\n", + "Under this submission the following steps are done:\n", + "\n", + "- [Loading the dataset](#loading-the-dataset) loads the config files for loading UniProt dataset and a creating a graph connecting the atoms as mentioned above.\n", + "- [Loading and applying the lifting](#loading-and-applying-the-lifting) done by creating a close residue lifting, computing the distance between the connected residues and grouping them when are under a threshold. These residues will be connected by an hyperedge inside an hypergraph.\n", + "- [Create and run a simplicial nn model](#create-and-run-a-simplicial-nn-model) simply runs a forward pass of the model to check that everything is working as expected.\n", + "\n", + "***\n", + "***\n", + "\n", + "Note that for simplicity the notebook is setup to use a simple graph. However, there is a set of available datasets that you can play with.\n", + "\n", + "To switch to one of the available datasets, simply change the *dataset_name* variable in [Dataset config](#dataset-config) to one of the following names:\n", + "\n", + "* cocitation_cora\n", + "* cocitation_citeseer\n", + "* cocitation_pubmed\n", + "* MUTAG\n", + "* NCI1\n", + "* NCI109\n", + "* PROTEINS_TU\n", + "* AQSOL\n", + "* ZINC\n", + "* UniProt\n", + "\n", + "With this implementation, also **UniProt** is available.\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports and utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "# With this cell any imported module is reloaded before each cell execution\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "from modules.data.load.loaders import GraphLoader\n", + "from modules.data.preprocess.preprocessor import PreProcessor\n", + "from modules.utils.utils import (\n", + " describe_data,\n", + " load_dataset_config,\n", + " load_model_config,\n", + " load_transform_config,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading the dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we just need to specify the name of the available dataset that we want to load, in this case, UniProt dataset. First, the dataset config is read from the corresponding yaml file (located at `/configs/datasets/` directory), and then the data is loaded via the implemented `Loaders`.\n", + "\n", + "In the dataset, different parameters are specified to load the data from the API, such as the number of samples to load (*limit*), the number of residues per protein (query: length),...\n", + "\n", + "Moreover, there is the *threshold* parameter that is used to group residues that are close to each other. This parameter is used to create the initial graph.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset configuration for UniProt:\n", + "\n", + "{'data_domain': 'graph',\n", + " 'data_type': 'UniProt',\n", + " 'data_name': 'UniProt',\n", + " 'data_dir': 'datasets/graph/UniProt',\n", + " 'query': 'length:[95 TO 155]',\n", + " 'format': 'tsv',\n", + " 'fields': 'accession,length',\n", + " 'size': 100,\n", + " 'threshold': 6.0,\n", + " 'num_features': 20,\n", + " 'num_classes': 1,\n", + " 'task': 'regression',\n", + " 'loss_type': 'mse',\n", + " 'monitor_metric': 'mae',\n", + " 'task_level': 'graph'}\n" + ] + } + ], + "source": [ + "dataset_name = \"UniProt\"\n", + "dataset_config = load_dataset_config(dataset_name)\n", + "loader = GraphLoader(dataset_config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then access to the data through the `load()`method. " + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PDB file for P02776 already exists.\n", + "PDB file for O14960 already exists.\n", + "PDB file for A8MQ03 already exists.\n", + "PDB file for O43914 already exists.\n", + "PDB file for Q16143 already exists.\n", + "PDB file for P61956 already exists.\n", + "PDB file for P61088 already exists.\n", + "PDB file for A6NNB3 already exists.\n", + "PDB file for P26885 already exists.\n", + "PDB file for P0DPB6 already exists.\n", + "PDB file for A2RU14 already exists.\n", + "PDB file for P55854 already exists.\n", + "PDB file for P80098 already exists.\n", + "PDB file for O15116 already exists.\n", + "PDB file for P0DI82 already exists.\n", + "PDB file for A6NFY7 already exists.\n", + "PDB file for P49901 already exists.\n", + "PDB file for P01308 already exists.\n", + "PDB file for Q16718 already exists.\n", + "PDB file for P0C5Z0 already exists.\n", + "PDB file for P26447 already exists.\n", + "PDB file for P27482 already exists.\n", + "PDB file for P62314 already exists.\n", + "PDB file for P99999 already exists.\n", + "PDB file for P23083 already exists.\n", + "PDB file for P04080 already exists.\n", + "PDB file for Q15726 already exists.\n", + "PDB file for O00453 already exists.\n", + "PDB file for O15511 already exists.\n", + "PDB file for P15090 already exists.\n", + "PDB file for P0DP58 already exists.\n", + "PDB file for O95139 already exists.\n", + "PDB file for P01825 already exists.\n", + "PDB file for P62266 already exists.\n", + "PDB file for P09912 already exists.\n", + "PDB file for O95990 already exists.\n", + "PDB file for P61970 already exists.\n", + "PDB file for P19875 already exists.\n", + "PDB file for P31949 already exists.\n", + "PDB file for P63172 already exists.\n", + "PDB file for Q0D2K3 already exists.\n", + "PDB file for P32320 already exists.\n", + "PDB file for P39019 already exists.\n", + "PDB file for P68036 already exists.\n", + "PDB file for P83876 already exists.\n", + "PDB file for O14519 already exists.\n", + "PDB file for P07737 already exists.\n", + "PDB file for P56851 already exists.\n", + "PDB file for P84243 already exists.\n", + "PDB file for O00422 already exists.\n", + "PDB file for P13164 already exists.\n", + "PDB file for Q02747 already exists.\n", + "PDB file for Q13021 already exists.\n", + "PDB file for P0C0S8 already exists.\n", + "PDB file for P49450 already exists.\n", + "PDB file for O14907 already exists.\n", + "PDB file for O60814 already exists.\n", + "PDB file for P58876 already exists.\n", + "PDB file for P01270 already exists.\n", + "PDB file for O60519 already exists.\n", + "PDB file for Q15543 already exists.\n", + "PDB file for P06899 already exists.\n", + "PDB file for O75379 already exists.\n", + "PDB file for P08700 already exists.\n", + "PDB file for O14933 already exists.\n", + "PDB file for P01615 already exists.\n", + "PDB file for P33778 already exists.\n", + "PDB file for Q02575 already exists.\n", + "PDB file for P29034 already exists.\n", + "PDB file for P61604 already exists.\n", + "PDB file for P10620 already exists.\n", + "PDB file for P52926 already exists.\n", + "PDB file for O95298 already exists.\n", + "PDB file for P17096 already exists.\n", + "PDB file for P14174 already exists.\n", + "PDB file for P0DI81 already exists.\n", + "PDB file for P07492 already exists.\n", + "PDB file for Q16568 already exists.\n", + "PDB file for C9JLW8 already exists.\n", + "PDB file for P0C7P0 already exists.\n", + "PDB file for P61927 already exists.\n", + "PDB file for P01597 already exists.\n", + "PDB file for P27449 already exists.\n", + "PDB file for P01764 already exists.\n", + "PDB file for P06454 already exists.\n", + "PDB file for O15540 already exists.\n", + "PDB file for P55000 already exists.\n", + "PDB file for P05386 already exists.\n", + "PDB file for O95670 already exists.\n", + "PDB file for P62310 already exists.\n", + "PDB file for Q15836 already exists.\n", + "PDB file for P53567 already exists.\n", + "PDB file for O75956 already exists.\n", + "PDB file for O95777 already exists.\n", + "PDB file for P09683 already exists.\n", + "PDB file for P62277 already exists.\n", + "PDB file for Q03403 already exists.\n", + "PDB file for P57105 already exists.\n", + "PDB file for P82932 already exists.\n", + "PDB file for O95415 already exists.\n", + "PDB file for P02776 already exists.\n", + "PDB file for O14960 already exists.\n", + "PDB file for A8MQ03 already exists.\n", + "PDB file for O43914 already exists.\n", + "PDB file for Q16143 already exists.\n", + "PDB file for P61956 already exists.\n", + "PDB file for P61088 already exists.\n", + "PDB file for A6NNB3 already exists.\n", + "PDB file for P26885 already exists.\n", + "PDB file for P0DPB6 already exists.\n", + "PDB file for A2RU14 already exists.\n", + "PDB file for P55854 already exists.\n", + "PDB file for P80098 already exists.\n", + "PDB file for O15116 already exists.\n", + "PDB file for P0DI82 already exists.\n", + "PDB file for A6NFY7 already exists.\n", + "PDB file for P49901 already exists.\n", + "PDB file for P01308 already exists.\n", + "PDB file for Q16718 already exists.\n", + "PDB file for P0C5Z0 already exists.\n", + "PDB file for P26447 already exists.\n", + "PDB file for P27482 already exists.\n", + "PDB file for P62314 already exists.\n", + "PDB file for P99999 already exists.\n", + "PDB file for P23083 already exists.\n", + "PDB file for P04080 already exists.\n", + "PDB file for Q15726 already exists.\n", + "PDB file for O00453 already exists.\n", + "PDB file for O15511 already exists.\n", + "PDB file for P15090 already exists.\n", + "PDB file for P0DP58 already exists.\n", + "PDB file for O95139 already exists.\n", + "PDB file for P01825 already exists.\n", + "PDB file for P62266 already exists.\n", + "PDB file for P09912 already exists.\n", + "PDB file for O95990 already exists.\n", + "PDB file for P61970 already exists.\n", + "PDB file for P19875 already exists.\n", + "PDB file for P31949 already exists.\n", + "PDB file for P63172 already exists.\n", + "PDB file for Q0D2K3 already exists.\n", + "PDB file for P32320 already exists.\n", + "PDB file for P39019 already exists.\n", + "PDB file for P68036 already exists.\n", + "PDB file for P83876 already exists.\n", + "PDB file for O14519 already exists.\n", + "PDB file for P07737 already exists.\n", + "PDB file for P56851 already exists.\n", + "PDB file for P84243 already exists.\n", + "PDB file for O00422 already exists.\n", + "PDB file for P13164 already exists.\n", + "PDB file for Q02747 already exists.\n", + "PDB file for Q13021 already exists.\n", + "PDB file for P0C0S8 already exists.\n", + "PDB file for P49450 already exists.\n", + "PDB file for O14907 already exists.\n", + "PDB file for O60814 already exists.\n", + "PDB file for P58876 already exists.\n", + "PDB file for P01270 already exists.\n", + "PDB file for O60519 already exists.\n", + "PDB file for Q15543 already exists.\n", + "PDB file for P06899 already exists.\n", + "PDB file for O75379 already exists.\n", + "PDB file for P08700 already exists.\n", + "PDB file for O14933 already exists.\n", + "PDB file for P01615 already exists.\n", + "PDB file for P33778 already exists.\n", + "PDB file for Q02575 already exists.\n", + "PDB file for P29034 already exists.\n", + "PDB file for P61604 already exists.\n", + "PDB file for P10620 already exists.\n", + "PDB file for P52926 already exists.\n", + "PDB file for O95298 already exists.\n", + "PDB file for P17096 already exists.\n", + "PDB file for P14174 already exists.\n", + "PDB file for P0DI81 already exists.\n", + "PDB file for P07492 already exists.\n", + "PDB file for Q16568 already exists.\n", + "PDB file for C9JLW8 already exists.\n", + "PDB file for P0C7P0 already exists.\n", + "PDB file for P61927 already exists.\n", + "PDB file for P01597 already exists.\n", + "PDB file for P27449 already exists.\n", + "PDB file for P01764 already exists.\n", + "PDB file for P06454 already exists.\n", + "PDB file for O15540 already exists.\n", + "PDB file for P55000 already exists.\n", + "PDB file for P05386 already exists.\n", + "PDB file for O95670 already exists.\n", + "PDB file for P62310 already exists.\n", + "PDB file for Q15836 already exists.\n", + "PDB file for P53567 already exists.\n", + "PDB file for O75956 already exists.\n", + "PDB file for O95777 already exists.\n", + "PDB file for P09683 already exists.\n", + "PDB file for P62277 already exists.\n", + "PDB file for Q03403 already exists.\n", + "PDB file for P57105 already exists.\n", + "PDB file for P82932 already exists.\n", + "PDB file for O95415 already exists.\n", + "\n", + "Dataset contains 17 samples.\n", + "\n", + "Providing more details about sample 0/17:\n", + " - Graph with 50 vertices and 78 edges.\n", + " - Features dimensions: [20, 2]\n", + "tensor([[ 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,\n", + " 10, 11, 12, 13, 13, 13, 14, 14, 15, 16, 17, 17, 18, 19, 19, 19, 20, 20,\n", + " 21, 21, 22, 22, 23, 23, 23, 24, 24, 24, 25, 26, 27, 27, 28, 29, 30, 31,\n", + " 32, 33, 34, 35, 36, 37, 37, 37, 38, 39, 40, 41, 42, 43, 43, 43, 44, 44,\n", + " 45, 45, 46, 46, 47, 48],\n", + " [ 1, 2, 3, 24, 4, 23, 5, 22, 6, 21, 7, 20, 8, 19, 9, 18, 10, 17,\n", + " 11, 12, 13, 14, 15, 16, 15, 17, 16, 17, 18, 38, 19, 20, 36, 37, 21, 35,\n", + " 22, 34, 23, 33, 24, 31, 32, 25, 28, 30, 26, 27, 28, 29, 29, 30, 31, 32,\n", + " 33, 34, 35, 36, 37, 38, 39, 40, 39, 40, 41, 42, 43, 44, 45, 46, 45, 47,\n", + " 46, 48, 47, 49, 48, 49]])\n", + " - There are 0 isolated nodes.\n", + "\n" + ] + } + ], + "source": [ + "dataset = loader.load()\n", + "describe_data(dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading and Applying the Lifting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section we will instantiate the lifting we want to apply to the data. \n", + "\n", + "A **close-based lifting** is created by computing the distance between the connected residues and grouping them when are under a threshold. These residues will be connected by an hyperedge inside an hypergraph.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2hypergraph/close_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'HypergraphCloseLifting',\n", + " 'feature_lifting': 'ProjectionSum',\n", + " 'distance': 6.0}\n" + ] + } + ], + "source": [ + "# Define transformation type and id\n", + "transform_type = \"liftings\"\n", + "# If the transform is a topological lifting, it should include both the type of the lifting and the identifier\n", + "transform_id = \"graph2hypergraph/close_lifting\"\n", + "\n", + "# Read yaml file\n", + "transform_config = {\n", + " \"lifting\": load_transform_config(transform_type, transform_id)\n", + " # other transforms (e.g. data manipulations, feature liftings) can be added here\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We than apply the transform via our `PreProcesor`:" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /home/bmiquel/Documents/Projects/Topo/challenge-icml-2024/datasets/graph/UniProt/UniProt/lifting/2549867618\n", + "\n", + "Dataset only contains 1 sample:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Hypergraph with 16 vertices and 40 hyperedges.\n", + " - The nodes have feature dimensions 20.\n", + " - The hyperedges have feature dimensions 20.\n", + "\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and Run a Cell NN Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section a simple model is created to test that the used lifting works as intended. In this case the model uses the `incidence_hyperedges` matrix so the lifting should make sure to add it to the data." + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Model configuration for hypergraph UNIGCN:\n", + "\n", + "{'in_channels': None,\n", + " 'hidden_channels': 32,\n", + " 'out_channels': None,\n", + " 'n_layers': 2}\n" + ] + } + ], + "source": [ + "from modules.models.hypergraph.unigcn import UniGCNModel\n", + "\n", + "model_type = \"hypergraph\"\n", + "model_id = \"unigcn\"\n", + "model_config = load_model_config(model_type, model_id)\n", + "\n", + "model = UniGCNModel(model_config, dataset_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "y_hat = model(lifted_dataset.get(0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is correct the cell above should execute without errors. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv_topox", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/graph2hypergraph/knn_lifting.ipynb b/tutorials/graph2hypergraph/knn_lifting.ipynb index 40bf15b9..b5a1726d 100644 --- a/tutorials/graph2hypergraph/knn_lifting.ipynb +++ b/tutorials/graph2hypergraph/knn_lifting.ipynb @@ -48,9 +48,30 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": {}, "outputs": [], + "source": [ + "import sys\n", + "\n", + "# add ../../ so I can read other modules\n", + "sys.path.append(\"../../\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "# With this cell any imported module is reloaded before each cell execution\n", "%load_ext autoreload\n", @@ -81,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -119,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -132,7 +153,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -146,6 +167,8 @@ "text": [ " - Graph with 8 vertices and 13 edges.\n", " - Features dimensions: [1, 0]\n", + "tensor([[0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 3, 5, 5],\n", + " [1, 2, 4, 7, 2, 4, 3, 5, 7, 4, 6, 6, 7]])\n", " - There are 0 isolated nodes.\n", "\n" ] @@ -156,6 +179,26 @@ "describe_data(dataset)" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Data(x=[8, 1], edge_index=[2, 13], y=[8], num_nodes=8)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset[0]" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -185,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -225,21 +268,21 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Transform parameters are the same, using existing data_dir: /Users/leone/Desktop/PhD-S/projects/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/557134810\n", + "Transform parameters are the same, using existing data_dir: /home/bmiquel/Documents/Projects/Topo/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/557134810\n", "\n", "Dataset only contains 1 sample:\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -279,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -308,7 +351,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [