Setup for final runs on GlyPP data

Author: Old-Shatterhand

configs/downstream/final.yaml

@@ -0,0 +1,81 @@
+seed: [42, 1234, 1337]
+root_dir: /scratch/SCRATCH_SAS/roman/Gothenburg/GIFFLAR/data_final
+logs_dir: /scratch/SCRATCH_SAS/roman/Gothenburg/GIFFLAR/logs_final
+datasets:
+  - name: Taxonomy_Kingdom
+    task: multilabel
+  - name: Tissue
+    task: multilabel
+  - name: Glycosylation
+    task: classification
+  - name: Spectrum
+    task: spectrum
+pre-transforms:
+  GIFFLARTransform:
+  GNNGLYTransform:
+  ECFPTransform:
+  SweetNetTransform:
+  RGCNTransform:
+  RandomWalkPE:
+    dim: 20
+    individual: False
+  LaplacianPE:
+    dim: 20
+    individual: False
+model:
+  - name: rf
+    n_estimators: 500
+    n_jobs: -1
+    random_state: 42
+  - name: svm
+    random_state: 42
+  - name: xgb
+    random_state: 42
+  - name: mlp
+    feat_dim: 1024
+    hidden_dim: 1024
+    batch_size: 256
+    num_layers: 3
+    epochs: 100
+    patience: 30
+    learning_rate: 0.001
+    optimizer: Adam
+  - name: sweetnet
+    feat_dim: 128
+    hidden_dim: 1024
+    batch_size: 512
+    num_layers: 16
+    epochs: 100
+    patience: 30
+    learning_rate: 0.001
+    optimizer: Adam
+    suffix:
+  - name: gnngly
+    feat_dim: 128
+    hidden_dim: 1024
+    batch_size: 512
+    num_layers: 8
+    epochs: 100
+    patience: 30
+    learning_rate: 0.001
+    optimizer: Adam
+    suffix:
+  - name: rgcn
+    feat_dim: 128
+    hidden_dim: 1024
+    batch_size: 256
+    num_layers: 8
+    epochs: 100
+    learning_rate: 0.001
+    optimizer: Adam
+    suffix:
+  - name: gifflar
+    feat_dim: 128
+    hidden_dim: 1024
+    batch_size: 256
+    num_layers: 8
+    epochs: 100
+    learning_rate: 0.001
+    optimizer: Adam
+    pooling: global_mean
+    suffix:

configs/downstream/spec.yaml

@@ -1,6 +1,6 @@
 seed: 42
 root_dir: /scratch/SCRATCH_SAS/roman/Gothenburg/GIFFLAR/data
-logs_dir: /scratch/SCRATCH_SAS/roman/Gothenburg/GIFFLAR/logs_spec_mse
+logs_dir: /scratch/SCRATCH_SAS/roman/Gothenburg/GIFFLAR/logs_spec
 datasets:
   - name: Spectrum
     task: spectrum
@@ -11,69 +11,22 @@ pre-transforms:
   SweetNetTransform:
   RGCNTransform:
 model:
-  # - name: rf
-  #   n_estimators: 500
-  #   n_jobs: -1
-  #   random_state: 42
-  # - name: svm
-  #   random_state: 42
-  # - name: xgb
-  #   random_state: 42
   - name: mlp
     feat_dim: 1024
     hidden_dim: 1024
-    batch_size: 256
+    batch_size: 16
     num_layers: 3
-    epochs: 3
+    epochs: 100
     patience: 30
     learning_rate: 0.001
     optimizer: Adam
-  # - name: sweetnet
-  #   feat_dim: 128
-  #   hidden_dim: 1024
-  #   batch_size: 512
-  #   num_layers: 16
-  #   epochs: 100
-  #   patience: 30
-  #   learning_rate: 0.001
-  #   optimizer: Adam
-  #   suffix:
-  # - name: gnngly
-  #   feat_dim: 128
-  #   hidden_dim: 1024
-  #   batch_size: 512
-  #   num_layers: 8
-  #   epochs: 100
-  #   patience: 30
-  #   learning_rate: 0.001
-  #   optimizer: Adam
-  #   suffix:
-  # - name: rgcn
-  #   feat_dim: 128
-  #   hidden_dim: 1024
-  #   batch_size: 256
-  #   num_layers: 8
-  #   epochs: 100
-  #   learning_rate: 0.001
-  #   optimizer: Adam
-  #   suffix:
-  # - name: gifflar
-  #   feat_dim: 128
-  #   hidden_dim: 1024
-  #   batch_size: 256
-  #   num_layers: 8
-  #   epochs: 100
-  #   learning_rate: 0.001
-  #   optimizer: Adam
-  #   pooling: global_mean
-  #   suffix: _128_8_gp
-  # - name: glylm
-  #   token_file: /scratch/SCRATCH_SAS/roman/Gothenburg/GIFFLAR/unique/GlyLM/bpe_lib_2500.pkl
-  #   model_dir: /scratch/SCRATCH_SAS/roman/Gothenburg/GIFFLAR/unique/GlyLM/bpe_lib_2500_t6/checkpoint-5927260
-  #   pre_tokenizer: lib
-  #   hidden_dim: 320
-  #   epochs: 100
-  #   learning_rate: 0.001
-  #   batch_size: 256
-  #   optimizer: Adam
-  #   suffix: _bpe_lib_25_t6_20
+  - name: gifflar
+    feat_dim: 128
+    hidden_dim: 1024
+    batch_size: 16
+    num_layers: 8
+    epochs: 100
+    learning_rate: 0.001
+    optimizer: Adam
+    pooling: global_mean
+    suffix: _128_8_gp

gifflar/benchmarks.py

@@ -4,33 +4,12 @@
 
 import numpy as np
 import pandas as pd
-from glycowork.glycan_data.loader import df_species as taxonomy
+from glycowork.glycan_data.loader import df_species, df_glycan, build_custom_df
 from tqdm import tqdm
 
 from gifflar.utils import iupac2smiles
 
 
-def get_taxonomy(root: Path | str) -> pd.DataFrame:
-    """
-    Download full taxonomy data, process it, and save it as a tsv file.
-
-    Args:
-        root: The root directory to save the data to.
-
-    Returns:
-        The processed taxonomy data.
-    """
-    if not (p := (root / Path("taxonomy.tsv"))).exists():
-        mask = []
-        # convert to IUPAC to SMILES and build a mask to remove not-convertable molecules.
-        for i in tqdm(taxonomy["glycan"]):
-            smiles = iupac2smiles(i)
-            mask.append(smiles is not None)
-        tax = taxonomy[mask]
-        tax.to_csv(p, sep="\t", index=False)
-    return pd.read_csv(p, sep="\t")
-
-
 def get_taxonomic_level(
         root: Path | str,
         level: Literal["Domain", "Kingdom", "Phylum", "Class", "Order", "Family", "Genus", "Species"]
@@ -47,7 +26,7 @@ def get_taxonomic_level(
     """
     if not (p := (root / Path(f"taxonomy_{level}.tsv"))).exists():
         # Chop to taxonomic level of interest and remove invalid rows
-        tax = get_taxonomy(root)[["glycan", level]]
+        tax = df_species[["glycan", level]]
         tax.rename(columns={"glycan": "IUPAC"}, inplace=True)
         tax[tax[level] == "undetermined"] = np.nan
         tax.dropna(inplace=True)
@@ -83,45 +62,17 @@ def get_tissue(root: Path | str) -> Path:
     """
     if not (p := (root / Path("tissue.tsv"))).exists():
         # Process the data and remove unnecessary columns
-        df = pd.read_csv("datasets/tissue_multilabel_df.csv")
-        df.rename(columns={"glycan": "IUPAC"}, inplace=True)
-        df.dropna(inplace=True)
-
-        df["split"] = np.random.choice(["train", "val", "test"], df.shape[0], p=[0.7, 0.2, 0.1])
-        df.to_csv(p, sep="\t", index=False)
-    return p
-
-
-def get_immunogenicity(root: Path | str) -> Path:
-    """
-    Download immunogenicity data, process it, and save it as a tsv file.
-
-    Args:
-        root: The root directory to save the data to.
-
-    Returns:
-        The filepath of the processed immunogenicity data.
-    """
-    root = Path(root)
-    if not (p := (root / "immunogenicity.tsv")).exists():
-        # Download the data
-        urllib.request.urlretrieve("https://torchglycan.s3.us-east-2.amazonaws.com/downstream/glycan_immunogenicity.csv", p.with_suffix(".csv"))
-
-        # Process the data and remove unnecessary columns
-        df = pd.read_csv(p.with_suffix(".csv"))[["glycan", "immunogenicity"]]
+        df = build_custom_df(df_glycan, "df_tissue")[["glycan", "tissue_sample"]]
         df.rename(columns={"glycan": "IUPAC"}, inplace=True)
+        df.drop_duplicates(inplace=True)
         df.dropna(inplace=True)
 
         # One-hot encode the individual classes and collate them for glycans that are the same
-        classes = {n: i for i, n in enumerate(df["immunogenicity"].unique())}
-        df["label"] = df["immunogenicity"].map(classes)
-        df["split"] = np.random.choice(["train", "val", "test"], df.shape[0], p=[0.7, 0.2, 0.1])
+        df = pd.concat([df["IUPAC"], pd.get_dummies(df["tissue_sample"])], axis=1)
+        df = df.groupby('IUPAC').agg("sum").reset_index()
 
-        df.drop("immunogenicity", axis=1, inplace=True)
+        df["split"] = np.random.choice(["train", "val", "test"], df.shape[0], p=[0.7, 0.2, 0.1])
         df.to_csv(p, sep="\t", index=False)
-        with open(root / "immunogenicity_classes.tsv", "w") as f:
-            for n, i in classes.items():
-                print(n, i, sep="\t", file=f)
     return p
 
 
@@ -137,16 +88,15 @@ def get_glycosylation(root: Path | str) -> Path:
     """
     root = Path(root)
     if not (p := root / "glycosylation.tsv").exists():
-        urllib.request.urlretrieve("https://torchglycan.s3.us-east-2.amazonaws.com/downstream/glycan_properties.csv", p.with_suffix(".csv"))
-        df = pd.read_csv(p.with_suffix(".csv"))[["glycan", "link"]]
+        df = df_glycan[["glycan", "glycan_type"]]
         df.rename(columns={"glycan": "IUPAC"}, inplace=True)
         df.dropna(inplace=True)
 
-        classes = {n: i for i, n in enumerate(df["link"].unique())}
-        df["label"] = df["link"].map(classes)
+        classes = {n: i for i, n in enumerate(df["glycan_type"].unique())}
+        df["label"] = df["glycan_type"].map(classes)
         df["split"] = np.random.choice(["train", "val", "test"], df.shape[0], p=[0.7, 0.2, 0.1])
 
-        df.drop("link", axis=1, inplace=True)
+        df.drop("glycan_type", axis=1, inplace=True)
         df.to_csv(p, sep="\t", index=False)
         with open(root / "glycosylation_classes.tsv", "w") as f:
             for n, i in classes.items():
@@ -164,12 +114,12 @@ def get_spectrum(root: Path | str) -> Path:
     Returns:
         The filepath of the processed spectrum data.
     """
-    root = Path(root)
-    #if not (p := root / "spectrum.tsv").exists():
-    p = root / "spectrum.tsv"
-    df = pd.read_csv(Path("/") / "scratch" / "SCRATCH_SAS" / "roman" / "Gothenburg" / "GIFFLAR" / "spectrum_pred_512_small.tsv", sep="\t")
-    df.to_csv(p, sep="\t", index=False)
-    return p
+    # root = Path(root)
+    # if not (p := root / "spectrum.tsv").exists():
+    #     p = root / "spectrum.tsv"
+    #     df = pd.read_csv(Path("/") / "scratch" / "SCRATCH_SAS" / "roman" / "Gothenburg" / "GIFFLAR" / "spectrum_pred_2048.tsv", sep="\t")
+    #     df.to_csv(p, sep="\t", index=False)
+    return Path("/") / "scratch" / "SCRATCH_SAS" / "roman" / "Gothenburg" / "GIFFLAR" / "spectrum_pred_2048.tsv"
 
 
 def get_dataset(data_config: dict, root: Path | str) -> dict:
@@ -190,9 +140,7 @@ def get_dataset(data_config: dict, root: Path | str) -> dict:
             path = get_taxonomic_level(root, name_fracs[1])
         case "Tissue":
             path = get_tissue(root)
-        case "Immunogenicity":
-            path = get_immunogenicity(root)
-        case "Glycosylation":
+        case "Glycosylation" | "Linkage":
             path = get_glycosylation(root)
         case "Spectrum":
             path = get_spectrum(root)

gifflar/metrics.py

@@ -20,10 +20,10 @@ class ModifiedCosineSimilarity(Metric):
     Args:
         tolerance: The tolerance value for the modified cosine similarity.
     """
-    def __init__(self, num_bins, tolerance: float = 0.2):
+    def __init__(self, num_bins: Optional[int] = None, tolerance: float = 0.2):
         super(ModifiedCosineSimilarity, self).__init__()
         self.mod_cos = matchms.similarity.ModifiedCosine(tolerance=tolerance)
-        self.mz = np.arange(MIN, MAX, (MAX - MIN) / num_bins)
+        self.mz = None if num_bins is None else np.arange(MIN, MAX, (MAX - MIN) / num_bins)
         self.add_state("mod_cos_sim", default=[], dist_reduce_fx="cat")
 
     def update(self, pred: torch.Tensor, true: torch.Tensor, precursor_masses: list[float]) -> torch.Tensor:
@@ -32,9 +32,11 @@ def update(self, pred: torch.Tensor, true: torch.Tensor, precursor_masses: list[
         assert len(true.shape) == 2, "The true values must have dimensions (batch_size, num_predictions)"
         assert pred.shape[0] == len(precursor_masses), "The batch size the precursor masses must match those of predictions, and true values"
 
+        if self.mz is None:
+            self.mz = np.arange(MIN, MAX, (MAX - MIN) / pred.shape[1])
         self.mod_cos_sim += [float(self.mod_cos.pair(
-            matchms.Spectrum(mz=self.mz, intensities=pred[i].cpu().numpy(), metadata={"precursor_mz": precursor_masses[i]}), 
-            matchms.Spectrum(mz=self.mz, intensities=true[i].cpu().numpy(), metadata={"precursor_mz": precursor_masses[i]})
+            matchms.Spectrum(mz=self.mz, intensities=pred[i].cpu().numpy().astype(float), metadata={"precursor_mz": precursor_masses[i]}), 
+            matchms.Spectrum(mz=self.mz, intensities=true[i].cpu().numpy().astype(float), metadata={"precursor_mz": precursor_masses[i]})
         )["score"]) for i in range(pred.shape[0])]
 
     def compute(self) -> torch.Tensor:

gifflar/model/base.py

@@ -1,6 +1,8 @@
 from typing import Literal, Optional, Any
 
 import torch
+import matplotlib
+matplotlib.use('TkAgg',force=True)
 from glycowork.glycan_data.loader import lib
 from pytorch_lightning import LightningModule
 from torch import nn

gifflar/model/utils.py

@@ -177,7 +177,7 @@ def get_spectrum_prediction_head(
     m = MetricCollection([
         CosineSimilarity(reduction="mean"),
         KLDivergence(reduction="mean", log_prob=True),
-        ModifiedCosineSimilarity(num_bins=512, tolerance=0.2),
+        ModifiedCosineSimilarity(num_bins=2048, tolerance=0.2),
     ])
     metrics = {
         "train": m.clone(prefix="train/" + metric_prefix), 

gifflar/train.py

@@ -1,6 +1,3 @@
-import os
-# os.environ["CUDA_VISIBLE_DEVICES"] = "1"
-
 from pathlib import Path
 from typing import Any
 import time
@@ -143,15 +140,16 @@ def train(**kwargs: Any) -> None:
     data_config, datamodule, logger, _ = setup(3, **kwargs)
     model = MODELS[kwargs["model"]["name"]](output_dim=data_config["num_classes"], task=data_config["task"],
                                             pre_transform_args=kwargs.get("pre-transforms", {}), **kwargs["model"])
+    print("Using device", "CUDA" if torch.cuda.is_available() else "CPU")
     trainer = Trainer(
         callbacks=[
             RichModelSummary(),
             RichProgressBar(),
         ],
         max_epochs=kwargs["model"]["epochs"],
         logger=logger,
-        limit_train_batches=3,
-        limit_val_batches=3,
+        # limit_train_batches=3,
+        # limit_val_batches=3,
         # accelerator="cpu",
     )
     start = time.time()